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> devi;
87 auto &UsbSrvClient = UsbSrvClient::GetInstance();
88 auto ret = UsbSrvClient.GetDevices(devi);
89 ASSERT_EQ(ret, 0);
90 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d ret=%{public}d", __LINE__, ret);
91 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
92 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d size=%{public}zu", __LINE__,
93 devi.size());
94 USBDevicePipe pipe;
95 UsbDevice device = devi.front();
96 UsbSrvClient.RequestRight(device.GetName());
97 ret = UsbSrvClient.OpenDevice(device, pipe);
98 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d OpenDevice=%{public}d",
99 __LINE__, ret);
100 ASSERT_EQ(ret, 0);
101 uint8_t speed = 0;
102 ret = UsbSrvClient.GetDeviceSpeed(pipe, speed);
103 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d GetFileDescriptor=%{public}d",
104 __LINE__, ret);
105 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed001 %{public}d speed=%{public}u",
106 __LINE__, speed);
107 ASSERT_EQ(ret, 0);
108 ret = UsbSrvClient.Close(pipe);
109 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
110 EXPECT_TRUE(ret);
111 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed001");
112 }
113
114 /**
115 * @tc.name: GetDeviceSpeed002
116 * @tc.desc: Test functions to GetDeviceSpeed
117 * @tc.type: FUNC
118 */
119 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed002, TestSize.Level1)
120 {
121 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed002");
122 vector<UsbDevice> devi;
123 auto &UsbSrvClient = UsbSrvClient::GetInstance();
124 auto ret = UsbSrvClient.GetDevices(devi);
125 ASSERT_EQ(ret, 0);
126 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d ret=%{public}d", __LINE__, ret);
127 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
128 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d size=%{public}zu", __LINE__,
129 devi.size());
130 USBDevicePipe pipe;
131 UsbDevice device = devi.front();
132 UsbSrvClient.RequestRight(device.GetName());
133 ret = UsbSrvClient.OpenDevice(device, pipe);
134 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d OpenDevice=%{public}d",
135 __LINE__, ret);
136 ASSERT_EQ(ret, 0);
137 USBDevicePipe pipeTmp = pipe;
138 pipeTmp.SetBusNum(BUFFER_SIZE);
139 uint8_t speed = 0;
140 ret = UsbSrvClient.GetDeviceSpeed(pipeTmp, speed);
141 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d GetFileDescriptor=%{public}d",
142 __LINE__, ret);
143 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed002 %{public}d speed=%{public}u",
144 __LINE__, speed);
145 ASSERT_NE(ret, 0);
146 pipe.SetBusNum(device.GetBusNum());
147 ret = UsbSrvClient.Close(pipe);
148 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
149 EXPECT_TRUE(ret);
150 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed002");
151 }
152
153 /**
154 * @tc.name: GetDeviceSpeed003
155 * @tc.desc: Test functions to GetDeviceSpeed
156 * @tc.type: FUNC
157 */
158 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed003, TestSize.Level1)
159 {
160 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed003");
161 vector<UsbDevice> devi;
162 auto &UsbSrvClient = UsbSrvClient::GetInstance();
163 auto ret = UsbSrvClient.GetDevices(devi);
164 ASSERT_EQ(ret, 0);
165 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d ret=%{public}d", __LINE__, ret);
166 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
167 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d size=%{public}zu", __LINE__,
168 devi.size());
169 USBDevicePipe pipe;
170 UsbDevice device = devi.front();
171 UsbSrvClient.RequestRight(device.GetName());
172 ret = UsbSrvClient.OpenDevice(device, pipe);
173 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d OpenDevice=%{public}d",
174 __LINE__, ret);
175 ASSERT_EQ(ret, 0);
176 USBDevicePipe pipeTmp = pipe;
177 pipeTmp.SetDevAddr(BUFFER_SIZE);
178 uint8_t speed = 0;
179 ret = UsbSrvClient.GetDeviceSpeed(pipeTmp, speed);
180 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d GetFileDescriptor=%{public}d",
181 __LINE__, ret);
182 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed003 %{public}d speed=%{public}u",
183 __LINE__, speed);
184 ASSERT_NE(ret, 0);
185 pipe.SetDevAddr(device.GetDevAddr());
186 ret = UsbSrvClient.Close(pipe);
187 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
188 EXPECT_TRUE(ret);
189 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed003");
190 }
191
192 /**
193 * @tc.name: GetDeviceSpeed004
194 * @tc.desc: Test functions to GetDeviceSpeed
195 * @tc.type: FUNC
196 */
197 HWTEST_F(UsbDeviceStatusTest, GetDeviceSpeed004, TestSize.Level1)
198 {
199 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetDeviceSpeed004");
200 vector<UsbDevice> devi;
201 auto &UsbSrvClient = UsbSrvClient::GetInstance();
202 auto ret = UsbSrvClient.GetDevices(devi);
203 ASSERT_EQ(ret, 0);
204 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d ret=%{public}d", __LINE__, ret);
205 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
206 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d size=%{public}zu", __LINE__,
207 devi.size());
208 USBDevicePipe pipe;
209 UsbDevice device = devi.front();
210 UsbSrvClient.RequestRight(device.GetName());
211 ret = UsbSrvClient.OpenDevice(device, pipe);
212 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d OpenDevice=%{public}d",
213 __LINE__, ret);
214 ASSERT_EQ(ret, 0);
215 USBDevicePipe pipeTmp = pipe;
216 pipeTmp.SetBusNum(BUFFER_SIZE);
217 pipeTmp.SetDevAddr(BUFFER_SIZE);
218 uint8_t speed = 0;
219 ret = UsbSrvClient.GetDeviceSpeed(pipeTmp, speed);
220 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d GetFileDescriptor=%{public}d",
221 __LINE__, ret);
222 USB_HILOGI(MODULE_USB_SERVICE, "GetDeviceSpeed004 %{public}d speed=%{public}u",
223 __LINE__, speed);
224 ASSERT_NE(ret, 0);
225 pipe.SetBusNum(device.GetBusNum());
226 pipe.SetDevAddr(device.GetDevAddr());
227 ret = UsbSrvClient.Close(pipe);
228 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::Close=%{public}d", ret);
229 EXPECT_TRUE(ret);
230 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetDeviceSpeed004");
231 }
232
233 /**
234 * @tc.name: ClearHalt001
235 * @tc.desc: Test functions to ClearHalt
236 * @tc.type: FUNC
237 */
238 HWTEST_F(UsbDeviceStatusTest, ClearHalt001, TestSize.Level1)
239 {
240 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt001");
241 vector<UsbDevice> devi;
242 auto &UsbSrvClient = UsbSrvClient::GetInstance();
243 auto ret = UsbSrvClient.GetDevices(devi);
244 ASSERT_EQ(ret, 0);
245 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d ret=%{public}d", __LINE__, ret);
246 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
247 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d size=%{public}zu", __LINE__,
248 devi.size());
249 USBDevicePipe pipe;
250 UsbDevice device = devi.front();
251 UsbSrvClient.RequestRight(device.GetName());
252 ret = UsbSrvClient.OpenDevice(device, pipe);
253 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d OpenDevice=%{public}d", __LINE__, ret);
254 ASSERT_EQ(ret, 0);
255 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
256 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
257 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt001 %{public}d ClaimInterface=%{public}d", __LINE__,
258 ret);
259 ASSERT_EQ(ret, 0);
260
261 if (!interface.GetEndpoints().empty()) {
262 USBEndpoint ep = interface.GetEndpoints().front();
263 ret = UsbSrvClient.ClearHalt(pipe, ep);
264 ASSERT_EQ(ret, 0);
265 } else {
266 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt001 %{public}d no endpoints", __LINE__);
267 }
268
269 bool close = UsbSrvClient.Close(pipe);
270 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt001 %{public}d close=%{public}d", __LINE__, close);
271 EXPECT_TRUE(close);
272 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt001");
273 }
274
275 /**
276 * @tc.name: ClearHalt002
277 * @tc.desc: Test functions to ClearHalt
278 * @tc.type: FUNC
279 */
280 HWTEST_F(UsbDeviceStatusTest, ClearHalt002, TestSize.Level1)
281 {
282 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt002");
283 vector<UsbDevice> devi;
284 auto &UsbSrvClient = UsbSrvClient::GetInstance();
285 auto ret = UsbSrvClient.GetDevices(devi);
286 ASSERT_EQ(ret, 0);
287 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d ret=%{public}d", __LINE__, ret);
288 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
289 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d size=%{public}zu", __LINE__,
290 devi.size());
291 USBDevicePipe pipe;
292 UsbDevice device = devi.front();
293 UsbSrvClient.RequestRight(device.GetName());
294 ret = UsbSrvClient.OpenDevice(device, pipe);
295 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d OpenDevice=%{public}d", __LINE__, ret);
296 ASSERT_EQ(ret, 0);
297 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
298 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
299 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt002 %{public}d ClaimInterface=%{public}d", __LINE__,
300 ret);
301 ASSERT_EQ(ret, 0);
302
303 pipe.SetBusNum(BUFFER_SIZE);
304 if (!interface.GetEndpoints().empty()) {
305 USBEndpoint ep = interface.GetEndpoints().front();
306 ret = UsbSrvClient.ClearHalt(pipe, ep);
307 EXPECT_FALSE(ret == 0);
308 } else {
309 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt002 %{public}d no endpoints", __LINE__);
310 }
311
312 bool close = UsbSrvClient.Close(pipe);
313 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt002 %{public}d close=%{public}d", __LINE__, close);
314 EXPECT_TRUE(!close);
315 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt002");
316 }
317
318 /**
319 * @tc.name: ClearHalt003
320 * @tc.desc: Test functions to ClearHalt
321 * @tc.type: FUNC
322 */
323 HWTEST_F(UsbDeviceStatusTest, ClearHalt003, TestSize.Level1)
324 {
325 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt003");
326 vector<UsbDevice> devi;
327 auto &UsbSrvClient = UsbSrvClient::GetInstance();
328 auto ret = UsbSrvClient.GetDevices(devi);
329 ASSERT_EQ(ret, 0);
330 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d ret=%{public}d", __LINE__, ret);
331 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
332 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d size=%{public}zu", __LINE__,
333 devi.size());
334 USBDevicePipe pipe;
335 UsbDevice device = devi.front();
336 UsbSrvClient.RequestRight(device.GetName());
337 ret = UsbSrvClient.OpenDevice(device, pipe);
338 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d OpenDevice=%{public}d", __LINE__, ret);
339 ASSERT_EQ(ret, 0);
340 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
341 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
342 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt003 %{public}d ClaimInterface=%{public}d", __LINE__,
343 ret);
344 ASSERT_EQ(ret, 0);
345
346 pipe.SetDevAddr(BUFFER_SIZE);
347 if (!interface.GetEndpoints().empty()) {
348 USBEndpoint ep = interface.GetEndpoints().front();
349 ret = UsbSrvClient.ClearHalt(pipe, ep);
350 EXPECT_FALSE(ret == 0);
351 } else {
352 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt003 %{public}d no endpoints", __LINE__);
353 }
354
355 bool close = UsbSrvClient.Close(pipe);
356 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt003 %{public}d close=%{public}d", __LINE__, close);
357 EXPECT_TRUE(!close);
358 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt003");
359 }
360
361 /**
362 * @tc.name: ClearHalt004
363 * @tc.desc: Test functions to ClearHalt
364 * @tc.type: FUNC
365 */
366 HWTEST_F(UsbDeviceStatusTest, ClearHalt004, TestSize.Level1)
367 {
368 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : ClearHalt004");
369 vector<UsbDevice> devi;
370 auto &UsbSrvClient = UsbSrvClient::GetInstance();
371 auto ret = UsbSrvClient.GetDevices(devi);
372 ASSERT_EQ(ret, 0);
373 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d ret=%{public}d", __LINE__, ret);
374 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
375 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d size=%{public}zu", __LINE__,
376 devi.size());
377 USBDevicePipe pipe;
378 UsbDevice device = devi.front();
379 UsbSrvClient.RequestRight(device.GetName());
380 ret = UsbSrvClient.OpenDevice(device, pipe);
381 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d OpenDevice=%{public}d", __LINE__, ret);
382 ASSERT_EQ(ret, 0);
383 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
384 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
385 USB_HILOGI(MODULE_USB_SERVICE, "UsbDeviceStatusTest::ClearHalt004 %{public}d ClaimInterface=%{public}d", __LINE__,
386 ret);
387 ASSERT_EQ(ret, 0);
388 pipe.SetBusNum(BUFFER_SIZE);
389 pipe.SetDevAddr(BUFFER_SIZE);
390 if (!interface.GetEndpoints().empty()) {
391 USBEndpoint ep = interface.GetEndpoints().front();
392 ret = UsbSrvClient.ClearHalt(pipe, ep);
393 EXPECT_FALSE(ret == 0);
394 } else {
395 USB_HILOGW(MODULE_USB_SERVICE, "ClearHalt004 %{public}d no endpoints", __LINE__);
396 }
397
398 bool close = UsbSrvClient.Close(pipe);
399 USB_HILOGI(MODULE_USB_SERVICE, "ClearHalt004 %{public}d close=%{public}d", __LINE__, close);
400 EXPECT_TRUE(!close);
401 USB_HILOGI(MODULE_USB_SERVICE, "Case End : ClearHalt004");
402 }
403
404 /**
405 * @tc.name: GetInterfaceStatus001
406 * @tc.desc: Test functions to GetInterfaceStatus
407 * @tc.type: FUNC
408 */
409 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus001, TestSize.Level1)
410 {
411 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus001");
412 vector<UsbDevice> devi;
413 auto &UsbSrvClient = UsbSrvClient::GetInstance();
414 auto ret = UsbSrvClient.GetDevices(devi);
415 ASSERT_EQ(ret, 0);
416 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d ret=%{public}d", __LINE__, ret);
417 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
418 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d size=%{public}zu", __LINE__,
419 devi.size());
420 USBDevicePipe pipe;
421 UsbDevice device = devi.front();
422 UsbSrvClient.RequestRight(device.GetName());
423 ret = UsbSrvClient.OpenDevice(device, pipe);
424 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d OpenDevice=%{public}d", __LINE__,
425 ret);
426 ASSERT_EQ(ret, 0);
427 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
428 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
429 USB_HILOGI(MODULE_USB_SERVICE, "UsbDevicePipeTest::SetInterface006 %{public}d ClaimInterface=%{public}d", __LINE__,
430 ret);
431 ASSERT_EQ(ret, 0);
432 bool unactived = 1;
433 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
434 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d GetInterfaceStatus=%{public}d",
435 __LINE__, ret);
436 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d unactived=%{public}d",
437 __LINE__, unactived);
438 ASSERT_EQ(ret, 0);
439 bool close = UsbSrvClient.Close(pipe);
440 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus001 %{public}d close=%{public}d", __LINE__, close);
441 EXPECT_TRUE(close);
442 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus001");
443 }
444
445 /**
446 * @tc.name: GetInterfaceStatus002
447 * @tc.desc: Test functions to GetInterfaceStatus
448 * @tc.type: FUNC
449 */
450 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus002, TestSize.Level1)
451 {
452 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus002");
453 vector<UsbDevice> devi;
454 auto &UsbSrvClient = UsbSrvClient::GetInstance();
455 auto ret = UsbSrvClient.GetDevices(devi);
456 ASSERT_EQ(ret, 0);
457 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d ret=%{public}d", __LINE__, ret);
458 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
459 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d size=%{public}zu", __LINE__,
460 devi.size());
461 USBDevicePipe pipe;
462 UsbDevice device = devi.front();
463 UsbSrvClient.RequestRight(device.GetName());
464 ret = UsbSrvClient.OpenDevice(device, pipe);
465 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d OpenDevice=%{public}d", __LINE__,
466 ret);
467 ASSERT_EQ(ret, 0);
468 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
469 pipe.SetBusNum(BUFFER_SIZE);
470 bool unactived = 1;
471 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
472 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d GetInterfaceStatus=%{public}d",
473 __LINE__, ret);
474 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d unactived=%{public}d",
475 __LINE__, unactived);
476 ASSERT_NE(ret, 0);
477 pipe.SetBusNum(device.GetBusNum());
478 bool close = UsbSrvClient.Close(pipe);
479 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus002 %{public}d close=%{public}d", __LINE__, close);
480 EXPECT_TRUE(close);
481 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus002");
482 }
483
484 /**
485 * @tc.name: GetInterfaceStatus003
486 * @tc.desc: Test functions to GetInterfaceStatus
487 * @tc.type: FUNC
488 */
489 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus003, TestSize.Level1)
490 {
491 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus003");
492 vector<UsbDevice> devi;
493 auto &UsbSrvClient = UsbSrvClient::GetInstance();
494 auto ret = UsbSrvClient.GetDevices(devi);
495 ASSERT_EQ(ret, 0);
496 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d ret=%{public}d", __LINE__, ret);
497 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
498 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d size=%{public}zu", __LINE__,
499 devi.size());
500 USBDevicePipe pipe;
501 UsbDevice device = devi.front();
502 UsbSrvClient.RequestRight(device.GetName());
503 ret = UsbSrvClient.OpenDevice(device, pipe);
504 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d OpenDevice=%{public}d", __LINE__,
505 ret);
506 ASSERT_EQ(ret, 0);
507 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
508 pipe.SetDevAddr(BUFFER_SIZE);
509 bool unactived = 1;
510 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
511 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d GetInterfaceStatus=%{public}d",
512 __LINE__, ret);
513 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d unactived=%{public}d",
514 __LINE__, unactived);
515 ASSERT_NE(ret, 0);
516 pipe.SetDevAddr(device.GetDevAddr());
517 bool close = UsbSrvClient.Close(pipe);
518 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus003 %{public}d close=%{public}d", __LINE__, close);
519 EXPECT_TRUE(close);
520 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus003");
521 }
522
523 /**
524 * @tc.name: GetInterfaceStatus004
525 * @tc.desc: Test functions to GetInterfaceStatus
526 * @tc.type: FUNC
527 */
528 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus004, TestSize.Level1)
529 {
530 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus004");
531 vector<UsbDevice> devi;
532 auto &UsbSrvClient = UsbSrvClient::GetInstance();
533 auto ret = UsbSrvClient.GetDevices(devi);
534 ASSERT_EQ(ret, 0);
535 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d ret=%{public}d", __LINE__, ret);
536 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
537 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d size=%{public}zu", __LINE__,
538 devi.size());
539 USBDevicePipe pipe;
540 UsbDevice device = devi.front();
541 UsbSrvClient.RequestRight(device.GetName());
542 ret = UsbSrvClient.OpenDevice(device, pipe);
543 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d OpenDevice=%{public}d", __LINE__,
544 ret);
545 ASSERT_EQ(ret, 0);
546 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
547 bool unactived = 1;
548 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
549 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d GetInterfaceStatus=%{public}d",
550 __LINE__, ret);
551 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d unactived=%{public}d",
552 __LINE__, unactived);
553 ASSERT_EQ(ret, 0);
554 bool close = UsbSrvClient.Close(pipe);
555 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus004 %{public}d close=%{public}d", __LINE__, close);
556 EXPECT_TRUE(close);
557 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus004");
558 }
559
560 /**
561 * @tc.name: GetInterfaceStatus005
562 * @tc.desc: Test functions to GetInterfaceStatus
563 * @tc.type: FUNC
564 */
565 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus005, TestSize.Level1)
566 {
567 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus005");
568 vector<UsbDevice> devi;
569 auto &UsbSrvClient = UsbSrvClient::GetInstance();
570 auto ret = UsbSrvClient.GetDevices(devi);
571 ASSERT_EQ(ret, 0);
572 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d ret=%{public}d", __LINE__, ret);
573 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
574 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d size=%{public}zu", __LINE__,
575 devi.size());
576 USBDevicePipe pipe;
577 UsbDevice device = devi.front();
578 UsbSrvClient.RequestRight(device.GetName());
579 ret = UsbSrvClient.OpenDevice(device, pipe);
580 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d OpenDevice=%{public}d", __LINE__,
581 ret);
582 ASSERT_EQ(ret, 0);
583 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
584 pipe.SetBusNum(BUFFER_SIZE);
585 bool unactived = 1;
586 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
587 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d GetInterfaceStatus=%{public}d",
588 __LINE__, ret);
589 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d unactived=%{public}d",
590 __LINE__, unactived);
591 ASSERT_NE(ret, 0);
592 pipe.SetBusNum(device.GetBusNum());
593 bool close = UsbSrvClient.Close(pipe);
594 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus005 %{public}d close=%{public}d", __LINE__, close);
595 EXPECT_TRUE(close);
596 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus005");
597 }
598
599 /**
600 * @tc.name: GetInterfaceStatus006
601 * @tc.desc: Test functions to GetInterfaceStatus
602 * @tc.type: FUNC
603 */
604 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus006, TestSize.Level1)
605 {
606 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus007");
607 vector<UsbDevice> devi;
608 auto &UsbSrvClient = UsbSrvClient::GetInstance();
609 auto ret = UsbSrvClient.GetDevices(devi);
610 ASSERT_EQ(ret, 0);
611 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d ret=%{public}d", __LINE__, ret);
612 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
613 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d size=%{public}zu", __LINE__,
614 devi.size());
615 USBDevicePipe pipe;
616 UsbDevice device = devi.front();
617 UsbSrvClient.RequestRight(device.GetName());
618 ret = UsbSrvClient.OpenDevice(device, pipe);
619 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d OpenDevice=%{public}d", __LINE__,
620 ret);
621 ASSERT_EQ(ret, 0);
622 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
623 pipe.SetDevAddr(BUFFER_SIZE);
624 bool unactived = 1;
625 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
626 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d GetInterfaceStatus=%{public}d",
627 __LINE__, ret);
628 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d unactived=%{public}d",
629 __LINE__, unactived);
630 ASSERT_NE(ret, 0);
631 pipe.SetDevAddr(device.GetDevAddr());
632 bool close = UsbSrvClient.Close(pipe);
633 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d close=%{public}d", __LINE__, close);
634 EXPECT_TRUE(close);
635 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus006");
636 }
637
638 /**
639 * @tc.name: GetInterfaceStatus007
640 * @tc.desc: Test functions to GetInterfaceStatus
641 * @tc.type: FUNC
642 */
643 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus007, TestSize.Level1)
644 {
645 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus007");
646 vector<UsbDevice> devi;
647 auto &UsbSrvClient = UsbSrvClient::GetInstance();
648 auto ret = UsbSrvClient.GetDevices(devi);
649 ASSERT_EQ(ret, 0);
650 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d ret=%{public}d", __LINE__, ret);
651 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
652 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d size=%{public}zu", __LINE__,
653 devi.size());
654 USBDevicePipe pipe;
655 UsbDevice device = devi.front();
656 UsbSrvClient.RequestRight(device.GetName());
657 ret = UsbSrvClient.OpenDevice(device, pipe);
658 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d OpenDevice=%{public}d", __LINE__,
659 ret);
660 ASSERT_EQ(ret, 0);
661 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(0);
662 pipe.SetDevAddr(BUFFER_SIZE);
663 pipe.SetBusNum(BUFFER_SIZE);
664 bool unactived = 1;
665 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
666 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d GetInterfaceStatus=%{public}d",
667 __LINE__, ret);
668 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d unactived=%{public}d",
669 __LINE__, unactived);
670 ASSERT_NE(ret, 0);
671 pipe.SetDevAddr(device.GetDevAddr());
672 pipe.SetBusNum(device.GetBusNum());
673 bool close = UsbSrvClient.Close(pipe);
674 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus007 %{public}d close=%{public}d", __LINE__, close);
675 EXPECT_TRUE(close);
676 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus007");
677 }
678
679 /**
680 * @tc.name: GetInterfaceStatus008
681 * @tc.desc: Test functions to GetInterfaceStatus
682 * @tc.type: FUNC
683 */
684 HWTEST_F(UsbDeviceStatusTest, GetInterfaceStatus008, TestSize.Level1)
685 {
686 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : GetInterfaceStatus008");
687 vector<UsbDevice> devi;
688 auto &UsbSrvClient = UsbSrvClient::GetInstance();
689 auto ret = UsbSrvClient.GetDevices(devi);
690 ASSERT_EQ(ret, 0);
691 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d ret=%{public}d", __LINE__, ret);
692 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
693 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d size=%{public}zu", __LINE__,
694 devi.size());
695 USBDevicePipe pipe;
696 UsbDevice device = devi.front();
697 UsbSrvClient.RequestRight(device.GetName());
698 ret = UsbSrvClient.OpenDevice(device, pipe);
699 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d OpenDevice=%{public}d", __LINE__,
700 ret);
701 ASSERT_EQ(ret, 0);
702 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
703 pipe.SetDevAddr(BUFFER_SIZE);
704 pipe.SetBusNum(BUFFER_SIZE);
705 bool unactived = 1;
706 ret = UsbSrvClient.GetInterfaceActiveStatus(pipe, interface, unactived);
707 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d GetInterfaceStatus=%{public}d",
708 __LINE__, ret);
709 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d unactived=%{public}d",
710 __LINE__, unactived);
711 ASSERT_NE(ret, 0);
712 pipe.SetDevAddr(device.GetDevAddr());
713 pipe.SetBusNum(device.GetBusNum());
714 bool close = UsbSrvClient.Close(pipe);
715 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus008 %{public}d close=%{public}d", __LINE__, close);
716 EXPECT_TRUE(close);
717 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus008");
718 }
719
720 /**
721 * @tc.name: UsbDetachKernelDriver001
722 * @tc.desc: Test functions to UsbDetachKernelDriver
723 * @tc.type: FUNC
724 */
725 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver001, TestSize.Level1)
726 {
727 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver001");
728 vector<UsbDevice> devi;
729 auto &UsbSrvClient = UsbSrvClient::GetInstance();
730 auto ret = UsbSrvClient.GetDevices(devi);
731 ASSERT_EQ(ret, 0);
732 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d ret=%{public}d", __LINE__, ret);
733 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
734 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d size=%{public}zu", __LINE__,
735 devi.size());
736 USBDevicePipe pipe;
737 UsbDevice device = devi.front();
738 UsbSrvClient.RequestRight(device.GetName());
739 ret = UsbSrvClient.OpenDevice(device, pipe);
740 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d OpenDevice=%{public}d", __LINE__,
741 ret);
742 ASSERT_EQ(ret, 0);
743 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
744 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d UsbAttachKernelDriver=%{public}d",
745 __LINE__, ret);
746 ASSERT_EQ(ret, 0);
747 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
748 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d UsbDetachKernelDriver=%{public}d",
749 __LINE__, ret);
750 ASSERT_EQ(ret, 0);
751 bool close = UsbSrvClient.Close(pipe);
752 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver001 %{public}d close=%{public}d", __LINE__, close);
753 EXPECT_TRUE(close);
754 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver001");
755 }
756
757 /**
758 * @tc.name: UsbDetachKernelDriver002
759 * @tc.desc: Test functions to UsbDetachKernelDriver
760 * @tc.type: FUNC
761 */
762 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver002, TestSize.Level1)
763 {
764 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver002");
765 vector<UsbDevice> devi;
766 auto &UsbSrvClient = UsbSrvClient::GetInstance();
767 auto ret = UsbSrvClient.GetDevices(devi);
768 ASSERT_EQ(ret, 0);
769 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d ret=%{public}d", __LINE__, ret);
770 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
771 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d size=%{public}zu", __LINE__,
772 devi.size());
773 USBDevicePipe pipe;
774 UsbDevice device = devi.front();
775 UsbSrvClient.RequestRight(device.GetName());
776 ret = UsbSrvClient.OpenDevice(device, pipe);
777 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d OpenDevice=%{public}d", __LINE__,
778 ret);
779 ASSERT_EQ(ret, 0);
780 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
781 pipe.SetBusNum(BUFFER_SIZE);
782 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
783 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d UsbDetachKernelDriver=%{public}d",
784 __LINE__, ret);
785 ASSERT_NE(ret, 0);
786 pipe.SetBusNum(device.GetBusNum());
787 bool close = UsbSrvClient.Close(pipe);
788 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver002 %{public}d close=%{public}d", __LINE__, close);
789 EXPECT_TRUE(close);
790 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver002");
791 }
792
793 /**
794 * @tc.name: UsbDetachKernelDriver003
795 * @tc.desc: Test functions to UsbDetachKernelDriver
796 * @tc.type: FUNC
797 */
798 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver003, TestSize.Level1)
799 {
800 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver003");
801 vector<UsbDevice> devi;
802 auto &UsbSrvClient = UsbSrvClient::GetInstance();
803 auto ret = UsbSrvClient.GetDevices(devi);
804 ASSERT_EQ(ret, 0);
805 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d ret=%{public}d", __LINE__, ret);
806 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
807 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d size=%{public}zu", __LINE__,
808 devi.size());
809 USBDevicePipe pipe;
810 UsbDevice device = devi.front();
811 UsbSrvClient.RequestRight(device.GetName());
812 ret = UsbSrvClient.OpenDevice(device, pipe);
813 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d OpenDevice=%{public}d", __LINE__,
814 ret);
815 ASSERT_EQ(ret, 0);
816 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
817 pipe.SetDevAddr(BUFFER_SIZE);
818 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
819 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d UsbDetachKernelDriver=%{public}d",
820 __LINE__, ret);
821 ASSERT_NE(ret, 0);
822 pipe.SetDevAddr(device.GetDevAddr());
823 bool close = UsbSrvClient.Close(pipe);
824 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver003 %{public}d close=%{public}d", __LINE__, close);
825 EXPECT_TRUE(close);
826 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver003");
827 }
828
829 /**
830 * @tc.name: UsbDetachKernelDriver004
831 * @tc.desc: Test functions to UsbDetachKernelDriver
832 * @tc.type: FUNC
833 */
834 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver004, TestSize.Level1)
835 {
836 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver004");
837 vector<UsbDevice> devi;
838 auto &UsbSrvClient = UsbSrvClient::GetInstance();
839 auto ret = UsbSrvClient.GetDevices(devi);
840 ASSERT_EQ(ret, 0);
841 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d ret=%{public}d", __LINE__, ret);
842 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
843 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d size=%{public}zu", __LINE__,
844 devi.size());
845 USBDevicePipe pipe;
846 UsbDevice device = devi.front();
847 UsbSrvClient.RequestRight(device.GetName());
848 ret = UsbSrvClient.OpenDevice(device, pipe);
849 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d OpenDevice=%{public}d", __LINE__,
850 ret);
851 ASSERT_EQ(ret, 0);
852 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
853 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
854 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d UsbAttachKernelDriver=%{public}d",
855 __LINE__, ret);
856 ASSERT_EQ(ret, 0);
857 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
858 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d UsbDetachKernelDriver=%{public}d",
859 __LINE__, ret);
860 ASSERT_EQ(ret, 0);
861 bool close = UsbSrvClient.Close(pipe);
862 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver004 %{public}d close=%{public}d", __LINE__, close);
863 EXPECT_TRUE(close);
864 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver004");
865 }
866
867 /**
868 * @tc.name: UsbDetachKernelDriver005
869 * @tc.desc: Test functions to UsbDetachKernelDriver
870 * @tc.type: FUNC
871 */
872 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver005, TestSize.Level1)
873 {
874 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver005");
875 vector<UsbDevice> devi;
876 auto &UsbSrvClient = UsbSrvClient::GetInstance();
877 auto ret = UsbSrvClient.GetDevices(devi);
878 ASSERT_EQ(ret, 0);
879 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d ret=%{public}d", __LINE__, ret);
880 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
881 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d size=%{public}zu", __LINE__,
882 devi.size());
883 USBDevicePipe pipe;
884 UsbDevice device = devi.front();
885 UsbSrvClient.RequestRight(device.GetName());
886 ret = UsbSrvClient.OpenDevice(device, pipe);
887 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d OpenDevice=%{public}d", __LINE__,
888 ret);
889 ASSERT_EQ(ret, 0);
890 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
891 pipe.SetBusNum(BUFFER_SIZE);
892 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
893 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d UsbDetachKernelDriver=%{public}d",
894 __LINE__, ret);
895 ASSERT_NE(ret, 0);
896 pipe.SetBusNum(device.GetBusNum());
897 bool close = UsbSrvClient.Close(pipe);
898 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver005 %{public}d close=%{public}d", __LINE__, close);
899 EXPECT_TRUE(close);
900 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver005");
901 }
902
903 /**
904 * @tc.name: UsbDetachKernelDriver006
905 * @tc.desc: Test functions to UsbDetachKernelDriver
906 * @tc.type: FUNC
907 */
908 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver006, TestSize.Level1)
909 {
910 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver006");
911 vector<UsbDevice> devi;
912 auto &UsbSrvClient = UsbSrvClient::GetInstance();
913 auto ret = UsbSrvClient.GetDevices(devi);
914 ASSERT_EQ(ret, 0);
915 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d ret=%{public}d", __LINE__, ret);
916 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
917 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d size=%{public}zu", __LINE__,
918 devi.size());
919 USBDevicePipe pipe;
920 UsbDevice device = devi.front();
921 UsbSrvClient.RequestRight(device.GetName());
922 ret = UsbSrvClient.OpenDevice(device, pipe);
923 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d OpenDevice=%{public}d", __LINE__,
924 ret);
925 ASSERT_EQ(ret, 0);
926 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
927 pipe.SetDevAddr(BUFFER_SIZE);
928 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
929 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver006 %{public}d UsbDetachKernelDriver=%{public}d",
930 __LINE__, ret);
931 ASSERT_NE(ret, 0);
932 pipe.SetDevAddr(device.GetDevAddr());
933 bool close = UsbSrvClient.Close(pipe);
934 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d close=%{public}d", __LINE__, close);
935 EXPECT_TRUE(close);
936 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus006");
937 }
938
939 /**
940 * @tc.name: UsbDetachKernelDriver007
941 * @tc.desc: Test functions to UsbDetachKernelDriver
942 * @tc.type: FUNC
943 */
944 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver007, TestSize.Level1)
945 {
946 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver007");
947 vector<UsbDevice> devi;
948 auto &UsbSrvClient = UsbSrvClient::GetInstance();
949 auto ret = UsbSrvClient.GetDevices(devi);
950 ASSERT_EQ(ret, 0);
951 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d ret=%{public}d", __LINE__, ret);
952 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
953 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d size=%{public}zu", __LINE__,
954 devi.size());
955 USBDevicePipe pipe;
956 UsbDevice device = devi.front();
957 UsbSrvClient.RequestRight(device.GetName());
958 ret = UsbSrvClient.OpenDevice(device, pipe);
959 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d OpenDevice=%{public}d", __LINE__,
960 ret);
961 ASSERT_EQ(ret, 0);
962 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(0);
963 pipe.SetDevAddr(BUFFER_SIZE);
964 pipe.SetBusNum(BUFFER_SIZE);
965 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
966 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d UsbDetachKernelDriver=%{public}d",
967 __LINE__, ret);
968 ASSERT_NE(ret, 0);
969 pipe.SetDevAddr(device.GetDevAddr());
970 pipe.SetBusNum(device.GetBusNum());
971 bool close = UsbSrvClient.Close(pipe);
972 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver007 %{public}d close=%{public}d", __LINE__, close);
973 EXPECT_TRUE(close);
974 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver007");
975 }
976
977 /**
978 * @tc.name: UsbDetachKernelDriver008
979 * @tc.desc: Test functions to UsbDetachKernelDriver
980 * @tc.type: FUNC
981 */
982 HWTEST_F(UsbDeviceStatusTest, UsbDetachKernelDriver008, TestSize.Level1)
983 {
984 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbDetachKernelDriver008");
985 vector<UsbDevice> devi;
986 auto &UsbSrvClient = UsbSrvClient::GetInstance();
987 auto ret = UsbSrvClient.GetDevices(devi);
988 ASSERT_EQ(ret, 0);
989 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d ret=%{public}d", __LINE__, ret);
990 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
991 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d size=%{public}zu", __LINE__,
992 devi.size());
993 USBDevicePipe pipe;
994 UsbDevice device = devi.front();
995 UsbSrvClient.RequestRight(device.GetName());
996 ret = UsbSrvClient.OpenDevice(device, pipe);
997 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d OpenDevice=%{public}d", __LINE__,
998 ret);
999 ASSERT_EQ(ret, 0);
1000 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1001 pipe.SetDevAddr(BUFFER_SIZE);
1002 pipe.SetBusNum(BUFFER_SIZE);
1003 ret = UsbSrvClient.UsbDetachKernelDriver(pipe, interface);
1004 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d UsbDetachKernelDriver=%{public}d",
1005 __LINE__, ret);
1006 ASSERT_NE(ret, 0);
1007 pipe.SetDevAddr(device.GetDevAddr());
1008 pipe.SetBusNum(device.GetBusNum());
1009 bool close = UsbSrvClient.Close(pipe);
1010 USB_HILOGI(MODULE_USB_SERVICE, "UsbDetachKernelDriver008 %{public}d close=%{public}d", __LINE__, close);
1011 EXPECT_TRUE(close);
1012 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbDetachKernelDriver008");
1013 }
1014
1015 /**
1016 * @tc.name: UsbAttachKernelDriver001
1017 * @tc.desc: Test functions to UsbAttachKernelDriver
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver001, TestSize.Level1)
1021 {
1022 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver001");
1023 vector<UsbDevice> devi;
1024 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1025 auto ret = UsbSrvClient.GetDevices(devi);
1026 ASSERT_EQ(ret, 0);
1027 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d ret=%{public}d", __LINE__, ret);
1028 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1029 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d size=%{public}zu", __LINE__,
1030 devi.size());
1031 USBDevicePipe pipe;
1032 UsbDevice device = devi.front();
1033 UsbSrvClient.RequestRight(device.GetName());
1034 ret = UsbSrvClient.OpenDevice(device, pipe);
1035 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d OpenDevice=%{public}d", __LINE__,
1036 ret);
1037 ASSERT_EQ(ret, 0);
1038 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1039 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1040 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d UsbAttachKernelDriver=%{public}d",
1041 __LINE__, ret);
1042 ASSERT_EQ(ret, 0);
1043 bool close = UsbSrvClient.Close(pipe);
1044 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver001 %{public}d close=%{public}d", __LINE__, close);
1045 EXPECT_TRUE(close);
1046 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver001");
1047 }
1048
1049 /**
1050 * @tc.name: UsbAttachKernelDriver002
1051 * @tc.desc: Test functions to UsbAttachKernelDriver
1052 * @tc.type: FUNC
1053 */
1054 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver002, TestSize.Level1)
1055 {
1056 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver002");
1057 vector<UsbDevice> devi;
1058 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1059 auto ret = UsbSrvClient.GetDevices(devi);
1060 ASSERT_EQ(ret, 0);
1061 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d ret=%{public}d", __LINE__, ret);
1062 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1063 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d size=%{public}zu", __LINE__,
1064 devi.size());
1065 USBDevicePipe pipe;
1066 UsbDevice device = devi.front();
1067 UsbSrvClient.RequestRight(device.GetName());
1068 ret = UsbSrvClient.OpenDevice(device, pipe);
1069 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d OpenDevice=%{public}d", __LINE__,
1070 ret);
1071 ASSERT_EQ(ret, 0);
1072 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1073 pipe.SetBusNum(BUFFER_SIZE);
1074 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1075 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d UsbAttachKernelDriver=%{public}d",
1076 __LINE__, ret);
1077 ASSERT_NE(ret, 0);
1078 pipe.SetBusNum(device.GetBusNum());
1079 bool close = UsbSrvClient.Close(pipe);
1080 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver002 %{public}d close=%{public}d", __LINE__, close);
1081 EXPECT_TRUE(close);
1082 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver002");
1083 }
1084
1085 /**
1086 * @tc.name: UsbAttachKernelDriver003
1087 * @tc.desc: Test functions to UsbAttachKernelDriver
1088 * @tc.type: FUNC
1089 */
1090 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver003, TestSize.Level1)
1091 {
1092 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver003");
1093 vector<UsbDevice> devi;
1094 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1095 auto ret = UsbSrvClient.GetDevices(devi);
1096 ASSERT_EQ(ret, 0);
1097 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d ret=%{public}d", __LINE__, ret);
1098 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1099 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d size=%{public}zu", __LINE__,
1100 devi.size());
1101 USBDevicePipe pipe;
1102 UsbDevice device = devi.front();
1103 UsbSrvClient.RequestRight(device.GetName());
1104 ret = UsbSrvClient.OpenDevice(device, pipe);
1105 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d OpenDevice=%{public}d", __LINE__,
1106 ret);
1107 ASSERT_EQ(ret, 0);
1108 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
1109 pipe.SetDevAddr(BUFFER_SIZE);
1110 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1111 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d UsbAttachKernelDriver=%{public}d",
1112 __LINE__, ret);
1113 ASSERT_NE(ret, 0);
1114 pipe.SetDevAddr(device.GetDevAddr());
1115 bool close = UsbSrvClient.Close(pipe);
1116 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver003 %{public}d close=%{public}d", __LINE__, close);
1117 EXPECT_TRUE(close);
1118 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver003");
1119 }
1120
1121 /**
1122 * @tc.name: UsbAttachKernelDriver004
1123 * @tc.desc: Test functions to UsbAttachKernelDriver
1124 * @tc.type: FUNC
1125 */
1126 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver004, TestSize.Level1)
1127 {
1128 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver004");
1129 vector<UsbDevice> devi;
1130 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1131 auto ret = UsbSrvClient.GetDevices(devi);
1132 ASSERT_EQ(ret, 0);
1133 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d ret=%{public}d", __LINE__, ret);
1134 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1135 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d size=%{public}zu", __LINE__,
1136 devi.size());
1137 USBDevicePipe pipe;
1138 UsbDevice device = devi.front();
1139 UsbSrvClient.RequestRight(device.GetName());
1140 ret = UsbSrvClient.OpenDevice(device, pipe);
1141 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d OpenDevice=%{public}d", __LINE__,
1142 ret);
1143 ASSERT_EQ(ret, 0);
1144 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1145 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1146 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d UsbAttachKernelDriver=%{public}d",
1147 __LINE__, ret);
1148 ASSERT_EQ(ret, 0);
1149 bool close = UsbSrvClient.Close(pipe);
1150 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver004 %{public}d close=%{public}d", __LINE__, close);
1151 EXPECT_TRUE(close);
1152 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver004");
1153 }
1154
1155 /**
1156 * @tc.name: UsbAttachKernelDriver005
1157 * @tc.desc: Test functions to UsbAttachKernelDriver
1158 * @tc.type: FUNC
1159 */
1160 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver005, TestSize.Level1)
1161 {
1162 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver005");
1163 vector<UsbDevice> devi;
1164 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1165 auto ret = UsbSrvClient.GetDevices(devi);
1166 ASSERT_EQ(ret, 0);
1167 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d ret=%{public}d", __LINE__, ret);
1168 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1169 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d size=%{public}zu", __LINE__,
1170 devi.size());
1171 USBDevicePipe pipe;
1172 UsbDevice device = devi.front();
1173 UsbSrvClient.RequestRight(device.GetName());
1174 ret = UsbSrvClient.OpenDevice(device, pipe);
1175 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d OpenDevice=%{public}d", __LINE__,
1176 ret);
1177 ASSERT_EQ(ret, 0);
1178 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1179 pipe.SetBusNum(BUFFER_SIZE);
1180 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1181 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d UsbAttachKernelDriver=%{public}d",
1182 __LINE__, ret);
1183 ASSERT_NE(ret, 0);
1184 pipe.SetBusNum(device.GetBusNum());
1185 bool close = UsbSrvClient.Close(pipe);
1186 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver005 %{public}d close=%{public}d", __LINE__, close);
1187 EXPECT_TRUE(close);
1188 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver005");
1189 }
1190
1191 /**
1192 * @tc.name: UsbAttachKernelDriver006
1193 * @tc.desc: Test functions to UsbAttachKernelDriver
1194 * @tc.type: FUNC
1195 */
1196 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver006, TestSize.Level1)
1197 {
1198 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver006");
1199 vector<UsbDevice> devi;
1200 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1201 auto ret = UsbSrvClient.GetDevices(devi);
1202 ASSERT_EQ(ret, 0);
1203 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d ret=%{public}d", __LINE__, ret);
1204 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1205 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d size=%{public}zu", __LINE__,
1206 devi.size());
1207 USBDevicePipe pipe;
1208 UsbDevice device = devi.front();
1209 UsbSrvClient.RequestRight(device.GetName());
1210 ret = UsbSrvClient.OpenDevice(device, pipe);
1211 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d OpenDevice=%{public}d", __LINE__,
1212 ret);
1213 ASSERT_EQ(ret, 0);
1214 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1215 pipe.SetDevAddr(BUFFER_SIZE);
1216 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1217 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver006 %{public}d UsbAttachKernelDriver=%{public}d",
1218 __LINE__, ret);
1219 ASSERT_NE(ret, 0);
1220 pipe.SetDevAddr(device.GetDevAddr());
1221 bool close = UsbSrvClient.Close(pipe);
1222 USB_HILOGI(MODULE_USB_SERVICE, "GetInterfaceStatus006 %{public}d close=%{public}d", __LINE__, close);
1223 EXPECT_TRUE(close);
1224 USB_HILOGI(MODULE_USB_SERVICE, "Case End : GetInterfaceStatus006");
1225 }
1226
1227 /**
1228 * @tc.name: UsbAttachKernelDriver007
1229 * @tc.desc: Test functions to UsbAttachKernelDriver
1230 * @tc.type: FUNC
1231 */
1232 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver007, TestSize.Level1)
1233 {
1234 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver007");
1235 vector<UsbDevice> devi;
1236 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1237 auto ret = UsbSrvClient.GetDevices(devi);
1238 ASSERT_EQ(ret, 0);
1239 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d ret=%{public}d", __LINE__, ret);
1240 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1241 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d size=%{public}zu", __LINE__,
1242 devi.size());
1243 USBDevicePipe pipe;
1244 UsbDevice device = devi.front();
1245 UsbSrvClient.RequestRight(device.GetName());
1246 ret = UsbSrvClient.OpenDevice(device, pipe);
1247 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d OpenDevice=%{public}d", __LINE__,
1248 ret);
1249 ASSERT_EQ(ret, 0);
1250 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(0);
1251 pipe.SetDevAddr(BUFFER_SIZE);
1252 pipe.SetBusNum(BUFFER_SIZE);
1253 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1254 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d UsbAttachKernelDriver=%{public}d",
1255 __LINE__, ret);
1256 ASSERT_NE(ret, 0);
1257 pipe.SetDevAddr(device.GetDevAddr());
1258 pipe.SetBusNum(device.GetBusNum());
1259 bool close = UsbSrvClient.Close(pipe);
1260 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver007 %{public}d close=%{public}d", __LINE__, close);
1261 EXPECT_TRUE(close);
1262 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver007");
1263 }
1264
1265 /**
1266 * @tc.name: UsbAttachKernelDriver008
1267 * @tc.desc: Test functions to UsbAttachKernelDriver
1268 * @tc.type: FUNC
1269 */
1270 HWTEST_F(UsbDeviceStatusTest, UsbAttachKernelDriver008, TestSize.Level1)
1271 {
1272 USB_HILOGI(MODULE_USB_SERVICE, "Case Start : UsbAttachKernelDriver008");
1273 vector<UsbDevice> devi;
1274 auto &UsbSrvClient = UsbSrvClient::GetInstance();
1275 auto ret = UsbSrvClient.GetDevices(devi);
1276 ASSERT_EQ(ret, 0);
1277 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d ret=%{public}d", __LINE__, ret);
1278 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
1279 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d size=%{public}zu", __LINE__,
1280 devi.size());
1281 USBDevicePipe pipe;
1282 UsbDevice device = devi.front();
1283 UsbSrvClient.RequestRight(device.GetName());
1284 ret = UsbSrvClient.OpenDevice(device, pipe);
1285 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d OpenDevice=%{public}d", __LINE__,
1286 ret);
1287 ASSERT_EQ(ret, 0);
1288 UsbInterface interface = device.GetConfigs().at(0).GetInterfaces().at(1);
1289 pipe.SetDevAddr(BUFFER_SIZE);
1290 pipe.SetBusNum(BUFFER_SIZE);
1291 ret = UsbSrvClient.UsbAttachKernelDriver(pipe, interface);
1292 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d UsbAttachKernelDriver=%{public}d",
1293 __LINE__, ret);
1294 ASSERT_NE(ret, 0);
1295 pipe.SetDevAddr(device.GetDevAddr());
1296 pipe.SetBusNum(device.GetBusNum());
1297 bool close = UsbSrvClient.Close(pipe);
1298 USB_HILOGI(MODULE_USB_SERVICE, "UsbAttachKernelDriver008 %{public}d close=%{public}d", __LINE__, close);
1299 EXPECT_TRUE(close);
1300 USB_HILOGI(MODULE_USB_SERVICE, "Case End : UsbAttachKernelDriver008");
1301 }
1302 } // USB
1303 } // OHOS
1304