1 /*
2 * Copyright (c) 2021-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 "usb_device_status_test.h"
17
18 #include <sys/time.h>
19
20 #include <iostream>
21 #include <vector>
22
23 #include "delayed_sp_singleton.h"
24 #include "hilog_wrapper.h"
25 #include "if_system_ability_manager.h"
26 #include "system_ability_definition.h"
27 #include "usb_common_test.h"
28 #include "usb_srv_client.h"
29 #include "usb_errors.h"
30 #include "v1_2/iusb_interface.h"
31 #include "v1_0/usb_types.h"
32
33 constexpr int SLEEP_TIME = 3;
34 constexpr int32_t BUFFER_SIZE = 255;
35
36 using namespace std;
37 using namespace testing::ext;
38 using namespace OHOS;
39 using namespace OHOS::USB;
40 using namespace OHOS::USB::Common;
41 using namespace OHOS::HDI::Usb::V1_2;
42
43
44 namespace OHOS {
45 namespace USB {
46
SetUpTestCase(void)47 void UsbDeviceStatusTest::SetUpTestCase(void)
48 {
49 UsbCommonTest::GrantPermissionSysNative();
50 auto &srvClient = UsbSrvClient::GetInstance();
51 auto ret = srvClient.SetPortRole(1, 1, 1);
52 sleep(SLEEP_TIME);
53 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest:: [Device] SetPortRole=%{public}d", ret);
54 ret = UsbCommonTest::SwitchErrCode(ret);
55 ASSERT_TRUE(ret == 0);
56 if (ret != 0) {
57 exit(0);
58 }
59
60 std::cout << "please connect device, press enter to continue" << std::endl;
61 int32_t c;
62 while ((c = getchar()) != '\n' && c != EOF) {
63 ;
64 }
65 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbDeviceStatusTest");
66 }
67
TearDownTestCase(void)68 void UsbDeviceStatusTest::TearDownTestCase(void)
69 {
70 USB_HILOGI(MODULE_USB_SERVICE, "End UsbDeviceStatusTest");
71 }
72
SetUp(void)73 void UsbDeviceStatusTest::SetUp(void) {}
74
TearDown(void)75 void UsbDeviceStatusTest::TearDown(void) {}
76
77
78 /**
79 * @tc.name: GetDeviceSpeed001
80 * @tc.desc: Test functions to GetDeviceSpeed
81 * @tc.type: FUNC
82 */
83 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed001, TestSize.Level1)
84 {
85 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed001");
86 vector<UsbDevice> delist;
87 auto &UsbSrvClient = UsbSrvClient::GetInstance();
88 auto ret = UsbSrvClient.GetDevices(delist);
89 ASSERT_EQ(ret, 0);
90 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d ret=%{public}d", __LINE__, ret);
91 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
92 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d size=%{public}zu", __LINE__,
93 delist.size());
94 USBDevicePipe pipe;
95 UsbDevice device;
96 bool hasDevice = false;
97 for (int32_t i = 0; i < delist.size(); i++) {
98 if (delist[i].GetClass() != 9) {
99 device = delist[i];
100 hasDevice = true;
101 }
102 }
103 EXPECT_TRUE(hasDevice);
104 UsbSrvClient.RequestRight(device.GetName());
105 ret = UsbSrvClient.OpenDevice(device, pipe);
106 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d OpenDevice=%{public}d",
107 __LINE__, ret);
108 ASSERT_EQ(ret, 0);
109 uint8_t speed = 0;
110 ret = UsbSrvClient.GetDeviceSpeed(pipe, speed);
111 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d GetFileDescriptor=%{public}d",
112 __LINE__, ret);
113 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d speed=%{public}u",
114 __LINE__, speed);
115 ASSERT_EQ(ret, 0);
116 ret = UsbSrvClient.Close(pipe);
117 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
118 EXPECT_TRUE(ret);
119 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed001");
120 }
121
122 /**
123 * @tc.name: GetDeviceSpeed002
124 * @tc.desc: Test functions to GetDeviceSpeed
125 * @tc.type: FUNC
126 */
127 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed002, TestSize.Level1)
128 {
129 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed002");
130 vector<UsbDevice> delist;
131 auto &UsbSrvClient = UsbSrvClient::GetInstance();
132 auto ret = UsbSrvClient.GetDevices(delist);
133 ASSERT_EQ(ret, 0);
134 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d ret=%{public}d", __LINE__, ret);
135 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
136 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d size=%{public}zu", __LINE__,
137 delist.size());
138 USBDevicePipe pipe;
139 UsbDevice device;
140 bool hasDevice = false;
141 for (int32_t i = 0; i < delist.size(); i++) {
142 if (delist[i].GetClass() != 9) {
143 device = delist[i];
144 hasDevice = true;
145 }
146 }
147 EXPECT_TRUE(hasDevice);
148 UsbSrvClient.RequestRight(device.GetName());
149 ret = UsbSrvClient.OpenDevice(device, pipe);
150 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d OpenDevice=%{public}d",
151 __LINE__, ret);
152 ASSERT_EQ(ret, 0);
153 USBDevicePipe pipeTmp = pipe;
154 pipeTmp.SetBusNum(BUFFER_SIZE);
155 uint8_t speed = 0;
156 ret = UsbSrvClient.GetDeviceSpeed(pipeTmp, speed);
157 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d GetFileDescriptor=%{public}d",
158 __LINE__, ret);
159 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d speed=%{public}u",
160 __LINE__, speed);
161 ASSERT_NE(ret, 0);
162 pipe.SetBusNum(device.GetBusNum());
163 ret = UsbSrvClient.Close(pipe);
164 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
165 EXPECT_TRUE(ret);
166 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed002");
167 }
168
169 /**
170 * @tc.name: GetDeviceSpeed003
171 * @tc.desc: Test functions to GetDeviceSpeed
172 * @tc.type: FUNC
173 */
174 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed003, TestSize.Level1)
175 {
176 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed003");
177 vector<UsbDevice> delist;
178 auto &UsbSrvClient = UsbSrvClient::GetInstance();
179 auto ret = UsbSrvClient.GetDevices(delist);
180 ASSERT_EQ(ret, 0);
181 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d ret=%{public}d", __LINE__, ret);
182 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
183 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d size=%{public}zu", __LINE__,
184 delist.size());
185 USBDevicePipe pipe;
186 UsbDevice device;
187 bool hasDevice = false;
188 for (int32_t i = 0; i < delist.size(); i++) {
189 if (delist[i].GetClass() != 9) {
190 device = delist[i];
191 hasDevice = true;
192 }
193 }
194 EXPECT_TRUE(hasDevice);
195 UsbSrvClient.RequestRight(device.GetName());
196 ret = UsbSrvClient.OpenDevice(device, pipe);
197 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d OpenDevice=%{public}d",
198 __LINE__, ret);
199 ASSERT_EQ(ret, 0);
200 USBDevicePipe pipeTmp = pipe;
201 pipeTmp.SetDevAddr(BUFFER_SIZE);
202 uint8_t speed = 0;
203 ret = UsbSrvClient.GetDeviceSpeed(pipeTmp, speed);
204 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d GetFileDescriptor=%{public}d",
205 __LINE__, ret);
206 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d speed=%{public}u",
207 __LINE__, speed);
208 ASSERT_NE(ret, 0);
209 pipe.SetDevAddr(device.GetDevAddr());
210 ret = UsbSrvClient.Close(pipe);
211 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
212 EXPECT_TRUE(ret);
213 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed003");
214 }
215
216 /**
217 * @tc.name: GetDeviceSpeed004
218 * @tc.desc: Test functions to GetDeviceSpeed
219 * @tc.type: FUNC
220 */
221 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed004, TestSize.Level1)
222 {
223 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed004");
224 vector<UsbDevice> delist;
225 auto &UsbSrvClient = UsbSrvClient::GetInstance();
226 auto ret = UsbSrvClient.GetDevices(delist);
227 ASSERT_EQ(ret, 0);
228 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d ret=%{public}d", __LINE__, ret);
229 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
230 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d size=%{public}zu", __LINE__,
231 delist.size());
232 USBDevicePipe pipe;
233 UsbDevice device;
234 bool hasDevice = false;
235 for (int32_t i = 0; i < delist.size(); i++) {
236 if (delist[i].GetClass() != 9) {
237 device = delist[i];
238 hasDevice = true;
239 }
240 }
241 EXPECT_TRUE(hasDevice);
242 UsbSrvClient.RequestRight(device.GetName());
243 ret = UsbSrvClient.OpenDevice(device, pipe);
244 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d OpenDevice=%{public}d",
245 __LINE__, ret);
246 ASSERT_EQ(ret, 0);
247 USBDevicePipe pipeTmp = pipe;
248 pipeTmp.SetBusNum(BUFFER_SIZE);
249 pipeTmp.SetDevAddr(BUFFER_SIZE);
250 uint8_t speed = 0;
251 ret = UsbSrvClient.GetDeviceSpeed(pipeTmp, speed);
252 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d GetFileDescriptor=%{public}d",
253 __LINE__, ret);
254 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d speed=%{public}u",
255 __LINE__, speed);
256 ASSERT_NE(ret, 0);
257 pipe.SetBusNum(device.GetBusNum());
258 pipe.SetDevAddr(device.GetDevAddr());
259 ret = UsbSrvClient.Close(pipe);
260 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
261 EXPECT_TRUE(ret);
262 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed004");
263 }
264
265 /**
266 * @tc.name: ClearHalt001
267 * @tc.desc: Test functions to ClearHalt
268 * @tc.type: FUNC
269 */
270 HWTEST_F(UsbDeviceStatusTest, ClearHalt001, TestSize.Level1)
271 {
272 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt001");
273 vector<UsbDevice> delist;
274 auto &UsbSrvClient = UsbSrvClient::GetInstance();
275 auto ret = UsbSrvClient.GetDevices(delist);
276 ASSERT_EQ(ret, 0);
277 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d ret=%{public}d", __LINE__, ret);
278 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
279 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d size=%{public}zu", __LINE__,
280 delist.size());
281 USBDevicePipe pipe;
282 UsbDevice device;
283 bool hasDevice = false;
284 for (int32_t i = 0; i < delist.size(); i++) {
285 if (delist[i].GetClass() != 9) {
286 device = delist[i];
287 hasDevice = true;
288 }
289 }
290 EXPECT_TRUE(hasDevice);
291 UsbSrvClient.RequestRight(device.GetName());
292 ret = UsbSrvClient.OpenDevice(device, pipe);
293 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
294 ASSERT_EQ(ret, 0);
295 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
296 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
297 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt001 %{public}d ClaimInterface=%{public}d", __LINE__,
298 ret);
299 ASSERT_EQ(ret, 0);
300
301 if (!interface.GetEndpoints().empty()) {
302 USBEndpoint ep = interface.GetEndpoints().front();
303 ret = UsbSrvClient.ClearHalt(pipe, ep);
304 ASSERT_EQ(ret, 0);
305 } else {
306 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt001 %{public}d no endpoints", __LINE__);
307 }
308
309 bool close = UsbSrvClient.Close(pipe);
310 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d close=%{public}d", __LINE__, close);
311 EXPECT_TRUE(close);
312 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt001");
313 }
314
315 /**
316 * @tc.name: ClearHalt002
317 * @tc.desc: Test functions to ClearHalt
318 * @tc.type: FUNC
319 */
320 HWTEST_F(UsbDeviceStatusTest, ClearHalt002, TestSize.Level1)
321 {
322 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt002");
323 vector<UsbDevice> delist;
324 auto &UsbSrvClient = UsbSrvClient::GetInstance();
325 auto ret = UsbSrvClient.GetDevices(delist);
326 ASSERT_EQ(ret, 0);
327 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d ret=%{public}d", __LINE__, ret);
328 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
329 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d size=%{public}zu", __LINE__,
330 delist.size());
331 USBDevicePipe pipe;
332 UsbDevice device;
333 bool hasDevice = false;
334 for (int32_t i = 0; i < delist.size(); i++) {
335 if (delist[i].GetClass() != 9) {
336 device = delist[i];
337 hasDevice = true;
338 }
339 }
340 EXPECT_TRUE(hasDevice);
341 UsbSrvClient.RequestRight(device.GetName());
342 ret = UsbSrvClient.OpenDevice(device, pipe);
343 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
344 ASSERT_EQ(ret, 0);
345 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
346 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
347 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt002 %{public}d ClaimInterface=%{public}d", __LINE__,
348 ret);
349 ASSERT_EQ(ret, 0);
350
351 pipe.SetBusNum(BUFFER_SIZE);
352 if (!interface.GetEndpoints().empty()) {
353 USBEndpoint ep = interface.GetEndpoints().front();
354 ret = UsbSrvClient.ClearHalt(pipe, ep);
355 EXPECT_FALSE(ret == 0);
356 } else {
357 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt002 %{public}d no endpoints", __LINE__);
358 }
359
360 bool close = UsbSrvClient.Close(pipe);
361 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d close=%{public}d", __LINE__, close);
362 EXPECT_TRUE(!close);
363 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt002");
364 }
365
366 /**
367 * @tc.name: ClearHalt003
368 * @tc.desc: Test functions to ClearHalt
369 * @tc.type: FUNC
370 */
371 HWTEST_F(UsbDeviceStatusTest, ClearHalt003, TestSize.Level1)
372 {
373 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt003");
374 vector<UsbDevice> delist;
375 auto &UsbSrvClient = UsbSrvClient::GetInstance();
376 auto ret = UsbSrvClient.GetDevices(delist);
377 ASSERT_EQ(ret, 0);
378 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d ret=%{public}d", __LINE__, ret);
379 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
380 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d size=%{public}zu", __LINE__,
381 delist.size());
382 USBDevicePipe pipe;
383 UsbDevice device;
384 bool hasDevice = false;
385 for (int32_t i = 0; i < delist.size(); i++) {
386 if (delist[i].GetClass() != 9) {
387 device = delist[i];
388 hasDevice = true;
389 }
390 }
391 EXPECT_TRUE(hasDevice);
392 UsbSrvClient.RequestRight(device.GetName());
393 ret = UsbSrvClient.OpenDevice(device, pipe);
394 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
395 ASSERT_EQ(ret, 0);
396 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
397 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
398 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt003 %{public}d ClaimInterface=%{public}d", __LINE__,
399 ret);
400 ASSERT_EQ(ret, 0);
401
402 pipe.SetDevAddr(BUFFER_SIZE);
403 if (!interface.GetEndpoints().empty()) {
404 USBEndpoint ep = interface.GetEndpoints().front();
405 ret = UsbSrvClient.ClearHalt(pipe, ep);
406 EXPECT_FALSE(ret == 0);
407 } else {
408 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt003 %{public}d no endpoints", __LINE__);
409 }
410
411 bool close = UsbSrvClient.Close(pipe);
412 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d close=%{public}d", __LINE__, close);
413 EXPECT_TRUE(!close);
414 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt003");
415 }
416
417 /**
418 * @tc.name: ClearHalt004
419 * @tc.desc: Test functions to ClearHalt
420 * @tc.type: FUNC
421 */
422 HWTEST_F(UsbDeviceStatusTest, ClearHalt004, TestSize.Level1)
423 {
424 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt004");
425 vector<UsbDevice> delist;
426 auto &UsbSrvClient = UsbSrvClient::GetInstance();
427 auto ret = UsbSrvClient.GetDevices(delist);
428 ASSERT_EQ(ret, 0);
429 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d ret=%{public}d", __LINE__, ret);
430 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
431 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d size=%{public}zu", __LINE__,
432 delist.size());
433 USBDevicePipe pipe;
434 UsbDevice device;
435 bool hasDevice = false;
436 for (int32_t i = 0; i < delist.size(); i++) {
437 if (delist[i].GetClass() != 9) {
438 device = delist[i];
439 hasDevice = true;
440 }
441 }
442 EXPECT_TRUE(hasDevice);
443 UsbSrvClient.RequestRight(device.GetName());
444 ret = UsbSrvClient.OpenDevice(device, pipe);
445 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d OpenDevice=%{public}d", __LINE__, ret);
446 ASSERT_EQ(ret, 0);
447 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
448 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
449 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt004 %{public}d ClaimInterface=%{public}d", __LINE__,
450 ret);
451 ASSERT_EQ(ret, 0);
452 pipe.SetBusNum(BUFFER_SIZE);
453 pipe.SetDevAddr(BUFFER_SIZE);
454 if (!interface.GetEndpoints().empty()) {
455 USBEndpoint ep = interface.GetEndpoints().front();
456 ret = UsbSrvClient.ClearHalt(pipe, ep);
457 EXPECT_FALSE(ret == 0);
458 } else {
459 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt004 %{public}d no endpoints", __LINE__);
460 }
461
462 bool close = UsbSrvClient.Close(pipe);
463 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d close=%{public}d", __LINE__, close);
464 EXPECT_TRUE(!close);
465 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt004");
466 }
467
468 /**
469 * @tc.name: GetInterfaceStatus001
470 * @tc.desc: Test functions to GetInterfaceStatus
471 * @tc.type: FUNC
472 */
473 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus001, TestSize.Level1)
474 {
475 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus001");
476 vector<UsbDevice> delist;
477 auto &UsbSrvClient = UsbSrvClient::GetInstance();
478 auto ret = UsbSrvClient.GetDevices(delist);
479 ASSERT_EQ(ret, 0);
480 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d ret=%{public}d", __LINE__, ret);
481 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
482 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d size=%{public}zu", __LINE__,
483 delist.size());
484 USBDevicePipe pipe;
485 UsbDevice device;
486 bool hasDevice = false;
487 for (int32_t i = 0; i < delist.size(); i++) {
488 if (delist[i].GetClass() != 9) {
489 device = delist[i];
490 hasDevice = true;
491 }
492 }
493 EXPECT_TRUE(hasDevice);
494 UsbSrvClient.RequestRight(device.GetName());
495 ret = UsbSrvClient.OpenDevice(device, pipe);
496 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d OpenDevice=%{public}d", __LINE__,
497 ret);
498 ASSERT_EQ(ret, 0);
499 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
500 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
501 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ClaimInterface=%{public}d", __LINE__,
502 ret);
503 ASSERT_EQ(ret, 0);
504 bool unactived = 1;
505 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
506 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d GetInterfaceStatus=%{public}d",
507 __LINE__, ret);
508 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d unactived=%{public}d",
509 __LINE__, unactived);
510 ASSERT_EQ(ret, 0);
511 bool close = UsbSrvClient.Close(pipe);
512 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d close=%{public}d", __LINE__, close);
513 EXPECT_TRUE(close);
514 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus001");
515 }
516
517 /**
518 * @tc.name: GetInterfaceStatus002
519 * @tc.desc: Test functions to GetInterfaceStatus
520 * @tc.type: FUNC
521 */
522 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus002, TestSize.Level1)
523 {
524 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus002");
525 vector<UsbDevice> delist;
526 auto &UsbSrvClient = UsbSrvClient::GetInstance();
527 auto ret = UsbSrvClient.GetDevices(delist);
528 ASSERT_EQ(ret, 0);
529 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d ret=%{public}d", __LINE__, ret);
530 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
531 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d size=%{public}zu", __LINE__,
532 delist.size());
533 USBDevicePipe pipe;
534 UsbDevice device;
535 bool hasDevice = false;
536 for (int32_t i = 0; i < delist.size(); i++) {
537 if (delist[i].GetClass() != 9) {
538 device = delist[i];
539 hasDevice = true;
540 }
541 }
542 EXPECT_TRUE(hasDevice);
543 UsbSrvClient.RequestRight(device.GetName());
544 ret = UsbSrvClient.OpenDevice(device, pipe);
545 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d OpenDevice=%{public}d", __LINE__,
546 ret);
547 ASSERT_EQ(ret, 0);
548 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
549 pipe.SetBusNum(BUFFER_SIZE);
550 bool unactived = 1;
551 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
552 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d GetInterfaceStatus=%{public}d",
553 __LINE__, ret);
554 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d unactived=%{public}d",
555 __LINE__, unactived);
556 ASSERT_NE(ret, 0);
557 pipe.SetBusNum(device.GetBusNum());
558 bool close = UsbSrvClient.Close(pipe);
559 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d close=%{public}d", __LINE__, close);
560 EXPECT_TRUE(close);
561 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus002");
562 }
563
564 /**
565 * @tc.name: GetInterfaceStatus003
566 * @tc.desc: Test functions to GetInterfaceStatus
567 * @tc.type: FUNC
568 */
569 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus003, TestSize.Level1)
570 {
571 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus003");
572 vector<UsbDevice> delist;
573 auto &UsbSrvClient = UsbSrvClient::GetInstance();
574 auto ret = UsbSrvClient.GetDevices(delist);
575 ASSERT_EQ(ret, 0);
576 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d ret=%{public}d", __LINE__, ret);
577 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
578 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d size=%{public}zu", __LINE__,
579 delist.size());
580 USBDevicePipe pipe;
581 UsbDevice device;
582 bool hasDevice = false;
583 for (int32_t i = 0; i < delist.size(); i++) {
584 if (delist[i].GetClass() != 9) {
585 device = delist[i];
586 hasDevice = true;
587 }
588 }
589 EXPECT_TRUE(hasDevice);
590 UsbSrvClient.RequestRight(device.GetName());
591 ret = UsbSrvClient.OpenDevice(device, pipe);
592 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d OpenDevice=%{public}d", __LINE__,
593 ret);
594 ASSERT_EQ(ret, 0);
595 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
596 pipe.SetDevAddr(BUFFER_SIZE);
597 bool unactived = 1;
598 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
599 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d GetInterfaceStatus=%{public}d",
600 __LINE__, ret);
601 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d unactived=%{public}d",
602 __LINE__, unactived);
603 ASSERT_NE(ret, 0);
604 pipe.SetDevAddr(device.GetDevAddr());
605 bool close = UsbSrvClient.Close(pipe);
606 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d close=%{public}d", __LINE__, close);
607 EXPECT_TRUE(close);
608 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus003");
609 }
610
611 /**
612 * @tc.name: GetInterfaceStatus004
613 * @tc.desc: Test functions to GetInterfaceStatus
614 * @tc.type: FUNC
615 */
616 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus004, TestSize.Level1)
617 {
618 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus004");
619 vector<UsbDevice> delist;
620 auto &UsbSrvClient = UsbSrvClient::GetInstance();
621 auto ret = UsbSrvClient.GetDevices(delist);
622 ASSERT_EQ(ret, 0);
623 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d ret=%{public}d", __LINE__, ret);
624 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
625 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d size=%{public}zu", __LINE__,
626 delist.size());
627 USBDevicePipe pipe;
628 UsbDevice device;
629 bool hasDevice = false;
630 for (int32_t i = 0; i < delist.size(); i++) {
631 if (delist[i].GetClass() != 9) {
632 device = delist[i];
633 hasDevice = true;
634 }
635 }
636 EXPECT_TRUE(hasDevice);
637 UsbSrvClient.RequestRight(device.GetName());
638 ret = UsbSrvClient.OpenDevice(device, pipe);
639 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d OpenDevice=%{public}d", __LINE__,
640 ret);
641 ASSERT_EQ(ret, 0);
642 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
643 bool unactived = 1;
644 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
645 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d GetInterfaceStatus=%{public}d",
646 __LINE__, ret);
647 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d unactived=%{public}d",
648 __LINE__, unactived);
649 ASSERT_EQ(ret, 0);
650 bool close = UsbSrvClient.Close(pipe);
651 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d close=%{public}d", __LINE__, close);
652 EXPECT_TRUE(close);
653 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus004");
654 }
655
656 /**
657 * @tc.name: GetInterfaceStatus005
658 * @tc.desc: Test functions to GetInterfaceStatus
659 * @tc.type: FUNC
660 */
661 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus005, TestSize.Level1)
662 {
663 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus005");
664 vector<UsbDevice> delist;
665 auto &UsbSrvClient = UsbSrvClient::GetInstance();
666 auto ret = UsbSrvClient.GetDevices(delist);
667 ASSERT_EQ(ret, 0);
668 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d ret=%{public}d", __LINE__, ret);
669 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
670 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d size=%{public}zu", __LINE__,
671 delist.size());
672 USBDevicePipe pipe;
673 UsbDevice device;
674 bool hasDevice = false;
675 for (int32_t i = 0; i < delist.size(); i++) {
676 if (delist[i].GetClass() != 9) {
677 device = delist[i];
678 hasDevice = true;
679 }
680 }
681 EXPECT_TRUE(hasDevice);
682 UsbSrvClient.RequestRight(device.GetName());
683 ret = UsbSrvClient.OpenDevice(device, pipe);
684 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d OpenDevice=%{public}d", __LINE__,
685 ret);
686 ASSERT_EQ(ret, 0);
687 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
688 pipe.SetBusNum(BUFFER_SIZE);
689 bool unactived = 1;
690 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
691 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d GetInterfaceStatus=%{public}d",
692 __LINE__, ret);
693 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d unactived=%{public}d",
694 __LINE__, unactived);
695 ASSERT_NE(ret, 0);
696 pipe.SetBusNum(device.GetBusNum());
697 bool close = UsbSrvClient.Close(pipe);
698 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d close=%{public}d", __LINE__, close);
699 EXPECT_TRUE(close);
700 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus005");
701 }
702
703 /**
704 * @tc.name: GetInterfaceStatus006
705 * @tc.desc: Test functions to GetInterfaceStatus
706 * @tc.type: FUNC
707 */
708 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus006, TestSize.Level1)
709 {
710 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus007");
711 vector<UsbDevice> delist;
712 auto &UsbSrvClient = UsbSrvClient::GetInstance();
713 auto ret = UsbSrvClient.GetDevices(delist);
714 ASSERT_EQ(ret, 0);
715 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d ret=%{public}d", __LINE__, ret);
716 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
717 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d size=%{public}zu", __LINE__,
718 delist.size());
719 USBDevicePipe pipe;
720 UsbDevice device;
721 bool hasDevice = false;
722 for (int32_t i = 0; i < delist.size(); i++) {
723 if (delist[i].GetClass() != 9) {
724 device = delist[i];
725 hasDevice = true;
726 }
727 }
728 EXPECT_TRUE(hasDevice);
729 UsbSrvClient.RequestRight(device.GetName());
730 ret = UsbSrvClient.OpenDevice(device, pipe);
731 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d OpenDevice=%{public}d", __LINE__,
732 ret);
733 ASSERT_EQ(ret, 0);
734 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
735 pipe.SetDevAddr(BUFFER_SIZE);
736 bool unactived = 1;
737 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
738 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d GetInterfaceStatus=%{public}d",
739 __LINE__, ret);
740 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d unactived=%{public}d",
741 __LINE__, unactived);
742 ASSERT_NE(ret, 0);
743 pipe.SetDevAddr(device.GetDevAddr());
744 bool close = UsbSrvClient.Close(pipe);
745 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d close=%{public}d", __LINE__, close);
746 EXPECT_TRUE(close);
747 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus006");
748 }
749
750 /**
751 * @tc.name: GetInterfaceStatus007
752 * @tc.desc: Test functions to GetInterfaceStatus
753 * @tc.type: FUNC
754 */
755 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus007, TestSize.Level1)
756 {
757 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus007");
758 vector<UsbDevice> delist;
759 auto &UsbSrvClient = UsbSrvClient::GetInstance();
760 auto ret = UsbSrvClient.GetDevices(delist);
761 ASSERT_EQ(ret, 0);
762 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d ret=%{public}d", __LINE__, ret);
763 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
764 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d size=%{public}zu", __LINE__,
765 delist.size());
766 USBDevicePipe pipe;
767 UsbDevice device;
768 bool hasDevice = false;
769 for (int32_t i = 0; i < delist.size(); i++) {
770 if (delist[i].GetClass() != 9) {
771 device = delist[i];
772 hasDevice = true;
773 }
774 }
775 EXPECT_TRUE(hasDevice);
776 UsbSrvClient.RequestRight(device.GetName());
777 ret = UsbSrvClient.OpenDevice(device, pipe);
778 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d OpenDevice=%{public}d", __LINE__,
779 ret);
780 ASSERT_EQ(ret, 0);
781 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(0);
782 pipe.SetDevAddr(BUFFER_SIZE);
783 pipe.SetBusNum(BUFFER_SIZE);
784 bool unactived = 1;
785 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
786 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d GetInterfaceStatus=%{public}d",
787 __LINE__, ret);
788 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d unactived=%{public}d",
789 __LINE__, unactived);
790 ASSERT_NE(ret, 0);
791 pipe.SetDevAddr(device.GetDevAddr());
792 pipe.SetBusNum(device.GetBusNum());
793 bool close = UsbSrvClient.Close(pipe);
794 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d close=%{public}d", __LINE__, close);
795 EXPECT_TRUE(close);
796 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus007");
797 }
798
799 /**
800 * @tc.name: GetInterfaceStatus008
801 * @tc.desc: Test functions to GetInterfaceStatus
802 * @tc.type: FUNC
803 */
804 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus008, TestSize.Level1)
805 {
806 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus008");
807 vector<UsbDevice> delist;
808 auto &UsbSrvClient = UsbSrvClient::GetInstance();
809 auto ret = UsbSrvClient.GetDevices(delist);
810 ASSERT_EQ(ret, 0);
811 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d ret=%{public}d", __LINE__, ret);
812 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
813 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d size=%{public}zu", __LINE__,
814 delist.size());
815 USBDevicePipe pipe;
816 UsbDevice device;
817 bool hasDevice = false;
818 for (int32_t i = 0; i < delist.size(); i++) {
819 if (delist[i].GetClass() != 9) {
820 device = delist[i];
821 hasDevice = true;
822 }
823 }
824 EXPECT_TRUE(hasDevice);
825 UsbSrvClient.RequestRight(device.GetName());
826 ret = UsbSrvClient.OpenDevice(device, pipe);
827 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d OpenDevice=%{public}d", __LINE__,
828 ret);
829 ASSERT_EQ(ret, 0);
830 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
831 pipe.SetDevAddr(BUFFER_SIZE);
832 pipe.SetBusNum(BUFFER_SIZE);
833 bool unactived = 1;
834 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
835 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d GetInterfaceStatus=%{public}d",
836 __LINE__, ret);
837 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d unactived=%{public}d",
838 __LINE__, unactived);
839 ASSERT_NE(ret, 0);
840 pipe.SetDevAddr(device.GetDevAddr());
841 pipe.SetBusNum(device.GetBusNum());
842 bool close = UsbSrvClient.Close(pipe);
843 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d close=%{public}d", __LINE__, close);
844 EXPECT_TRUE(close);
845 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus008");
846 }
847
848 /**
849 * @tc.name: UsbDetachKernelDriver001
850 * @tc.desc: Test functions to UsbDetachKernelDriver
851 * @tc.type: FUNC
852 */
853 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver001, TestSize.Level1)
854 {
855 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver001");
856 vector<UsbDevice> delist;
857 auto &UsbSrvClient = UsbSrvClient::GetInstance();
858 auto ret = UsbSrvClient.GetDevices(delist);
859 ASSERT_EQ(ret, 0);
860 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d ret=%{public}d", __LINE__, ret);
861 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
862 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d size=%{public}zu", __LINE__,
863 delist.size());
864 USBDevicePipe pipe;
865 UsbDevice device;
866 bool hasDevice = false;
867 for (int32_t i = 0; i < delist.size(); i++) {
868 if (delist[i].GetClass() != 9) {
869 device = delist[i];
870 hasDevice = true;
871 }
872 }
873 EXPECT_TRUE(hasDevice);
874 UsbSrvClient.RequestRight(device.GetName());
875 ret = UsbSrvClient.OpenDevice(device, pipe);
876 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d OpenDevice=%{public}d", __LINE__,
877 ret);
878 ASSERT_EQ(ret, 0);
879 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
880 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d UsbAttachKernelDriver=%{public}d",
881 __LINE__, ret);
882 ASSERT_EQ(ret, 0);
883 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
884 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d UsbDetachKernelDriver=%{public}d",
885 __LINE__, ret);
886 ASSERT_EQ(ret, 0);
887 bool close = UsbSrvClient.Close(pipe);
888 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d close=%{public}d", __LINE__, close);
889 EXPECT_TRUE(close);
890 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver001");
891 }
892
893 /**
894 * @tc.name: UsbDetachKernelDriver002
895 * @tc.desc: Test functions to UsbDetachKernelDriver
896 * @tc.type: FUNC
897 */
898 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver002, TestSize.Level1)
899 {
900 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver002");
901 vector<UsbDevice> delist;
902 auto &UsbSrvClient = UsbSrvClient::GetInstance();
903 auto ret = UsbSrvClient.GetDevices(delist);
904 ASSERT_EQ(ret, 0);
905 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d ret=%{public}d", __LINE__, ret);
906 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
907 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d size=%{public}zu", __LINE__,
908 delist.size());
909 USBDevicePipe pipe;
910 UsbDevice device;
911 bool hasDevice = false;
912 for (int32_t i = 0; i < delist.size(); i++) {
913 if (delist[i].GetClass() != 9) {
914 device = delist[i];
915 hasDevice = true;
916 }
917 }
918 EXPECT_TRUE(hasDevice);
919 UsbSrvClient.RequestRight(device.GetName());
920 ret = UsbSrvClient.OpenDevice(device, pipe);
921 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d OpenDevice=%{public}d", __LINE__,
922 ret);
923 ASSERT_EQ(ret, 0);
924 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
925 pipe.SetBusNum(BUFFER_SIZE);
926 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
927 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d UsbDetachKernelDriver=%{public}d",
928 __LINE__, ret);
929 ASSERT_NE(ret, 0);
930 pipe.SetBusNum(device.GetBusNum());
931 bool close = UsbSrvClient.Close(pipe);
932 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d close=%{public}d", __LINE__, close);
933 EXPECT_TRUE(close);
934 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver002");
935 }
936
937 /**
938 * @tc.name: UsbDetachKernelDriver003
939 * @tc.desc: Test functions to UsbDetachKernelDriver
940 * @tc.type: FUNC
941 */
942 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver003, TestSize.Level1)
943 {
944 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver003");
945 vector<UsbDevice> delist;
946 auto &UsbSrvClient = UsbSrvClient::GetInstance();
947 auto ret = UsbSrvClient.GetDevices(delist);
948 ASSERT_EQ(ret, 0);
949 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d ret=%{public}d", __LINE__, ret);
950 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
951 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d size=%{public}zu", __LINE__,
952 delist.size());
953 USBDevicePipe pipe;
954 UsbDevice device;
955 bool hasDevice = false;
956 for (int32_t i = 0; i < delist.size(); i++) {
957 if (delist[i].GetClass() != 9) {
958 device = delist[i];
959 hasDevice = true;
960 }
961 }
962 EXPECT_TRUE(hasDevice);
963 UsbSrvClient.RequestRight(device.GetName());
964 ret = UsbSrvClient.OpenDevice(device, pipe);
965 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d OpenDevice=%{public}d", __LINE__,
966 ret);
967 ASSERT_EQ(ret, 0);
968 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
969 pipe.SetDevAddr(BUFFER_SIZE);
970 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
971 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d UsbDetachKernelDriver=%{public}d",
972 __LINE__, ret);
973 ASSERT_NE(ret, 0);
974 pipe.SetDevAddr(device.GetDevAddr());
975 bool close = UsbSrvClient.Close(pipe);
976 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d close=%{public}d", __LINE__, close);
977 EXPECT_TRUE(close);
978 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver003");
979 }
980
981 /**
982 * @tc.name: UsbDetachKernelDriver004
983 * @tc.desc: Test functions to UsbDetachKernelDriver
984 * @tc.type: FUNC
985 */
986 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver004, TestSize.Level1)
987 {
988 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver004");
989 vector<UsbDevice> delist;
990 auto &UsbSrvClient = UsbSrvClient::GetInstance();
991 auto ret = UsbSrvClient.GetDevices(delist);
992 ASSERT_EQ(ret, 0);
993 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d ret=%{public}d", __LINE__, ret);
994 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
995 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d size=%{public}zu", __LINE__,
996 delist.size());
997 USBDevicePipe pipe;
998 UsbDevice device;
999 bool hasDevice = false;
1000 for (int32_t i = 0; i < delist.size(); i++) {
1001 if (delist[i].GetClass() != 9) {
1002 device = delist[i];
1003 hasDevice = true;
1004 }
1005 }
1006 EXPECT_TRUE(hasDevice);
1007 UsbSrvClient.RequestRight(device.GetName());
1008 ret = UsbSrvClient.OpenDevice(device, pipe);
1009 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d OpenDevice=%{public}d", __LINE__,
1010 ret);
1011 ASSERT_EQ(ret, 0);
1012 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1013 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1014 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d UsbAttachKernelDriver=%{public}d",
1015 __LINE__, ret);
1016 ASSERT_EQ(ret, 0);
1017 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
1018 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d UsbDetachKernelDriver=%{public}d",
1019 __LINE__, ret);
1020 ASSERT_EQ(ret, 0);
1021 bool close = UsbSrvClient.Close(pipe);
1022 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d close=%{public}d", __LINE__, close);
1023 EXPECT_TRUE(close);
1024 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver004");
1025 }
1026
1027 /**
1028 * @tc.name: UsbDetachKernelDriver005
1029 * @tc.desc: Test functions to UsbDetachKernelDriver
1030 * @tc.type: FUNC
1031 */
1032 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver005, TestSize.Level1)
1033 {
1034 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver005");
1035 vector<UsbDevice> delist;
1036 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1037 auto ret = UsbSrvClient.GetDevices(delist);
1038 ASSERT_EQ(ret, 0);
1039 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d ret=%{public}d", __LINE__, ret);
1040 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1041 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d size=%{public}zu", __LINE__,
1042 delist.size());
1043 USBDevicePipe pipe;
1044 UsbDevice device;
1045 bool hasDevice = false;
1046 for (int32_t i = 0; i < delist.size(); i++) {
1047 if (delist[i].GetClass() != 9) {
1048 device = delist[i];
1049 hasDevice = true;
1050 }
1051 }
1052 EXPECT_TRUE(hasDevice);
1053 UsbSrvClient.RequestRight(device.GetName());
1054 ret = UsbSrvClient.OpenDevice(device, pipe);
1055 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d OpenDevice=%{public}d", __LINE__,
1056 ret);
1057 ASSERT_EQ(ret, 0);
1058 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1059 pipe.SetBusNum(BUFFER_SIZE);
1060 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
1061 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d UsbDetachKernelDriver=%{public}d",
1062 __LINE__, ret);
1063 ASSERT_NE(ret, 0);
1064 pipe.SetBusNum(device.GetBusNum());
1065 bool close = UsbSrvClient.Close(pipe);
1066 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d close=%{public}d", __LINE__, close);
1067 EXPECT_TRUE(close);
1068 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver005");
1069 }
1070
1071 /**
1072 * @tc.name: UsbDetachKernelDriver006
1073 * @tc.desc: Test functions to UsbDetachKernelDriver
1074 * @tc.type: FUNC
1075 */
1076 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver006, TestSize.Level1)
1077 {
1078 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver006");
1079 vector<UsbDevice> delist;
1080 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1081 auto ret = UsbSrvClient.GetDevices(delist);
1082 ASSERT_EQ(ret, 0);
1083 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d ret=%{public}d", __LINE__, ret);
1084 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1085 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d size=%{public}zu", __LINE__,
1086 delist.size());
1087 USBDevicePipe pipe;
1088 UsbDevice device;
1089 bool hasDevice = false;
1090 for (int32_t i = 0; i < delist.size(); i++) {
1091 if (delist[i].GetClass() != 9) {
1092 device = delist[i];
1093 hasDevice = true;
1094 }
1095 }
1096 EXPECT_TRUE(hasDevice);
1097 UsbSrvClient.RequestRight(device.GetName());
1098 ret = UsbSrvClient.OpenDevice(device, pipe);
1099 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d OpenDevice=%{public}d", __LINE__,
1100 ret);
1101 ASSERT_EQ(ret, 0);
1102 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1103 pipe.SetDevAddr(BUFFER_SIZE);
1104 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
1105 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d UsbDetachKernelDriver=%{public}d",
1106 __LINE__, ret);
1107 ASSERT_NE(ret, 0);
1108 pipe.SetDevAddr(device.GetDevAddr());
1109 bool close = UsbSrvClient.Close(pipe);
1110 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d close=%{public}d", __LINE__, close);
1111 EXPECT_TRUE(close);
1112 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus006");
1113 }
1114
1115 /**
1116 * @tc.name: UsbDetachKernelDriver007
1117 * @tc.desc: Test functions to UsbDetachKernelDriver
1118 * @tc.type: FUNC
1119 */
1120 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver007, TestSize.Level1)
1121 {
1122 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver007");
1123 vector<UsbDevice> delist;
1124 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1125 auto ret = UsbSrvClient.GetDevices(delist);
1126 ASSERT_EQ(ret, 0);
1127 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d ret=%{public}d", __LINE__, ret);
1128 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1129 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d size=%{public}zu", __LINE__,
1130 delist.size());
1131 USBDevicePipe pipe;
1132 UsbDevice device;
1133 bool hasDevice = false;
1134 for (int32_t i = 0; i < delist.size(); i++) {
1135 if (delist[i].GetClass() != 9) {
1136 device = delist[i];
1137 hasDevice = true;
1138 }
1139 }
1140 EXPECT_TRUE(hasDevice);
1141 UsbSrvClient.RequestRight(device.GetName());
1142 ret = UsbSrvClient.OpenDevice(device, pipe);
1143 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d OpenDevice=%{public}d", __LINE__,
1144 ret);
1145 ASSERT_EQ(ret, 0);
1146 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(0);
1147 pipe.SetDevAddr(BUFFER_SIZE);
1148 pipe.SetBusNum(BUFFER_SIZE);
1149 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
1150 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d UsbDetachKernelDriver=%{public}d",
1151 __LINE__, ret);
1152 ASSERT_NE(ret, 0);
1153 pipe.SetDevAddr(device.GetDevAddr());
1154 pipe.SetBusNum(device.GetBusNum());
1155 bool close = UsbSrvClient.Close(pipe);
1156 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d close=%{public}d", __LINE__, close);
1157 EXPECT_TRUE(close);
1158 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver007");
1159 }
1160
1161 /**
1162 * @tc.name: UsbDetachKernelDriver008
1163 * @tc.desc: Test functions to UsbDetachKernelDriver
1164 * @tc.type: FUNC
1165 */
1166 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver008, TestSize.Level1)
1167 {
1168 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver008");
1169 vector<UsbDevice> delist;
1170 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1171 auto ret = UsbSrvClient.GetDevices(delist);
1172 ASSERT_EQ(ret, 0);
1173 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d ret=%{public}d", __LINE__, ret);
1174 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1175 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d size=%{public}zu", __LINE__,
1176 delist.size());
1177 USBDevicePipe pipe;
1178 UsbDevice device;
1179 bool hasDevice = false;
1180 for (int32_t i = 0; i < delist.size(); i++) {
1181 if (delist[i].GetClass() != 9) {
1182 device = delist[i];
1183 hasDevice = true;
1184 }
1185 }
1186 EXPECT_TRUE(hasDevice);
1187 UsbSrvClient.RequestRight(device.GetName());
1188 ret = UsbSrvClient.OpenDevice(device, pipe);
1189 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d OpenDevice=%{public}d", __LINE__,
1190 ret);
1191 ASSERT_EQ(ret, 0);
1192 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1193 pipe.SetDevAddr(BUFFER_SIZE);
1194 pipe.SetBusNum(BUFFER_SIZE);
1195 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
1196 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d UsbDetachKernelDriver=%{public}d",
1197 __LINE__, ret);
1198 ASSERT_NE(ret, 0);
1199 pipe.SetDevAddr(device.GetDevAddr());
1200 pipe.SetBusNum(device.GetBusNum());
1201 bool close = UsbSrvClient.Close(pipe);
1202 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d close=%{public}d", __LINE__, close);
1203 EXPECT_TRUE(close);
1204 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver008");
1205 }
1206
1207 /**
1208 * @tc.name: UsbAttachKernelDriver001
1209 * @tc.desc: Test functions to UsbAttachKernelDriver
1210 * @tc.type: FUNC
1211 */
1212 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver001, TestSize.Level1)
1213 {
1214 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver001");
1215 vector<UsbDevice> delist;
1216 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1217 auto ret = UsbSrvClient.GetDevices(delist);
1218 ASSERT_EQ(ret, 0);
1219 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d ret=%{public}d", __LINE__, ret);
1220 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1221 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d size=%{public}zu", __LINE__,
1222 delist.size());
1223 USBDevicePipe pipe;
1224 UsbDevice device;
1225 bool hasDevice = false;
1226 for (int32_t i = 0; i < delist.size(); i++) {
1227 if (delist[i].GetClass() != 9) {
1228 device = delist[i];
1229 hasDevice = true;
1230 }
1231 }
1232 EXPECT_TRUE(hasDevice);
1233 UsbSrvClient.RequestRight(device.GetName());
1234 ret = UsbSrvClient.OpenDevice(device, pipe);
1235 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d OpenDevice=%{public}d", __LINE__,
1236 ret);
1237 ASSERT_EQ(ret, 0);
1238 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1239 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1240 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d UsbAttachKernelDriver=%{public}d",
1241 __LINE__, ret);
1242 ASSERT_EQ(ret, 0);
1243 bool close = UsbSrvClient.Close(pipe);
1244 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d close=%{public}d", __LINE__, close);
1245 EXPECT_TRUE(close);
1246 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver001");
1247 }
1248
1249 /**
1250 * @tc.name: UsbAttachKernelDriver002
1251 * @tc.desc: Test functions to UsbAttachKernelDriver
1252 * @tc.type: FUNC
1253 */
1254 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver002, TestSize.Level1)
1255 {
1256 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver002");
1257 vector<UsbDevice> delist;
1258 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1259 auto ret = UsbSrvClient.GetDevices(delist);
1260 ASSERT_EQ(ret, 0);
1261 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d ret=%{public}d", __LINE__, ret);
1262 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1263 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d size=%{public}zu", __LINE__,
1264 delist.size());
1265 USBDevicePipe pipe;
1266 UsbDevice device;
1267 bool hasDevice = false;
1268 for (int32_t i = 0; i < delist.size(); i++) {
1269 if (delist[i].GetClass() != 9) {
1270 device = delist[i];
1271 hasDevice = true;
1272 }
1273 }
1274 EXPECT_TRUE(hasDevice);
1275 UsbSrvClient.RequestRight(device.GetName());
1276 ret = UsbSrvClient.OpenDevice(device, pipe);
1277 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d OpenDevice=%{public}d", __LINE__,
1278 ret);
1279 ASSERT_EQ(ret, 0);
1280 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1281 pipe.SetBusNum(BUFFER_SIZE);
1282 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1283 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d UsbAttachKernelDriver=%{public}d",
1284 __LINE__, ret);
1285 ASSERT_NE(ret, 0);
1286 pipe.SetBusNum(device.GetBusNum());
1287 bool close = UsbSrvClient.Close(pipe);
1288 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d close=%{public}d", __LINE__, close);
1289 EXPECT_TRUE(close);
1290 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver002");
1291 }
1292
1293 /**
1294 * @tc.name: UsbAttachKernelDriver003
1295 * @tc.desc: Test functions to UsbAttachKernelDriver
1296 * @tc.type: FUNC
1297 */
1298 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver003, TestSize.Level1)
1299 {
1300 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver003");
1301 vector<UsbDevice> delist;
1302 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1303 auto ret = UsbSrvClient.GetDevices(delist);
1304 ASSERT_EQ(ret, 0);
1305 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d ret=%{public}d", __LINE__, ret);
1306 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1307 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d size=%{public}zu", __LINE__,
1308 delist.size());
1309 USBDevicePipe pipe;
1310 UsbDevice device;
1311 bool hasDevice = false;
1312 for (int32_t i = 0; i < delist.size(); i++) {
1313 if (delist[i].GetClass() != 9) {
1314 device = delist[i];
1315 hasDevice = true;
1316 }
1317 }
1318 EXPECT_TRUE(hasDevice);
1319 UsbSrvClient.RequestRight(device.GetName());
1320 ret = UsbSrvClient.OpenDevice(device, pipe);
1321 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d OpenDevice=%{public}d", __LINE__,
1322 ret);
1323 ASSERT_EQ(ret, 0);
1324 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1325 pipe.SetDevAddr(BUFFER_SIZE);
1326 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1327 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d UsbAttachKernelDriver=%{public}d",
1328 __LINE__, ret);
1329 ASSERT_NE(ret, 0);
1330 pipe.SetDevAddr(device.GetDevAddr());
1331 bool close = UsbSrvClient.Close(pipe);
1332 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d close=%{public}d", __LINE__, close);
1333 EXPECT_TRUE(close);
1334 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver003");
1335 }
1336
1337 /**
1338 * @tc.name: UsbAttachKernelDriver004
1339 * @tc.desc: Test functions to UsbAttachKernelDriver
1340 * @tc.type: FUNC
1341 */
1342 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver004, TestSize.Level1)
1343 {
1344 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver004");
1345 vector<UsbDevice> delist;
1346 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1347 auto ret = UsbSrvClient.GetDevices(delist);
1348 ASSERT_EQ(ret, 0);
1349 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d ret=%{public}d", __LINE__, ret);
1350 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1351 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d size=%{public}zu", __LINE__,
1352 delist.size());
1353 USBDevicePipe pipe;
1354 UsbDevice device;
1355 bool hasDevice = false;
1356 for (int32_t i = 0; i < delist.size(); i++) {
1357 if (delist[i].GetClass() != 9) {
1358 device = delist[i];
1359 hasDevice = true;
1360 }
1361 }
1362 EXPECT_TRUE(hasDevice);
1363 UsbSrvClient.RequestRight(device.GetName());
1364 ret = UsbSrvClient.OpenDevice(device, pipe);
1365 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d OpenDevice=%{public}d", __LINE__,
1366 ret);
1367 ASSERT_EQ(ret, 0);
1368 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1369 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1370 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d UsbAttachKernelDriver=%{public}d",
1371 __LINE__, ret);
1372 ASSERT_EQ(ret, 0);
1373 bool close = UsbSrvClient.Close(pipe);
1374 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d close=%{public}d", __LINE__, close);
1375 EXPECT_TRUE(close);
1376 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver004");
1377 }
1378
1379 /**
1380 * @tc.name: UsbAttachKernelDriver005
1381 * @tc.desc: Test functions to UsbAttachKernelDriver
1382 * @tc.type: FUNC
1383 */
1384 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver005, TestSize.Level1)
1385 {
1386 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver005");
1387 vector<UsbDevice> delist;
1388 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1389 auto ret = UsbSrvClient.GetDevices(delist);
1390 ASSERT_EQ(ret, 0);
1391 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d ret=%{public}d", __LINE__, ret);
1392 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1393 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d size=%{public}zu", __LINE__,
1394 delist.size());
1395 USBDevicePipe pipe;
1396 UsbDevice device;
1397 bool hasDevice = false;
1398 for (int32_t i = 0; i < delist.size(); i++) {
1399 if (delist[i].GetClass() != 9) {
1400 device = delist[i];
1401 hasDevice = true;
1402 }
1403 }
1404 EXPECT_TRUE(hasDevice);
1405 UsbSrvClient.RequestRight(device.GetName());
1406 ret = UsbSrvClient.OpenDevice(device, pipe);
1407 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d OpenDevice=%{public}d", __LINE__,
1408 ret);
1409 ASSERT_EQ(ret, 0);
1410 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1411 pipe.SetBusNum(BUFFER_SIZE);
1412 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1413 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d UsbAttachKernelDriver=%{public}d",
1414 __LINE__, ret);
1415 ASSERT_NE(ret, 0);
1416 pipe.SetBusNum(device.GetBusNum());
1417 bool close = UsbSrvClient.Close(pipe);
1418 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d close=%{public}d", __LINE__, close);
1419 EXPECT_TRUE(close);
1420 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver005");
1421 }
1422
1423 /**
1424 * @tc.name: UsbAttachKernelDriver006
1425 * @tc.desc: Test functions to UsbAttachKernelDriver
1426 * @tc.type: FUNC
1427 */
1428 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver006, TestSize.Level1)
1429 {
1430 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver006");
1431 vector<UsbDevice> delist;
1432 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1433 auto ret = UsbSrvClient.GetDevices(delist);
1434 ASSERT_EQ(ret, 0);
1435 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d ret=%{public}d", __LINE__, ret);
1436 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1437 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d size=%{public}zu", __LINE__,
1438 delist.size());
1439 USBDevicePipe pipe;
1440 UsbDevice device;
1441 bool hasDevice = false;
1442 for (int32_t i = 0; i < delist.size(); i++) {
1443 if (delist[i].GetClass() != 9) {
1444 device = delist[i];
1445 hasDevice = true;
1446 }
1447 }
1448 EXPECT_TRUE(hasDevice);
1449 UsbSrvClient.RequestRight(device.GetName());
1450 ret = UsbSrvClient.OpenDevice(device, pipe);
1451 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d OpenDevice=%{public}d", __LINE__,
1452 ret);
1453 ASSERT_EQ(ret, 0);
1454 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1455 pipe.SetDevAddr(BUFFER_SIZE);
1456 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1457 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d UsbAttachKernelDriver=%{public}d",
1458 __LINE__, ret);
1459 ASSERT_NE(ret, 0);
1460 pipe.SetDevAddr(device.GetDevAddr());
1461 bool close = UsbSrvClient.Close(pipe);
1462 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d close=%{public}d", __LINE__, close);
1463 EXPECT_TRUE(close);
1464 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus006");
1465 }
1466
1467 /**
1468 * @tc.name: UsbAttachKernelDriver007
1469 * @tc.desc: Test functions to UsbAttachKernelDriver
1470 * @tc.type: FUNC
1471 */
1472 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver007, TestSize.Level1)
1473 {
1474 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver007");
1475 vector<UsbDevice> delist;
1476 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1477 auto ret = UsbSrvClient.GetDevices(delist);
1478 ASSERT_EQ(ret, 0);
1479 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d ret=%{public}d", __LINE__, ret);
1480 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1481 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d size=%{public}zu", __LINE__,
1482 delist.size());
1483 USBDevicePipe pipe;
1484 UsbDevice device;
1485 bool hasDevice = false;
1486 for (int32_t i = 0; i < delist.size(); i++) {
1487 if (delist[i].GetClass() != 9) {
1488 device = delist[i];
1489 hasDevice = true;
1490 }
1491 }
1492 EXPECT_TRUE(hasDevice);
1493 UsbSrvClient.RequestRight(device.GetName());
1494 ret = UsbSrvClient.OpenDevice(device, pipe);
1495 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d OpenDevice=%{public}d", __LINE__,
1496 ret);
1497 ASSERT_EQ(ret, 0);
1498 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(0);
1499 pipe.SetDevAddr(BUFFER_SIZE);
1500 pipe.SetBusNum(BUFFER_SIZE);
1501 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1502 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d UsbAttachKernelDriver=%{public}d",
1503 __LINE__, ret);
1504 ASSERT_NE(ret, 0);
1505 pipe.SetDevAddr(device.GetDevAddr());
1506 pipe.SetBusNum(device.GetBusNum());
1507 bool close = UsbSrvClient.Close(pipe);
1508 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d close=%{public}d", __LINE__, close);
1509 EXPECT_TRUE(close);
1510 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver007");
1511 }
1512
1513 /**
1514 * @tc.name: UsbAttachKernelDriver008
1515 * @tc.desc: Test functions to UsbAttachKernelDriver
1516 * @tc.type: FUNC
1517 */
1518 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver008, TestSize.Level1)
1519 {
1520 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver008");
1521 vector<UsbDevice> delist;
1522 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1523 auto ret = UsbSrvClient.GetDevices(delist);
1524 ASSERT_EQ(ret, 0);
1525 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d ret=%{public}d", __LINE__, ret);
1526 EXPECT_TRUE(!(delist.empty())) << "delist NULL";
1527 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d size=%{public}zu", __LINE__,
1528 delist.size());
1529 USBDevicePipe pipe;
1530 UsbDevice device;
1531 bool hasDevice = false;
1532 for (int32_t i = 0; i < delist.size(); i++) {
1533 if (delist[i].GetClass() != 9) {
1534 device = delist[i];
1535 hasDevice = true;
1536 }
1537 }
1538 EXPECT_TRUE(hasDevice);
1539 UsbSrvClient.RequestRight(device.GetName());
1540 ret = UsbSrvClient.OpenDevice(device, pipe);
1541 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d OpenDevice=%{public}d", __LINE__,
1542 ret);
1543 ASSERT_EQ(ret, 0);
1544 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1545 pipe.SetDevAddr(BUFFER_SIZE);
1546 pipe.SetBusNum(BUFFER_SIZE);
1547 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1548 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d UsbAttachKernelDriver=%{public}d",
1549 __LINE__, ret);
1550 ASSERT_NE(ret, 0);
1551 pipe.SetDevAddr(device.GetDevAddr());
1552 pipe.SetBusNum(device.GetBusNum());
1553 bool close = UsbSrvClient.Close(pipe);
1554 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d close=%{public}d", __LINE__, close);
1555 EXPECT_TRUE(close);
1556 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver008");
1557 }
1558 } // USB
1559 } // OHOS
1560