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
16 #include "serial_test.h"
17
18 #include "bundle_mgr_interface.h"
19 #include "bundle_mgr_proxy.h"
20 #include "v1_0/serial_types.h"
21 #include "usb_serial_type.h"
22 #include "usb_srv_client.h"
23 #include "usb_errors.h"
24 #include "napi_util.h"
25 #include "hilog_wrapper.h"
26 #include "grant_sys_permission.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::HDI::Usb::Serial::V1_0;
30 using namespace OHOS::Security::AccessToken;
31
32 using OHOS::USB::UsbSrvClient;
33 using OHOS::USB::UsbSerialAttr;
34 using OHOS::USB::MODULE_USB_SERVICE;
35 using OHOS::USB::USB_MGR_LABEL;
36 using OHOS::USB::UEC_INTERFACE_TIMED_OUT;
37 using OHOS::USB::UEC_SERIAL_PORT_NOT_EXIST;
38
39 constexpr int32_t VALID_PORTID = 0;
40 constexpr int32_t INVALID_PORTID = -1;
41 constexpr int32_t OK = 0;
42 constexpr int32_t ONE_KBYTE = 1024;
43 constexpr int32_t ONE_SECOND = 1000;
44 static std::vector<OHOS::USB::UsbSerialPort> g_portList;
45
46
47 namespace OHOS {
48 namespace SERIAL {
SetUpTestCase(void)49 void SerialTest::SetUpTestCase(void)
50 {
51 GrantPermissionSysNative();
52 UsbSrvClient::GetInstance().SerialGetPortList(g_portList);
53 bool hasRight = false;
54 UsbSrvClient::GetInstance().RequestSerialRight(VALID_PORTID, hasRight);
55 if (!UsbSrvClient::GetInstance().HasSerialRight(VALID_PORTID, hasRight) || !hasRight) {
56 return;
57 }
58 }
59
TearDownTestCase(void)60 void SerialTest::TearDownTestCase(void) {}
61
SetUp(void)62 void SerialTest::SetUp(void) {}
63
TearDown(void)64 void SerialTest::TearDown(void) {}
65
66 /**
67 * @tc.name: SerialGetPortList_001
68 * @tc.desc: Test functions to int32_t SerialGetPortList(std::vector<OHOS::HDI::Usb::Serial::V1_0::SerialPort>&
69 * portList)
70 * @tc.type: FUNC
71 */
72 HWTEST_F(SerialTest, SerialGetPortList_001, TestSize.Level1)
73 {
74 EXPECT_NE(g_portList.size(), 0);
75 EXPECT_EQ(g_portList[0].portId_, VALID_PORTID);
76 }
77
78 /**
79 * @tc.name: SerialOpen_001
80 * @tc.desc: Test functions to int32_t SerialOpen(int32_t portId)
81 * @tc.type: FUNC
82 */
83 HWTEST_F(SerialTest, SerialOpen_001, TestSize.Level1)
84 {
85 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
86 EXPECT_EQ(UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID), OK);
87 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
88 }
89
90 /**
91 * @tc.name: SerialOpen_002
92 * @tc.desc: Test functions to int32_t SerialOpen(int32_t portId)
93 * @tc.type: FUNC
94 */
95 HWTEST_F(SerialTest, SerialOpen_002, TestSize.Level1)
96 {
97 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
98 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
99 EXPECT_NE(UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID), OK);
100 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
101 }
102
103 /**
104 * @tc.name: SerialOpen_003
105 * @tc.desc: Test functions to int32_t SerialOpen(int32_t portId)
106 * @tc.type: FUNC
107 */
108 HWTEST_F(SerialTest, SerialOpen_003, TestSize.Level1)
109 {
110 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
111 UsbSrvClient::GetInstance().SerialOpen(INVALID_PORTID);
112 EXPECT_NE(UsbSrvClient::GetInstance().SerialOpen(INVALID_PORTID), OK);
113 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
114 }
115
116 /**
117 * @tc.name: SerialWrite_001
118 * @tc.desc: Test functions to int32_t SerialWrite(int32_t portId, const std::vector<uint8_t> &data,
119 * uint32_t size, uint32_t timeout)
120 * @tc.type: FUNC
121 */
122 HWTEST_F(SerialTest, SerialWrite_001, TestSize.Level1)
123 {
124 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
125 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
126 std::vector<uint8_t> data = { 't', 'e', 's', 't' };
127 uint32_t actualSize = 0;
128 int32_t ret = UsbSrvClient::GetInstance().SerialWrite(VALID_PORTID, data, data.size(), actualSize, 0);
129 EXPECT_EQ(ret, OK);
130 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
131 }
132
133 /**
134 * @tc.name: SerialWrite_002
135 * @tc.desc: Test functions to int32_t SerialWrite(int32_t portId, const std::vector<uint8_t> &data,
136 * uint32_t size, uint32_t timeout)
137 * @tc.type: FUNC
138 */
139 HWTEST_F(SerialTest, SerialWrite_002, TestSize.Level1)
140 {
141 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
142 UsbSrvClient::GetInstance().SerialOpen(INVALID_PORTID);
143 std::vector<uint8_t> data = { 't', 'e', 's', 't' };
144 uint32_t actualSize = 0;
145 int32_t ret = UsbSrvClient::GetInstance().SerialWrite(INVALID_PORTID, data, data.size(), actualSize, 0);
146 EXPECT_EQ(ret, UEC_SERIAL_PORT_NOT_EXIST);
147 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
148 }
149
150 /**
151 * @tc.name: SerialRead_001
152 * @tc.desc: Test functions to int32_t SerialRead(int32_t portId, uint8_t *data,
153 * uint32_t size, uint32_t timeout)
154 * @tc.type: FUNC
155 */
156 HWTEST_F(SerialTest, SerialRead_001, TestSize.Level1)
157 {
158 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
159 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
160 uint32_t actualSize = 0;
161 std::vector<uint8_t> data;
162 int32_t ret = UsbSrvClient::GetInstance().SerialRead(VALID_PORTID, data, ONE_KBYTE, actualSize, ONE_SECOND);
163 EXPECT_EQ(ret, UEC_INTERFACE_TIMED_OUT);
164 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
165 }
166
167 /**
168 * @tc.name: SerialRead_002
169 * @tc.desc: Test functions to int32_t SerialRead(int32_t portId, uint8_t *data,
170 * uint32_t size, uint32_t timeout)
171 * @tc.type: FUNC
172 */
173 HWTEST_F(SerialTest, SerialRead_002, TestSize.Level1)
174 {
175 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
176 UsbSrvClient::GetInstance().SerialOpen(INVALID_PORTID);
177 std::vector<uint8_t> data;
178 uint32_t actualSize = 0;
179 int32_t ret = UsbSrvClient::GetInstance().SerialRead(INVALID_PORTID, data, ONE_KBYTE, actualSize, 0);
180 EXPECT_EQ(ret, UEC_SERIAL_PORT_NOT_EXIST);
181 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
182 }
183
184 /**
185 * @tc.name: SerialRead_003
186 * @tc.desc: Test functions to int32_t SerialRead(int32_t portId, uint8_t *data,
187 * uint32_t size, uint32_t timeout)
188 * @tc.type: FUNC
189 */
190 HWTEST_F(SerialTest, SerialRead_003, TestSize.Level1)
191 {
192 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
193 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
194 std::cout << "Please open the serial port tool to send data in ";
195 std::cout << "a single transmission, and press Enter to continue" << std::endl;
196 getchar();
197 std::vector<uint8_t> data;
198 uint32_t actualSize = 0;
199 int32_t ret = UsbSrvClient::GetInstance().SerialRead(VALID_PORTID, data, ONE_KBYTE, actualSize, 0);
200 EXPECT_EQ(ret, 0);
201 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
202 }
203
204 /**
205 * @tc.name: SerialGetAttribute_001
206 * @tc.desc: Test functions to int32_t SerialGetAttribute(int32_t portId,
207 * OHOS::HDI::Usb::Serial::V1_0::SerialAttribute& attributeInfo)
208 * @tc.type: FUNC
209 */
210 HWTEST_F(SerialTest, SerialGetAttribute_001, TestSize.Level1)
211 {
212 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
213 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
214 UsbSerialAttr attributeInfo;
215 int32_t ret = UsbSrvClient::GetInstance().SerialGetAttribute(VALID_PORTID, attributeInfo);
216 EXPECT_EQ(ret, OK);
217 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
218 }
219
220 /**
221 * @tc.name: SerialGetAttribute_002
222 * @tc.desc: Test functions to int32_t SerialGetAttribute(int32_t portId,
223 * OHOS::HDI::Usb::Serial::V1_0::SerialAttribute& attributeInfo)
224 * @tc.type: FUNC
225 */
226 HWTEST_F(SerialTest, SerialGetAttribute_002, TestSize.Level1)
227 {
228 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
229 UsbSrvClient::GetInstance().SerialOpen(INVALID_PORTID);
230 UsbSerialAttr attributeInfo;
231 int32_t ret = UsbSrvClient::GetInstance().SerialGetAttribute(INVALID_PORTID, attributeInfo);
232 EXPECT_NE(ret, OK);
233 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
234 }
235
236 /**
237 * @tc.name: SerialSetAttribute_001
238 * @tc.desc: Test functions to int32_t SerialSetAttribute(int32_t portId,
239 * const OHOS::HDI::Usb::Serial::V1_0::SerialAttribute& attributeInfo)
240 * @tc.type: FUNC
241 */
242 HWTEST_F(SerialTest, SerialSetAttribute_001, TestSize.Level1)
243 {
244 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
245 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
246 UsbSerialAttr attributeInfo;
247 attributeInfo.baudRate_ = OHOS::HDI::Usb::Serial::V1_0::BAUDRATE_576000;
248 attributeInfo.dataBits_ = OHOS::HDI::Usb::Serial::V1_0::USB_ATTR_DATABIT_6;
249 attributeInfo.parity_ = OHOS::HDI::Usb::Serial::V1_0::USB_ATTR_PARITY_ODD;
250 attributeInfo.stopBits_ = OHOS::HDI::Usb::Serial::V1_0::USB_ATTR_STOPBIT_2;
251 int32_t ret = UsbSrvClient::GetInstance().SerialSetAttribute(VALID_PORTID, attributeInfo);
252 EXPECT_EQ(ret, OK);
253 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
254 }
255
256 /**
257 * @tc.name: SerialSetAttribute_002
258 * @tc.desc: Test functions to int32_t SerialSetAttribute(int32_t portId,
259 * const OHOS::HDI::Usb::Serial::V1_0::SerialAttribute& attributeInfo)
260 * @tc.type: FUNC
261 */
262 HWTEST_F(SerialTest, SerialSetAttribute_002, TestSize.Level1)
263 {
264 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
265 UsbSrvClient::GetInstance().SerialOpen(INVALID_PORTID);
266 UsbSerialAttr attributeInfo;
267 attributeInfo.baudRate_ = OHOS::HDI::Usb::Serial::V1_0::BAUDRATE_576000;
268 attributeInfo.dataBits_ = OHOS::HDI::Usb::Serial::V1_0::USB_ATTR_DATABIT_6;
269 attributeInfo.parity_ = OHOS::HDI::Usb::Serial::V1_0::USB_ATTR_PARITY_ODD;
270 attributeInfo.stopBits_ = OHOS::HDI::Usb::Serial::V1_0::USB_ATTR_STOPBIT_2;
271 int32_t ret = UsbSrvClient::GetInstance().SerialSetAttribute(INVALID_PORTID, attributeInfo);
272 EXPECT_NE(ret, OK);
273 UsbSrvClient::GetInstance().SerialClose(INVALID_PORTID);
274 }
275
276 /**
277 * @tc.name: SerialClose_001
278 * @tc.desc: Test functions to int32_t SerialClose(int32_t portId)
279 * @tc.type: FUNC
280 */
281 HWTEST_F(SerialTest, SerialClose_001, TestSize.Level1)
282 {
283 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
284 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
285 EXPECT_EQ(UsbSrvClient::GetInstance().SerialClose(VALID_PORTID), OK);
286 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
287 }
288
289 /**
290 * @tc.name: SerialClose_002
291 * @tc.desc: Test functions to int32_t SerialClose(int32_t portId)
292 * @tc.type: FUNC
293 */
294 HWTEST_F(SerialTest, SerialClose_002, TestSize.Level1)
295 {
296 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
297 UsbSrvClient::GetInstance().SerialOpen(VALID_PORTID);
298 UsbSrvClient::GetInstance().SerialClose(VALID_PORTID);
299 EXPECT_NE(UsbSrvClient::GetInstance().SerialClose(VALID_PORTID), OK);
300 }
301 }
302 }