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