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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include <string>
19 #include "usb_serial_api.h"
20 #include "v1_0/iusb_serial_ddk.h"
21
22 using namespace std;
23 using namespace testing::ext;
24 using namespace OHOS::HDI::Usb::UsbSerialDdk::V1_0;
25
26 namespace OHOS {
27 namespace HDI {
28 namespace Usb {
29 namespace UsbSerialDdk {
30 namespace V1_0 {
31
operator ==(const UsbSerialDeviceHandle & lhs,const UsbSerialDeviceHandle & rhs)32 bool operator==(const UsbSerialDeviceHandle &lhs, const UsbSerialDeviceHandle &rhs)
33 {
34 if (&lhs == &rhs) {
35 return true;
36 }
37 return std::make_tuple(lhs.fd) == std::make_tuple(rhs.fd);
38 }
39 }}}}}
40
41 void SetDdk(OHOS::sptr<IUsbSerialDdk>&);
42 UsbSerial_Device *NewSerialDeviceHandle();
43
44 namespace {
45
46 constexpr int TEST_TIMES = 1;
47 constexpr uint32_t USB_SERIAL_TEST_BAUDRATE = 9600;
48 constexpr uint8_t USB_SERIAL_TEST_DATA_BITS = 8;
49
50 class MockUsbSerialDdk : public IUsbSerialDdk {
51 public:
52 MOCK_METHOD(int, Init, (), (override));
53 MOCK_METHOD(int, Release, (), (override));
54 MOCK_METHOD(int, Open, (uint64_t deviceId, uint64_t interfaceIndex, UsbSerialDeviceHandle& dev), (override));
55 MOCK_METHOD(int, Close, (const UsbSerialDeviceHandle& dev), (override));
56 MOCK_METHOD(int, Read, (const UsbSerialDeviceHandle& dev, uint32_t bufferSize, vector<uint8_t>& buff), (override));
57 MOCK_METHOD(int, Write, (const UsbSerialDeviceHandle& dev, const vector<uint8_t>& buff,
58 uint32_t& bytesWritten), (override));
59 MOCK_METHOD(int, SetBaudRate, (const UsbSerialDeviceHandle& dev, uint32_t baudRate), (override));
60 MOCK_METHOD(int, SetParams, (const UsbSerialDeviceHandle& dev, const UsbSerialParams& params), (override));
61 MOCK_METHOD(int, SetTimeout, (const UsbSerialDeviceHandle& dev, int32_t timeout), (override));
62 MOCK_METHOD(int, SetFlowControl, (const UsbSerialDeviceHandle& dev, UsbSerialFlowControl flowControl), (override));
63 MOCK_METHOD(int, Flush, (const UsbSerialDeviceHandle& dev), (override));
64 MOCK_METHOD(int, FlushInput, (const UsbSerialDeviceHandle& dev), (override));
65 MOCK_METHOD(int, FlushOutput, (const UsbSerialDeviceHandle& dev), (override));
66 };
67
68 class UsbSerialTest : public testing::Test {
69 };
70
71 HWTEST_F(UsbSerialTest, ReleaseErrorTest, TestSize.Level1)
72 {
73 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
74 ASSERT_NE(mockDdk, nullptr);
75 EXPECT_CALL(*mockDdk, Release())
76 .Times(TEST_TIMES)
77 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
78 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
79 SetDdk(ddk);
80 ASSERT_EQ(OH_UsbSerial_Release(), USB_SERIAL_DDK_SERVICE_ERROR);
81 }
82
83 HWTEST_F(UsbSerialTest, OpenErrorTest001, TestSize.Level1)
84 {
85 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
86 ASSERT_NE(mockDdk, nullptr);
87 EXPECT_CALL(*mockDdk, Open(testing::_, testing::_, testing::_))
88 .Times(TEST_TIMES)
89 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
90 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
91 SetDdk(ddk);
92 UsbSerial_Device *dev = nullptr;;
93 ASSERT_EQ(OH_UsbSerial_Open(0, 0, &dev), USB_SERIAL_DDK_SERVICE_ERROR);
94 }
95
96 HWTEST_F(UsbSerialTest, OpenErrorTest002, TestSize.Level1)
97 {
98 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
99 ASSERT_NE(mockDdk, nullptr);
100 EXPECT_CALL(*mockDdk, Open(testing::_, testing::_, testing::_))
101 .Times(TEST_TIMES)
102 .WillOnce(testing::Return(USB_SERIAL_DDK_MEMORY_ERROR));
103 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
104 SetDdk(ddk);
105 UsbSerial_Device *dev = nullptr;;
106 ASSERT_EQ(OH_UsbSerial_Open(0, 0, &dev), USB_SERIAL_DDK_MEMORY_ERROR);
107 }
108
109 HWTEST_F(UsbSerialTest, OpenErrorTest003, TestSize.Level1)
110 {
111 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
112 ASSERT_NE(mockDdk, nullptr);
113 EXPECT_CALL(*mockDdk, Open(testing::_, testing::_, testing::_))
114 .Times(TEST_TIMES)
115 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
116 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
117 SetDdk(ddk);
118 UsbSerial_Device *dev = nullptr;;
119 ASSERT_EQ(OH_UsbSerial_Open(0, 0, &dev), USB_SERIAL_DDK_IO_ERROR);
120 }
121
122 HWTEST_F(UsbSerialTest, CloseErrorTest001, TestSize.Level1)
123 {
124 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
125 ASSERT_NE(mockDdk, nullptr);
126 EXPECT_CALL(*mockDdk, Close(testing::_))
127 .Times(TEST_TIMES)
128 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
129 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
130 SetDdk(ddk);
131 auto dev = NewSerialDeviceHandle();
132 ASSERT_EQ(OH_UsbSerial_Close(&dev), USB_SERIAL_DDK_SERVICE_ERROR);
133 }
134
135 HWTEST_F(UsbSerialTest, CloseErrorTest002, TestSize.Level1)
136 {
137 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
138 ASSERT_NE(mockDdk, nullptr);
139 EXPECT_CALL(*mockDdk, Close(testing::_))
140 .Times(TEST_TIMES)
141 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
142 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
143 SetDdk(ddk);
144 auto dev = NewSerialDeviceHandle();
145 ASSERT_EQ(OH_UsbSerial_Close(&dev), USB_SERIAL_DDK_IO_ERROR);
146 }
147
148 HWTEST_F(UsbSerialTest, ReadErrorTest001, TestSize.Level1)
149 {
150 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
151 ASSERT_NE(mockDdk, nullptr);
152 EXPECT_CALL(*mockDdk, Read(testing::_, testing::_, testing::_))
153 .Times(TEST_TIMES)
154 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
155 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
156 SetDdk(ddk);
157 auto dev = NewSerialDeviceHandle();
158 uint8_t dataBuff[8];
159 uint32_t bytesRead = 0;
160 ASSERT_EQ(OH_UsbSerial_Read(dev, dataBuff, sizeof(dataBuff), &bytesRead), USB_SERIAL_DDK_SERVICE_ERROR);
161 }
162
163 HWTEST_F(UsbSerialTest, ReadErrorTest002, TestSize.Level1)
164 {
165 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
166 ASSERT_NE(mockDdk, nullptr);
167 EXPECT_CALL(*mockDdk, Read(testing::_, testing::_, testing::_))
168 .Times(TEST_TIMES)
169 .WillOnce(testing::Return(USB_SERIAL_DDK_MEMORY_ERROR));
170 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
171 SetDdk(ddk);
172 auto dev = NewSerialDeviceHandle();
173 uint8_t dataBuff[8];
174 uint32_t bytesRead = 0;
175 ASSERT_EQ(OH_UsbSerial_Read(dev, dataBuff, sizeof(dataBuff), &bytesRead), USB_SERIAL_DDK_MEMORY_ERROR);
176 }
177
178 HWTEST_F(UsbSerialTest, ReadErrorTest003, TestSize.Level1)
179 {
180 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
181 ASSERT_NE(mockDdk, nullptr);
182 EXPECT_CALL(*mockDdk, Read(testing::_, testing::_, testing::_))
183 .Times(TEST_TIMES)
184 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
185 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
186 SetDdk(ddk);
187 auto dev = NewSerialDeviceHandle();
188 uint8_t dataBuff[8];
189 uint32_t bytesRead = 0;
190 ASSERT_EQ(OH_UsbSerial_Read(dev, dataBuff, sizeof(dataBuff), &bytesRead), USB_SERIAL_DDK_IO_ERROR);
191 }
192
193 HWTEST_F(UsbSerialTest, WriteErrorTest001, TestSize.Level1)
194 {
195 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
196 ASSERT_NE(mockDdk, nullptr);
197 EXPECT_CALL(*mockDdk, Write(testing::_, testing::_, testing::_))
198 .Times(TEST_TIMES)
199 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
200 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
201 SetDdk(ddk);
202 auto dev = NewSerialDeviceHandle();
203 uint8_t writeBuff[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0A};
204 uint32_t bytesWritten = 0;
205 ASSERT_EQ(OH_UsbSerial_Write(dev, writeBuff, sizeof(writeBuff), &bytesWritten), USB_SERIAL_DDK_SERVICE_ERROR);
206 }
207
208 HWTEST_F(UsbSerialTest, WriteErrorTest002, TestSize.Level1)
209 {
210 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
211 ASSERT_NE(mockDdk, nullptr);
212 EXPECT_CALL(*mockDdk, Write(testing::_, testing::_, testing::_))
213 .Times(TEST_TIMES)
214 .WillOnce(testing::Return(USB_SERIAL_DDK_MEMORY_ERROR));
215 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
216 SetDdk(ddk);
217 auto dev = NewSerialDeviceHandle();
218 uint8_t writeBuff[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0A};
219 uint32_t bytesWritten = 0;
220 ASSERT_EQ(OH_UsbSerial_Write(dev, writeBuff, sizeof(writeBuff), &bytesWritten), USB_SERIAL_DDK_MEMORY_ERROR);
221 }
222
223 HWTEST_F(UsbSerialTest, WriteErrorTest003, TestSize.Level1)
224 {
225 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
226 ASSERT_NE(mockDdk, nullptr);
227 EXPECT_CALL(*mockDdk, Write(testing::_, testing::_, testing::_))
228 .Times(TEST_TIMES)
229 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
230 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
231 SetDdk(ddk);
232 auto dev = NewSerialDeviceHandle();
233 uint8_t writeBuff[] = {0x01, 0x03, 0x00, 0x00, 0x00, 0x01, 0x84, 0x0A};
234 uint32_t bytesWritten = 0;
235 ASSERT_EQ(OH_UsbSerial_Write(dev, writeBuff, sizeof(writeBuff), &bytesWritten), USB_SERIAL_DDK_IO_ERROR);
236 }
237
238 HWTEST_F(UsbSerialTest, SetBaudRateErrorTest001, TestSize.Level1)
239 {
240 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
241 ASSERT_NE(mockDdk, nullptr);
242 EXPECT_CALL(*mockDdk, SetBaudRate(testing::_, testing::_))
243 .Times(TEST_TIMES)
244 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
245 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
246 SetDdk(ddk);
247 auto dev = NewSerialDeviceHandle();
248 uint32_t baudRate = 9600;
249 ASSERT_EQ(OH_UsbSerial_SetBaudRate(dev, baudRate), USB_SERIAL_DDK_SERVICE_ERROR);
250 }
251
252 HWTEST_F(UsbSerialTest, SetBaudRateErrorTest002, TestSize.Level1)
253 {
254 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
255 ASSERT_NE(mockDdk, nullptr);
256 EXPECT_CALL(*mockDdk, SetBaudRate(testing::_, testing::_))
257 .Times(TEST_TIMES)
258 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
259 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
260 SetDdk(ddk);
261 auto dev = NewSerialDeviceHandle();
262 uint32_t baudRate = 9600;
263 ASSERT_EQ(OH_UsbSerial_SetBaudRate(dev, baudRate), USB_SERIAL_DDK_IO_ERROR);
264 }
265
266 HWTEST_F(UsbSerialTest, SetParamsRateErrorTest001, TestSize.Level1)
267 {
268 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
269 ASSERT_NE(mockDdk, nullptr);
270 EXPECT_CALL(*mockDdk, SetParams(testing::_, testing::_))
271 .Times(TEST_TIMES)
272 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
273 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
274 SetDdk(ddk);
275 auto dev = NewSerialDeviceHandle();
276 UsbSerial_Params serialParams;
277 serialParams.baudRate = USB_SERIAL_TEST_BAUDRATE;
278 serialParams.nDataBits = USB_SERIAL_TEST_DATA_BITS;
279 serialParams.nStopBits = 1;
280 serialParams.parity = 1;
281 ASSERT_EQ(OH_UsbSerial_SetParams(dev, &serialParams), USB_SERIAL_DDK_SERVICE_ERROR);
282 }
283
284 HWTEST_F(UsbSerialTest, SetParamsRateErrorTest002, TestSize.Level1)
285 {
286 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
287 ASSERT_NE(mockDdk, nullptr);
288 EXPECT_CALL(*mockDdk, SetParams(testing::_, testing::_))
289 .Times(TEST_TIMES)
290 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
291 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
292 SetDdk(ddk);
293 auto dev = NewSerialDeviceHandle();
294 UsbSerial_Params serialParams;
295 serialParams.baudRate = USB_SERIAL_TEST_BAUDRATE;
296 serialParams.nDataBits = USB_SERIAL_TEST_DATA_BITS;
297 serialParams.nStopBits = 1;
298 serialParams.parity = 1;
299 ASSERT_EQ(OH_UsbSerial_SetParams(dev, &serialParams), USB_SERIAL_DDK_IO_ERROR);
300 }
301
302 HWTEST_F(UsbSerialTest, SetTimeoutErrorTest001, TestSize.Level1)
303 {
304 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
305 ASSERT_NE(mockDdk, nullptr);
306 EXPECT_CALL(*mockDdk, SetTimeout(testing::_, testing::_))
307 .Times(TEST_TIMES)
308 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
309 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
310 SetDdk(ddk);
311 auto dev = NewSerialDeviceHandle();
312 uint32_t readTimeout = 1; // 0 means no timeout
313 ASSERT_EQ(OH_UsbSerial_SetTimeout(dev, readTimeout), USB_SERIAL_DDK_SERVICE_ERROR);
314 }
315
316 HWTEST_F(UsbSerialTest, SetTimeoutErrorTest002, TestSize.Level1)
317 {
318 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
319 ASSERT_NE(mockDdk, nullptr);
320 EXPECT_CALL(*mockDdk, SetTimeout(testing::_, testing::_))
321 .Times(TEST_TIMES)
322 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
323 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
324 SetDdk(ddk);
325 auto dev = NewSerialDeviceHandle();
326 uint32_t readTimeout = 1; // 0 means no timeout
327 ASSERT_EQ(OH_UsbSerial_SetTimeout(dev, readTimeout), USB_SERIAL_DDK_IO_ERROR);
328 }
329
330 HWTEST_F(UsbSerialTest, SetFlowControlErrorTest001, TestSize.Level1)
331 {
332 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
333 ASSERT_NE(mockDdk, nullptr);
334 EXPECT_CALL(*mockDdk, SetFlowControl(testing::_, testing::_))
335 .Times(TEST_TIMES)
336 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
337 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
338 SetDdk(ddk);
339 auto dev = NewSerialDeviceHandle();
340 UsbSerial_FlowControl flowControl = ::USB_SERIAL_NO_FLOW_CONTROL; // 0 means no flow control
341 ASSERT_EQ(OH_UsbSerial_SetFlowControl(dev, flowControl), USB_SERIAL_DDK_SERVICE_ERROR);
342 }
343
344 HWTEST_F(UsbSerialTest, SetFlowControlErrorTest002, TestSize.Level1)
345 {
346 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
347 ASSERT_NE(mockDdk, nullptr);
348 EXPECT_CALL(*mockDdk, SetFlowControl(testing::_, testing::_))
349 .Times(TEST_TIMES)
350 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
351 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
352 SetDdk(ddk);
353 auto dev = NewSerialDeviceHandle();
354 UsbSerial_FlowControl flowControl = ::USB_SERIAL_NO_FLOW_CONTROL; // 0 means no flow control
355 ASSERT_EQ(OH_UsbSerial_SetFlowControl(dev, flowControl), USB_SERIAL_DDK_IO_ERROR);
356 }
357
358 HWTEST_F(UsbSerialTest, FlushErrorTest001, TestSize.Level1)
359 {
360 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
361 ASSERT_NE(mockDdk, nullptr);
362 EXPECT_CALL(*mockDdk, Flush(testing::_))
363 .Times(TEST_TIMES)
364 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
365 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
366 SetDdk(ddk);
367 auto dev = NewSerialDeviceHandle();
368 ASSERT_EQ(OH_UsbSerial_Flush(dev), USB_SERIAL_DDK_IO_ERROR);
369 }
370
371 HWTEST_F(UsbSerialTest, FlushErrorTest002, TestSize.Level1)
372 {
373 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
374 ASSERT_NE(mockDdk, nullptr);
375 EXPECT_CALL(*mockDdk, Flush(testing::_))
376 .Times(TEST_TIMES)
377 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
378 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
379 SetDdk(ddk);
380 auto dev = NewSerialDeviceHandle();
381 ASSERT_EQ(OH_UsbSerial_Flush(dev), USB_SERIAL_DDK_SERVICE_ERROR);
382 }
383
384 HWTEST_F(UsbSerialTest, FlushInputErrorTest001, TestSize.Level1)
385 {
386 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
387 ASSERT_NE(mockDdk, nullptr);
388 EXPECT_CALL(*mockDdk, FlushInput(testing::_))
389 .Times(TEST_TIMES)
390 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
391 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
392 SetDdk(ddk);
393 auto dev = NewSerialDeviceHandle();
394 ASSERT_EQ(OH_UsbSerial_FlushInput(dev), USB_SERIAL_DDK_IO_ERROR);
395 }
396
397 HWTEST_F(UsbSerialTest, FlushInputErrorTest002, TestSize.Level1)
398 {
399 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
400 ASSERT_NE(mockDdk, nullptr);
401 EXPECT_CALL(*mockDdk, FlushInput(testing::_))
402 .Times(TEST_TIMES)
403 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
404 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
405 SetDdk(ddk);
406 auto dev = NewSerialDeviceHandle();
407 ASSERT_EQ(OH_UsbSerial_FlushInput(dev), USB_SERIAL_DDK_SERVICE_ERROR);
408 }
409
410 HWTEST_F(UsbSerialTest, FlushOutputErrorTest001, TestSize.Level1)
411 {
412 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
413 ASSERT_NE(mockDdk, nullptr);
414 EXPECT_CALL(*mockDdk, FlushOutput(testing::_))
415 .Times(TEST_TIMES)
416 .WillOnce(testing::Return(USB_SERIAL_DDK_SERVICE_ERROR));
417 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
418 SetDdk(ddk);
419 auto dev = NewSerialDeviceHandle();
420 ASSERT_EQ(OH_UsbSerial_FlushOutput(dev), USB_SERIAL_DDK_SERVICE_ERROR);
421 }
422
423 HWTEST_F(UsbSerialTest, FlushOutputErrorTest002, TestSize.Level1)
424 {
425 auto mockDdk = OHOS::sptr<MockUsbSerialDdk>::MakeSptr();
426 ASSERT_NE(mockDdk, nullptr);
427 EXPECT_CALL(*mockDdk, FlushOutput(testing::_))
428 .Times(TEST_TIMES)
429 .WillOnce(testing::Return(USB_SERIAL_DDK_IO_ERROR));
430 auto ddk = OHOS::sptr<IUsbSerialDdk>(mockDdk);
431 SetDdk(ddk);
432 auto dev = NewSerialDeviceHandle();
433 ASSERT_EQ(OH_UsbSerial_FlushOutput(dev), USB_SERIAL_DDK_IO_ERROR);
434 }
435 } // namespace
436