1 /*
2 * Copyright (c) 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 #include <iostream>
16 #include <vector>
17
18 #include "hdf_log.h"
19 #include "securec.h"
20 #include "usbd_transfer_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 uint32_t MAX_BUFFER_LENGTH = 255;
26 const uint8_t INTERFACEID_OK = 0;
27 const uint8_t POINTID_BULK_OUT = 0;
28 const uint8_t POINTID_INTERRUPT_IN = 129;
29 const int32_t TRANSFER_TIME_OUT = 1000;
30
31 using namespace testing::ext;
32 using namespace OHOS;
33 using namespace OHOS::USB;
34 using namespace std;
35 using namespace OHOS::HDI::Usb::V1_0;
36
37 UsbDev UsbdTransferTestAdditional::dev_ = {0, 0};
38 sptr<UsbSubscriberTest> UsbdTransferTestAdditional::subscriber_ = nullptr;
39
40 namespace {
41 sptr<IUsbInterface> g_usbInterface = nullptr;
42
SwitchErrCode(int32_t ret)43 int32_t SwitchErrCode(int32_t ret)
44 {
45 return ret == HDF_ERR_NOT_SUPPORT ? HDF_SUCCESS : ret;
46 }
47
SetUpTestCase(void)48 void UsbdTransferTestAdditional::SetUpTestCase(void)
49 {
50 g_usbInterface = IUsbInterface::Get();
51 if (g_usbInterface == nullptr) {
52 HDF_LOGE("%{public}s:IUsbInterface::Get() failed.", __func__);
53 exit(0);
54 }
55 const int32_t DEFAULT_PORT_ID = 1;
56 const int32_t DEFAULT_ROLE_HOST = 1;
57 auto ret = g_usbInterface->SetPortRole(DEFAULT_PORT_ID, DEFAULT_ROLE_HOST, DEFAULT_ROLE_HOST);
58 sleep(SLEEP_TIME);
59 HDF_LOGI("UsbdTransferTestAdditional::[Device] %{public}d SetPortRole=%{public}d", __LINE__, ret);
60 ret = SwitchErrCode(ret);
61 ASSERT_EQ(0, ret);
62 if (ret != 0) {
63 exit(0);
64 }
65
66 subscriber_ = new UsbSubscriberTest();
67 if (subscriber_ == nullptr) {
68 HDF_LOGE("%{public}s:UsbSubscriberTest new failed.", __func__);
69 exit(0);
70 }
71 if (g_usbInterface->BindUsbdSubscriber(subscriber_) != HDF_SUCCESS) {
72 HDF_LOGE("%{public}s: bind usbd subscriber_ failed\n", __func__);
73 exit(0);
74 }
75
76 std::cout << "please connect device, press enter to continue" << std::endl;
77 int c;
78 do {
79 c = getchar();
80 } while (c != '\n' && c != EOF);
81
82 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
83 ret = g_usbInterface->OpenDevice(dev_);
84 HDF_LOGI("UsbdTransferTestAdditional:: %{public}d OpenDevice=%{public}d", __LINE__, ret);
85 ASSERT_EQ(0, ret);
86 }
87
TearDownTestCase(void)88 void UsbdTransferTestAdditional::TearDownTestCase(void)
89 {
90 g_usbInterface->UnbindUsbdSubscriber(subscriber_);
91 dev_ = {subscriber_->busNum_, subscriber_->devAddr_};
92 auto ret = g_usbInterface->CloseDevice(dev_);
93 HDF_LOGI("UsbdTransferTestAdditional:: %{public}d Close=%{public}d", __LINE__, ret);
94 ASSERT_EQ(0, ret);
95 }
96
SetUp(void)97 void UsbdTransferTestAdditional::SetUp(void) {}
98
TearDown(void)99 void UsbdTransferTestAdditional::TearDown(void) {}
100
101 /**
102 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0700
103 * @tc.name: testHdiUsbTransferTestInterruptTransferWrite001
104 * @tc.desc: Writes data on a specified endpoint during interrupt transfer.
105 * bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', ','}.
106 */
107 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestInterruptTransferWrite001, TestSize.Level1)
108 {
109 struct UsbDev dev = dev_;
110 uint8_t interfaceId = INTERFACEID_OK;
111 uint8_t pointId = POINTID_BULK_OUT;
112 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
113 ASSERT_EQ(0, ret);
114 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
115 std::vector<uint8_t> bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', ','};
116 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
117 ASSERT_NE(0, ret);
118 }
119
120 /**
121 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0800
122 * @tc.name: testHdiUsbTransferTestInterruptTransferWrite002
123 * @tc.desc: Writes data on a specified endpoint during interrupt transfer.
124 * bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '!'}.
125 */
126 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestInterruptTransferWrite002, TestSize.Level1)
127 {
128 struct UsbDev dev = dev_;
129 uint8_t interfaceId = INTERFACEID_OK;
130 uint8_t pointId = POINTID_BULK_OUT;
131 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
132 ASSERT_EQ(0, ret);
133 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
134 std::vector<uint8_t> bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '!'};
135 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
136 ASSERT_NE(0, ret);
137 }
138
139 /**
140 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_0900
141 * @tc.name: testHdiUsbTransferTestInterruptTransferWrite003
142 * @tc.desc: Writes data on a specified endpoint during interrupt transfer.
143 * bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '~'}.
144 */
145 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestInterruptTransferWrite003, TestSize.Level1)
146 {
147 struct UsbDev dev = dev_;
148 uint8_t interfaceId = INTERFACEID_OK;
149 uint8_t pointId = POINTID_BULK_OUT;
150 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
151 ASSERT_EQ(0, ret);
152 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
153 std::vector<uint8_t> bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '~'};
154 ret = g_usbInterface->InterruptTransferWrite(dev, pipe, TRANSFER_TIME_OUT, bufferData);
155 ASSERT_NE(0, ret);
156 }
157
158 /**
159 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1000
160 * @tc.name: testHdiUsbTransferTestInterruptTransferRead001
161 * @tc.desc: Reads data on a specified endpoint during interrupt transfer.
162 * bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '~'} Check if the read is correct.
163 */
164 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestInterruptTransferRead001, TestSize.Level1)
165 {
166 struct UsbDev dev = dev_;
167 uint8_t interfaceId = INTERFACEID_OK;
168 uint8_t pointId = POINTID_BULK_OUT;
169 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
170 ASSERT_EQ(0, ret);
171 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
172 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
173 pipe = {interfaceId, POINTID_INTERRUPT_IN};
174 ret = g_usbInterface->InterruptTransferRead(dev, pipe, -1, bufferData1);
175 ASSERT_EQ(0, ret);
176 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
177 std::cout << bufferData1[i] << " ";
178 }
179 std::cout << std::endl;
180 }
181
182 /**
183 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1100
184 * @tc.name: testHdiUsbTransferTestInterruptTransferRead002
185 * @tc.desc: Reads data on a specified endpoint during interrupt transfer.
186 * bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', '!'} Check if the read is correct.
187 */
188 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestInterruptTransferRead002, TestSize.Level1)
189 {
190 struct UsbDev dev = dev_;
191 uint8_t interfaceId = INTERFACEID_OK;
192 uint8_t pointId = POINTID_BULK_OUT;
193 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
194 ASSERT_EQ(0, ret);
195 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
196 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
197 pipe = {interfaceId, POINTID_INTERRUPT_IN};
198 ret = g_usbInterface->InterruptTransferRead(dev, pipe, -1, bufferData1);
199 ASSERT_EQ(0, ret);
200 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
201 std::cout << bufferData1[i] << " ";
202 }
203 std::cout << std::endl;
204 }
205
206 /**
207 * @tc.number: SUB_USB_HostManager_HDI_CompatibilityTransferAddTest_1200
208 * @tc.name: testHdiUsbTransferTestInterruptTransferRead003
209 * @tc.desc: Reads data on a specified endpoint during interrupt transfer.
210 * bufferData = {'I', 'n', 't', 'w', 'r', 'i', 't', 'e', '0', ','} Check if the read is correct.
211 */
212 HWTEST_F(UsbdTransferTestAdditional, testHdiUsbTransferTestInterruptTransferRead003, TestSize.Level1)
213 {
214 struct UsbDev dev = dev_;
215 uint8_t interfaceId = INTERFACEID_OK;
216 uint8_t pointId = POINTID_BULK_OUT;
217 auto ret = g_usbInterface->ClaimInterface(dev, interfaceId, 1);
218 ASSERT_EQ(0, ret);
219 OHOS::HDI::Usb::V1_0::UsbPipe pipe = {interfaceId, pointId};
220 std::vector<uint8_t> bufferData1(MAX_BUFFER_LENGTH);
221 pipe = {interfaceId, POINTID_INTERRUPT_IN};
222 ret = g_usbInterface->InterruptTransferRead(dev, pipe, -1, bufferData1);
223 ASSERT_EQ(0, ret);
224 for (uint8_t i = 0; i < bufferData1.size(); ++i) {
225 std::cout << bufferData1[i] << " ";
226 }
227 std::cout << std::endl;
228 }
229 } // namespace
230