1 /*
2 * Copyright (c) 2021-2023 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_0/iusb_interface.h"
21 #include "v1_0/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
29 const int SLEEP_TIME = 3;
30 const uint8_t BUS_NUM_255 = 255;
31 const uint8_t DEV_ADDR_255 = 255;
32 sptr<UsbSubscriberTest> UsbdDeviceTest::subscriber_ = nullptr;
33
34 namespace {
35 sptr<IUsbInterface> g_usbInterface = nullptr;
36
37 struct UsbDev UsbdDeviceTest::dev_ = { 0, 0 };
38
SetUpTestCase(void)39 void UsbdDeviceTest::SetUpTestCase(void)
40 {
41 g_usbInterface = IUsbInterface::Get();
42 if (g_usbInterface == nullptr) {
43 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
44 exit(0);
45 }
46 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
47 sleep(SLEEP_TIME);
48 HDF_LOGI("UsbdDeviceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
49 ASSERT_EQ(0, ret);
50 if (ret != 0) {
51 exit(0);
52 }
53
54 subscriber_ = new UsbSubscriberTest();
55 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
56 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
57 exit(0);
58 }
59 dev_ = { subscriber_->busNum_, subscriber_->devAddr_ };
60
61 std::cout << "please connect device, press enter to continue" << std::endl;
62 int c;
63 while ((c = getchar()) != '\n' && c != EOF) {
64 }
65 }
66
TearDownTestCase(void)67 void UsbdDeviceTest::TearDownTestCase(void)
68 {
69 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
70 }
71
SetUp(void)72 void UsbdDeviceTest::SetUp(void) {}
73
TearDown(void)74 void UsbdDeviceTest::TearDown(void) {}
75
76 /**
77 * @tc.name: SUB_USB_HDI_0010
78 * @tc.desc: Test functions to OpenDevice
79 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
80 * @tc.desc: Positive test: parameters correctly
81 * @tc.type: FUNC
82 */
83 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0010, Function | MediumTest | Level1)
84 {
85 struct UsbDev dev = dev_;
86 auto ret = g_usbInterface->OpenDevice(dev);
87 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result =%{public}d", __LINE__, ret);
88 ASSERT_EQ(0, ret);
89 }
90
91 /**
92 * @tc.name: SUB_USB_HDI_0020
93 * @tc.desc: Test functions to OpenDevice
94 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
95 * @tc.desc: Negative test: parameters exception, busNum error
96 * @tc.type: FUNC
97 */
98 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0020, Function | MediumTest | Level1)
99 {
100 struct UsbDev dev = { BUS_NUM_255, dev_.devAddr };
101 auto ret = g_usbInterface->OpenDevice(dev);
102 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
103 ASSERT_NE(ret, 0);
104 }
105
106 /**
107 * @tc.name: SUB_USB_HDI_0030
108 * @tc.desc: Test functions to OpenDevice
109 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
110 * @tc.desc: Negative test: parameters exception, devAddr error
111 * @tc.type: FUNC
112 */
113 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0030, Function | MediumTest | Level1)
114 {
115 struct UsbDev dev = { dev_.busNum, DEV_ADDR_255 };
116 auto ret = g_usbInterface->OpenDevice(dev);
117 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
118 ASSERT_NE(ret, 0);
119 }
120
121 /**
122 * @tc.name: SUB_USB_HDI_0040
123 * @tc.desc: Test functions to OpenDevice
124 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
125 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
126 * @tc.type: FUNC
127 */
128 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0040, Function | MediumTest | Level1)
129 {
130 struct UsbDev dev = { BUS_NUM_255, DEV_ADDR_255 };
131 auto ret = g_usbInterface->OpenDevice(dev);
132 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
133 ASSERT_NE(ret, 0);
134 }
135
136 /**********************************************************************************************************/
137
138 /**
139 * @tc.name: SUB_USB_HDI_0050
140 * @tc.desc: Test functions to CloseDevice
141 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
142 * @tc.desc: Positive test: parameters correctly
143 * @tc.type: FUNC
144 */
145 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0050, Function | MediumTest | Level1)
146 {
147 struct UsbDev dev = dev_;
148 auto ret = g_usbInterface->OpenDevice(dev);
149 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
150 ASSERT_EQ(0, ret);
151 ret = g_usbInterface->CloseDevice(dev);
152 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
153 ASSERT_EQ(0, ret);
154 }
155
156 /**
157 * @tc.name: SUB_USB_HDI_0060
158 * @tc.desc: Test functions to CloseDevice
159 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
160 * @tc.desc: Negative test: parameters exception, busNum error
161 * @tc.type: FUNC
162 */
163 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0060, Function | MediumTest | Level1)
164 {
165 struct UsbDev dev = dev_;
166 auto ret = g_usbInterface->OpenDevice(dev);
167 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
168 ASSERT_EQ(0, ret);
169 dev.busNum = BUS_NUM_255;
170 ret = g_usbInterface->CloseDevice(dev);
171 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
172 ASSERT_NE(ret, 0);
173 dev = dev_;
174 g_usbInterface->CloseDevice(dev);
175 }
176
177 /**
178 * @tc.name: SUB_USB_HDI_0070
179 * @tc.desc: Test functions to CloseDevice
180 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
181 * @tc.desc: Negative test: parameters exception, devAddr error
182 * @tc.type: FUNC
183 */
184 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0070, Function | MediumTest | Level1)
185 {
186 struct UsbDev dev = dev_;
187 auto ret = g_usbInterface->OpenDevice(dev);
188 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
189 ASSERT_EQ(0, ret);
190 dev.devAddr = DEV_ADDR_255;
191 ret = g_usbInterface->CloseDevice(dev);
192 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
193 ASSERT_NE(ret, 0);
194 dev = dev_;
195 g_usbInterface->CloseDevice(dev);
196 }
197
198 /**
199 * @tc.name: SUB_USB_HDI_0080
200 * @tc.desc: Test functions to CloseDevice
201 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
202 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
203 * @tc.type: FUNC
204 */
205 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0080, Function | MediumTest | Level1)
206 {
207 struct UsbDev dev = dev_;
208 auto ret = g_usbInterface->OpenDevice(dev);
209 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
210 ASSERT_EQ(0, ret);
211 dev.busNum = BUS_NUM_255;
212 dev.devAddr = DEV_ADDR_255;
213 ret = g_usbInterface->CloseDevice(dev);
214 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
215 ASSERT_NE(ret, 0);
216 dev = dev_;
217 g_usbInterface->CloseDevice(dev);
218 }
219 } // namespace