1 /*
2 * Copyright (c) 2021-2022 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 "UsbSubscriberTest.h"
19 #include "hdf_log.h"
20 #include "usbd_device_test.h"
21 #include "v1_0/iusb_interface.h"
22 #include "v1_0/usb_types.h"
23
24 const int SLEEP_TIME = 3;
25 const uint8_t BUS_NUM_255 = 255;
26 const uint8_t DEV_ADDR_255 = 255;
27
28 using namespace testing::ext;
29 using namespace OHOS;
30 using namespace OHOS::USB;
31 using namespace std;
32 using namespace OHOS::HDI::Usb::V1_0;
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 sptr<UsbSubscriberTest> 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
SetUp(void)69 void UsbdDeviceTest::SetUp(void) {}
70
TearDown(void)71 void UsbdDeviceTest::TearDown(void) {}
72
73 /**
74 * @tc.name: SUB_USB_HDI_0010
75 * @tc.desc: Test functions to OpenDevice
76 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
77 * @tc.desc: Positive test: parameters correctly
78 * @tc.type: FUNC
79 */
80 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0010, Function | MediumTest | Level1)
81 {
82 struct UsbDev dev = dev_;
83 auto ret = g_usbInterface->OpenDevice(dev);
84 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result =%{public}d", __LINE__, ret);
85 ASSERT_EQ(0, ret);
86 }
87
88 /**
89 * @tc.name: SUB_USB_HDI_0020
90 * @tc.desc: Test functions to OpenDevice
91 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
92 * @tc.desc: Negative test: parameters exception, busNum error
93 * @tc.type: FUNC
94 */
95 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0020, Function | MediumTest | Level1)
96 {
97 struct UsbDev dev = { BUS_NUM_255, dev_.devAddr };
98 auto ret = g_usbInterface->OpenDevice(dev);
99 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
100 ASSERT_NE(ret, 0);
101 }
102
103 /**
104 * @tc.name: SUB_USB_HDI_0030
105 * @tc.desc: Test functions to OpenDevice
106 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
107 * @tc.desc: Negative test: parameters exception, devAddr error
108 * @tc.type: FUNC
109 */
110 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0030, Function | MediumTest | Level1)
111 {
112 struct UsbDev dev = { dev_.busNum, DEV_ADDR_255 };
113 auto ret = g_usbInterface->OpenDevice(dev);
114 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
115 ASSERT_NE(ret, 0);
116 }
117
118 /**
119 * @tc.name: SUB_USB_HDI_0040
120 * @tc.desc: Test functions to OpenDevice
121 * @tc.desc: int32_t OpenDevice(const UsbDev &dev);
122 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
123 * @tc.type: FUNC
124 */
125 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0040, Function | MediumTest | Level1)
126 {
127 struct UsbDev dev = { BUS_NUM_255, DEV_ADDR_255 };
128 auto ret = g_usbInterface->OpenDevice(dev);
129 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
130 ASSERT_NE(ret, 0);
131 }
132
133 /**********************************************************************************************************/
134
135 /**
136 * @tc.name: SUB_USB_HDI_0050
137 * @tc.desc: Test functions to CloseDevice
138 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
139 * @tc.desc: Positive test: parameters correctly
140 * @tc.type: FUNC
141 */
142 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0050, Function | MediumTest | Level1)
143 {
144 struct UsbDev dev = dev_;
145 auto ret = g_usbInterface->OpenDevice(dev);
146 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
147 ASSERT_EQ(0, ret);
148 ret = g_usbInterface->CloseDevice(dev);
149 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
150 ASSERT_EQ(0, ret);
151 }
152
153 /**
154 * @tc.name: SUB_USB_HDI_0060
155 * @tc.desc: Test functions to CloseDevice
156 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
157 * @tc.desc: Negative test: parameters exception, busNum error
158 * @tc.type: FUNC
159 */
160 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0060, Function | MediumTest | Level1)
161 {
162 struct UsbDev dev = dev_;
163 auto ret = g_usbInterface->OpenDevice(dev);
164 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
165 ASSERT_EQ(0, ret);
166 dev.busNum = BUS_NUM_255;
167 ret = g_usbInterface->CloseDevice(dev);
168 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
169 ASSERT_NE(ret, 0);
170 dev = dev_;
171 g_usbInterface->CloseDevice(dev);
172 }
173
174 /**
175 * @tc.name: SUB_USB_HDI_0070
176 * @tc.desc: Test functions to CloseDevice
177 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
178 * @tc.desc: Negative test: parameters exception, devAddr error
179 * @tc.type: FUNC
180 */
181 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0070, Function | MediumTest | Level1)
182 {
183 struct UsbDev dev = dev_;
184 auto ret = g_usbInterface->OpenDevice(dev);
185 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
186 ASSERT_EQ(0, ret);
187 dev.devAddr = DEV_ADDR_255;
188 ret = g_usbInterface->CloseDevice(dev);
189 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
190 ASSERT_NE(ret, 0);
191 dev = dev_;
192 g_usbInterface->CloseDevice(dev);
193 }
194
195 /**
196 * @tc.name: SUB_USB_HDI_0080
197 * @tc.desc: Test functions to CloseDevice
198 * @tc.desc: int32_t CloseDevice(const UsbDev &dev);
199 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
200 * @tc.type: FUNC
201 */
202 HWTEST_F(UsbdDeviceTest, SUB_USB_HDI_0080, Function | MediumTest | Level1)
203 {
204 struct UsbDev dev = dev_;
205 auto ret = g_usbInterface->OpenDevice(dev);
206 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d OpenDevice result=%{public}d", __LINE__, ret);
207 ASSERT_EQ(0, ret);
208 dev.busNum = BUS_NUM_255;
209 dev.devAddr = DEV_ADDR_255;
210 ret = g_usbInterface->CloseDevice(dev);
211 HDF_LOGI("UsbdDeviceTest:: Line:%{public}d Close result=%{public}d", __LINE__, ret);
212 ASSERT_NE(ret, 0);
213 dev = dev_;
214 g_usbInterface->CloseDevice(dev);
215 }
216 } // namespace