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_socket_thread_test.h"
17 #include <thread>
18 #include <string>
19 #include <memory>
20 #include <vector>
21 #include <sys/socket.h>
22 #include <cerrno>
23 #include <fstream>
24 #include <algorithm>
25 #include <unistd.h>
26 #include "audio_policy_log.h"
27 #include "audio_errors.h"
28 #include "audio_pnp_server.h"
29 using namespace std;
30 using namespace std::chrono;
31 using namespace testing::ext;
32
33 namespace OHOS {
34 namespace AudioStandard {
35 namespace {
36 const int32_t HDF_ERR_INVALID_PARAM = -3;
37 } // namespace
38
SetUpTestCase(void)39 void AudioSocketThreadUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)40 void AudioSocketThreadUnitTest::TearDownTestCase(void) {}
SetUp(void)41 void AudioSocketThreadUnitTest::SetUp(void) {}
TearDown(void)42 void AudioSocketThreadUnitTest::TearDown(void) {}
43
44
45 #define PRINT_LINE printf("debug __LINE__:%d\n", __LINE__)
46
47 /**
48 * @tc.name : Test AudioSocketThread.
49 * @tc.number: AudioSocketThread_001
50 * @tc.desc : Test IsUpdatePnpDeviceState.
51 */
52 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_001, TestSize.Level1)
53 {
54 AudioEvent event1;
55 event1.eventType = 1;
56 event1.deviceType = 2;
57 event1.name = "Device1";
58 event1.address = "Address1";
59 event1.anahsName = "AnahsName1";
60
61 audioSocketThread_.UpdatePnpDeviceState(&event1);
62
63 //Test the exact same event
64 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event1), false);
65
66 //Test events with different eventtypes
67 AudioEvent event2;
68 event2.eventType = 2; // change eventType
69 event2.deviceType = 2;
70 event2.name = "Device1";
71 event2.address = "Address1";
72 event2.anahsName = "AnahsName1";
73 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event2), true);
74
75 //Test for events with different deviceTypes
76 AudioEvent event3;
77 event3.eventType = 1;
78 event3.deviceType = 1;
79 event3.name = "Device1";
80 event3.address = "Address1";
81 event3.anahsName = "AnahsName1";
82 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event3), true);
83
84 //Test events with different names
85 AudioEvent event4;
86 event4.eventType = 1;
87 event4.deviceType = 1;
88 event4.name = "Device2";
89 event4.address = "Address1";
90 event4.anahsName = "AnahsName1";
91 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event4), true);
92
93 // Test events with different addresses
94 AudioEvent event5;
95 event5.eventType = 1;
96 event5.deviceType = 1;
97 event5.name = "Device1";
98 event5.address = "Address2";
99 event5.anahsName = "AnahsName1";
100 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event5), true);
101
102 //Test the anahsName for different events
103 AudioEvent event6;
104 event6.eventType = 1;
105 event6.deviceType = 1;
106 event6.name = "Device1";
107 event6.address = "Address1";
108 event6.anahsName = "AnahsName2";
109
110 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event6), true);
111 }
112
113 /**
114 * @tc.name : Test AudioSocketThread.
115 * @tc.number: AudioSocketThread_002
116 * @tc.desc : Test IsUpdatePnpDeviceState.
117 */
118 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_002, TestSize.Level1)
119 {
120 AudioEvent event1;
121 event1.eventType = 1;
122 event1.deviceType = 1;
123 event1.name = "Device1";
124 event1.address = "Address1";
125 event1.anahsName = "AnahsName1";
126
127 //Set the start state
128 audioSocketThread_.UpdatePnpDeviceState(&event1);
129
130 //Test completely different events
131 AudioEvent event2;
132 event2.eventType = 2;
133 event2.deviceType = 2;
134 event2.name = "Device2";
135 event2.address = "Address2";
136 event2.anahsName = "AnahsName2";
137 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event2), true);
138
139 //Test events where both eventType and eventType are different
140 AudioEvent event3;
141 event3.eventType = 2;
142 event3.deviceType = 2;
143 event3.name = "Device1";
144 event3.address = "Address1";
145 event3.anahsName = "AnahsName1";
146 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event3), true);
147
148 //Test for events where deviceType and name are different
149 AudioEvent event4;
150 event4.eventType = 1;
151 event4.deviceType = 2;
152 event4.name = "Device2";
153 event4.address = "Address1";
154 event4.anahsName = "AnahsName1";
155 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event4), true);
156
157 //Test for events where both name and adress are different
158 AudioEvent event5;
159 event5.eventType = 1;
160 event5.deviceType = 1;
161 event5.name = "Device2";
162 event5.address = "Address2";
163 event5.anahsName = "AnahsName1";
164 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event5), true);
165
166 //Test for events where both adress and anahsName are different
167 AudioEvent event6;
168 event6.eventType = 1;
169 event6.deviceType = 1;
170 event6.name = "Device1";
171 event6.address = "Address2";
172 event6.anahsName = "AnahsName2";
173 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event6), true);
174 }
175
176 /**
177 * @tc.name : Test AudioSocketThread.
178 * @tc.number: AudioSocketThread_003
179 * @tc.desc : Test IsUpdatePnpDeviceState.
180 */
181 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_003, TestSize.Level1)
182 {
183 AudioEvent event1;
184 event1.eventType = 1;
185 event1.deviceType = 1;
186 event1.name = "Device1";
187 event1.address = "Address1";
188 event1.anahsName = "AnahsName1";
189
190 audioSocketThread_.UpdatePnpDeviceState(&event1);
191
192 //Test events with different eventType, eventType, and name
193 AudioEvent event2;
194 event2.eventType = 2;
195 event2.eventType = 2;
196 event2.name = "Device2";
197 event2.address = "Address1";
198 event2.anahsName = "AnahsName1";
199 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event2), true);
200
201 //Test events with different eventType, name, and address
202 AudioEvent event3;
203 event3.eventType = 2;
204 event3.eventType = 2;
205 event3.name = "Device2";
206 event3.address = "Address1";
207 event3.anahsName = "AnahsName1";
208 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event3), true);
209
210 //Test for events where name, address, and anahsName are different
211 AudioEvent event4;
212 event4.eventType = 2;
213 event4.eventType = 2;
214 event4.name = "Device2";
215 event4.address = "Address1";
216 event4.anahsName = "AnahsName1";
217 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event4), true);
218
219 // Test foraddress,anahsName and eventType are different
220 AudioEvent event5;
221 event5.eventType = 2;
222 event5.eventType = 1;
223 event5.name = "Device1";
224 event5.address = "Address2";
225 event5.anahsName = "AnahsName2";
226 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event5), true);
227
228 //Test for events where address, anahsName, and eventType are different
229 AudioEvent event6;
230 event6.eventType = 2;
231 event6.eventType = 2;
232 event6.name = "Device1";
233 event6.address = "Address1";
234 event6.anahsName = "AnahsName2";
235 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event6), true);
236 }
237
238 /**
239 * @tc.name : Test AudioSocketThread.
240 * @tc.number: AudioSocketThread_004
241 * @tc.desc : Test IsUpdatePnpDeviceState.
242 */
243 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_004, TestSize.Level1)
244 {
245 AudioEvent event1;
246 event1.eventType = 1;
247 event1.deviceType = 1;
248 event1.name = "Device1";
249 event1.address = "Address1";
250 event1.anahsName = "AnahsName1";
251
252 audioSocketThread_.UpdatePnpDeviceState(&event1);
253
254 //Test events that are different for eventType, eventType, name, and adress
255 AudioEvent event2;
256 event2.eventType = 2;
257 event2.deviceType = 2;
258 event2.name = "Device2";
259 event2.address = "Address2";
260 event2.anahsName = "AnahsName1";
261 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event2), true);
262
263 //Test events where eventType, name, adress, and anahsName are all different
264 AudioEvent event3;
265 event3.eventType = 1;
266 event3.deviceType = 2;
267 event3.name = "Device2";
268 event3.address = "Address2";
269 event3.anahsName = "AnahsName2";
270 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event3), true);
271
272 //Test for events where name, adress, anahsName, and eventType are all different
273 AudioEvent event4;
274 event4.eventType = 2;
275 event4.deviceType = 1;
276 event4.name = "Device2";
277 event4.address = "Address2";
278 event4.anahsName = "AnahsName2";
279 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event4), true);
280
281 //Test for events where adress, anahsName, eventType, and deviceType are all different
282 AudioEvent event5;
283 event5.eventType = 2;
284 event5.deviceType = 2;
285 event5.name = "Device1";
286 event5.address = "Address2";
287 event5.anahsName = "AnahsName2";
288 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event5), true);
289
290 //Test for events where anahsName, eventType, deviceType, and name are all different
291 AudioEvent event6;
292 event6.eventType = 2;
293 event6.deviceType = 2;
294 event6.name = "Device2";
295 event6.address = "Address1";
296 event6.anahsName = "AnahsName2";
297 EXPECT_EQ(audioSocketThread_.IsUpdatePnpDeviceState(&event6), true);
298 }
299
300 /**
301 * @tc.name : Test AudioSocketThread.
302 * @tc.number: AudioSocketThread_005
303 * @tc.desc : Test SetAudioPnpUevent REMOVE_AUDIO_DEVICE
304 */
305 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_005, TestSize.Level1)
306 {
307 AudioPnpUevent uevent = {
308 .action = "remove",
309 .name = "TestDevice",
310 .state = "removed",
311 .devType = "headset",
312 .subSystem = "audio",
313 .switchName = "h2w",
314 .switchState = "0",
315 .hidName = "hid",
316 .devName = "TestDevName",
317 .anahsName = "anahs"
318 };
319
320 AudioEvent event;
321 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
322 EXPECT_NE(result, SUCCESS);
323 EXPECT_NE(event.eventType, PNP_EVENT_DEVICE_REMOVE);
324 EXPECT_NE(event.deviceType, PNP_DEVICE_HEADSET);
325 EXPECT_NE(event.name, "TestDevice");
326 EXPECT_NE(event.address, "TestDevName");
327 }
328
329 /**
330 * @tc.name : Test AudioSocketThread.
331 * @tc.number: AudioSocketThread_006
332 * @tc.desc : Test SetAudioPnpUevent ADD_DEVICE_HEADSET
333 */
334 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_006, TestSize.Level1)
335 {
336 AudioPnpUevent uevent = {
337 .action = "add",
338 .name = "TestDevice",
339 .state = "added",
340 .devType = "headset",
341 .subSystem = "switch",
342 .switchName = "h2w",
343 .switchState = "1",
344 .hidName = "hid",
345 .devName = "TestDevName",
346 .anahsName = "anahs"
347 };
348
349 AudioEvent event;
350 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
351 EXPECT_EQ(result, SUCCESS);
352 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
353 EXPECT_EQ(event.deviceType, PNP_DEVICE_HEADSET);
354 EXPECT_EQ(event.name, "TestDevice");
355 EXPECT_EQ(event.address, "TestDevName");
356 }
357
358 /**
359 * @tc.name : Test AudioSocketThread.
360 * @tc.number: AudioSocketThread_007
361 * @tc.desc : Test SetAudioPnpUevent ADD_DEVICE_HEADSET_WITHOUT_MIC
362 */
363 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_007, TestSize.Level1)
364 {
365 AudioPnpUevent uevent = {
366 .action = "add",
367 .name = "TestDevice",
368 .state = "added",
369 .devType = "headset_without_mic",
370 .subSystem = "switch",
371 .switchName = "h2w",
372 .switchState = "2",
373 .hidName = "hid",
374 .devName = "TestDevName",
375 .anahsName = "anahs"
376 };
377
378 AudioEvent event;
379 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
380
381 EXPECT_EQ(result, SUCCESS);
382 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
383 EXPECT_EQ(event.deviceType, PNP_DEVICE_HEADPHONE);
384 EXPECT_EQ(event.name, "TestDevice");
385 EXPECT_EQ(event.address, "TestDevName");
386 }
387
388 /**
389 * @tc.name : Test AudioSocketThread.
390 * @tc.number: AudioSocketThread_008
391 * @tc.desc : Test SetAudioPnpUevent_ADD_DEVICE_ADAPTER
392 */
393 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_008, TestSize.Level1)
394 {
395 AudioPnpUevent uevent = {
396 .action = "add",
397 .name = "TestDevice",
398 .state = "added",
399 .devType = "adapter",
400 .subSystem = "switch",
401 .switchName = "h2w",
402 .switchState = "4",
403 .hidName = "hid",
404 .devName = "TestDevName",
405 .anahsName = "anahs"
406 };
407
408 AudioEvent event;
409 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
410
411 EXPECT_EQ(result, SUCCESS);
412 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
413 EXPECT_EQ(event.deviceType, PNP_DEVICE_ADAPTER_DEVICE);
414 EXPECT_EQ(event.name, "TestDevice");
415 EXPECT_EQ(event.address, "TestDevName");
416 }
417
418 /**
419 * @tc.name : Test AudioSocketThread.
420 * @tc.number: AudioSocketThread_009
421 * @tc.desc : Test SetAudioPnpUevent_ADD_DEVICE_MIC_BLOCKED
422 */
423 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_009, TestSize.Level1)
424 {
425 AudioPnpUevent uevent = {
426 .action = "block",
427 .name = "TestDevice",
428 .state = "blocked",
429 .devType = "mic",
430 .subSystem = "switch",
431 .switchName = "h2w",
432 .switchState = "5",
433 .hidName = "hid",
434 .devName = "TestDevName",
435 .anahsName = "anahs"
436 };
437
438 AudioEvent event;
439 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
440
441 EXPECT_EQ(result, SUCCESS);
442 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
443 EXPECT_EQ(event.deviceType, PNP_DEVICE_UNKNOWN);
444 EXPECT_EQ(event.name, "TestDevice");
445 EXPECT_EQ(event.address, "TestDevName");
446 }
447
448 /**
449 * @tc.name : Test AudioSocketThread.
450 * @tc.number: AudioSocketThread_010
451 * @tc.desc : Test SetAudioPnpUevent_ADD_DEVICE_MIC_UN_BLOCKED
452 */
453 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_010, TestSize.Level1)
454 {
455 AudioPnpUevent uevent = {
456 .action = "unblock",
457 .name = "TestDevice",
458 .state = "unblocked",
459 .devType = "mic",
460 .subSystem = "switch",
461 .switchName = "h2w",
462 .switchState = "6",
463 .hidName = "hid",
464 .devName = "TestDevName",
465 .anahsName = "anahs"
466 };
467
468 AudioEvent event;
469 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
470
471 EXPECT_EQ(result, SUCCESS);
472 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
473 EXPECT_EQ(event.deviceType, PNP_DEVICE_UNKNOWN);
474 EXPECT_EQ(event.name, "TestDevice");
475 EXPECT_EQ(event.address, "TestDevName");
476 }
477
478 /**
479 * @tc.name : Test AudioSocketThread.
480 * @tc.number: AudioSocketThread_011
481 * @tc.desc : Test SetAudioPnpUevent_UnknownState
482 */
483 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_011, TestSize.Level1)
484 {
485 AudioPnpUevent uevent = {
486 .action = "unknown",
487 .name = "TestDevice",
488 .state = "unknown",
489 .devType = "unknown",
490 .subSystem = "switch",
491 .switchName = "h2w",
492 .switchState = "X", // 'X' UnknownState
493 .hidName = "hid",
494 .devName = "TestDevName",
495 .anahsName = "anahs"
496 };
497
498 AudioEvent event;
499 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
500
501 EXPECT_EQ(result, SUCCESS);
502 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
503 EXPECT_EQ(event.deviceType, PNP_DEVICE_UNKNOWN);
504 EXPECT_EQ(event.name, "TestDevice");
505 EXPECT_EQ(event.address, "TestDevName");
506 }
507
508 /**
509 * @tc.name : Test AudioSocketThread.
510 * @tc.number: AudioSocketThread_012
511 * @tc.desc : Test SetAudioPnpUevent_NonSwitchSubsystem
512 */
513 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_012, TestSize.Level1)
514 {
515 AudioPnpUevent uevent = {
516 .action = "change",
517 .name = "headset",
518 .state = "analog_hs0",
519 .devType = "extcon",
520 .subSystem = "other",
521 .switchName = "h2w",
522 .switchState = "0",
523 .hidName = "hid",
524 .devName = "TestDevName",
525 .anahsName = "anahs"
526 };
527
528 AudioEvent event;
529 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
530 EXPECT_EQ(result, ERROR);
531 }
532
533 /**
534 * @tc.name : Test AudioSocketThread.
535 * @tc.number: AudioSocketThread_013
536 * @tc.desc : Test SetAudioPnpUevent_InvalidSwitchName
537 */
538 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_013, TestSize.Level1)
539 {
540 AudioPnpUevent uevent = {
541 .action = "remove",
542 .name = "TestDevice",
543 .state = "removed",
544 .devType = "headset",
545 .subSystem = "switch",
546 .switchName = "invalid",
547 .switchState = "0",
548 .hidName = "hid",
549 .devName = "TestDevName",
550 .anahsName = "anahs"
551 };
552
553 AudioEvent event;
554 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
555 EXPECT_EQ(result, ERROR);
556 }
557
558 /**
559 * @tc.name : Test AudioSocketThread.
560 * @tc.number: AudioSocketThread_014
561 * @tc.desc : Test SetAudioPnpUevent_InvalidAction
562 */
563 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_014, TestSize.Level1)
564 {
565 AudioPnpUevent uevent = {
566 .action = "invalid",
567 .name = "headset",
568 .state = "analog_hs0",
569 .devType = "extcon",
570 .subSystem = "other",
571 .switchName = "h2w",
572 .switchState = "0",
573 .hidName = "hid",
574 .devName = "TestDevName",
575 .anahsName = "anahs"
576 };
577
578 AudioEvent event;
579 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
580 EXPECT_EQ(result, ERROR);
581 }
582
583 /**
584 * @tc.name : Test AudioSocketThread.
585 * @tc.number: AudioSocketThread_015
586 * @tc.desc : Test SetAudioPnpUevent_InvalidDevType
587 */
588 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_015, TestSize.Level1)
589 {
590 AudioPnpUevent uevent = {
591 .action = "change",
592 .name = "headset",
593 .state = "analog_hs0",
594 .devType = "invalid",
595 .subSystem = "other",
596 .switchName = "h2w",
597 .switchState = "0",
598 .hidName = "hid",
599 .devName = "TestDevName",
600 .anahsName = "anahs"
601 };
602 AudioEvent event;
603 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
604 EXPECT_EQ(result, ERROR);
605 }
606
607 /**
608 * @tc.name : Test AudioSocketThread.
609 * @tc.number: AudioSocketThread_016
610 * @tc.desc : Test SetAudioPnpUevent_InvalidState
611 */
612 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_016, TestSize.Level1)
613 {
614 AudioPnpUevent uevent = {
615 .action = "change",
616 .name = "headset",
617 .state = "invalid",
618 .devType = "extcon",
619 .subSystem = "other",
620 .switchName = "h2w",
621 .switchState = "0",
622 .hidName = "hid",
623 .devName = "TestDevName",
624 .anahsName = "anahs"
625 };
626 AudioEvent event;
627 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
628 EXPECT_EQ(result, ERROR);
629 }
630
631 /**
632 * @tc.name : Test AudioSocketThread.
633 * @tc.number: AudioSocketThread_017
634 * @tc.desc : Test SetAudioPnpUevent REMOVE by ANALOG_HS0 in non-switch subsystem
635 */
636 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_017, TestSize.Level4)
637 {
638 AudioPnpUevent uevent = {
639 .action = "change",
640 .name = "headset",
641 .state = "MICROPHONE=0",
642 .devType = "extcon3",
643 .subSystem = "audio",
644 .switchName = "h2w",
645 .switchState = "0",
646 .hidName = "hid",
647 .devName = "TestDevName0",
648 .anahsName = "anahs"
649 };
650
651 AudioEvent event;
652 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
653
654 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_REMOVE);
655 EXPECT_EQ(event.deviceType, PNP_DEVICE_HEADSET);
656 EXPECT_EQ(result, SUCCESS);
657 }
658
659 /**
660 * @tc.name : Test AudioSocketThread.
661 * @tc.number: AudioSocketThread_018
662 * @tc.desc : Test SetAudioPnpUevent ADD by ANALOG_HS1 in non-switch subsystem
663 */
664 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_018, TestSize.Level4)
665 {
666 AudioPnpUevent uevent = {
667 .action = "change",
668 .name = "headset",
669 .state = "MICROPHONE=1",
670 .devType = "extcon3",
671 .subSystem = "audio",
672 .switchName = "h2w",
673 .switchState = "1",
674 .hidName = "hid",
675 .devName = "TestDevName1",
676 .anahsName = "anahs"
677 };
678
679 AudioEvent event;
680 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
681
682 EXPECT_EQ(event.eventType, PNP_EVENT_DEVICE_ADD);
683 EXPECT_EQ(event.deviceType, PNP_DEVICE_HEADSET);
684 EXPECT_EQ(result, SUCCESS);
685 }
686
687 /**
688 * @tc.name : Test AudioSocketThread.
689 * @tc.number: AudioSocketThread_019
690 * @tc.desc : Test SetAudioPnpUevent with unsupported ANALOG_HSx state
691 */
692 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_019, TestSize.Level4)
693 {
694 AudioPnpUevent uevent = {
695 .action = "change",
696 .name = "headset",
697 .state = "unsupported",
698 .devType = "extcon3",
699 .subSystem = "audio",
700 .switchName = "h2w",
701 .switchState = "1",
702 .hidName = "hid",
703 .devName = "TestDevNameInvalid",
704 .anahsName = "anahs"
705 };
706
707 AudioEvent event;
708 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
709
710 EXPECT_EQ(result, ERROR);
711 }
712
713 /**
714 * @tc.name : Test AudioSocketThread.
715 * @tc.number: AudioSocketThread_020
716 * @tc.desc : Test SetAudioPnpUevent with switchState = '0' (REMOVE_AUDIO_DEVICE)
717 */
718 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_020, TestSize.Level4)
719 {
720 AudioPnpUevent uevent = {
721 .action = "remove",
722 .name = "TestDevice_Remove",
723 .state = "removed",
724 .devType = "headset",
725 .subSystem = "switch",
726 .switchName = "h2w",
727 .switchState = "0",
728 .hidName = "hid",
729 .devName = "TestDevName_Remove",
730 .anahsName = "anahs"
731 };
732
733 AudioEvent event;
734 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
735
736 EXPECT_EQ(result, SUCCESS);
737 EXPECT_EQ(event.name, "TestDevice_Remove");
738 EXPECT_EQ(event.address, "TestDevName_Remove");
739 }
740
741 /**
742 * @tc.name : Test AudioSocketThread.
743 * @tc.number: AudioSocketThread_029
744 * @tc.desc : Test AudioDpDetectDevice
745 */
746 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_029, TestSize.Level1)
747 {
748 AudioSocketThread audioSocketThread;
749 // Test case 1: Invalid parameter (NULL audioPnpUevent)
750 {
751 int32_t result = audioSocketThread.AudioDpDetectDevice(nullptr);
752 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
753 }
754 // Test case 2: Invalid subSystem
755 {
756 AudioPnpUevent uevent = {
757 .subSystem = "invalid",
758 .switchName = "hdmi_audio",
759 .action = "change",
760 .switchState = "1"
761 };
762 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
763 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
764 }
765 // Test case 3: Invalid switchName
766 {
767 AudioPnpUevent uevent = {
768 .subSystem = "switch",
769 .switchName = "invalid",
770 .action = "change",
771 .switchState = "1"
772 };
773 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
774 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
775 }
776 }
777
778 /**
779 * @tc.name : Test AudioSocketThread.
780 * @tc.number: AudioSocketThread_030
781 * @tc.desc : Test AudioDpDetectDevice
782 */
783 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_030, TestSize.Level1)
784 {
785 AudioSocketThread audioSocketThread;
786 // Test case 4: Invalid action
787 {
788 AudioPnpUevent uevent = {
789 .subSystem = "switch",
790 .switchName = "hdmi_audio",
791 .action = "invalid",
792 .switchState = "1"
793 };
794 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
795 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
796 }
797 // Test case 5: Device Add Event
798 {
799 AudioPnpUevent uevent = {
800 .subSystem = "switch",
801 .switchName = "hdmi_audio1device_port=1",
802 .action = "change",
803 .switchState = "1"
804 };
805 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
806 EXPECT_EQ(result, SUCCESS);
807 // Additional checks can be added here to verify the internal state
808 }
809 // Test case 6: Device Remove Event
810 {
811 AudioPnpUevent uevent = {
812 .subSystem = "switch",
813 .switchName = "hdmi_audio1device_port=1",
814 .action = "change",
815 .switchState = "0"
816 };
817 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
818 EXPECT_EQ(result, SUCCESS);
819 // Additional checks can be added here to verify the internal state
820 }
821 }
822
823 /**
824 * @tc.name : Test AudioSocketThread.
825 * @tc.number: AudioSocketThread_031
826 * @tc.desc : Test AudioDpDetectDevice
827 */
828 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_031, TestSize.Level1)
829 {
830 AudioSocketThread audioSocketThread;
831 // Test case 7: Invalid switchState
832 {
833 AudioPnpUevent uevent = {
834 .subSystem = "switch",
835 .switchName = "hdmi_audio1device_port=1",
836 .action = "change",
837 .switchState = "invalid"
838 };
839 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
840 EXPECT_EQ(result, ERROR);
841 }
842 // Test case 8: No device_port in switchName
843 {
844 AudioPnpUevent uevent = {
845 .subSystem = "switch",
846 .switchName = "hdmi_audio1",
847 .action = "change",
848 .switchState = "1"
849 };
850 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
851 EXPECT_EQ(result, SUCCESS);
852 }
853 }
854
855 /**
856 * @tc.name : Test AudioSocketThread.
857 * @tc.number: AudioSocketThread_032
858 * @tc.desc : Test AudioDpDetectDevice when same device state is reported again
859 */
860 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_032, TestSize.Level4)
861 {
862 AudioSocketThread audioSocketThread;
863
864 AudioPnpUevent uevent = {
865 .subSystem = "switch",
866 .switchName = "hdmi_audio1device_port=HDMI-0",
867 .action = "change",
868 .switchState = "1"};
869
870 auto ret = audioSocketThread.AudioDpDetectDevice(&uevent);
871 EXPECT_EQ(ret, SUCCESS);
872 EXPECT_EQ(audioSocketThread.AudioDpDetectDevice(&uevent), SUCCESS);
873 }
874
875 /**
876 * @tc.name : Test AudioSocketThread.
877 * @tc.number: AudioSocketThread_033
878 * @tc.desc : Test UpdateDeviceState
879 */
880 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_033, TestSize.Level1)
881 {
882 AudioSocketThread audioSocketThread;
883 //Test: No update required
884 AudioEvent noUpdateEvent = {1, 1, "device", "address", "anahs"};
885 AudioEvent audioSocketEvent_ = noUpdateEvent;
886 audioSocketThread.UpdateDeviceState(noUpdateEvent);
887 //Test: Successful update
888 AudioEvent successUpdateEvent = {1, 2, "device", "address", "anahs"};
889 audioSocketThread.UpdateDeviceState(successUpdateEvent);
890 //Test：snprintf_s failed
891 AudioEvent snprintfFailEvent = {1, 2, "device", "address", "anahs"};
892 audioSocketThread.UpdateDeviceState(snprintfFailEvent);
893 AudioEvent snprintfSuccessEvent = {1, 2, "device", "address", "anahs"};
894 audioSocketThread.UpdateDeviceState(snprintfSuccessEvent);
895 }
896
897 /**
898 * @tc.name : Test AudioSocketThread.
899 * @tc.number: AudioSocketThread_034
900 * @tc.desc : Test AudioAnalogHeadsetDetectDevice
901 */
902 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_034, TestSize.Level1)
903 {
904 AudioSocketThread audioSocketThread;
905 AudioPnpUevent audioPnpUevent = {
906 .action = "change",
907 .name = "headset",
908 .state = "analog_hs1",
909 .devType = "extcon",
910 .subSystem = "switch",
911 .switchName = "h2w",
912 .switchState = "on",
913 .hidName = "hid_name",
914 .devName = "test_dev_name",
915 .anahsName = "anahs_name"
916 };
917 EXPECT_EQ(audioSocketThread.AudioAnalogHeadsetDetectDevice(&audioPnpUevent), SUCCESS);
918 }
919
920 /**
921 * @tc.name : Test AudioSocketThread.
922 * @tc.number: AudioSocketThread_035
923 * @tc.desc : Test SetAudioPnpServerEventValue
924 */
925 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_035, TestSize.Level1)
926 {
927 AudioSocketThread audioSocketThread;
928 AudioPnpUevent audioPnpUevent = {
929 .action = "change",
930 .name = "headset",
931 .state = "analog_hs1",
932 .devType = "extcon",
933 .subSystem = "switch",
934 .switchName = "h2w",
935 .switchState = "on",
936 .hidName = "hid_name",
937 .devName = "dev_name",
938 .anahsName = "anahs_name"
939 };
940 AudioEvent audioEvent;
941
942 EXPECT_EQ(audioSocketThread.SetAudioPnpServerEventValue(&audioEvent, &audioPnpUevent), SUCCESS);
943 EXPECT_EQ(audioEvent.eventType, PNP_EVENT_DEVICE_ADD);
944 EXPECT_NE(audioEvent.deviceType, PNP_DEVICE_HEADSET);
945 EXPECT_EQ(audioEvent.name, "headset");
946 EXPECT_EQ(audioEvent.address, "dev_name");
947 }
948
949 /**
950 * @tc.name : Test AudioSocketThread.
951 * @tc.number: AudioSocketThread_036
952 * @tc.desc : Test SetAudioPnpServerEventValue
953 */
954 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_036, TestSize.Level1)
955 {
956 AudioSocketThread audioSocketThread;
957 AudioPnpUevent audioPnpUevent = {
958 .action = "change",
959 .name = "headset",
960 .state = "analog_hs0",
961 .devType = "extcon",
962 .subSystem = "not_switch",
963 .switchName = "h2w",
964 .switchState = "on",
965 .hidName = "hid_name",
966 .devName = "dev_name",
967 .anahsName = "anahs_name"
968 };
969 AudioEvent audioEvent;
970
971 EXPECT_NE(audioSocketThread.SetAudioPnpServerEventValue(&audioEvent, &audioPnpUevent), SUCCESS);
972 EXPECT_NE(audioEvent.eventType, PNP_EVENT_DEVICE_REMOVE);
973 EXPECT_NE(audioEvent.deviceType, PNP_DEVICE_HEADSET);
974 }
975
976 /**
977 * @tc.name : Test AudioSocketThread.
978 * @tc.number: AudioSocketThread_037
979 * @tc.desc : Test AudioAnahsDetectDevice
980 */
981 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_037, TestSize.Level1)
982 {
983 AudioSocketThread audioSocketThread;
984 // Test case 1: NULL input
985 EXPECT_EQ(HDF_ERR_INVALID_PARAM, audioSocketThread.AudioAnahsDetectDevice(nullptr));
986
987 // Test case 2: Valid input with UEVENT_INSERT
988 struct AudioPnpUevent validUeventInsert = {
989 .subSystem = UEVENT_PLATFORM,
990 .anahsName = UEVENT_INSERT
991 };
992 EXPECT_EQ(SUCCESS, audioSocketThread.AudioAnahsDetectDevice(&validUeventInsert));
993 EXPECT_STREQ(UEVENT_INSERT, AudioSocketThread::audioSocketEvent_.anahsName.c_str());
994
995 // Test case 3: Valid input with UEVENT_REMOVE
996 struct AudioPnpUevent validUeventRemove = {
997 .subSystem = UEVENT_PLATFORM,
998 .anahsName = UEVENT_REMOVE
999 };
1000 EXPECT_EQ(SUCCESS, audioSocketThread.AudioAnahsDetectDevice(&validUeventRemove));
1001 EXPECT_STREQ(UEVENT_REMOVE, AudioSocketThread::audioSocketEvent_.anahsName.c_str());
1002
1003 // Test case 4: Invalid subsystem
1004 struct AudioPnpUevent invalidSubsystem = {
1005 .subSystem = "invalid",
1006 .anahsName = UEVENT_INSERT
1007 };
1008 EXPECT_EQ(ERROR, audioSocketThread.AudioAnahsDetectDevice(&invalidSubsystem));
1009
1010 // Test case 5: Invalid anahsName
1011 struct AudioPnpUevent invalidAnahsName = {
1012 .subSystem = UEVENT_PLATFORM,
1013 .anahsName = "invalid"
1014 };
1015 EXPECT_EQ(ERROR, audioSocketThread.AudioAnahsDetectDevice(&invalidAnahsName));
1016
1017 // Test case 6: Same anahsName as previous event
1018 EXPECT_EQ(SUCCESS, audioSocketThread.AudioAnahsDetectDevice(&validUeventRemove));
1019 EXPECT_STREQ(UEVENT_REMOVE, AudioSocketThread::audioSocketEvent_.anahsName.c_str());
1020 }
1021
1022 /**
1023 * @tc.name : Test AudioSocketThread.
1024 * @tc.number: AudioSocketThread_038
1025 * @tc.desc : Test SetAudioPnpServerEventValue
1026 */
1027 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_038, TestSize.Level1)
1028 {
1029 AudioPnpUevent uevent = {
1030 .action = "change",
1031 .name = "headset",
1032 .state = "invalid",
1033 .devType = "extcon",
1034 .subSystem = "other",
1035 .switchName = "h2w",
1036 .switchState = "01",
1037 .hidName = "hid",
1038 .devName = "TestDevName",
1039 .anahsName = "anahs"
1040 };
1041 AudioEvent event;
1042 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
1043 EXPECT_EQ(result, ERROR);
1044 }
1045
1046 /**
1047 * @tc.name : Test AudioSocketThread.
1048 * @tc.number: AudioSocketThread_039
1049 * @tc.desc : Test AudioAnalogHeadsetDetectDevice
1050 */
1051 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_039, TestSize.Level1)
1052 {
1053 AudioSocketThread audioSocketThread;
1054 // Test case 1: NULL input
1055 EXPECT_EQ(HDF_ERR_INVALID_PARAM, audioSocketThread.AudioAnalogHeadsetDetectDevice(nullptr));
1056
1057 AudioPnpUevent audioPnpUevent = {
1058 .action = "add",
1059 .name = "TestDevice",
1060 .state = "added",
1061 .devType = "headset",
1062 .subSystem = "switch",
1063 .switchName = "h2w",
1064 .switchState = "1",
1065 .hidName = "hid",
1066 .devName = "TestDevName",
1067 .anahsName = "anahs"
1068 };
1069 int32_t ret = audioSocketThread.AudioAnalogHeadsetDetectDevice(&audioPnpUevent);
1070 EXPECT_EQ(ret, SUCCESS);
1071 }
1072
1073 /**
1074 * @tc.name : Test AudioSocketThread.
1075 * @tc.number: AudioSocketThread_040
1076 * @tc.desc : Test AudioHDMIDetectDevice
1077 */
1078 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_040, TestSize.Level1)
1079 {
1080 AudioSocketThread audioSocketThread;
1081 // Test case 1: Invalid parameter (NULL audioPnpUevent)
1082 {
1083 int32_t result = audioSocketThread.AudioHDMIDetectDevice(nullptr);
1084 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
1085 }
1086 // Test case 2: Invalid subSystem
1087 {
1088 AudioPnpUevent uevent = {
1089 .subSystem = "invalid",
1090 .switchName = "hdmi_mipi_audio",
1091 .action = "change",
1092 .switchState = "1"
1093 };
1094 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1095 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
1096 }
1097 // Test case 3: Invalid switchName
1098 {
1099 AudioPnpUevent uevent = {
1100 .subSystem = "switch",
1101 .switchName = "invalid",
1102 .action = "change",
1103 .switchState = "1"
1104 };
1105 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1106 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
1107 }
1108 }
1109
1110 /**
1111 * @tc.name : Test AudioSocketThread.
1112 * @tc.number: AudioSocketThread_041
1113 * @tc.desc : Test AudioHDMIDetectDevice
1114 */
1115 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_041, TestSize.Level1)
1116 {
1117 AudioSocketThread audioSocketThread;
1118 // Test case 4: Invalid action
1119 {
1120 AudioPnpUevent uevent = {
1121 .subSystem = "switch",
1122 .switchName = "hdmi_mipi_audio",
1123 .action = "invalid",
1124 .switchState = "1"
1125 };
1126 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1127 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
1128 }
1129 // Test case 5: Device Add Event
1130 {
1131 AudioPnpUevent uevent = {
1132 .subSystem = "switch",
1133 .switchName = "hdmi_mipi_audio,device_port=HDMI-0",
1134 .action = "change",
1135 .switchState = "1"
1136 };
1137 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1138 EXPECT_EQ(result, SUCCESS);
1139 // Additional checks can be added here to verify the internal state
1140 }
1141 // Test case 6: Device Remove Event
1142 {
1143 AudioPnpUevent uevent = {
1144 .subSystem = "switch",
1145 .switchName = "hdmi_mipi_audio,device_port=HDMI-0",
1146 .action = "change",
1147 .switchState = "0"
1148 };
1149 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1150 EXPECT_EQ(result, SUCCESS);
1151 // Additional checks can be added here to verify the internal state
1152 }
1153 }
1154
1155 /**
1156 * @tc.name : Test AudioSocketThread.
1157 * @tc.number: AudioSocketThread_042
1158 * @tc.desc : Test AudioHDMIDetectDevice
1159 */
1160 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_042, TestSize.Level1)
1161 {
1162 AudioSocketThread audioSocketThread;
1163 // Test case 7: Invalid switchState
1164 {
1165 AudioPnpUevent uevent = {
1166 .subSystem = "switch",
1167 .switchName = "hdmi_mipi_audio,device_port=HDMI-0",
1168 .action = "change",
1169 .switchState = "invalid"
1170 };
1171 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1172 EXPECT_EQ(result, ERROR);
1173 }
1174 // Test case 8: No device_port in switchName
1175 {
1176 AudioPnpUevent uevent = {
1177 .subSystem = "switch",
1178 .switchName = "hdmi_mipi_audio,",
1179 .action = "change",
1180 .switchState = "1"
1181 };
1182 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1183 EXPECT_EQ(result, SUCCESS);
1184 }
1185 }
1186
1187 /**
1188 * @tc.name : Test AudioSocketThread.
1189 * @tc.number: AudioSocketThread_043
1190 * @tc.desc : Test AudioAnalogHeadsetDetectDevice when device state is the same, should early return.
1191 */
1192 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_043, TestSize.Level4)
1193 {
1194 AudioSocketThread audioSocketThread;
1195
1196 AudioPnpUevent ueventInit = {
1197 .action = "add",
1198 .name = "SameDevice",
1199 .state = "added",
1200 .devType = "headset",
1201 .subSystem = "switch",
1202 .switchName = "h2w",
1203 .switchState = "1",
1204 .hidName = "hid",
1205 .devName = "SameDevAddress",
1206 .anahsName = "SameAnahs"
1207 };
1208
1209 auto ret = audioSocketThread.AudioAnalogHeadsetDetectDevice(&ueventInit);
1210 EXPECT_EQ(ret, SUCCESS);
1211 EXPECT_EQ(audioSocketThread.AudioAnalogHeadsetDetectDevice(&ueventInit), SUCCESS);
1212 }
1213
1214 /**
1215 * @tc.name : DetectAnalogHeadsetState_Headset_Remove
1216 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_003
1217 * @tc.desc : Test DetectAnalogHeadsetState function when headset is removed.
1218 */
1219 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Headset_Remove, TestSize.Level0)
1220 {
1221 AudioEvent audioEvent;
1222 // Act
1223 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1224
1225 // Assert
1226 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1227 }
1228
1229 /**
1230 * @tc.name : DetectDPState_Success_WhenStateAndNameValid
1231 * @tc.number: AudioSocketThreadTest_001
1232 * @tc.desc : Test DetectDPState function when state and name are valid.
1233 */
1234 HWTEST_F(AudioSocketThreadUnitTest, DetectDPState_Success_WhenStateAndNameValid, TestSize.Level0)
1235 {
1236 AudioEvent audioEvent;
1237 // Arrange
1238 audioEvent.eventType = PNP_EVENT_DEVICE_ADD;
1239 audioEvent.name = "testName";
1240
1241 // Act
1242 int32_t result = audioSocketThread_.DetectDPState(&audioEvent);
1243
1244 // Assert
1245 EXPECT_NE(result, SUCCESS);
1246 EXPECT_EQ(audioEvent.deviceType, 0);
1247 EXPECT_EQ(audioEvent.address, "");
1248 }
1249
1250 /**
1251 * @tc.name : DetectDPState_Fail_WhenStateInvalid
1252 * @tc.number: AudioSocketThreadTest_002
1253 * @tc.desc : Test DetectDPState function when state is invalid.
1254 */
1255 HWTEST_F(AudioSocketThreadUnitTest, DetectDPState_Fail_WhenStateInvalid, TestSize.Level0)
1256 {
1257 AudioEvent audioEvent;
1258 // Arrange
1259 audioEvent.eventType = PNP_EVENT_DEVICE_ADD;
1260 audioEvent.name = "testName";
1261
1262 // Act
1263 int32_t result = audioSocketThread_.DetectDPState(&audioEvent);
1264
1265 // Assert
1266 EXPECT_EQ(result, ERROR);
1267 }
1268
1269 /**
1270 * @tc.name : ReadAndScanDpState_Success_WhenFileContains1
1271 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpState_001
1272 * @tc.desc : Test ReadAndScanDpState function when file contains '1'
1273 */
1274 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpState_Success_WhenFileContains1, TestSize.Level0)
1275 {
1276 std::string testPath = "/tmp/test_path";
1277 // Given
1278 std::ofstream file(testPath);
1279 file << '1';
1280 file.close();
1281
1282 uint32_t eventType;
1283 // When
1284 int32_t ret = audioSocketThread_.ReadAndScanDpState(testPath, eventType);
1285
1286 // Then
1287 EXPECT_EQ(ret, SUCCESS);
1288 EXPECT_EQ(eventType, PNP_EVENT_DEVICE_ADD);
1289 }
1290
1291 /**
1292 * @tc.name : ReadAndScanDpState_Failure_WhenFileContainsInvalidChar
1293 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpState_002
1294 * @tc.desc : Test ReadAndScanDpState function when file contains invalid character (not '1' or '0')
1295 */
1296 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpState_Failure_WhenFileContainsInvalidChar, TestSize.Level4)
1297 {
1298 std::string testPath = "/tmp/test_path_invalid";
1299
1300 std::ofstream file(testPath);
1301 file << 'x';
1302 file.close();
1303
1304 uint32_t eventType = 0;
1305 int32_t ret = audioSocketThread_.ReadAndScanDpState(testPath, eventType);
1306
1307 EXPECT_EQ(ret, ERROR);
1308 }
1309
1310 /**
1311 * @tc.name : AudioNnDetectDevice_InvalidParam_Test
1312 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_001
1313 * @tc.desc : Test AudioNnDetectDevice function with invalid parameters.
1314 */
1315 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_InvalidParam_Test, TestSize.Level2)
1316 {
1317 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(NULL), -3);
1318 struct AudioPnpUevent audioPnpUevent;
1319 audioPnpUevent.action = "add";
1320 audioPnpUevent.name = "send_nn_state1";
1321 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), -3);
1322 audioPnpUevent.action = "change";
1323 audioPnpUevent.name = "test_send_nn_state1";
1324 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), -3);
1325 }
1326
1327 /**
1328 * @tc.name : AudioNnDetectDevice_ValidParam_Test
1329 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_002
1330 * @tc.desc : Test AudioNnDetectDevice function with valid parameters.
1331 */
1332 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_ValidParam_Test, TestSize.Level2)
1333 {
1334 struct AudioPnpUevent audioPnpUevent;
1335 audioPnpUevent.action = "change";
1336 audioPnpUevent.name = "send_nn_state1";
1337 EXPECT_NE(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), SUCCESS);
1338 }
1339
1340 /**
1341 * @tc.name : AudioNnDetectDevice_StateNotSupported_Test
1342 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_003
1343 * @tc.desc : Test AudioNnDetectDevice function with state not supported.
1344 */
1345 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_StateNotSupported_Test, TestSize.Level2)
1346 {
1347 struct AudioPnpUevent audioPnpUevent;
1348 audioPnpUevent.action = "change";
1349 audioPnpUevent.name = "send_nn_state00";
1350 EXPECT_NE(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), SUCCESS);
1351 }
1352
1353 /**
1354 * @tc.name : AudioNnDetectDevice_StateNnOff_Test
1355 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_004
1356 * @tc.desc : Test AudioNnDetectDevice function with state nn off.
1357 */
1358 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_StateNnOff_Test, TestSize.Level2)
1359 {
1360 struct AudioPnpUevent audioPnpUevent;
1361 audioPnpUevent.action = "change";
1362 audioPnpUevent.name = "send_nn_state01";
1363 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), STATE_NN_OFF);
1364 }
1365
1366 /**
1367 * @tc.name : AudioNnDetectDevice_StateNnOn_Test
1368 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_005
1369 * @tc.desc : Test AudioNnDetectDevice function with state nn on.
1370 */
1371 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_StateNnOn_Test, TestSize.Level2)
1372 {
1373 struct AudioPnpUevent audioPnpUevent;
1374 audioPnpUevent.action = "change";
1375 audioPnpUevent.name = "send_nn_state02";
1376 EXPECT_NE(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), SUCCESS);
1377 }
1378
1379 /**
1380 * @tc.name : AudioNnDetectDevice_InvalidState_Test
1381 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_006
1382 * @tc.desc : Test AudioNnDetectDevice function with invalid state.
1383 */
1384 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_InvalidState_Test, TestSize.Level2)
1385 {
1386 struct AudioPnpUevent audioPnpUevent;
1387 audioPnpUevent.action = "change";
1388 audioPnpUevent.name = "send_nn_state04";
1389 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), HDF_ERR_INVALID_PARAM);
1390 }
1391
1392 /**
1393 * @tc.name : AudioNnDetectDevice_SendNnStateChangeCallback_Failed_Test
1394 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_007
1395 * @tc.desc : Test AudioNnDetectDevice function with failed SendNnStateChangeCallback.
1396 */
1397 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_SendNnStateChangeCallback_Failed_Test, TestSize.Level2)
1398 {
1399 struct AudioPnpUevent audioPnpUevent;
1400 audioPnpUevent.action = "change";
1401 audioPnpUevent.name = "send_nn_state03";
1402 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), HDF_ERR_INVALID_PARAM);
1403 }
1404
1405 /**
1406 * @tc.name : AudioPnpUeventParse_Test_01
1407 * @tc.number: Audio_AudioPnpUeventParse_001
1408 * @tc.desc : Test AudioPnpUeventParse function when msg starts with "libudev"
1409 */
1410 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_001, TestSize.Level0)
1411 {
1412 const char *msg = "libudev";
1413 ssize_t strLength = strlen(msg);
1414 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1415 }
1416
1417 /**
1418 * @tc.name : AudioPnpUeventParse_Test_02
1419 * @tc.number: Audio_AudioPnpUeventParse_002
1420 * @tc.desc : Test AudioPnpUeventParse function when strLength > UEVENT_MSG_LEN + 1
1421 */
1422 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_002, TestSize.Level0)
1423 {
1424 const char *msg = "test message";
1425 ssize_t strLength = UEVENT_MSG_LEN + 2;
1426 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1427 }
1428
1429 /**
1430 * @tc.name : AudioPnpUeventParse_Test_03
1431 * @tc.number: Audio_AudioPnpUeventParse_003
1432 * @tc.desc : Test AudioPnpUeventParse function when no matching UEVENT_ARR_SIZE is found
1433 */
1434 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_003, TestSize.Level0)
1435 {
1436 const char *msg = "unmatched event";
1437 ssize_t strLength = strlen(msg);
1438 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1439 }
1440
1441 /**
1442 * @tc.name : AudioPnpUeventParse_Test_04
1443 * @tc.number: Audio_AudioPnpUeventParse_004
1444 * @tc.desc : Test AudioPnpUeventParse function when all detect devices return SUCCESS
1445 */
1446 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_004, TestSize.Level0)
1447 {
1448 const char *msg = "matched event";
1449 ssize_t strLength = strlen(msg);
1450 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1451 }
1452
1453 /**
1454 * @tc.name : AudioPnpUeventParse_Test_05
1455 * @tc.number: Audio_AudioPnpUeventParse_005
1456 * @tc.desc : Cover branch where *msgTmp == '\0' to test skip behavior
1457 */
1458 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_005, TestSize.Level4)
1459 {
1460 AudioSocketThread audioSocketThread;
1461
1462 std::vector<char> msgVec;
1463 const char *seg1 = "ACTION=change";
1464 const char *seg2 = "";
1465 const char *seg3 = "NAME=mic_blocked";
1466 msgVec.insert(msgVec.end(), seg1, seg1 + strlen(seg1) + 1);
1467 msgVec.insert(msgVec.end(), seg2, seg2 + strlen(seg2) + 1);
1468 msgVec.insert(msgVec.end(), seg3, seg3 + strlen(seg3) + 1);
1469
1470 ssize_t strLength = msgVec.size();
1471 const char *msg = msgVec.data();
1472
1473 EXPECT_EQ(audioSocketThread.AudioPnpUeventParse(msg, strLength), true);
1474 }
1475
1476 /**
1477 * @tc.name : DetectAnalogHeadsetState_Fail_OpenFile
1478 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_001
1479 * @tc.desc : Test DetectAnalogHeadsetState function when open file fail.
1480 */
1481 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Fail_OpenFile, TestSize.Level0)
1482 {
1483 std::ofstream ofs;
1484 ofs.open(SWITCH_STATE_PATH, std::ofstream::out);
1485 ofs.close();
1486 unlink(SWITCH_STATE_PATH);
1487 AudioEvent audioEvent;
1488 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1489 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1490 }
1491
1492 /**
1493 * @tc.name : DetectAnalogHeadsetState_Fail_ReadFile
1494 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_002
1495 * @tc.desc : Test DetectAnalogHeadsetState function when read file fail.
1496 */
1497 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Fail_ReadFile, TestSize.Level0)
1498 {
1499 std::ofstream ofs(SWITCH_STATE_PATH);
1500 ofs.close();
1501 AudioEvent audioEvent;
1502 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1503 EXPECT_NE(ret, SUCCESS);
1504 }
1505
1506 /**
1507 * @tc.name : DetectAnalogHeadsetState_Headset_Remove_003
1508 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_003
1509 * @tc.desc : Test DetectAnalogHeadsetState function when headset is removed.
1510 */
1511 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Headset_Remove_003, TestSize.Level0)
1512 {
1513 AudioEvent audioEvent;
1514 audioSocketThread_.SetAudioPnpUevent(&audioEvent, REMOVE_AUDIO_DEVICE);
1515 EXPECT_EQ(audioEvent.eventType, PNP_EVENT_DEVICE_REMOVE);
1516 }
1517
1518 /**
1519 * @tc.name : DetectAnalogHeadsetState_Headset_Add_004
1520 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_004
1521 * @tc.desc : Test DetectAnalogHeadsetState function when headset is added.
1522 */
1523 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Headset_Add_004, TestSize.Level0)
1524 {
1525 AudioEvent audioEvent;
1526 audioSocketThread_.SetAudioPnpUevent(&audioEvent, ADD_DEVICE_HEADSET);
1527 EXPECT_EQ(audioEvent.eventType, PNP_EVENT_DEVICE_ADD);
1528 }
1529
1530 /**
1531 * @tc.name : ReadAndScanDpName_Success_WhenFileExists
1532 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_001
1533 * @tc.desc : Test ReadAndScanDpName function when file exists and can be read successfully.
1534 */
1535 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Success_WhenFileExists, TestSize.Level0)
1536 {
1537 std::string testPath = "/tmp/test_path";
1538 std::string testName = "test_name";
1539 std::ofstream file(testPath);
1540 file << testName;
1541 file.close();
1542 std::string name;
1543 int32_t ret = audioSocketThread_.ReadAndScanDpName(testPath, name);
1544 EXPECT_EQ(ret, ERROR);
1545 remove(testPath.c_str());
1546 }
1547
1548 /**
1549 * @tc.name : ReadAndScanDpName_Fail_WhenFileNotExists
1550 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_002
1551 * @tc.desc : Test ReadAndScanDpName function when file does not exist.
1552 */
1553 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Fail_WhenFileNotExists, TestSize.Level0)
1554 {
1555 std::string testPath = "/tmp/test_path";
1556 std::string testName = "test_name";
1557 std::ofstream file(testPath);
1558 file << testName;
1559 file.close();
1560 std::string name;
1561 int32_t ret = audioSocketThread_.ReadAndScanDpName("/invalid/path", name);
1562 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1563 remove(testPath.c_str());
1564 }
1565
1566 /**
1567 * @tc.name : ReadAndScanDpName_Fail_WhenFileReadFails
1568 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_003
1569 * @tc.desc : Test ReadAndScanDpName function when file read fails.
1570 */
1571 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Fail_WhenFileReadFails, TestSize.Level0)
1572 {
1573 std::string testPath = "/tmp/test_path";
1574 std::string testName = "test_name";
1575 std::ofstream file(testPath);
1576 file << testName;
1577 file.close();
1578 std::string name;
1579 int32_t ret = audioSocketThread_.ReadAndScanDpName("/dev/null", name);
1580 EXPECT_EQ(ret, ERROR);
1581 remove(testPath.c_str());
1582 }
1583
1584 /**
1585 * @tc.name : ReadAndScanDpName_Fail_WhenDevicePortNotFound
1586 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_004
1587 * @tc.desc : Test ReadAndScanDpName function when device port not found in file content.
1588 */
1589 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Fail_WhenDevicePortNotFound, TestSize.Level0)
1590 {
1591 std::string testName = "invalid_name";
1592 std::string testPath = "/tmp/test_path";
1593 std::ofstream file(testPath);
1594 file << testName;
1595 file.close();
1596
1597 std::string name;
1598 int32_t ret = audioSocketThread_.ReadAndScanDpName(testPath, name);
1599 EXPECT_NE(ret, SUCCESS);
1600 remove(testPath.c_str());
1601 }
1602
1603 /**
1604 * @tc.name : ReadAndScanDpName_Success_WhenDevicePortFound
1605 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_005
1606 * @tc.desc : Test ReadAndScanDpName function when device port string exists and ends with '\n'.
1607 */
1608 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Success_WhenDevicePortFound, TestSize.Level4)
1609 {
1610 std::string testPath = "/tmp/test_path";
1611 std::string testContent = "some_prefix" + std::string(DEVICE_PORT) + "dp-name\n";
1612 std::ofstream file(testPath);
1613 file << testContent;
1614 file.close();
1615
1616 std::string name;
1617 int32_t ret = audioSocketThread_.ReadAndScanDpName(testPath, name);
1618
1619 EXPECT_EQ(ret, SUCCESS);
1620 EXPECT_EQ(name, "dp-name");
1621 remove(testPath.c_str());
1622 }
1623
1624 /**
1625 * @tc.name : Test AudioSocketThread
1626 * @tc.number: AudioSocketThread_101
1627 * @tc.desc : Test AudioSocketThread
1628 */
1629 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_101, TestSize.Level0)
1630 {
1631 auto audioSocketThread = std::make_shared<AudioSocketThread>();
1632 EXPECT_NE(audioSocketThread, nullptr);
1633
1634 struct AudioPnpUevent *audioPnpUevent = nullptr;
1635 auto ret = audioSocketThread->AudioMicBlockDevice(audioPnpUevent);
1636 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1637 }
1638
1639 /**
1640 * @tc.name : Test AudioSocketThread
1641 * @tc.number: AudioSocketThread_102
1642 * @tc.desc : Test AudioSocketThread
1643 */
1644 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_102, TestSize.Level0)
1645 {
1646 auto audioSocketThread = std::make_shared<AudioSocketThread>();
1647 EXPECT_NE(audioSocketThread, nullptr);
1648
1649 struct AudioPnpUevent *audioPnpUevent = new AudioPnpUevent();
1650 EXPECT_NE(audioPnpUevent, nullptr);
1651 audioPnpUevent->name = "mic_blocked";
1652 auto ret = audioSocketThread->AudioMicBlockDevice(audioPnpUevent);
1653 EXPECT_EQ(ret, SUCCESS);
1654
1655 if (audioPnpUevent != nullptr) {
1656 delete audioPnpUevent;
1657 audioPnpUevent = nullptr;
1658 }
1659 }
1660
1661 /**
1662 * @tc.name : Test AudioSocketThread
1663 * @tc.number: AudioSocketThread_103
1664 * @tc.desc : Test AudioMicBlockDevice with "mic_un_blocked"
1665 */
1666 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_103, TestSize.Level4)
1667 {
1668 auto audioSocketThread = std::make_shared<AudioSocketThread>();
1669 EXPECT_NE(audioSocketThread, nullptr);
1670
1671 struct AudioPnpUevent *audioPnpUevent = new AudioPnpUevent();
1672 EXPECT_NE(audioPnpUevent, nullptr);
1673 audioPnpUevent->name = "mic_un_blocked";
1674 int32_t ret = audioSocketThread->AudioMicBlockDevice(audioPnpUevent);
1675 EXPECT_EQ(ret, SUCCESS);
1676 delete audioPnpUevent;
1677 }
1678 } // namespace AudioStandard
1679 } // namespace OHOS
1680