1 /*
2 * Copyright (c) 2024-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_setting_provider_unit_test.h"
17 #include "audio_errors.h"
18
19 using namespace testing;
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AudioStandard {
24
SetUp(void)25 void AudioSettingProviderUnitTest::SetUp(void) {}
26
TearDown(void)27 void AudioSettingProviderUnitTest::TearDown(void) {}
28
29 /**
30 * @tc.name : Test OnChange API
31 * @tc.type : FUNC
32 * @tc.number: OnChange_001
33 * @tc.desc : Test update_= nullptr
34 */
35 HWTEST(AudioSettingProviderUnitTest, OnChange_001, TestSize.Level1)
36 {
37 auto audioSettingObserverTest_ = std::make_shared<AudioSettingObserver>();
38 ASSERT_TRUE(audioSettingObserverTest_ != nullptr);
39
40 audioSettingObserverTest_->update_ = nullptr;
41
42 audioSettingObserverTest_->OnChange();
43 EXPECT_EQ(audioSettingObserverTest_->update_, nullptr);
44 }
45
46 /**
47 * @tc.name : Test OnChange API
48 * @tc.type : FUNC
49 * @tc.number: OnChange_002
50 * @tc.desc : Test Test update_ != nullptr
51 */
52 HWTEST(AudioSettingProviderUnitTest, OnChange_002, TestSize.Level1)
53 {
54 auto audioSettingObserverTest_ = std::make_shared<AudioSettingObserver>();
55 ASSERT_TRUE(audioSettingObserverTest_ != nullptr);
56
57 AudioSettingObserver::UpdateFunc func;
__anond676e81f0102(const std::string &str) 58 func = [](const std::string &str) {
59 return true;
60 };
61
62 audioSettingObserverTest_->SetUpdateFunc(func);
63
64 audioSettingObserverTest_->OnChange();
65 ASSERT_TRUE(audioSettingObserverTest_->update_ != nullptr);
66 }
67
68 /**
69 * @tc.name : Test GetInstance API
70 * @tc.type : FUNC
71 * @tc.number: GetInstance_001
72 * @tc.desc : Test GetInstance interface
73 */
74 HWTEST(AudioSettingProviderUnitTest, GetInstance_001, TestSize.Level1)
75 {
76 AudioSettingProvider* audioSettingProviderTest1 = nullptr;
77 AudioSettingProvider* audioSettingProviderTest2 = nullptr;
78
79 int32_t systemAbilityId = 1;
80 audioSettingProviderTest1 = &AudioSettingProvider::GetInstance(systemAbilityId);
81 ASSERT_TRUE(audioSettingProviderTest1 != nullptr);
82
83 audioSettingProviderTest2 = &AudioSettingProvider::GetInstance(systemAbilityId);
84 ASSERT_TRUE(audioSettingProviderTest2 != nullptr);
85 }
86
87 /**
88 * @tc.name : Test ParseFirstOfKey API
89 * @tc.type : FUNC
90 * @tc.number: ParseFirstOfKey_001
91 * @tc.desc : Test pos < len && isspace(input[pos]
92 */
93 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_001, TestSize.Level1)
94 {
95 size_t pos_ = 0;
96 std::string input_ = " =example";
97 size_t len_ = input_.length();
98
99 AudioSettingProvider* audioSettingProvider_ = nullptr;
100 int32_t systemAbilityId = 1;
101 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
102 ASSERT_TRUE(audioSettingProvider_ != nullptr);
103
104 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
105 EXPECT_EQ(ret, "example");
106 }
107
108 /**
109 * @tc.name : Test ParseFirstOfKey API
110 * @tc.type : FUNC
111 * @tc.number: ParseFirstOfKey_002
112 * @tc.desc : Test pos < len && !isspace
113 */
114 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_002, TestSize.Level1)
115 {
116 size_t pos_ = 0;
117 std::string input_ = "=example";
118 size_t len_ = input_.length();
119
120 AudioSettingProvider* audioSettingProvider_ = nullptr;
121 int32_t systemAbilityId = 1;
122 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
123 ASSERT_TRUE(audioSettingProvider_ != nullptr);
124
125 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
126 EXPECT_EQ(ret, "example");
127 }
128
129 /**
130 * @tc.name : Test ParseFirstOfKey API
131 * @tc.type : FUNC
132 * @tc.number: ParseFirstOfKey_003
133 * @tc.desc : Test pos >= len
134 */
135 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_003, TestSize.Level1)
136 {
137 size_t pos_ = 3;
138 size_t len_ = 1;
139 std::string input_ = "=example";
140
141 AudioSettingProvider* audioSettingProvider_ = nullptr;
142 int32_t systemAbilityId = 1;
143 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
144 ASSERT_TRUE(audioSettingProvider_ != nullptr);
145
146 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
147 EXPECT_EQ(ret, "");
148 }
149
150 /**
151 * @tc.name : Test ParseFirstOfKey API
152 * @tc.type : FUNC
153 * @tc.number: ParseFirstOfKey_004
154 * @tc.desc : Test pos < len && input[pos] != '"'.
155 */
156 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_004, TestSize.Level1)
157 {
158 size_t pos_ = 0;
159 std::string input_ = "=name: 30";
160 size_t len_ = input_.length();
161
162 AudioSettingProvider* audioSettingProvider_ = nullptr;
163 int32_t systemAbilityId = 1;
164 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
165 ASSERT_TRUE(audioSettingProvider_ != nullptr);
166
167 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
168 EXPECT_EQ(ret, "name: 30");
169 }
170
171 /**
172 * @tc.name : Test ParseFirstOfKey API
173 * @tc.type : FUNC
174 * @tc.number: ParseFirstOfKey_005
175 * @tc.desc : Test Test pos < len && input[pos] = '"'.
176 */
177 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_005, TestSize.Level1)
178 {
179 size_t pos_ = 0;
180 size_t len_ = 4;
181 std::string input_ = "\"id\"";
182
183 AudioSettingProvider* audioSettingProvider_ = nullptr;
184 int32_t systemAbilityId = 1;
185 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
186 ASSERT_TRUE(audioSettingProvider_ != nullptr);
187
188 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
189 EXPECT_EQ(ret, "id");
190 }
191
192 /**
193 * @tc.name : Test ParseFirstOfKey API
194 * @tc.type : FUNC
195 * @tc.number: ParseFirstOfKey_006
196 * @tc.desc : Test ParseFirstOfKey interface.
197 */
198 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_006, TestSize.Level1)
199 {
200 size_t pos_ = 0;
201 size_t len_ = 5;
202 std::string input_ = "\"name\": \"John\"";
203
204 AudioSettingProvider* audioSettingProvider_ = nullptr;
205 int32_t systemAbilityId = 1;
206 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
207 ASSERT_TRUE(audioSettingProvider_ != nullptr);
208
209 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
210 EXPECT_EQ(ret, "name");
211 EXPECT_EQ(pos_, 5);
212 }
213
214 /**
215 * @tc.name : Test ParseFirstOfKey API
216 * @tc.type : FUNC
217 * @tc.number: ParseFirstOfKey_007
218 * @tc.desc : Test ParseFirstOfKey interface.
219 */
220 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_007, TestSize.Level1)
221 {
222 size_t pos_ = 0;
223 size_t len_ = 100;
224 std::string input_ = "=example";
225
226 AudioSettingProvider* audioSettingProvider_ = nullptr;
227 int32_t systemAbilityId = 1;
228 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
229 ASSERT_TRUE(audioSettingProvider_ != nullptr);
230
231 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
232 EXPECT_EQ(ret, "example");
233 EXPECT_EQ(pos_ > input_.length(), true);
234 }
235
236 /**
237 * @tc.name : Test ParseFirstOfKey API
238 * @tc.type : FUNC
239 * @tc.number: ParseFirstOfKey_008
240 * @tc.desc : Test ParseFirstOfKey interface.
241 */
242 HWTEST(AudioSettingProviderUnitTest, ParseFirstOfKey_008, TestSize.Level1)
243 {
244 size_t pos_ = 0;
245 size_t len_ = 5;
246 std::string input_ = "=exampleTest";
247
248 AudioSettingProvider* audioSettingProvider_ = nullptr;
249 int32_t systemAbilityId = 1;
250 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
251 ASSERT_TRUE(audioSettingProvider_ != nullptr);
252
253 std::string ret = audioSettingProvider_->ParseFirstOfKey(pos_, len_, input_);
254 EXPECT_EQ(ret, "exam");
255 EXPECT_EQ(pos_, 5);
256 }
257
258 /**
259 * @tc.name : Test ParseSecondOfValue API
260 * @tc.type : FUNC
261 * @tc.number: ParseSecondOfValue_001
262 * @tc.desc : Test pos < len && isspace(input[pos]
263 */
264 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_001, TestSize.Level1)
265 {
266 size_t pos_ = 1;
267 size_t len_ = 8;
268 std::string input_ = " example";
269
270 AudioSettingProvider* audioSettingProvider_ = nullptr;
271 int32_t systemAbilityId = 1;
272 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
273 ASSERT_TRUE(audioSettingProvider_ != nullptr);
274
275 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
276 EXPECT_EQ(ret, "example");
277 }
278
279 /**
280 * @tc.name : Test ParseSecondOfValue API
281 * @tc.type : FUNC
282 * @tc.number: ParseSecondOfValue_002
283 * @tc.desc : Test pos < len && !isspace
284 */
285 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_002, TestSize.Level1)
286 {
287 size_t pos_ = 0;
288 size_t len_ = 8;
289 std::string input_ = "example";
290
291 AudioSettingProvider* audioSettingProvider_ = nullptr;
292 int32_t systemAbilityId = 1;
293 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
294 ASSERT_TRUE(audioSettingProvider_ != nullptr);
295
296 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
297 EXPECT_EQ(ret, "example");
298 }
299
300 /**
301 * @tc.name : Test ParseSecondOfValue API
302 * @tc.type : FUNC
303 * @tc.number: ParseSecondOfValue_003
304 * @tc.desc : Test pos >= len
305 */
306 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_003, TestSize.Level1)
307 {
308 size_t pos_ = 0;
309 size_t len_ = 8;
310 std::string input_ = "example";
311
312 AudioSettingProvider* audioSettingProvider_ = nullptr;
313 int32_t systemAbilityId = 1;
314 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
315 ASSERT_TRUE(audioSettingProvider_ != nullptr);
316
317 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
318 EXPECT_EQ(ret, "example");
319 }
320
321 /**
322 * @tc.name : Test ParseFirstOfKey API
323 * @tc.type : FUNC
324 * @tc.number: ParseSecondOfValue_004
325 * @tc.desc : Test pos < len && input[pos] != '"'.
326 */
327 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_004, TestSize.Level1)
328 {
329 size_t pos_ = 0;
330 size_t len_ = 8;
331 std::string input_ = "name: 30";
332
333 AudioSettingProvider* audioSettingProvider_ = nullptr;
334 int32_t systemAbilityId = 1;
335 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
336 ASSERT_TRUE(audioSettingProvider_ != nullptr);
337
338 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
339 EXPECT_EQ(ret, "name: 30");
340 }
341
342 /**
343 * @tc.name : Test ParseSecondOfValue API
344 * @tc.type : FUNC
345 * @tc.number: ParseSecondOfValue_005
346 * @tc.desc : Test pos < len && input[pos] = ','.
347 */
348 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_005, TestSize.Level1)
349 {
350 size_t pos_ = 0;
351 size_t len_ = 4;
352 std::string input_ = "\"id\"";
353
354 AudioSettingProvider* audioSettingProvider_ = nullptr;
355 int32_t systemAbilityId = 1;
356 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
357 ASSERT_TRUE(audioSettingProvider_ != nullptr);
358
359 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
360 EXPECT_EQ(ret, "\"id\"");
361 }
362
363 /**
364 * @tc.name : Test ParseSecondOfValue API
365 * @tc.type : FUNC
366 * @tc.number: ParseSecondOfValue_006
367 * @tc.desc : Test pos < len && !input[pos] = '"'.
368 */
369 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_006, TestSize.Level1)
370 {
371 size_t pos_ = 1;
372 size_t len_ = 5;
373 std::string input_ = "\"name\": \"John\"";
374
375 AudioSettingProvider* audioSettingProvider_ = nullptr;
376 int32_t systemAbilityId = 1;
377 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
378 ASSERT_TRUE(audioSettingProvider_ != nullptr);
379
380 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
381 EXPECT_EQ(ret, "name");
382 EXPECT_EQ(pos_, 5);
383 }
384
385 /**
386 * @tc.name : Test ParseSecondOfValue API
387 * @tc.type : FUNC
388 * @tc.number: ParseSecondOfValue_007
389 * @tc.desc : Test pos < len && !input[pos] = '"'.
390 */
391 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_007, TestSize.Level1)
392 {
393 size_t pos_ = 1;
394 size_t len_ = 5;
395 std::string input_ = "\"name\": \"John\"";
396
397 AudioSettingProvider* audioSettingProvider_ = nullptr;
398 int32_t systemAbilityId = 1;
399 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
400 ASSERT_TRUE(audioSettingProvider_ != nullptr);
401
402 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
403 EXPECT_EQ(ret, "name");
404 EXPECT_EQ(pos_, 5);
405 }
406
407 /**
408 * @tc.name : Test ParseSecondOfValue API
409 * @tc.type : FUNC
410 * @tc.number: ParseSecondOfValue_008
411 * @tc.desc : Test ParseSecondOfValue interface.
412 */
413 HWTEST(AudioSettingProviderUnitTest, ParseSecondOfValue_008, TestSize.Level1)
414 {
415 size_t pos_ = 0;
416 size_t len_ = 100;
417 std::string input_ = "example";
418
419 AudioSettingProvider* audioSettingProvider_ = nullptr;
420 int32_t systemAbilityId = 1;
421 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
422 ASSERT_TRUE(audioSettingProvider_ != nullptr);
423
424 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
425 EXPECT_EQ(ret, "example");
426 EXPECT_EQ(pos_ > input_.length(), true);
427 }
428
429 /**
430 * @tc.name : Test ParseSecondOfValue API
431 * @tc.type : FUNC
432 * @tc.number: PParseSecondOfValue_009
433 * @tc.desc : Test ParseSecondOfValue interface.
434 */
435 HWTEST(AudioSettingProviderUnitTest, PParseSecondOfValue_009, TestSize.Level1)
436 {
437 size_t pos_ = 0;
438 size_t len_ = 5;
439 std::string input_ = "exampleTest";
440
441 AudioSettingProvider* audioSettingProvider_ = nullptr;
442 int32_t systemAbilityId = 1;
443 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
444 ASSERT_TRUE(audioSettingProvider_ != nullptr);
445
446 std::string ret = audioSettingProvider_->ParseSecondOfValue(pos_, len_, input_);
447 EXPECT_EQ(ret, "examp");
448 EXPECT_EQ(pos_, 5);
449 }
450
451 /**
452 * @tc.name : Test IsValidKey API
453 * @tc.type : FUNC
454 * @tc.number: IsValidKey_001
455 * @tc.desc : Test ret != ERR_NAME_NOT_FOUND;
456 */
457 HWTEST(AudioSettingProviderUnitTest, IsValidKey_001, TestSize.Level1)
458 {
459 std::string key = "test";
460
461 AudioSettingProvider* audioSettingProvider_ = nullptr;
462 int32_t systemAbilityId = 1;
463 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
464 ASSERT_TRUE(audioSettingProvider_ != nullptr);
465
466 audioSettingProvider_->SetDataShareReady(false);
467 bool ret = audioSettingProvider_->IsValidKey(key);
468 EXPECT_EQ(ret, false);
469 }
470
471 /**
472 * @tc.name : Test IsValidKey API
473 * @tc.type : FUNC
474 * @tc.number: IsValidKey_002
475 * @tc.desc : Test ret != ERR_NAME_NOT_FOUND;
476 */
477 HWTEST(AudioSettingProviderUnitTest, IsValidKey_002, TestSize.Level1)
478 {
479 std::string key = "";
480 AudioSettingProvider* audioSettingProvider_ = nullptr;
481 int32_t systemAbilityId = 1;
482 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
483 ASSERT_TRUE(audioSettingProvider_ != nullptr);
484
485 audioSettingProvider_->SetDataShareReady(true);
486 bool ret = audioSettingProvider_->IsValidKey(key);
487 EXPECT_EQ(ret, false);
488 }
489
490 /**
491 * @tc.name : Test ExecRegisterCb API
492 * @tc.type : FUNC
493 * @tc.number: ExecRegisterCb_001
494 * @tc.desc : Test observer == nullptr
495 */
496 HWTEST(AudioSettingProviderUnitTest, ExecRegisterCb_001, TestSize.Level1)
497 {
498 AudioSettingProvider* audioSettingProvider_ = nullptr;
499 int32_t systemAbilityId = 1;
500 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
501 ASSERT_TRUE(audioSettingProvider_ != nullptr);
502
503 audioSettingProvider_->ExecRegisterCb(nullptr);
504 }
505
506 /**
507 * @tc.name : Test UnregisterObserver API
508 * @tc.type : FUNC
509 * @tc.number: UnregisterObserver_001
510 * @tc.desc : Test UnregisterObserver
511 */
512 HWTEST(AudioSettingProviderUnitTest, UnregisterObserver_001, TestSize.Level1)
513 {
514 AudioSettingProvider* audioSettingProvider_ = nullptr;
515 int32_t systemAbilityId = 1;
516 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
517 ASSERT_TRUE(audioSettingProvider_ != nullptr);
518
519 audioSettingProvider_->SetDataShareReady(false);
520
521 sptr<AudioSettingObserver> observerPtr = new AudioSettingObserver();
522 ErrCode ret = audioSettingProvider_->UnregisterObserver(observerPtr, "TEST");
523 EXPECT_EQ(ret, ERR_NO_INIT);
524 }
525
526 /**
527 * @tc.name : Test UnregisterObserver API
528 * @tc.type : FUNC
529 * @tc.number: UnregisterObserver_002
530 * @tc.desc : Test UnregisterObserver
531 */
532 HWTEST(AudioSettingProviderUnitTest, UnregisterObserver_002, TestSize.Level1)
533 {
534 AudioSettingProvider* audioSettingProvider_ = nullptr;
535 int32_t systemAbilityId = 1;
536 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
537 ASSERT_TRUE(audioSettingProvider_ != nullptr);
538
539 audioSettingProvider_->SetDataShareReady(true);
540 sptr<AudioSettingObserver> observerPtr = new AudioSettingObserver();
541 ErrCode ret = audioSettingProvider_->UnregisterObserver(observerPtr, "TEST");
542 EXPECT_EQ(ret, ERR_OK);
543 }
544
545 /**
546 * @tc.name : Test PutStringValue API
547 * @tc.type : FUNC
548 * @tc.number: PutStringValue_001
549 * @tc.desc : Test PutStringValue
550 */
551 HWTEST(AudioSettingProviderUnitTest, PutStringValue_001, TestSize.Level1)
552 {
553 AudioSettingProvider* audioSettingProvider_ = nullptr;
554 int32_t systemAbilityId = 1;
555 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
556 ASSERT_TRUE(audioSettingProvider_ != nullptr);
557
558 audioSettingProvider_->SetDataShareReady(true);
559
560 ErrCode ret = audioSettingProvider_->PutStringValue("key", "value", "tableType", false, 0);
561 EXPECT_EQ(ret, ERR_OK);
562 }
563
564 /**
565 * @tc.name : Test CreateDataShareHelper API
566 * @tc.type : FUNC
567 * @tc.number: CreateDataShareHelper_001
568 * @tc.desc : Test CreateDataShareHelper
569 */
570 HWTEST(AudioSettingProviderUnitTest, CreateDataShareHelper_001, TestSize.Level1)
571 {
572 AudioSettingProvider* audioSettingProvider_ = nullptr;
573 int32_t systemAbilityId = 1;
574 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
575 ASSERT_TRUE(audioSettingProvider_ != nullptr);
576
577 audioSettingProvider_->SetDataShareReady(true);
578
579 auto helper = audioSettingProvider_->CreateDataShareHelper("system", -1);
580 ASSERT_TRUE(helper != nullptr);
581 }
582
583 /**
584 * @tc.name : Test CreateDataShareHelper API
585 * @tc.type : FUNC
586 * @tc.number: CreateDataShareHelper_002
587 * @tc.desc : Test CreateDataShareHelper
588 */
589 HWTEST(AudioSettingProviderUnitTest, CreateDataShareHelper_002, TestSize.Level1)
590 {
591 AudioSettingProvider* audioSettingProvider_ = nullptr;
592 int32_t systemAbilityId = 1;
593 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
594 ASSERT_TRUE(audioSettingProvider_ != nullptr);
595
596 audioSettingProvider_->SetDataShareReady(true);
597
598 auto helper = audioSettingProvider_->CreateDataShareHelper("secure", -1);
599 ASSERT_TRUE(helper != nullptr);
600 }
601
602 /**
603 * @tc.name : Test AssembleUri API
604 * @tc.type : FUNC
605 * @tc.number: AssembleUri_001
606 * @tc.desc : Test AssembleUri
607 */
608 HWTEST(AudioSettingProviderUnitTest, AssembleUri_001, TestSize.Level1)
609 {
610 AudioSettingProvider* audioSettingProvider_ = nullptr;
611 int32_t systemAbilityId = 1;
612 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
613 ASSERT_TRUE(audioSettingProvider_ != nullptr);
614
615 audioSettingProvider_->SetDataShareReady(true);
616
617 Uri uri = audioSettingProvider_->AssembleUri("TEST", "secure", -1);
618 ASSERT_TRUE(uri.uriString_.length() > 0);
619 }
620
621 /**
622 * @tc.name : Test AssembleUri API
623 * @tc.type : FUNC
624 * @tc.number: AssembleUri_002
625 * @tc.desc : Test AssembleUri
626 */
627 HWTEST(AudioSettingProviderUnitTest, AssembleUri_002, TestSize.Level1)
628 {
629 AudioSettingProvider* audioSettingProvider_ = nullptr;
630 int32_t systemAbilityId = 1;
631 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
632 ASSERT_TRUE(audioSettingProvider_ != nullptr);
633
634 audioSettingProvider_->SetDataShareReady(true);
635
636 Uri uri = audioSettingProvider_->AssembleUri("TEST", "system", -1);
637 ASSERT_TRUE(uri.uriString_.length() > 0);
638 }
639
640 /**
641 * @tc.name : Test CreateDataShareHelper API
642 * @tc.type : FUNC
643 * @tc.number: CreateDataShareHelper_003
644 * @tc.desc : Test CreateDataShareHelper
645 */
646 HWTEST(AudioSettingProviderUnitTest, CreateDataShareHelper_003, TestSize.Level1)
647 {
648 #define SUPPORT_USER_ACCOUNT
649 AudioSettingProvider* audioSettingProvider_ = nullptr;
650 int32_t systemAbilityId = 1;
651 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
652 ASSERT_TRUE(audioSettingProvider_ != nullptr);
653
654 audioSettingProvider_->SetDataShareReady(true);
655
656 auto helper = audioSettingProvider_->CreateDataShareHelper("test", MIN_USER_ACCOUNT);
657 ASSERT_TRUE(helper != nullptr);
658 }
659
660 /**
661 * @tc.name : Test GetBoolValue API
662 * @tc.type : FUNC
663 * @tc.number: GetBoolValue_001
664 * @tc.desc : Test GetBoolValue
665 */
666 HWTEST(AudioSettingProviderUnitTest, GetBoolValue_001, TestSize.Level1)
667 {
668 AudioSettingProvider* audioSettingProvider_ = nullptr;
669 int32_t systemAbilityId = 1;
670 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
671 ASSERT_TRUE(audioSettingProvider_ != nullptr);
672
673 audioSettingProvider_->SetDataShareReady(false);
674
675 std::string key = "test";
676 bool value = true;
677 ErrCode ret = audioSettingProvider_->GetBoolValue(key, value, "system", -1);
678 ASSERT_TRUE(ret != ERR_OK);
679 }
680
681 /**
682 * @tc.name : Test GetMapValue API
683 * @tc.type : FUNC
684 * @tc.number: GetMapValue_001
685 * @tc.desc : Test GetMapValue
686 */
687 HWTEST(AudioSettingProviderUnitTest, GetMapValue_001, TestSize.Level1)
688 {
689 AudioSettingProvider* audioSettingProvider_ = nullptr;
690 int32_t systemAbilityId = 1;
691 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
692 ASSERT_TRUE(audioSettingProvider_ != nullptr);
693
694 audioSettingProvider_->SetDataShareReady(false);
695
696 std::string key = "test";
697 std::vector<std::map<std::string, std::string>> value;
698 ErrCode ret = audioSettingProvider_->GetMapValue(key, value, "system");
699 ASSERT_TRUE(ret != ERR_OK);
700 }
701
702 /**
703 * @tc.name : Test ParseJsonArray API
704 * @tc.type : FUNC
705 * @tc.number: ParseJsonArray_000
706 * @tc.desc : Test ParseJsonArray pos >= len
707 */
708 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_000, TestSize.Level1)
709 {
710 AudioSettingProvider* audioSettingProvider_ = nullptr;
711 int32_t systemAbilityId = 1;
712 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
713 ASSERT_TRUE(audioSettingProvider_ != nullptr);
714
715 std::string json = "";
716 auto result = audioSettingProvider_->ParseJsonArray(json);
717
718 ASSERT_EQ(result.size(), 0);
719 }
720
721 /**
722 * @tc.name : Test ParseJsonArray API
723 * @tc.type : FUNC
724 * @tc.number: ParseJsonArray_001
725 * @tc.desc : Test ParseJsonArray pos < len && isspace(input[pos] is false
726 */
727 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_001, TestSize.Level1)
728 {
729 AudioSettingProvider* audioSettingProvider_ = nullptr;
730 int32_t systemAbilityId = 1;
731 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
732 ASSERT_TRUE(audioSettingProvider_ != nullptr);
733
734 std::string json = ":tests";
735 auto result = audioSettingProvider_->ParseJsonArray(json);
736
737 ASSERT_EQ(result.size(), 0);
738 }
739
740 /**
741 * @tc.name : Test ParseJsonArray API
742 * @tc.type : FUNC
743 * @tc.number: ParseJsonArray_002
744 * @tc.desc : Test ParseJsonArray pos < len && isspace(input[pos] is true
745 */
746 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_002, TestSize.Level1)
747 {
748 AudioSettingProvider* audioSettingProvider_ = nullptr;
749 int32_t systemAbilityId = 1;
750 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
751 ASSERT_TRUE(audioSettingProvider_ != nullptr);
752
753 std::string json = " :test";
754 auto result = audioSettingProvider_->ParseJsonArray(json);
755
756 ASSERT_EQ(result.size(), 0);
757 }
758
759 /**
760 * @tc.name : Test ParseJsonArray API
761 * @tc.type : FUNC
762 * @tc.number: ParseJsonArray_003
763 * @tc.desc : Test ParseJsonArray input[pos++] == '[' && pos >= len
764 */
765 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_003, TestSize.Level1)
766 {
767 AudioSettingProvider* audioSettingProvider_ = nullptr;
768 int32_t systemAbilityId = 1;
769 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
770 ASSERT_TRUE(audioSettingProvider_ != nullptr);
771
772 std::string json = "[";
773 auto result = audioSettingProvider_->ParseJsonArray(json);
774
775 ASSERT_EQ(result.size(), 0);
776 }
777
778 /**
779 * @tc.name : Test ParseJsonArray API
780 * @tc.type : FUNC
781 * @tc.number: ParseJsonArray_004
782 * @tc.desc : Test ParseJsonArray input[pos] == ']'
783 */
784 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_004, TestSize.Level1)
785 {
786 AudioSettingProvider* audioSettingProvider_ = nullptr;
787 int32_t systemAbilityId = 1;
788 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
789 ASSERT_TRUE(audioSettingProvider_ != nullptr);
790
791 std::string json = "[ ]";
792 auto result = audioSettingProvider_->ParseJsonArray(json);
793
794 ASSERT_EQ(result.size(), 0);
795 }
796
797 /**
798 * @tc.name : Test ParseJsonArray API
799 * @tc.type : FUNC
800 * @tc.number: ParseJsonArray_005
801 * @tc.desc : Test ParseJsonArray input[pos++]!= '{'
802 */
803 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_005, TestSize.Level1)
804 {
805 AudioSettingProvider* audioSettingProvider_ = nullptr;
806 int32_t systemAbilityId = 1;
807 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
808 ASSERT_TRUE(audioSettingProvider_ != nullptr);
809
810 std::string json = "[ ";
811 auto result = audioSettingProvider_->ParseJsonArray(json);
812
813 ASSERT_EQ(result.size(), 0);
814 }
815
816 /**
817 * @tc.name : Test ParseJsonArray API
818 * @tc.type : FUNC
819 * @tc.number: ParseJsonArray_006
820 * @tc.desc : Test ParseJsonArray input[pos++]!= '{'
821 */
822 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_006, TestSize.Level1)
823 {
824 AudioSettingProvider* audioSettingProvider_ = nullptr;
825 int32_t systemAbilityId = 1;
826 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
827 ASSERT_TRUE(audioSettingProvider_ != nullptr);
828
829 std::string json = "[{";
830 auto result = audioSettingProvider_->ParseJsonArray(json);
831
832 ASSERT_EQ(result.size(), 1);
833 EXPECT_EQ(result[0][""], "");
834 }
835
836 /**
837 * @tc.name : Test ParseJsonArray API
838 * @tc.type : FUNC
839 * @tc.number: ParseJsonArray_007
840 * @tc.desc : Test ParseJsonArray input[pos] == '}'
841 */
842 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_007, TestSize.Level1)
843 {
844 AudioSettingProvider* audioSettingProvider_ = nullptr;
845 int32_t systemAbilityId = 1;
846 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
847 ASSERT_TRUE(audioSettingProvider_ != nullptr);
848
849 std::string json = "[{}";
850 auto result = audioSettingProvider_->ParseJsonArray(json);
851
852 ASSERT_EQ(result.size(), 1);
853 EXPECT_EQ(result[0][""], "");
854 }
855
856 /**
857 * @tc.name : Test ParseJsonArray API
858 * @tc.type : FUNC
859 * @tc.number: ParseJsonArray_008
860 * @tc.desc : Test ParseJsonArray key != "uid" && input.find(',', pos) == std::string::npos
861 */
862 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_008, TestSize.Level1)
863 {
864 AudioSettingProvider* audioSettingProvider_ = nullptr;
865 int32_t systemAbilityId = 1;
866 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
867 ASSERT_TRUE(audioSettingProvider_ != nullptr);
868
869 std::string json = "[{test}";
870 auto result = audioSettingProvider_->ParseJsonArray(json);
871
872 ASSERT_EQ(result.size(), 1);
873 EXPECT_EQ(result[0][""], "");
874 }
875
876 /**
877 * @tc.name : Test ParseJsonArray API
878 * @tc.type : FUNC
879 * @tc.number: ParseJsonArray_009
880 * @tc.desc : Test ParseJsonArray key != "uid" && input.find(',', pos) != std::string::npos
881 */
882 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_009, TestSize.Level1)
883 {
884 AudioSettingProvider* audioSettingProvider_ = nullptr;
885 int32_t systemAbilityId = 1;
886 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
887 ASSERT_TRUE(audioSettingProvider_ != nullptr);
888
889 std::string json = "[{test,}";
890 auto result = audioSettingProvider_->ParseJsonArray(json);
891
892 ASSERT_EQ(result.size(), 1);
893 EXPECT_EQ(result[0][""], "");
894 }
895
896 /**
897 * @tc.name : Test ParseJsonArray API
898 * @tc.type : FUNC
899 * @tc.number: ParseJsonArray_010
900 * @tc.desc : Test ParseJsonArray key == "uid" && input.find(',', pos) == std::string::npos
901 */
902 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_010, TestSize.Level1)
903 {
904 AudioSettingProvider* audioSettingProvider_ = nullptr;
905 int32_t systemAbilityId = 1;
906 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
907 ASSERT_TRUE(audioSettingProvider_ != nullptr);
908
909 std::string json = "[{\" uid}";
910 auto result = audioSettingProvider_->ParseJsonArray(json);
911
912 ASSERT_EQ(result.size(), 1);
913 EXPECT_EQ(result[0][""], "");
914 }
915
916 /**
917 * @tc.name : Test ParseJsonArray API
918 * @tc.type : FUNC
919 * @tc.number: ParseJsonArray_011
920 * @tc.desc : Test ParseJsonArray key == "uid" && input.find(',', pos) != std::string::npos
921 */
922 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_011, TestSize.Level1)
923 {
924 AudioSettingProvider* audioSettingProvider_ = nullptr;
925 int32_t systemAbilityId = 1;
926 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
927 ASSERT_TRUE(audioSettingProvider_ != nullptr);
928
929 std::string json = "[{\" uid\",}";
930 auto result = audioSettingProvider_->ParseJsonArray(json);
931
932 ASSERT_EQ(result.size(), 1);
933 EXPECT_EQ(result[0][""], "");
934 }
935
936 /**
937 * @tc.name : Test ParseJsonArray API
938 * @tc.type : FUNC
939 * @tc.number: ParseJsonArray_012
940 * @tc.desc : Test ParseJsonArray !key.empty()
941 */
942 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_012, TestSize.Level1)
943 {
944 AudioSettingProvider* audioSettingProvider_ = nullptr;
945 int32_t systemAbilityId = 1;
946 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
947 ASSERT_TRUE(audioSettingProvider_ != nullptr);
948
949 std::string json = "[{\" uid\":}";
950 auto result = audioSettingProvider_->ParseJsonArray(json);
951
952 ASSERT_EQ(result.size(), 1);
953 EXPECT_EQ(result[0][""], "");
954 }
955
956 /**
957 * @tc.name : Test ParseJsonArray API
958 * @tc.type : FUNC
959 * @tc.number: ParseJsonArray_013
960 * @tc.desc : Test ParseJsonArray !key.empty()
961 */
962 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_013, TestSize.Level1)
963 {
964 AudioSettingProvider* audioSettingProvider_ = nullptr;
965 int32_t systemAbilityId = 1;
966 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
967 ASSERT_TRUE(audioSettingProvider_ != nullptr);
968
969 std::string json = "[{\" uid\":}";
970 auto result = audioSettingProvider_->ParseJsonArray(json);
971
972 ASSERT_EQ(result.size(), 1);
973 EXPECT_EQ(result[0][""], "");
974 }
975
976 /**
977 * @tc.name : Test ParseJsonArray API
978 * @tc.type : FUNC
979 * @tc.number: ParseJsonArray_014
980 * @tc.desc : Test ParseJsonArray !key.empty() && !value.empty()
981 */
982 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_014, TestSize.Level1)
983 {
984 AudioSettingProvider* audioSettingProvider_ = nullptr;
985 int32_t systemAbilityId = 1;
986 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
987 ASSERT_TRUE(audioSettingProvider_ != nullptr);
988
989 std::string json = "[{\" uid\":\"123\"}]";
990 auto result = audioSettingProvider_->ParseJsonArray(json);
991
992 ASSERT_EQ(result.size(), 1);
993
994 for (const auto& mapItem : result) {
995 for (const auto& [key, value] : mapItem) {
996 EXPECT_EQ(key, "123");
997 EXPECT_EQ(value, "1");
998 }
999 }
1000 }
1001
1002 /**
1003 * @tc.name : Test ParseJsonArray API
1004 * @tc.type : FUNC
1005 * @tc.number: ParseJsonArray_015
1006 * @tc.desc : Test ParseJsonArray !input[pos] == ','
1007 */
1008 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_015, TestSize.Level1)
1009 {
1010 AudioSettingProvider* audioSettingProvider_ = nullptr;
1011 int32_t systemAbilityId = 1;
1012 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
1013 ASSERT_TRUE(audioSettingProvider_ != nullptr);
1014
1015 std::string json = "[{\" uid\":\"123\"},]";
1016 auto result = audioSettingProvider_->ParseJsonArray(json);
1017
1018 ASSERT_EQ(result.size(), 1);
1019 for (const auto& mapItem : result) {
1020 for (const auto& [key, value] : mapItem) {
1021 EXPECT_EQ(key, "123");
1022 EXPECT_EQ(value, "1");
1023 }
1024 }
1025 }
1026
1027 /**
1028 * @tc.name : Test ParseJsonArray API
1029 * @tc.type : FUNC
1030 * @tc.number: ParseJsonArray_016
1031 * @tc.desc : Test ParseJsonArray input[pos] != ']'
1032 */
1033 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_016, TestSize.Level1)
1034 {
1035 AudioSettingProvider* audioSettingProvider_ = nullptr;
1036 int32_t systemAbilityId = 1;
1037 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
1038 ASSERT_TRUE(audioSettingProvider_ != nullptr);
1039
1040 std::string json = "[{\" uid\":\"123\"}";
1041 auto result = audioSettingProvider_->ParseJsonArray(json);
1042
1043 ASSERT_EQ(result.size(), 1);
1044 for (const auto& mapItem : result) {
1045 for (const auto& [key, value] : mapItem) {
1046 EXPECT_EQ(key, "123");
1047 EXPECT_EQ(value, "1");
1048 }
1049 }
1050 }
1051
1052 /**
1053 * @tc.name : Test ParseJsonArray API
1054 * @tc.type : FUNC
1055 * @tc.number: ParseJsonArray_017
1056 * @tc.desc : Test ParseJsonArray
1057 */
1058 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_017, TestSize.Level1)
1059 {
1060 AudioSettingProvider* audioSettingProvider_ = nullptr;
1061 int32_t systemAbilityId = 1;
1062 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
1063 ASSERT_TRUE(audioSettingProvider_ != nullptr);
1064
1065 std::string json = "[{\" uid\":\"123\"},{\" uid\":\"456\"}]";
1066 auto result = audioSettingProvider_->ParseJsonArray(json);
1067
1068 ASSERT_EQ(result.size(), 1);
1069 for (const auto& mapItem : result) {
1070 for (const auto& [key, value] : mapItem) {
1071 if (key == "123") {
1072 EXPECT_EQ(key, "123");
1073 EXPECT_EQ(value, "1");
1074 }
1075 if (key == "456") {
1076 EXPECT_EQ(key, "456");
1077 EXPECT_EQ(value, "1");
1078 }
1079 }
1080 }
1081 }
1082
1083 /**
1084 * @tc.name : Test ParseJsonArray API
1085 * @tc.type : FUNC
1086 * @tc.number: ParseJsonArray_018
1087 * @tc.desc : Test ParseJsonArray
1088 */
1089 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_018, TestSize.Level1)
1090 {
1091 AudioSettingProvider* audioSettingProvider_ = nullptr;
1092 int32_t systemAbilityId = 1;
1093 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
1094 ASSERT_TRUE(audioSettingProvider_ != nullptr);
1095
1096 std::string json = "[{\" uid\":\"123\",\" name\":\"test\"}]";
1097 auto result = audioSettingProvider_->ParseJsonArray(json);
1098
1099 ASSERT_EQ(result.size(), 1);
1100 for (const auto& mapItem : result) {
1101 for (const auto& [key, value] : mapItem) {
1102 if (key == "123") {
1103 EXPECT_EQ(key, "123");
1104 EXPECT_EQ(value, "1");
1105 }
1106 if (key == "") {
1107 EXPECT_EQ(key, "");
1108 EXPECT_EQ(value, "");
1109 }
1110 }
1111 }
1112 }
1113
1114 /**
1115 * @tc.name : Test ParseJsonArray API
1116 * @tc.type : FUNC
1117 * @tc.number: ParseJsonArray_019
1118 * @tc.desc : Test ParseJsonArray
1119 */
1120 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_019, TestSize.Level1)
1121 {
1122 AudioSettingProvider* audioSettingProvider_ = nullptr;
1123 int32_t systemAbilityId = 1;
1124 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
1125 ASSERT_TRUE(audioSettingProvider_ != nullptr);
1126
1127 std::string json = "[ { \" uid\" : \"123\" } ]";
1128 auto result = audioSettingProvider_->ParseJsonArray(json);
1129
1130 ASSERT_EQ(result.size(), 1);
1131 for (const auto& mapItem : result) {
1132 for (const auto& [key, value] : mapItem) {
1133 EXPECT_EQ(key, "123");
1134 EXPECT_EQ(value, "1");
1135 }
1136 }
1137 }
1138
1139 /**
1140 * @tc.name : Test ParseJsonArray API
1141 * @tc.type : FUNC
1142 * @tc.number: ParseJsonArray_020
1143 * @tc.desc : Test ParseJsonArray
1144 */
1145 HWTEST(AudioSettingProviderUnitTest, ParseJsonArray_020, TestSize.Level1)
1146 {
1147 AudioSettingProvider* audioSettingProvider_ = nullptr;
1148 int32_t systemAbilityId = 1;
1149 audioSettingProvider_ = &AudioSettingProvider::GetInstance(systemAbilityId);
1150 ASSERT_TRUE(audioSettingProvider_ != nullptr);
1151
1152 std::string invalidJson = "[{\" uid\":\"123\"";
1153 auto result = audioSettingProvider_->ParseJsonArray(invalidJson);
1154
1155 EXPECT_FALSE(result.empty());
1156 }
1157 } // namespace AudioStandard
1158 } // namespace OHOS
1159