1 /*
2 * Copyright (c) 2021-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 "usb_submit_transfer_interrupt_test.h"
17
18 #include <csignal>
19 #include <iostream>
20 #include <vector>
21
22 #include "if_system_ability_manager.h"
23 #include "ipc_skeleton.h"
24 #include "iservice_registry.h"
25 #include "iusb_srv.h"
26 #include "system_ability_definition.h"
27 #include "usb_common.h"
28 #include "usb_common_test.h"
29 #include "usb_device_pipe.h"
30 #include "usb_request.h"
31 #include "usb_srv_client.h"
32 #include "v1_2/usb_types.h"
33 #include "usb_errors.h"
34 #include "ashmem.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::USB;
38 using namespace OHOS;
39 using namespace std;
40 using namespace OHOS::USB::Common;
41
42 namespace OHOS {
43 namespace USB {
44 namespace SubmitTransfer {
45 constexpr int32_t SLEEP_TIME = 3;
46
SetUpTestCase(void)47 void UsbSubmitTransferInterruptTest::SetUpTestCase(void)
48 {
49 UsbCommonTest::GrantPermissionSysNative();
50 auto &srvClient = UsbSrvClient::GetInstance();
51 auto ret = srvClient.SetPortRole(1, 1, 1);
52 sleep(SLEEP_TIME);
53 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptTest:: [Device] SetPortRole:%{public}d", ret);
54 ret = UsbCommonTest::SwitchErrCode(ret);
55 ASSERT_TRUE(ret == 0);
56 if (ret != 0) {
57 exit(0);
58 }
59 std::cout << "please connect device, press enter to continue" << std::endl;
60 int c;
61 do {
62 c = getchar();
63 } while (c != '\n' && c != EOF);
64 USB_HILOGI(MODULE_USB_SERVICE, "Start UsbSubmitTransferInterruptTest");
65 }
66
TearDownTestCase(void)67 void UsbSubmitTransferInterruptTest::TearDownTestCase(void)
68 {
69 USB_HILOGI(MODULE_USB_SERVICE, "End UsbSubmitTransferInterruptTest");
70 }
71
SetUp(void)72 void UsbSubmitTransferInterruptTest::SetUp(void) {}
73
TearDown(void)74 void UsbSubmitTransferInterruptTest::TearDown(void) {}
75
76 /**
77 * @tc.name: UsbSubmitTransferInterruptWrite
78 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer OK.
79 * @tc.type: FUNC
80 */
81 HWTEST_F(UsbSubmitTransferInterruptTest, UsbSubmitTransferInterruptWrite, TestSize.Level1)
82 {
83 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite enter.");
84 vector<UsbDevice> devi;
85 auto &UsbSrvClient = UsbSrvClient::GetInstance();
86 auto ret = UsbSrvClient.GetDevices(devi);
87 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite %{public}d ret=%{public}d", __LINE__, ret);
88 EXPECT_TRUE(!(devi.empty())) << "delist NULL";
89 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite %{public}d size=%{public}zu", __LINE__,
90 devi.size());
91 USBDevicePipe pipe;
92 UsbDevice device = devi.front();
93 UsbSrvClient.RequestRight(device.GetName());
94 ret = UsbSrvClient.OpenDevice(device, pipe);
95 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
96 USBEndpoint point = interface.GetEndpoints().front();
97 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite %{public}d point=%{public}d", __LINE__,
98 point.GetInterfaceId());
99 ret = UsbSrvClient.ClaimInterface(pipe, interface, true);
100 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
101 ASSERT_NE(ashmem, nullptr);
102 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
103 ashmem->MapReadAndWriteAshmem();
104 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
105 ASSERT_TRUE(writeSuccess);
106 HDI::Usb::V1_2::USBTransferInfo transferInfo;
107 transferInfo.endpoint = 0x01; // 0x01写 0x81读,中断写不支持，只能读
108 transferInfo.flags = 0;
109 transferInfo.type = TYPE_INTERRUPT; // 开发板仅支持bulk
110 transferInfo.timeOut = 2000;
111 transferInfo.length = TEN; // 期望长度
112 transferInfo.userData = 0;
113 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
114 auto callback = [](const TransferCallbackInfo &info,
__anon5aafc1370102(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 115 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
116 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite cb status:%{public}d,actualLength:%{public}d",
117 info.status, info.actualLength);
118 };
119 ret = UsbSrvClient.UsbSubmitTransfer(pipe, transferInfo, callback, ashmem);
120 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferInterruptWrite ret:%{public}d", __LINE__, ret);
121 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
122 bool close = UsbSrvClient.Close(pipe);
123 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite %{public}d close=%{public}d", __LINE__, close);
124 EXPECT_TRUE(close);
125 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWrite end.");
126 }
127
128 /**
129 * @tc.name: UsbSubmitTransferInterruptReadInvalidEndpoint
130 * @tc.desc: Test the USB data write functionality of UsbSubmitTransfer with invalid endpoint type
131 * @tc.type: FUNC
132 */
133 HWTEST_F(UsbSubmitTransferInterruptTest, UsbSubmitTransferInterruptReadInvalidEndpoint, TestSize.Level1)
134 {
135 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptReadInvalidEndpoint begin.");
136
137 vector<UsbDevice> delist;
138 auto &UsbSrvClient = UsbSrvClient::GetInstance();
139 auto ret = UsbSrvClient.GetDevices(delist);
140 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
141 UsbDevice device = delist.front();
142 ret = UsbSrvClient.RequestRight(device.GetName());
143 USBDevicePipe pip;
144 ret = UsbSrvClient.OpenDevice(device, pip);
145 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
146 USBEndpoint point = interface.GetEndpoints().front();
147 ret = UsbSrvClient.ClaimInterface(pip, interface, true);
148 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferInterruptReadInvalidEndpoint ret:%{public}d",
149 __LINE__, ret);
150
151 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
152 ASSERT_NE(ashmem, nullptr);
153 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
154 ashmem->MapReadAndWriteAshmem();
155 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
156 ASSERT_TRUE(writeSuccess);
157 HDI::Usb::V1_2::USBTransferInfo transferInfo;
158 transferInfo.endpoint = 0xFF; //无效参数
159 transferInfo.flags = 0;
160 transferInfo.type = TYPE_INTERRUPT; // 开发板仅支持bulk
161 transferInfo.timeOut = 2000;
162 transferInfo.length = TEN; // 期望长度
163 transferInfo.userData = 0;
164 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
165
166 auto callback = [](const TransferCallbackInfo &info,
__anon5aafc1370202(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 167 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
168 USB_HILOGI(MODULE_USB_SERVICE,
169 "UsbSubmitTransferInterruptReadInvalidEndpoint cb status: %{public}d, actualLength: %{public}d",
170 info.status, info.actualLength);
171 };
172 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
173 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferInterruptReadInvalidEndpoint ret=%{public}d",
174 __LINE__, ret);
175 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
176 bool close = UsbSrvClient.Close(pip);
177 EXPECT_TRUE(close);
178 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptReadInvalidEndpoint end.");
179 }
180
181 /**
182 * @tc.name: UsbSubmitTransferInterruptWriteIoError
183 * @tc.desc: Test USB I/O error when interface is not claimed.
184 * @tc.type: FUNC
185 */
186 HWTEST_F(UsbSubmitTransferInterruptTest, UsbSubmitTransferInterruptWriteIoError, TestSize.Level1)
187 {
188 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWriteIoError begin.");
189 vector<UsbDevice> delist;
190 auto &UsbSrvClient = UsbSrvClient::GetInstance();
191 auto ret = UsbSrvClient.GetDevices(delist);
192 EXPECT_TRUE(!(delist.empty())) << "Device list is empty";
193 UsbDevice device = delist.front();
194 ret = UsbSrvClient.RequestRight(device.GetName());
195 USBDevicePipe pip;
196 ret = UsbSrvClient.OpenDevice(device, pip);
197 UsbInterface interface = device.GetConfigs().front().GetInterfaces().at(0);
198 USBEndpoint point = interface.GetEndpoints().front();
199 UsbSrvClient.ReleaseInterface(pip, interface);
200 sptr<Ashmem> ashmem = Ashmem::CreateAshmem("usb_shared_memory", TEN);
201 ASSERT_NE(ashmem, nullptr);
202 const uint8_t dataToWrite[TEN] = {0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55};
203 ashmem->MapReadAndWriteAshmem();
204 bool writeSuccess = ashmem->WriteToAshmem(dataToWrite, sizeof(dataToWrite), 0);
205 ASSERT_TRUE(writeSuccess);
206
207 HDI::Usb::V1_2::USBTransferInfo transferInfo;
208 transferInfo.endpoint = 0x01; // 写操作（对于开发板，0x81是读操作）
209 transferInfo.flags = 0;
210 transferInfo.type = TYPE_INTERRUPT; // 开发板仅支持bulk
211 transferInfo.timeOut = 2000;
212 transferInfo.length = TEN; // 期望长度
213 transferInfo.userData = 0;
214 transferInfo.numIsoPackets = 0; // iso传输包数量 iso单包传输最大长度192
215 auto callback = [](const TransferCallbackInfo &info,
__anon5aafc1370302(const TransferCallbackInfo &info, const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) 216 const std::vector<HDI::Usb::V1_2::UsbIsoPacketDescriptor> &packets, uint64_t userData) {
217 USB_HILOGI(MODULE_USB_SERVICE, "InterruptWriteIoError status:%{public}d,actualLength:%{public}d",
218 info.status, info.actualLength);
219 };
220
221 ret = UsbSrvClient.UsbSubmitTransfer(pip, transferInfo, callback, ashmem);
222 USB_HILOGI(MODULE_USB_SERVICE, "%{public}d line. UsbSubmitTransferInterruptWriteIoError ret:%{public}d",
223 __LINE__, ret);
224 ASSERT_EQ(ret, USB_SUBMIT_TRANSFER_IO_ERROR);
225 bool close = UsbSrvClient.Close(pip);
226 EXPECT_TRUE(close);
227 USB_HILOGI(MODULE_USB_SERVICE, "UsbSubmitTransferInterruptWriteIoError end.");
228 }
229
230 } // namespace SubmitTransfer
231 } // namespace USB
232 } // namespace OHOS