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