1 /*
2 * Copyright (c) 2021-2025 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 #include <iostream>
16 #include <vector>
17
18 #include "hdf_log.h"
19 #include "usbd_device_test.h"
20 #include "v1_2/iusb_interface.h"
21 #include "v1_2/usb_types.h"
22
23 using namespace testing::ext;
24 using namespace OHOS;
25 using namespace OHOS::USB;
26 using namespace std;
27 using namespace OHOS::HDI::Usb::V1_0;
28 using namespace OHOS::HDI::Usb::V1_2;
29
30 const int SLEEP_TIME = 3;
31 const uint8_t BUS_NUM_INVALID = 255;
32 const uint8_t DEV_ADDR_INVALID = 255;
33 sptr<UsbSubscriberTest> UsbdDeviceTest::subscriber_ = nullptr;
34
35 namespace {
36 sptr<OHOS::HDI::Usb::V1_2::IUsbInterface> g_usbInterface = nullptr;
37
38 struct UsbDev UsbdDeviceTest::dev_ = { 0, 0 };
39
SetUpTestCase(void)40 void UsbdDeviceTest::SetUpTestCase(void)
41 {
42 g_usbInterface = OHOS::HDI::Usb::V1_2::IUsbInterface::Get();
43 if (g_usbInterface == nullptr) {
44 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
45 exit(0);
46 }
47 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
48 sleep(SLEEP_TIME);
49 HDF_LOGI("UsbdDeviceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
50 if (ret != 0) {
51 ASSERT_EQ(HDF_ERR_NOT_SUPPORT, ret);
52 } else {
53 ASSERT_EQ(0, ret);
54 }
55
56 subscriber_ = new UsbSubscriberTest();
57 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
58 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
59 exit(0);
60 }
61 dev_ = { subscriber_->busNum_, subscriber_->devAddr_ };
62
63 std::cout << "please connect device, press enter to continue" << std::endl;
64 int c;
65 while ((c = getchar()) != '\n' && c != EOF) {
66 }
67 }
68
TearDownTestCase(void)69 void UsbdDeviceTest::TearDownTestCase(void)
70 {
71 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
72 }
73
SetUp(void)74 void UsbdDeviceTest::SetUp(void) {}
75
TearDown(void)76 void UsbdDeviceTest::TearDown(void) {}
77
78 /**
79 * @tc.name: SUB_USB_HostManager_HDI_Func_0100
80 * @tc.desc: Test functions to OpenDevice
81 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
82 * @tc.desc: Positive test: parameters correctly
83 * @tc.type: FUNC
84 */
85 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Func_0100, Function | MediumTest | Level1)
86 {
87 struct UsbDev dev = dev_;
88 auto ret = g_usbInterface->OpenDevice(dev);
89 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result =%{public}d", __LINE__, ret);
90 ASSERT_EQ(0, ret);
91 }
92
93 /**
94 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_0100
95 * @tc.desc: Test functions to OpenDevice
96 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
97 * @tc.desc: Negative test: parameters exception, busNum error
98 * @tc.type: FUNC
99 */
100 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Compatibility_0100, Function | MediumTest | Level1)
101 {
102 struct UsbDev dev = { BUS_NUM_INVALID, dev_.devAddr };
103 auto ret = g_usbInterface->OpenDevice(dev);
104 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
105 ASSERT_NE(ret, 0);
106 }
107
108 /**
109 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_0200
110 * @tc.desc: Test functions to OpenDevice
111 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
112 * @tc.desc: Negative test: parameters exception, devAddr error
113 * @tc.type: FUNC
114 */
115 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Compatibility_0200, Function | MediumTest | Level1)
116 {
117 struct UsbDev dev = { dev_.busNum, DEV_ADDR_INVALID };
118 auto ret = g_usbInterface->OpenDevice(dev);
119 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
120 ASSERT_NE(ret, 0);
121 }
122
123 /**
124 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_0300
125 * @tc.desc: Test functions to OpenDevice
126 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
127 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
128 * @tc.type: FUNC
129 */
130 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Compatibility_0300, Function | MediumTest | Level1)
131 {
132 struct UsbDev dev = { BUS_NUM_INVALID, DEV_ADDR_INVALID };
133 auto ret = g_usbInterface->OpenDevice(dev);
134 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
135 ASSERT_NE(ret, 0);
136 }
137
138 /**********************************************************************************************************/
139
140 /**
141 * @tc.name: SUB_USB_HostManager_HDI_Func_1400
142 * @tc.desc: Test functions to CloseDevice
143 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
144 * @tc.desc: Positive test: parameters correctly
145 * @tc.type: FUNC
146 */
147 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Func_1400, Function | MediumTest | Level1)
148 {
149 struct UsbDev dev = dev_;
150 auto ret = g_usbInterface->OpenDevice(dev);
151 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
152 ASSERT_EQ(0, ret);
153 ret = g_usbInterface->CloseDevice(dev);
154 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
155 ASSERT_EQ(0, ret);
156 }
157
158 /**
159 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7000
160 * @tc.desc: Test functions to CloseDevice
161 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
162 * @tc.desc: Negative test: parameters exception, busNum error
163 * @tc.type: FUNC
164 */
165 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Compatibility_7000, Function | MediumTest | Level1)
166 {
167 struct UsbDev dev = dev_;
168 auto ret = g_usbInterface->OpenDevice(dev);
169 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
170 ASSERT_EQ(0, ret);
171 dev.busNum = BUS_NUM_INVALID;
172 ret = g_usbInterface->CloseDevice(dev);
173 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
174 ASSERT_NE(ret, 0);
175 dev = dev_;
176 g_usbInterface->CloseDevice(dev);
177 }
178
179 /**
180 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7100
181 * @tc.desc: Test functions to CloseDevice
182 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
183 * @tc.desc: Negative test: parameters exception, devAddr error
184 * @tc.type: FUNC
185 */
186 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Compatibility_7100, Function | MediumTest | Level1)
187 {
188 struct UsbDev dev = dev_;
189 auto ret = g_usbInterface->OpenDevice(dev);
190 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
191 ASSERT_EQ(0, ret);
192 dev.devAddr = DEV_ADDR_INVALID;
193 ret = g_usbInterface->CloseDevice(dev);
194 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
195 ASSERT_NE(ret, 0);
196 dev = dev_;
197 g_usbInterface->CloseDevice(dev);
198 }
199
200 /**
201 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7200
202 * @tc.desc: Test functions to CloseDevice
203 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
204 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
205 * @tc.type: FUNC
206 */
207 HWTEST_F(UsbdDeviceTest, SUB_USB_HostManager_HDI_Compatibility_7200, Function | MediumTest | Level1)
208 {
209 struct UsbDev dev = dev_;
210 auto ret = g_usbInterface->OpenDevice(dev);
211 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
212 ASSERT_EQ(0, ret);
213 dev.busNum = BUS_NUM_INVALID;
214 dev.devAddr = DEV_ADDR_INVALID;
215 ret = g_usbInterface->CloseDevice(dev);
216 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
217 ASSERT_NE(ret, 0);
218 dev = dev_;
219 g_usbInterface->CloseDevice(dev);
220 }
221
222 /**
223 * @tc.number : SUB_USB_HostManager_HDI_Func_1900
224 * @tc.name : UsbdResetDevice001
225 * @tc.desc : int32_t ResetDevice(const UsbDev &dev)
226 * @tc.desc : Positive test: parameters correctly
227 * @tc.size : MediumTest
228 * @tc.type : Function
229 * @tc.level : Level 3
230 */
231 HWTEST_F(UsbdDeviceTest, UsbdResetDevice001, Function | MediumTest | Level1)
232 {
233 struct UsbDev dev = dev_;
234 auto ret = g_usbInterface->OpenDevice(dev);
235 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
236 ASSERT_EQ(0, ret);
237 ret = g_usbInterface->ResetDevice(dev);
238 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d UsbdResetDevice001 result=%{public}d", __LINE__, ret);
239 ASSERT_EQ(0, ret);
240 ret = g_usbInterface->CloseDevice(dev);
241 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
242 ASSERT_EQ(0, ret);
243 }
244
245 /**
246 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_9000
247 * @tc.name : UsbdResetDevice002
248 * @tc.desc : int32_t ResetDevice(const UsbDev &dev)
249 * @tc.desc : Negative test
250 * @tc.size : MediumTest
251 * @tc.type : Function
252 * @tc.level : Level 3
253 */
254 HWTEST_F(UsbdDeviceTest, UsbdResetDevice002, Function | MediumTest | Level1)
255 {
256 struct UsbDev dev = dev_;
257 auto ret = g_usbInterface->OpenDevice(dev);
258 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
259 ASSERT_EQ(0, ret);
260 dev.busNum = BUS_NUM_INVALID;
261 ret = g_usbInterface->ResetDevice(dev);
262 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d UsbdResetDevice002 result=%{public}d", __LINE__, ret);
263 ASSERT_NE(0, ret);
264 ret = g_usbInterface->CloseDevice(dev);
265 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
266 ASSERT_NE(ret, 0);
267 dev = dev_;
268 g_usbInterface->CloseDevice(dev);
269 }
270
271 /**
272 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_9100
273 * @tc.name : UsbdResetDevice003
274 * @tc.desc : int32_t ResetDevice(const UsbDev &dev)
275 * @tc.desc : Negative test
276 * @tc.size : MediumTest
277 * @tc.type : Function
278 * @tc.level : Level 3
279 */
280 HWTEST_F(UsbdDeviceTest, UsbdResetDevice003, Function | MediumTest | Level1)
281 {
282 struct UsbDev dev = dev_;
283 auto ret = g_usbInterface->OpenDevice(dev);
284 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
285 ASSERT_EQ(0, ret);
286 dev.devAddr = DEV_ADDR_INVALID;
287 ret = g_usbInterface->ResetDevice(dev);
288 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d UsbdResetDevice003 result=%{public}d", __LINE__, ret);
289 ASSERT_NE(0, ret);
290 ret = g_usbInterface->CloseDevice(dev);
291 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
292 ASSERT_NE(ret, 0);
293 dev = dev_;
294 g_usbInterface->CloseDevice(dev);
295 }
296
297 /**
298 * @tc.number : SUB_USB_HostManager_HDI_Compatibility_9200
299 * @tc.name : UsbdResetDevice004
300 * @tc.desc : int32_t ResetDevice(const UsbDev &dev)
301 * @tc.desc : Negative test
302 * @tc.size : MediumTest
303 * @tc.type : Function
304 * @tc.level : Level 3
305 */
306 HWTEST_F(UsbdDeviceTest, UsbdResetDevice004, Function | MediumTest | Level1)
307 {
308 struct UsbDev dev = dev_;
309 auto ret = g_usbInterface->OpenDevice(dev);
310 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
311 ASSERT_EQ(0, ret);
312 dev.busNum = BUS_NUM_INVALID;
313 dev.devAddr = DEV_ADDR_INVALID;
314 ret = g_usbInterface->ResetDevice(dev);
315 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d UsbdResetDevice004 result=%{public}d", __LINE__, ret);
316 ASSERT_NE(0, ret);
317 ret = g_usbInterface->CloseDevice(dev);
318 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
319 ASSERT_NE(ret, 0);
320 dev = dev_;
321 g_usbInterface->CloseDevice(dev);
322 }
323 } // namespace