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_1/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_1;
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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(ret == 0);
260
261 if (!interface.GetEndpoints().empty()) {
262 USBEndpoint ep = interface.GetEndpoints().front();
263 ret = UsbSrvClient.ClearHalt(pipe, ep);
264 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 EXPECT_TRUE(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 } // USB
720 } // OHOS