1 /*
2 * Copyright (c) 2023-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 <thread>
17 #include <gtest/gtest.h>
18 #include "audio_utils.h"
19 #include "parameter.h"
20 #include "audio_channel_blend.h"
21 #include "volume_ramp.h"
22 #include "audio_speed.h"
23 #include "audio_errors.h"
24
25 using namespace testing::ext;
26 using namespace std;
27 namespace OHOS {
28 namespace AudioStandard {
29
30 class AudioUtilsProUnitTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33 static void TearDownTestCase(void);
34 void SetUp();
35 void TearDown();
36 };
37
SetUpTestCase(void)38 void AudioUtilsProUnitTest::SetUpTestCase(void)
39 {
40 // input testsuit setup step，setup invoked before all testcases
41 }
42
TearDownTestCase(void)43 void AudioUtilsProUnitTest::TearDownTestCase(void)
44 {
45 // input testsuit teardown step，teardown invoked after all testcases
46 }
47
SetUp(void)48 void AudioUtilsProUnitTest::SetUp(void)
49 {
50 // input testcase setup step，setup invoked before each testcases
51 }
52
TearDown(void)53 void AudioUtilsProUnitTest::TearDown(void)
54 {
55 // input testcase teardown step，teardown invoked after each testcases
56 }
57
58 /**
59 * @tc.name : Test SwitchStreamUtil API
60 * @tc.type : FUNC
61 * @tc.number: SwitchStreamUtil_001
62 * @tc.desc : Test SwitchStreamUtil::InsertSwitchStreamRecord().
63 */
64 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_001, TestSize.Level1)
65 {
66 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
67
68 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
69
70 auto ret = SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
71 EXPECT_EQ(ret, true);
72
73 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
74 EXPECT_EQ(ret, true);
75 }
76
77 /**
78 * @tc.name : Test SwitchStreamUtil API
79 * @tc.type : FUNC
80 * @tc.number: SwitchStreamUtil_002
81 * @tc.desc : Test SwitchStreamUtil::InsertSwitchStreamRecord().
82 */
83 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_002, TestSize.Level1)
84 {
85 SwitchStreamInfo info = {0, 0, 0, 0, 0, CAPTURER_PREPARED};
86
87 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
88
89 auto ret = SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
90 EXPECT_EQ(ret, true);
91 }
92
93 /**
94 * @tc.name : Test SwitchStreamUtil API
95 * @tc.type : FUNC
96 * @tc.number: SwitchStreamUtil_003
97 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
98 */
99 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_003, TestSize.Level1)
100 {
101 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
102 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
103
104 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
105
106 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
107 SwitchState targetState2 = SwitchState::SWITCH_STATE_CREATED;
108
109 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
110 EXPECT_EQ(ret, true);
111
112 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
113 EXPECT_EQ(ret, true);
114 }
115
116 /**
117 * @tc.name : Test SwitchStreamUtil API
118 * @tc.type : FUNC
119 * @tc.number: SwitchStreamUtil_004
120 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
121 */
122 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_004, TestSize.Level1)
123 {
124 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
125 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
126
127 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
128
129 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
130 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
131
132 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
133 EXPECT_EQ(ret, true);
134
135 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
136 EXPECT_EQ(ret, true);
137 }
138
139 /**
140 * @tc.name : Test SwitchStreamUtil API
141 * @tc.type : FUNC
142 * @tc.number: SwitchStreamUtil_005
143 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
144 */
145 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_005, TestSize.Level1)
146 {
147 SwitchStreamInfo info = {0, 2, 0, 0, 0, CAPTURER_RUNNING};
148 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
149
150 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
151
152 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
153 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
154
155 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
156 EXPECT_EQ(ret, false);
157
158 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
159 EXPECT_EQ(ret, true);
160 }
161
162 /**
163 * @tc.name : Test SwitchStreamUtil API
164 * @tc.type : FUNC
165 * @tc.number: SwitchStreamUtil_006
166 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
167 */
168 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_006, TestSize.Level1)
169 {
170 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
171 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
172
173 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
174
175 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
176 SwitchState targetState2 = SwitchState::SWITCH_STATE_CREATED;
177
178 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
179 EXPECT_EQ(ret, false);
180
181 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
182 EXPECT_EQ(ret, true);
183 }
184
185 /**
186 * @tc.name : Test SwitchStreamUtil API
187 * @tc.type : FUNC
188 * @tc.number: SwitchStreamUtil_007
189 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
190 */
191 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_007, TestSize.Level1)
192 {
193 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
194 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
195
196 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
197
198 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
199 SwitchState targetState2 = SwitchState::SWITCH_STATE_CREATED;
200
201 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
202 EXPECT_EQ(ret, false);
203
204 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
205 EXPECT_EQ(ret, true);
206 }
207
208 /**
209 * @tc.name : Test SwitchStreamUtil API
210 * @tc.type : FUNC
211 * @tc.number: SwitchStreamUtil_008
212 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
213 */
214 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_008, TestSize.Level1)
215 {
216 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
217 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
218
219 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
220
221 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
222 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
223
224 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
225 EXPECT_EQ(ret, false);
226
227 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
228 EXPECT_EQ(ret, true);
229 }
230
231 /**
232 * @tc.name : Test SwitchStreamUtil API
233 * @tc.type : FUNC
234 * @tc.number: SwitchStreamUtil_009
235 * @tc.desc : Test SwitchStreamUtil::IsSwitchStreamSwitching().
236 */
237 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_009, TestSize.Level1)
238 {
239 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
240 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
241
242 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
243
244 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
245 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
246
247 auto ret = SwitchStreamUtil::IsSwitchStreamSwitching(info2, targetState2);
248 EXPECT_EQ(ret, false);
249
250 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
251 EXPECT_EQ(ret, true);
252 }
253
254 /**
255 * @tc.name : Test SwitchStreamUtil API
256 * @tc.type : FUNC
257 * @tc.number: SwitchStreamUtil_010
258 * @tc.desc : Test SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord().
259 */
260 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_010, TestSize.Level1)
261 {
262 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
263 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
264
265 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
266
267 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
268 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
269
270 SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(info2, targetState2);
271
272 auto ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
273 EXPECT_EQ(ret, true);
274 }
275
276 /**
277 * @tc.name : Test SwitchStreamUtil API
278 * @tc.type : FUNC
279 * @tc.number: SwitchStreamUtil_011
280 * @tc.desc : Test SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord().
281 */
282 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_011, TestSize.Level1)
283 {
284 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
285 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
286
287 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
288
289 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
290 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
291
292 SwitchStreamUtil::TimeoutThreadHandleTimeoutRecord(info2, targetState2);
293
294 auto ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
295 EXPECT_EQ(ret, true);
296 }
297
298 /**
299 * @tc.name : Test SwitchStreamUtil API
300 * @tc.type : FUNC
301 * @tc.number: SwitchStreamUtil_012
302 * @tc.desc : Test SwitchStreamUtil::RemoveSwitchStreamRecord().
303 */
304 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_012, TestSize.Level1)
305 {
306 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
307 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
308
309 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
310
311 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
312 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
313
314 auto ret = SwitchStreamUtil::RemoveSwitchStreamRecord(info2, targetState2);
315 EXPECT_EQ(ret, true);
316
317 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
318 EXPECT_EQ(ret, true);
319 }
320
321 /**
322 * @tc.name : Test SwitchStreamUtil API
323 * @tc.type : FUNC
324 * @tc.number: SwitchStreamUtil_013
325 * @tc.desc : Test SwitchStreamUtil::RemoveSwitchStreamRecord().
326 */
327 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_013, TestSize.Level1)
328 {
329 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
330 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
331
332 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
333
334 auto ret = SwitchStreamUtil::RemoveSwitchStreamRecord(info, targetState);
335 EXPECT_EQ(ret, true);
336 }
337
338 /**
339 * @tc.name : Test SwitchStreamUtil API
340 * @tc.type : FUNC
341 * @tc.number: SwitchStreamUtil_014
342 * @tc.desc : Test SwitchStreamUtil::RemoveAllRecordBySessionId().
343 */
344 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_014, TestSize.Level1)
345 {
346 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
347 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
348
349 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
350
351 SwitchStreamInfo info2 = {1, 1, 0, 0, 0, CAPTURER_PREPARED};
352 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
353
354 SwitchStreamUtil::InsertSwitchStreamRecord(info2, targetState2);
355
356 auto ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
357 EXPECT_EQ(ret, true);
358
359 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(1);
360 EXPECT_EQ(ret, true);
361 }
362
363 /**
364 * @tc.name : Test SwitchStreamUtil API
365 * @tc.type : FUNC
366 * @tc.number: SwitchStreamUtil_015
367 * @tc.desc : Test SwitchStreamUtil::HandleStartedSwitchInfoInRecord().
368 */
369 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_015, TestSize.Level1)
370 {
371 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
372 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
373
374 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
375
376 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_RUNNING};
377 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
378
379 auto ret = SwitchStreamUtil::HandleStartedSwitchInfoInRecord(info2, targetState2);
380 EXPECT_EQ(ret, true);
381
382 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
383 EXPECT_EQ(ret, true);
384 }
385
386 /**
387 * @tc.name : Test SwitchStreamUtil API
388 * @tc.type : FUNC
389 * @tc.number: SwitchStreamUtil_016
390 * @tc.desc : Test SwitchStreamUtil::HandleStartedSwitchInfoInRecord().
391 */
392 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_016, TestSize.Level1)
393 {
394 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
395 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
396
397 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
398
399 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
400 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
401
402 auto ret = SwitchStreamUtil::HandleStartedSwitchInfoInRecord(info2, targetState2);
403 EXPECT_EQ(ret, true);
404
405 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
406 EXPECT_EQ(ret, true);
407 }
408
409 /**
410 * @tc.name : Test SwitchStreamUtil API
411 * @tc.type : FUNC
412 * @tc.number: SwitchStreamUtil_017
413 * @tc.desc : Test SwitchStreamUtil::HandleStartedSwitchInfoInRecord().
414 */
415 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_017, TestSize.Level1)
416 {
417 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
418 SwitchState targetState = SwitchState::SWITCH_STATE_STARTED;
419
420 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
421
422 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
423 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
424
425 auto ret = SwitchStreamUtil::HandleStartedSwitchInfoInRecord(info2, targetState2);
426 EXPECT_EQ(ret, true);
427
428 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
429 EXPECT_EQ(ret, true);
430 }
431
432 /**
433 * @tc.name : Test SwitchStreamUtil API
434 * @tc.type : FUNC
435 * @tc.number: SwitchStreamUtil_018
436 * @tc.desc : Test SwitchStreamUtil::HandleSwitchInfoInRecord().
437 */
438 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_018, TestSize.Level1)
439 {
440 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_INVALID};
441 SwitchState targetState = SwitchState::SWITCH_STATE_STARTED;
442
443 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
444
445 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_INVALID};
446 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
447
448 auto ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info2, targetState2);
449 EXPECT_EQ(ret, true);
450
451 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
452 EXPECT_EQ(ret, true);
453 }
454
455 /**
456 * @tc.name : Test SwitchStreamUtil API
457 * @tc.type : FUNC
458 * @tc.number: SwitchStreamUtil_019
459 * @tc.desc : Test SwitchStreamUtil::HandleSwitchInfoInRecord().
460 */
461 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_019, TestSize.Level1)
462 {
463 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
464 SwitchState targetState = SwitchState::SWITCH_STATE_CREATED;
465
466 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
467
468 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
469 SwitchState targetState2 = SwitchState::SWITCH_STATE_CREATED;
470
471 auto ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info2, targetState2);
472 EXPECT_EQ(ret, true);
473
474 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
475 EXPECT_EQ(ret, true);
476 }
477
478 /**
479 * @tc.name : Test SwitchStreamUtil API
480 * @tc.type : FUNC
481 * @tc.number: SwitchStreamUtil_020
482 * @tc.desc : Test SwitchStreamUtil::HandleSwitchInfoInRecord().
483 */
484 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_020, TestSize.Level1)
485 {
486 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
487 SwitchState targetState = SwitchState::SWITCH_STATE_FINISHED;
488
489 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
490
491 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
492 SwitchState targetState2 = SwitchState::SWITCH_STATE_FINISHED;
493
494 auto ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info2, targetState2);
495 EXPECT_EQ(ret, true);
496
497 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
498 EXPECT_EQ(ret, true);
499 }
500
501 /**
502 * @tc.name : Test SwitchStreamUtil API
503 * @tc.type : FUNC
504 * @tc.number: SwitchStreamUtil_021
505 * @tc.desc : Test SwitchStreamUtil::HandleCreatedSwitchInfoInRecord().
506 */
507 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_021, TestSize.Level1)
508 {
509 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
510 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
511
512 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
513
514 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_PREPARED};
515 SwitchState targetState2 = SwitchState::SWITCH_STATE_WAITING;
516
517 auto ret = SwitchStreamUtil::HandleCreatedSwitchInfoInRecord(info2, targetState2);
518 EXPECT_EQ(ret, true);
519
520 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
521 EXPECT_EQ(ret, true);
522 }
523
524 /**
525 * @tc.name : Test SwitchStreamUtil API
526 * @tc.type : FUNC
527 * @tc.number: SwitchStreamUtil_022
528 * @tc.desc : Test SwitchStreamUtil::HandleCreatedSwitchInfoInRecord().
529 */
530 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_022, TestSize.Level1)
531 {
532 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
533 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
534
535 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
536
537 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
538 SwitchState targetState2 = SwitchState::SWITCH_STATE_WAITING;
539
540 auto ret = SwitchStreamUtil::HandleCreatedSwitchInfoInRecord(info2, targetState2);
541 EXPECT_EQ(ret, true);
542
543 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
544 EXPECT_EQ(ret, true);
545 }
546
547 /**
548 * @tc.name : Test SwitchStreamUtil API
549 * @tc.type : FUNC
550 * @tc.number: SwitchStreamUtil_023
551 * @tc.desc : Test SwitchStreamUtil::HandleCreatedSwitchInfoInRecord().
552 */
553 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_023, TestSize.Level1)
554 {
555 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
556 SwitchState targetState = SwitchState::SWITCH_STATE_TIMEOUT;
557
558 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
559
560 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
561 SwitchState targetState2 = SwitchState::SWITCH_STATE_TIMEOUT;
562
563 auto ret = SwitchStreamUtil::HandleCreatedSwitchInfoInRecord(info2, targetState2);
564 EXPECT_EQ(ret, true);
565
566 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
567 EXPECT_EQ(ret, true);
568 }
569
570 /**
571 * @tc.name : Test SwitchStreamUtil API
572 * @tc.type : FUNC
573 * @tc.number: SwitchStreamUtil_024
574 * @tc.desc : Test SwitchStreamUtil::UpdateSwitchStreamRecord().
575 */
576 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_024, TestSize.Level1)
577 {
578 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
579 SwitchState targetState = SwitchState::SWITCH_STATE_TIMEOUT;
580
581 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
582
583 SwitchStreamInfo info2 = {0, 2, 0, 0, 0, CAPTURER_NEW};
584 SwitchState targetState2 = SwitchState::SWITCH_STATE_TIMEOUT;
585
586 auto ret = SwitchStreamUtil::UpdateSwitchStreamRecord(info2, targetState2);
587 EXPECT_EQ(ret, true);
588
589 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
590 EXPECT_EQ(ret, true);
591 }
592
593 /**
594 * @tc.name : Test SwitchStreamUtil API
595 * @tc.type : FUNC
596 * @tc.number: SwitchStreamUtil_025
597 * @tc.desc : Test SwitchStreamUtil::UpdateSwitchStreamRecord().
598 */
599 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_025, TestSize.Level1)
600 {
601 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
602 SwitchState targetState = SwitchState::SWITCH_STATE_TIMEOUT;
603
604 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
605
606 SwitchStreamInfo info2 = {0, 2, 0, 0, 0, CAPTURER_NEW};
607 SwitchState targetState2 = SwitchState::SWITCH_STATE_WAITING;
608
609 auto ret = SwitchStreamUtil::UpdateSwitchStreamRecord(info2, targetState2);
610 EXPECT_EQ(ret, true);
611
612 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
613 EXPECT_EQ(ret, true);
614 }
615
616 /**
617 * @tc.name : Test SwitchStreamUtil API
618 * @tc.type : FUNC
619 * @tc.number: SwitchStreamUtil_026
620 * @tc.desc : Test SwitchStreamUtil::UpdateSwitchStreamRecord().
621 */
622 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_026, TestSize.Level1)
623 {
624 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
625 SwitchState targetState = SwitchState::SWITCH_STATE_TIMEOUT;
626
627 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
628
629 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
630 SwitchState targetState2 = SwitchState::SWITCH_STATE_WAITING;
631
632 auto ret = SwitchStreamUtil::UpdateSwitchStreamRecord(info2, targetState2);
633 EXPECT_EQ(ret, false);
634
635 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
636 EXPECT_EQ(ret, true);
637 }
638
639 /**
640 * @tc.name : Test SwitchStreamUtil API
641 * @tc.type : FUNC
642 * @tc.number: SwitchStreamUtil_027
643 * @tc.desc : Test SwitchStreamUtil::UpdateSwitchStreamRecord().
644 */
645 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_027, TestSize.Level1)
646 {
647 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
648 SwitchState targetState = SwitchState::SWITCH_STATE_FINISHED;
649
650 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
651
652 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
653 SwitchState targetState2 = SwitchState::SWITCH_STATE_CREATED;
654
655 auto ret = SwitchStreamUtil::UpdateSwitchStreamRecord(info2, targetState2);
656 EXPECT_EQ(ret, false);
657
658 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
659 EXPECT_EQ(ret, true);
660 }
661
662 #ifdef TEMP_DISABLE
663 /**
664 * @tc.name : Test SwitchStreamUtil API
665 * @tc.type : FUNC
666 * @tc.number: SwitchStreamUtil_028
667 * @tc.desc : Test SwitchStreamUtil::UpdateSwitchStreamRecord().
668 */
669 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_028, TestSize.Level1)
670 {
671 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
672 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
673
674 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
675
676 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
677 SwitchState targetState2 = SwitchState::SWITCH_STATE_STARTED;
678
679 auto ret = SwitchStreamUtil::UpdateSwitchStreamRecord(info2, targetState2);
680 EXPECT_EQ(ret, true);
681
682 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
683 EXPECT_EQ(ret, true);
684 }
685
686 /**
687 * @tc.name : Test SwitchStreamUtil API
688 * @tc.type : FUNC
689 * @tc.number: SwitchStreamUtil_029
690 * @tc.desc : Test SwitchStreamUtil::UpdateSwitchStreamRecord().
691 */
692 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_029, TestSize.Level1)
693 {
694 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_NEW};
695 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
696
697 SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
698
699 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_NEW};
700 SwitchState targetState2 = SwitchState::SWITCH_STATE_TIMEOUT;
701
702 auto ret = SwitchStreamUtil::UpdateSwitchStreamRecord(info2, targetState2);
703 EXPECT_EQ(ret, false);
704
705 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
706 EXPECT_EQ(ret, true);
707 }
708 #endif
709
710 /**
711 * @tc.name : Test HandleSwitchInfoInRecord API
712 * @tc.type : FUNC
713 * @tc.number: HandleSwitchInfoInRecord_030
714 * @tc.desc : Test SwitchStreamUtil::HandleSwitchInfoInRecord().
715 */
716 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_030, TestSize.Level1)
717 {
718 SwitchStreamInfo info = {0, 1, 0, 0, 0, CAPTURER_STOPPED};
719 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
720
721 auto ret = SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
722 EXPECT_EQ(ret, true);
723
724 SwitchStreamInfo info2 = {0, 1, 0, 0, 0, CAPTURER_STOPPED};
725 SwitchStreamInfo info3 = {0, 1, 0, 0, 0, CAPTURER_PAUSED};
726 SwitchStreamInfo info4 = {0, 1, 0, 0, 0, CAPTURER_RELEASED};
727 SwitchStreamInfo info5 = {0, 1, 0, 0, 0, CAPTURER_INVALID};
728 SwitchState targetState2 = SwitchState::SWITCH_STATE_WAITING;
729
730 ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info2, targetState2);
731 EXPECT_EQ(ret, true);
732
733 ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info3, targetState2);
734 EXPECT_EQ(ret, true);
735
736 ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info4, targetState2);
737 EXPECT_EQ(ret, true);
738
739 ret = SwitchStreamUtil::HandleSwitchInfoInRecord(info5, targetState2);
740 EXPECT_EQ(ret, true);
741
742 ret = SwitchStreamUtil::RemoveAllRecordBySessionId(0);
743 EXPECT_EQ(ret, true);
744 }
745
746 /**
747 * @tc.name : Test HandleSwitchInfoInRecord API
748 * @tc.type : FUNC
749 * @tc.number: HandleSwitchInfoInRecord_031
750 * @tc.desc : Test InsertSwitchStreamRecord branch when in List.
751 */
752 HWTEST(AudioUtilsProUnitTest, SwitchStreamUtil_031, TestSize.Level1)
753 {
754 SwitchStreamInfo info = {0, 1041, 0, 0, 0, CAPTURER_PREPARED};
755 SwitchState targetState = SwitchState::SWITCH_STATE_WAITING;
756
757 auto ret = SwitchStreamUtil::InsertSwitchStreamRecord(info, targetState);
758 EXPECT_EQ(ret, true);
759 }
760 } // namespace AudioStandard
761 } // namespace OHOS