1 /*
2 * Copyright (c) 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
16 #include "usbd_manage_interface_test.h"
17
18 #include <iostream>
19 #include <vector>
20
21 #include "hdf_log.h"
22 #include "v1_0/iusb_interface.h"
23 #include "v1_0/usb_types.h"
24
25 const int SLEEP_TIME = 3;
26 const uint8_t BUS_NUM_INVALID = 255;
27 const uint8_t DEV_ADDR_INVALID = 255;
28 const uint8_t INTERFACEID_OK = 1;
29 const uint8_t INTERFACEID_OK_NEW = 0;
30 const uint8_t INTERFACEID_INVALID = 255;
31
32 using namespace testing::ext;
33 using namespace OHOS;
34 using namespace OHOS::USB;
35 using namespace std;
36 using namespace OHOS::HDI::Usb::V1_0;
37 namespace OHOS {
38 namespace USB {
39 namespace ManageInterface {
40 UsbDev UsbdManageInterfaceTest::dev_ = {0, 0};
41 sptr<UsbSubscriberTest> UsbdManageInterfaceTest::subscriber_ = nullptr;
42 sptr<IUsbInterface> g_usbInterface = nullptr;
43
SwitchErrCode(int32_t ret)44 int32_t SwitchErrCode(int32_t ret)
45 {
46 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
47 }
48
SetUpTestCase(void)49 void UsbdManageInterfaceTest::SetUpTestCase(void)
50 {
51 g_usbInterface = IUsbInterface::Get();
52 if (g_usbInterface == nullptr) {
53 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
54 exit(0);
55 }
56 auto ret = g_usbInterface->SetPortRole(1, 1, 1);
57 sleep(SLEEP_TIME);
58 HDF_LOGI("UsbdManageInterfaceTest::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
59 ret = SwitchErrCode(ret);
60 ASSERT_EQ(0, ret);
61 if (ret != 0) {
62 exit(0);
63 }
64
65 subscriber_ = new UsbSubscriberTest();
66 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
67 HDF_LOGE("%{public}s: bind usbd subscriber_ failed", __func__);
68 exit(0);
69 }
70
71 std::cout << "please connect device, press enter to continue" << std::endl;
72 int c;
73 while ((c = getchar()) != '\n' && c != EOF) {}
74 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
75
76 ret = g_usbInterface->OpenDevice(dev_);
77 HDF_LOGI("UsbdManageInterfaceTest:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
78 ASSERT_EQ(0, ret);
79 }
80
TearDownTestCase(void)81 void UsbdManageInterfaceTest::TearDownTestCase(void)
82 {
83 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
84 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
85 auto ret = g_usbInterface->CloseDevice(dev_);
86 HDF_LOGI("UsbdManageInterfaceTest:: %{public}d Close=%{public}d", __LINE__, ret);
87 ASSERT_EQ(0, ret);
88 }
89
SetUp(void)90 void UsbdManageInterfaceTest::SetUp(void) {}
91
TearDown(void)92 void UsbdManageInterfaceTest::TearDown(void) {}
93
94 /**
95 * @tc.name: SUB_USB_HostManager_HDI_Func_1500
96 * @tc.desc: Test functions to ManageInterface
97 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
98 * @tc.desc: Positive test: parameters correctly
99 * @tc.type: FUNC
100 */
101 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Func_1500, Function | MediumTest | Level1)
102 {
103 uint8_t interfaceId = INTERFACEID_OK_NEW;
104 struct UsbDev dev = dev_;
105 int32_t ret = -1;
106 for (; interfaceId < INTERFACEID_INVALID; interfaceId++) {
107 ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
108 if (ret == 0) {
109 break;
110 }
111 }
112 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Func_1500 %{public}d ManageInterface=%{public}d",
113 __LINE__, ret);
114 ASSERT_EQ(0, ret);
115 }
116
117 /**
118 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7300
119 * @tc.desc: Test functions to ManageInterface
120 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
121 * @tc.desc: Negative test: parameters exception, busNum error
122 * @tc.type: FUNC
123 */
124 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7300, Function | MediumTest | Level1)
125 {
126 uint8_t interfaceId = INTERFACEID_OK;
127 struct UsbDev dev = dev_;
128 dev.busNum = BUS_NUM_INVALID;
129 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
130 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7300 %{public}d ret=%{public}d",
131 __LINE__, ret);
132 ASSERT_NE(ret, 0);
133 }
134
135 /**
136 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7400
137 * @tc.desc: Test functions to ManageInterface
138 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
139 * @tc.desc: Negative test: parameters exception, devAddr error
140 * @tc.type: FUNC
141 */
142 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7400, Function | MediumTest | Level1)
143 {
144 uint8_t interfaceId = INTERFACEID_OK;
145 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
146 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
147 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7400 %{public}d ret=%{public}d",
148 __LINE__, ret);
149 ASSERT_NE(ret, 0);
150 }
151
152 /**
153 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7500
154 * @tc.desc: Test functions to ManageInterface
155 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
156 * @tc.desc: Negative test: parameters exception, interfaceid error
157 * @tc.type: FUNC
158 */
159 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7500, Function | MediumTest | Level1)
160 {
161 uint8_t interfaceId = INTERFACEID_OK;
162 struct UsbDev dev = dev_;
163 interfaceId = INTERFACEID_INVALID;
164 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
165 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7500 %{public}d ret=%{public}d",
166 __LINE__, ret);
167 ASSERT_NE(ret, 0);
168 }
169
170 /**
171 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7600
172 * @tc.desc: Test functions to ManageInterface
173 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
174 * @tc.desc: Negative test: parameters exception, busNum && devAddr error
175 * @tc.type: FUNC
176 */
177 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7600, Function | MediumTest | Level1)
178 {
179 uint8_t interfaceId = INTERFACEID_OK;
180 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
181 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
182 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7600 %{public}d ret=%{public}d",
183 __LINE__, ret);
184 ASSERT_NE(ret, 0);
185 }
186
187 /**
188 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7700
189 * @tc.desc: Test functions to ManageInterface
190 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
191 * @tc.desc: Negative test: parameters exception, busNum && interfaceid error
192 * @tc.type: FUNC
193 */
194 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7700, Function | MediumTest | Level1)
195 {
196 uint8_t interfaceId = INTERFACEID_INVALID;
197 struct UsbDev dev = {BUS_NUM_INVALID, dev_.devAddr};
198 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
199 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7700 %{public}d ret=%{public}d",
200 __LINE__, ret);
201 ASSERT_NE(ret, 0);
202 }
203
204 /**
205 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7800
206 * @tc.desc: Test functions to ManageInterface
207 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
208 * @tc.desc: Negative test: parameters exception, devAddr && interfaceid error
209 * @tc.type: FUNC
210 */
211 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7800, Function | MediumTest | Level1)
212 {
213 uint8_t interfaceId = INTERFACEID_INVALID;
214 struct UsbDev dev = {dev_.busNum, DEV_ADDR_INVALID};
215 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
216 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7800 %{public}d ret=%{public}d",
217 __LINE__, ret);
218 ASSERT_NE(ret, 0);
219 }
220
221 /**
222 * @tc.name: SUB_USB_HostManager_HDI_Compatibility_7900
223 * @tc.desc: Test functions to ManageInterface
224 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
225 * @tc.desc: Negative test: parameters exception, busNum && devAddr && interfaceid error
226 * @tc.type: FUNC
227 */
228 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Compatibility_7900, Function | MediumTest | Level1)
229 {
230 uint8_t interfaceId = INTERFACEID_INVALID;
231 struct UsbDev dev = {BUS_NUM_INVALID, DEV_ADDR_INVALID};
232 auto ret = g_usbInterface->ManageInterface(dev, interfaceId, true);
233 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Compatibility_7900 %{public}d ret=%{public}d",
234 __LINE__, ret);
235 ASSERT_NE(ret, 0);
236 }
237
238 /**
239 * @tc.name: SUB_USB_HostManager_HDI_Func_1600
240 * @tc.desc: Test functions to ManageInterface
241 * @tc.desc: int32_t ManageInterface(const UsbDev &dev, uint8_t interfaceId, bool disable);
242 * @tc.desc: Positive test: parameters correctly
243 * @tc.type: FUNC
244 */
245 HWTEST_F(UsbdManageInterfaceTest, SUB_USB_HostManager_HDI_Func_1600, Function | MediumTest | Level1)
246 {
247 uint8_t interfaceId = INTERFACEID_OK_NEW;
248 struct UsbDev dev = dev_;
249 int32_t ret = -1;
250 for (; interfaceId < INTERFACEID_INVALID; interfaceId++) {
251 ret = g_usbInterface->ManageInterface(dev, interfaceId, false);
252 if (ret == 0) {
253 break;
254 }
255 }
256 HDF_LOGI("UsbdManageInterfaceTest::SUB_USB_HostManager_HDI_Func_1600 %{public}d ManageInterface=%{public}d",
257 __LINE__, ret);
258 ASSERT_EQ(0, ret);
259 }
260 } // ManageInterface
261 } // USB
262 } // OHOS
263