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_HEADSET);
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_029
634 * @tc.desc : Test AudioDpDetectDevice
635 */
636 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_029, TestSize.Level1)
637 {
638 AudioSocketThread audioSocketThread;
639 // Test case 1: Invalid parameter (NULL audioPnpUevent)
640 {
641 int32_t result = audioSocketThread.AudioDpDetectDevice(nullptr);
642 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
643 }
644 // Test case 2: Invalid subSystem
645 {
646 AudioPnpUevent uevent = {
647 .subSystem = "invalid",
648 .switchName = "hdmi_audio",
649 .action = "change",
650 .switchState = "1"
651 };
652 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
653 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
654 }
655 // Test case 3: Invalid switchName
656 {
657 AudioPnpUevent uevent = {
658 .subSystem = "switch",
659 .switchName = "invalid",
660 .action = "change",
661 .switchState = "1"
662 };
663 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
664 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
665 }
666 }
667
668 /**
669 * @tc.name : Test AudioSocketThread.
670 * @tc.number: AudioSocketThread_030
671 * @tc.desc : Test AudioDpDetectDevice
672 */
673 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_030, TestSize.Level1)
674 {
675 AudioSocketThread audioSocketThread;
676 // Test case 4: Invalid action
677 {
678 AudioPnpUevent uevent = {
679 .subSystem = "switch",
680 .switchName = "hdmi_audio",
681 .action = "invalid",
682 .switchState = "1"
683 };
684 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
685 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
686 }
687 // Test case 5: Device Add Event
688 {
689 AudioPnpUevent uevent = {
690 .subSystem = "switch",
691 .switchName = "hdmi_audio1device_port=1",
692 .action = "change",
693 .switchState = "1"
694 };
695 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
696 EXPECT_EQ(result, SUCCESS);
697 // Additional checks can be added here to verify the internal state
698 }
699 // Test case 6: Device Remove Event
700 {
701 AudioPnpUevent uevent = {
702 .subSystem = "switch",
703 .switchName = "hdmi_audio1device_port=1",
704 .action = "change",
705 .switchState = "0"
706 };
707 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
708 EXPECT_EQ(result, SUCCESS);
709 // Additional checks can be added here to verify the internal state
710 }
711 }
712
713 /**
714 * @tc.name : Test AudioSocketThread.
715 * @tc.number: AudioSocketThread_031
716 * @tc.desc : Test AudioDpDetectDevice
717 */
718 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_031, TestSize.Level1)
719 {
720 AudioSocketThread audioSocketThread;
721 // Test case 7: Invalid switchState
722 {
723 AudioPnpUevent uevent = {
724 .subSystem = "switch",
725 .switchName = "hdmi_audio1device_port=1",
726 .action = "change",
727 .switchState = "invalid"
728 };
729 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
730 EXPECT_EQ(result, ERROR);
731 }
732 // Test case 8: No device_port in switchName
733 {
734 AudioPnpUevent uevent = {
735 .subSystem = "switch",
736 .switchName = "hdmi_audio1",
737 .action = "change",
738 .switchState = "1"
739 };
740 int32_t result = audioSocketThread.AudioDpDetectDevice(&uevent);
741 EXPECT_EQ(result, SUCCESS);
742 }
743 }
744
745 /**
746 * @tc.name : Test AudioSocketThread.
747 * @tc.number: AudioSocketThread_033
748 * @tc.desc : Test UpdateDeviceState
749 */
750 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_033, TestSize.Level1)
751 {
752 AudioSocketThread audioSocketThread;
753 //Test: No update required
754 AudioEvent noUpdateEvent = {1, 1, "device", "address", "anahs"};
755 AudioEvent audioSocketEvent_ = noUpdateEvent;
756 audioSocketThread.UpdateDeviceState(noUpdateEvent);
757 //Test: Successful update
758 AudioEvent successUpdateEvent = {1, 2, "device", "address", "anahs"};
759 audioSocketThread.UpdateDeviceState(successUpdateEvent);
760 //Test：snprintf_s failed
761 AudioEvent snprintfFailEvent = {1, 2, "device", "address", "anahs"};
762 audioSocketThread.UpdateDeviceState(snprintfFailEvent);
763 AudioEvent snprintfSuccessEvent = {1, 2, "device", "address", "anahs"};
764 audioSocketThread.UpdateDeviceState(snprintfSuccessEvent);
765 }
766
767 /**
768 * @tc.name : Test AudioSocketThread.
769 * @tc.number: AudioSocketThread_034
770 * @tc.desc : Test AudioAnalogHeadsetDetectDevice
771 */
772 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_034, TestSize.Level1)
773 {
774 AudioSocketThread audioSocketThread;
775 AudioPnpUevent audioPnpUevent = {
776 .action = "change",
777 .name = "headset",
778 .state = "analog_hs1",
779 .devType = "extcon",
780 .subSystem = "switch",
781 .switchName = "h2w",
782 .switchState = "on",
783 .hidName = "hid_name",
784 .devName = "test_dev_name",
785 .anahsName = "anahs_name"
786 };
787 EXPECT_EQ(audioSocketThread.AudioAnalogHeadsetDetectDevice(&audioPnpUevent), SUCCESS);
788 }
789
790 /**
791 * @tc.name : Test AudioSocketThread.
792 * @tc.number: AudioSocketThread_035
793 * @tc.desc : Test SetAudioPnpServerEventValue
794 */
795 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_035, TestSize.Level1)
796 {
797 AudioSocketThread audioSocketThread;
798 AudioPnpUevent audioPnpUevent = {
799 .action = "change",
800 .name = "headset",
801 .state = "analog_hs1",
802 .devType = "extcon",
803 .subSystem = "switch",
804 .switchName = "h2w",
805 .switchState = "on",
806 .hidName = "hid_name",
807 .devName = "dev_name",
808 .anahsName = "anahs_name"
809 };
810 AudioEvent audioEvent;
811
812 EXPECT_EQ(audioSocketThread.SetAudioPnpServerEventValue(&audioEvent, &audioPnpUevent), SUCCESS);
813 EXPECT_EQ(audioEvent.eventType, PNP_EVENT_DEVICE_ADD);
814 EXPECT_NE(audioEvent.deviceType, PNP_DEVICE_HEADSET);
815 EXPECT_EQ(audioEvent.name, "headset");
816 EXPECT_EQ(audioEvent.address, "dev_name");
817 }
818
819 /**
820 * @tc.name : Test AudioSocketThread.
821 * @tc.number: AudioSocketThread_036
822 * @tc.desc : Test SetAudioPnpServerEventValue
823 */
824 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_036, TestSize.Level1)
825 {
826 AudioSocketThread audioSocketThread;
827 AudioPnpUevent audioPnpUevent = {
828 .action = "change",
829 .name = "headset",
830 .state = "analog_hs0",
831 .devType = "extcon",
832 .subSystem = "not_switch",
833 .switchName = "h2w",
834 .switchState = "on",
835 .hidName = "hid_name",
836 .devName = "dev_name",
837 .anahsName = "anahs_name"
838 };
839 AudioEvent audioEvent;
840
841 EXPECT_NE(audioSocketThread.SetAudioPnpServerEventValue(&audioEvent, &audioPnpUevent), SUCCESS);
842 EXPECT_NE(audioEvent.eventType, PNP_EVENT_DEVICE_REMOVE);
843 EXPECT_NE(audioEvent.deviceType, PNP_DEVICE_HEADSET);
844 }
845
846 /**
847 * @tc.name : Test AudioSocketThread.
848 * @tc.number: AudioSocketThread_037
849 * @tc.desc : Test AudioAnahsDetectDevice
850 */
851 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_037, TestSize.Level1)
852 {
853 AudioSocketThread audioSocketThread;
854 // Test case 1: NULL input
855 EXPECT_EQ(HDF_ERR_INVALID_PARAM, audioSocketThread.AudioAnahsDetectDevice(nullptr));
856
857 // Test case 2: Valid input with UEVENT_INSERT
858 struct AudioPnpUevent validUeventInsert = {
859 .subSystem = UEVENT_PLATFORM,
860 .anahsName = UEVENT_INSERT
861 };
862 EXPECT_EQ(SUCCESS, audioSocketThread.AudioAnahsDetectDevice(&validUeventInsert));
863 EXPECT_STREQ(UEVENT_INSERT, AudioSocketThread::audioSocketEvent_.anahsName.c_str());
864
865 // Test case 3: Valid input with UEVENT_REMOVE
866 struct AudioPnpUevent validUeventRemove = {
867 .subSystem = UEVENT_PLATFORM,
868 .anahsName = UEVENT_REMOVE
869 };
870 EXPECT_EQ(SUCCESS, audioSocketThread.AudioAnahsDetectDevice(&validUeventRemove));
871 EXPECT_STREQ(UEVENT_REMOVE, AudioSocketThread::audioSocketEvent_.anahsName.c_str());
872
873 // Test case 4: Invalid subsystem
874 struct AudioPnpUevent invalidSubsystem = {
875 .subSystem = "invalid",
876 .anahsName = UEVENT_INSERT
877 };
878 EXPECT_EQ(ERROR, audioSocketThread.AudioAnahsDetectDevice(&invalidSubsystem));
879
880 // Test case 5: Invalid anahsName
881 struct AudioPnpUevent invalidAnahsName = {
882 .subSystem = UEVENT_PLATFORM,
883 .anahsName = "invalid"
884 };
885 EXPECT_EQ(ERROR, audioSocketThread.AudioAnahsDetectDevice(&invalidAnahsName));
886
887 // Test case 6: Same anahsName as previous event
888 EXPECT_EQ(SUCCESS, audioSocketThread.AudioAnahsDetectDevice(&validUeventRemove));
889 EXPECT_STREQ(UEVENT_REMOVE, AudioSocketThread::audioSocketEvent_.anahsName.c_str());
890 }
891
892 /**
893 * @tc.name : Test AudioSocketThread.
894 * @tc.number: AudioSocketThread_038
895 * @tc.desc : Test SetAudioPnpServerEventValue
896 */
897 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_038, TestSize.Level1)
898 {
899 AudioPnpUevent uevent = {
900 .action = "change",
901 .name = "headset",
902 .state = "invalid",
903 .devType = "extcon",
904 .subSystem = "other",
905 .switchName = "h2w",
906 .switchState = "01",
907 .hidName = "hid",
908 .devName = "TestDevName",
909 .anahsName = "anahs"
910 };
911 AudioEvent event;
912 int32_t result = AudioSocketThread::SetAudioPnpServerEventValue(&event, &uevent);
913 EXPECT_EQ(result, ERROR);
914 }
915
916 /**
917 * @tc.name : Test AudioSocketThread.
918 * @tc.number: AudioSocketThread_039
919 * @tc.desc : Test AudioAnalogHeadsetDetectDevice
920 */
921 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_039, TestSize.Level1)
922 {
923 AudioSocketThread audioSocketThread;
924 // Test case 1: NULL input
925 EXPECT_EQ(HDF_ERR_INVALID_PARAM, audioSocketThread.AudioAnalogHeadsetDetectDevice(nullptr));
926
927 AudioPnpUevent audioPnpUevent = {
928 .action = "add",
929 .name = "TestDevice",
930 .state = "added",
931 .devType = "headset",
932 .subSystem = "switch",
933 .switchName = "h2w",
934 .switchState = "1",
935 .hidName = "hid",
936 .devName = "TestDevName",
937 .anahsName = "anahs"
938 };
939 int32_t ret = audioSocketThread.AudioAnalogHeadsetDetectDevice(&audioPnpUevent);
940 EXPECT_EQ(ret, SUCCESS);
941 }
942
943 /**
944 * @tc.name : Test AudioSocketThread.
945 * @tc.number: AudioSocketThread_040
946 * @tc.desc : Test AudioHDMIDetectDevice
947 */
948 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_040, TestSize.Level1)
949 {
950 AudioSocketThread audioSocketThread;
951 // Test case 1: Invalid parameter (NULL audioPnpUevent)
952 {
953 int32_t result = audioSocketThread.AudioHDMIDetectDevice(nullptr);
954 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
955 }
956 // Test case 2: Invalid subSystem
957 {
958 AudioPnpUevent uevent = {
959 .subSystem = "invalid",
960 .switchName = "hdmi_mipi_audio",
961 .action = "change",
962 .switchState = "1"
963 };
964 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
965 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
966 }
967 // Test case 3: Invalid switchName
968 {
969 AudioPnpUevent uevent = {
970 .subSystem = "switch",
971 .switchName = "invalid",
972 .action = "change",
973 .switchState = "1"
974 };
975 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
976 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
977 }
978 }
979
980 /**
981 * @tc.name : Test AudioSocketThread.
982 * @tc.number: AudioSocketThread_041
983 * @tc.desc : Test AudioHDMIDetectDevice
984 */
985 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_041, TestSize.Level1)
986 {
987 AudioSocketThread audioSocketThread;
988 // Test case 4: Invalid action
989 {
990 AudioPnpUevent uevent = {
991 .subSystem = "switch",
992 .switchName = "hdmi_mipi_audio",
993 .action = "invalid",
994 .switchState = "1"
995 };
996 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
997 EXPECT_EQ(result, HDF_ERR_INVALID_PARAM);
998 }
999 // Test case 5: Device Add Event
1000 {
1001 AudioPnpUevent uevent = {
1002 .subSystem = "switch",
1003 .switchName = "hdmi_mipi_audio,device_port=HDMI-0",
1004 .action = "change",
1005 .switchState = "1"
1006 };
1007 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1008 EXPECT_EQ(result, SUCCESS);
1009 // Additional checks can be added here to verify the internal state
1010 }
1011 // Test case 6: Device Remove Event
1012 {
1013 AudioPnpUevent uevent = {
1014 .subSystem = "switch",
1015 .switchName = "hdmi_mipi_audio,device_port=HDMI-0",
1016 .action = "change",
1017 .switchState = "0"
1018 };
1019 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1020 EXPECT_EQ(result, SUCCESS);
1021 // Additional checks can be added here to verify the internal state
1022 }
1023 }
1024
1025 /**
1026 * @tc.name : Test AudioSocketThread.
1027 * @tc.number: AudioSocketThread_042
1028 * @tc.desc : Test AudioHDMIDetectDevice
1029 */
1030 HWTEST_F(AudioSocketThreadUnitTest, AudioSocketThread_042, TestSize.Level1)
1031 {
1032 AudioSocketThread audioSocketThread;
1033 // Test case 7: Invalid switchState
1034 {
1035 AudioPnpUevent uevent = {
1036 .subSystem = "switch",
1037 .switchName = "hdmi_mipi_audio,device_port=HDMI-0",
1038 .action = "change",
1039 .switchState = "invalid"
1040 };
1041 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1042 EXPECT_EQ(result, ERROR);
1043 }
1044 // Test case 8: No device_port in switchName
1045 {
1046 AudioPnpUevent uevent = {
1047 .subSystem = "switch",
1048 .switchName = "hdmi_mipi_audio,",
1049 .action = "change",
1050 .switchState = "1"
1051 };
1052 int32_t result = audioSocketThread.AudioHDMIDetectDevice(&uevent);
1053 EXPECT_EQ(result, SUCCESS);
1054 }
1055 }
1056
1057 /**
1058 * @tc.name : DetectAnalogHeadsetState_Headset_Remove
1059 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_003
1060 * @tc.desc : Test DetectAnalogHeadsetState function when headset is removed.
1061 */
1062 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Headset_Remove, TestSize.Level0)
1063 {
1064 AudioEvent audioEvent;
1065 // Act
1066 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1067
1068 // Assert
1069 EXPECT_NE(ret, SUCCESS);
1070 }
1071
1072 /**
1073 * @tc.name : DetectDPState_Success_WhenStateAndNameValid
1074 * @tc.number: AudioSocketThreadTest_001
1075 * @tc.desc : Test DetectDPState function when state and name are valid.
1076 */
1077 HWTEST_F(AudioSocketThreadUnitTest, DetectDPState_Success_WhenStateAndNameValid, TestSize.Level0)
1078 {
1079 AudioEvent audioEvent;
1080 // Arrange
1081 audioEvent.eventType = PNP_EVENT_DEVICE_ADD;
1082 audioEvent.name = "testName";
1083
1084 // Act
1085 int32_t result = audioSocketThread_.DetectDPState(&audioEvent);
1086
1087 // Assert
1088 EXPECT_NE(result, SUCCESS);
1089 EXPECT_EQ(audioEvent.deviceType, 0);
1090 EXPECT_EQ(audioEvent.address, "");
1091 }
1092
1093 /**
1094 * @tc.name : DetectDPState_Fail_WhenStateInvalid
1095 * @tc.number: AudioSocketThreadTest_002
1096 * @tc.desc : Test DetectDPState function when state is invalid.
1097 */
1098 HWTEST_F(AudioSocketThreadUnitTest, DetectDPState_Fail_WhenStateInvalid, TestSize.Level0)
1099 {
1100 AudioEvent audioEvent;
1101 // Arrange
1102 audioEvent.eventType = PNP_EVENT_DEVICE_ADD;
1103 audioEvent.name = "testName";
1104
1105 // Act
1106 int32_t result = audioSocketThread_.DetectDPState(&audioEvent);
1107
1108 // Assert
1109 EXPECT_EQ(result, ERROR);
1110 }
1111
1112 /**
1113 * @tc.name : ReadAndScanDpState_Success_WhenFileContains1
1114 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpState_001
1115 * @tc.desc : Test ReadAndScanDpState function when file contains '1'
1116 */
1117 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpState_Success_WhenFileContains1, TestSize.Level0)
1118 {
1119 std::string testPath = "/tmp/test_path";
1120 // Given
1121 std::ofstream file(testPath);
1122 file << '1';
1123 file.close();
1124
1125 uint32_t eventType;
1126 // When
1127 int32_t ret = audioSocketThread_.ReadAndScanDpState(testPath, eventType);
1128
1129 // Then
1130 EXPECT_EQ(ret, SUCCESS);
1131 EXPECT_EQ(eventType, PNP_EVENT_DEVICE_ADD);
1132 }
1133
1134 /**
1135 * @tc.name : AudioNnDetectDevice_InvalidParam_Test
1136 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_001
1137 * @tc.desc : Test AudioNnDetectDevice function with invalid parameters.
1138 */
1139 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_InvalidParam_Test, TestSize.Level2)
1140 {
1141 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(NULL), -3);
1142 struct AudioPnpUevent audioPnpUevent;
1143 audioPnpUevent.action = "add";
1144 audioPnpUevent.name = "send_nn_state1";
1145 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), -3);
1146 audioPnpUevent.action = "change";
1147 audioPnpUevent.name = "test_send_nn_state1";
1148 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), -3);
1149 }
1150
1151 /**
1152 * @tc.name : AudioNnDetectDevice_ValidParam_Test
1153 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_002
1154 * @tc.desc : Test AudioNnDetectDevice function with valid parameters.
1155 */
1156 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_ValidParam_Test, TestSize.Level2)
1157 {
1158 struct AudioPnpUevent audioPnpUevent;
1159 audioPnpUevent.action = "change";
1160 audioPnpUevent.name = "send_nn_state1";
1161 EXPECT_NE(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), SUCCESS);
1162 }
1163
1164 /**
1165 * @tc.name : AudioNnDetectDevice_StateNotSupported_Test
1166 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_003
1167 * @tc.desc : Test AudioNnDetectDevice function with state not supported.
1168 */
1169 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_StateNotSupported_Test, TestSize.Level2)
1170 {
1171 struct AudioPnpUevent audioPnpUevent;
1172 audioPnpUevent.action = "change";
1173 audioPnpUevent.name = "send_nn_state00";
1174 EXPECT_NE(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), SUCCESS);
1175 }
1176
1177 /**
1178 * @tc.name : AudioNnDetectDevice_StateNnOff_Test
1179 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_004
1180 * @tc.desc : Test AudioNnDetectDevice function with state nn off.
1181 */
1182 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_StateNnOff_Test, TestSize.Level2)
1183 {
1184 struct AudioPnpUevent audioPnpUevent;
1185 audioPnpUevent.action = "change";
1186 audioPnpUevent.name = "send_nn_state01";
1187 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), STATE_NN_OFF);
1188 }
1189
1190 /**
1191 * @tc.name : AudioNnDetectDevice_StateNnOn_Test
1192 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_005
1193 * @tc.desc : Test AudioNnDetectDevice function with state nn on.
1194 */
1195 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_StateNnOn_Test, TestSize.Level2)
1196 {
1197 struct AudioPnpUevent audioPnpUevent;
1198 audioPnpUevent.action = "change";
1199 audioPnpUevent.name = "send_nn_state02";
1200 EXPECT_NE(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), SUCCESS);
1201 }
1202
1203 /**
1204 * @tc.name : AudioNnDetectDevice_InvalidState_Test
1205 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_006
1206 * @tc.desc : Test AudioNnDetectDevice function with invalid state.
1207 */
1208 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_InvalidState_Test, TestSize.Level2)
1209 {
1210 struct AudioPnpUevent audioPnpUevent;
1211 audioPnpUevent.action = "change";
1212 audioPnpUevent.name = "send_nn_state04";
1213 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), HDF_ERR_INVALID_PARAM);
1214 }
1215
1216 /**
1217 * @tc.name : AudioNnDetectDevice_SendNnStateChangeCallback_Failed_Test
1218 * @tc.number: Audio_AudioSocketThread_AudioNnDetectDevice_007
1219 * @tc.desc : Test AudioNnDetectDevice function with failed SendNnStateChangeCallback.
1220 */
1221 HWTEST_F(AudioSocketThreadUnitTest, AudioNnDetectDevice_SendNnStateChangeCallback_Failed_Test, TestSize.Level2)
1222 {
1223 struct AudioPnpUevent audioPnpUevent;
1224 audioPnpUevent.action = "change";
1225 audioPnpUevent.name = "send_nn_state03";
1226 EXPECT_EQ(audioSocketThread_.AudioNnDetectDevice(&audioPnpUevent), HDF_ERR_INVALID_PARAM);
1227 }
1228
1229 /**
1230 * @tc.name : AudioPnpUeventParse_Test_01
1231 * @tc.number: Audio_AudioPnpUeventParse_001
1232 * @tc.desc : Test AudioPnpUeventParse function when msg starts with "libudev"
1233 */
1234 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_001, TestSize.Level0)
1235 {
1236 const char *msg = "libudev";
1237 ssize_t strLength = strlen(msg);
1238 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1239 }
1240
1241 /**
1242 * @tc.name : AudioPnpUeventParse_Test_02
1243 * @tc.number: Audio_AudioPnpUeventParse_002
1244 * @tc.desc : Test AudioPnpUeventParse function when strLength > UEVENT_MSG_LEN + 1
1245 */
1246 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_002, TestSize.Level0)
1247 {
1248 const char *msg = "test message";
1249 ssize_t strLength = UEVENT_MSG_LEN + 2;
1250 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1251 }
1252
1253 /**
1254 * @tc.name : AudioPnpUeventParse_Test_03
1255 * @tc.number: Audio_AudioPnpUeventParse_003
1256 * @tc.desc : Test AudioPnpUeventParse function when no matching UEVENT_ARR_SIZE is found
1257 */
1258 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_003, TestSize.Level0)
1259 {
1260 const char *msg = "unmatched event";
1261 ssize_t strLength = strlen(msg);
1262 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1263 }
1264
1265 /**
1266 * @tc.name : AudioPnpUeventParse_Test_04
1267 * @tc.number: Audio_AudioPnpUeventParse_004
1268 * @tc.desc : Test AudioPnpUeventParse function when all detect devices return SUCCESS
1269 */
1270 HWTEST_F(AudioSocketThreadUnitTest, Audio_AudioPnpUeventParse_004, TestSize.Level0)
1271 {
1272 const char *msg = "matched event";
1273 ssize_t strLength = strlen(msg);
1274 EXPECT_FALSE(audioSocketThread_.AudioPnpUeventParse(msg, strLength));
1275 }
1276
1277 /**
1278 * @tc.name : DetectAnalogHeadsetState_Fail_OpenFile
1279 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_001
1280 * @tc.desc : Test DetectAnalogHeadsetState function when open file fail.
1281 */
1282 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Fail_OpenFile, TestSize.Level0)
1283 {
1284 std::ofstream ofs;
1285 ofs.open(SWITCH_STATE_PATH, std::ofstream::out);
1286 ofs.close();
1287 unlink(SWITCH_STATE_PATH);
1288 AudioEvent audioEvent;
1289 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1290 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1291 }
1292
1293 /**
1294 * @tc.name : DetectAnalogHeadsetState_Fail_ReadFile
1295 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_002
1296 * @tc.desc : Test DetectAnalogHeadsetState function when read file fail.
1297 */
1298 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Fail_ReadFile, TestSize.Level0)
1299 {
1300 std::ofstream ofs(SWITCH_STATE_PATH);
1301 ofs.close();
1302 AudioEvent audioEvent;
1303 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1304 EXPECT_NE(ret, SUCCESS);
1305 }
1306
1307 /**
1308 * @tc.name : DetectAnalogHeadsetState_Headset_Remove_003
1309 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_003
1310 * @tc.desc : Test DetectAnalogHeadsetState function when headset is removed.
1311 */
1312 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Headset_Remove_003, TestSize.Level0)
1313 {
1314 std::ofstream ofs(SWITCH_STATE_PATH);
1315 ofs << '0';
1316 ofs.close();
1317 AudioEvent audioEvent;
1318 int32_t hdf_err_invalid_param = -3;
1319 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1320 EXPECT_EQ(ret, hdf_err_invalid_param);
1321 }
1322
1323 /**
1324 * @tc.name : DetectAnalogHeadsetState_Headset_Add_004
1325 * @tc.number: Audio_AudioSocketThread_DetectAnalogHeadsetState_004
1326 * @tc.desc : Test DetectAnalogHeadsetState function when headset is added.
1327 */
1328 HWTEST_F(AudioSocketThreadUnitTest, DetectAnalogHeadsetState_Headset_Add_004, TestSize.Level0)
1329 {
1330 std::ofstream ofs(SWITCH_STATE_PATH);
1331 ofs << '1';
1332 ofs.close();
1333 AudioEvent audioEvent;
1334 int32_t ret = audioSocketThread_.DetectAnalogHeadsetState(&audioEvent);
1335 int32_t hdf_err_invalid_param = -3;
1336 EXPECT_EQ(ret, hdf_err_invalid_param);
1337 }
1338
1339 /**
1340 * @tc.name : ReadAndScanDpName_Success_WhenFileExists
1341 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_001
1342 * @tc.desc : Test ReadAndScanDpName function when file exists and can be read successfully.
1343 */
1344 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Success_WhenFileExists, TestSize.Level0)
1345 {
1346 std::string testPath = "/tmp/test_path";
1347 std::string testName = "test_name";
1348 std::ofstream file(testPath);
1349 file << testName;
1350 file.close();
1351 std::string name;
1352 int32_t ret = audioSocketThread_.ReadAndScanDpName(testPath, name);
1353 EXPECT_EQ(ret, ERROR);
1354 remove(testPath.c_str());
1355 }
1356
1357 /**
1358 * @tc.name : ReadAndScanDpName_Fail_WhenFileNotExists
1359 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_002
1360 * @tc.desc : Test ReadAndScanDpName function when file does not exist.
1361 */
1362 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Fail_WhenFileNotExists, TestSize.Level0)
1363 {
1364 std::string testPath = "/tmp/test_path";
1365 std::string testName = "test_name";
1366 std::ofstream file(testPath);
1367 file << testName;
1368 file.close();
1369 std::string name;
1370 int32_t ret = audioSocketThread_.ReadAndScanDpName("/invalid/path", name);
1371 EXPECT_EQ(ret, HDF_ERR_INVALID_PARAM);
1372 remove(testPath.c_str());
1373 }
1374
1375 /**
1376 * @tc.name : ReadAndScanDpName_Fail_WhenFileReadFails
1377 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_003
1378 * @tc.desc : Test ReadAndScanDpName function when file read fails.
1379 */
1380 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Fail_WhenFileReadFails, TestSize.Level0)
1381 {
1382 std::string testPath = "/tmp/test_path";
1383 std::string testName = "test_name";
1384 std::ofstream file(testPath);
1385 file << testName;
1386 file.close();
1387 std::string name;
1388 int32_t ret = audioSocketThread_.ReadAndScanDpName("/dev/null", name);
1389 EXPECT_EQ(ret, ERROR);
1390 remove(testPath.c_str());
1391 }
1392
1393 /**
1394 * @tc.name : ReadAndScanDpName_Fail_WhenDevicePortNotFound
1395 * @tc.number: Audio_AudioSocketThread_ReadAndScanDpName_004
1396 * @tc.desc : Test ReadAndScanDpName function when device port not found in file content.
1397 */
1398 HWTEST_F(AudioSocketThreadUnitTest, ReadAndScanDpName_Fail_WhenDevicePortNotFound, TestSize.Level0)
1399 {
1400 std::string testName = "invalid_name";
1401 std::string testPath = "/tmp/test_path";
1402 std::ofstream file(testPath);
1403 file << testName;
1404 file.close();
1405
1406 std::string name;
1407 int32_t ret = audioSocketThread_.ReadAndScanDpName(testPath, name);
1408 EXPECT_NE(ret, SUCCESS);
1409 remove(testPath.c_str());
1410 }
1411 } // namespace AudioStandard
1412 } // namespace OHOS
1413