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 "scsi_peripheral_api.h"
20 #include "scsi_peripheral_types.h"
21 #include "v1_0/iscsi_peripheral_ddk.h"
22
23 using namespace std;
24 using namespace testing::ext;
25 using namespace OHOS::HDI::Usb::ScsiDdk::V1_0;
26
27 namespace OHOS {
28 namespace HDI {
29 namespace Usb {
30 namespace ScsiDdk {
31 namespace V1_0 {
32
operator ==(const ScsiPeripheralDevice & lhs,const ScsiPeripheralDevice & rhs)33 bool operator==(const ScsiPeripheralDevice &lhs, const ScsiPeripheralDevice &rhs)
34 {
35 if (&lhs == &rhs) {
36 return true;
37 }
38 return std::make_tuple(lhs.devFd, lhs.memMapFd, lhs.lbLength) ==
39 std::make_tuple(rhs.devFd, rhs.memMapFd, rhs.lbLength);
40 }
41 }}}}}
42
43 void SetDdk(OHOS::sptr<IScsiPeripheralDdk>&);
44 ScsiPeripheral_Device *NewScsiPeripheralDevice();
45 void DeleteScsiPeripheralDevice(ScsiPeripheral_Device **dev);
46
47 namespace {
48
49 constexpr int TEST_TIMES = 1;
50 constexpr uint8_t CDB_LENGTH = 1;
51
52 class MockScsiPeripheralDdk : public IScsiPeripheralDdk {
53 public:
54 MOCK_METHOD(int, Init, (), (override));
55 MOCK_METHOD(int, Release, (), (override));
56 MOCK_METHOD(int, Open, (uint64_t deviceId, uint8_t interfaceIndex, ScsiPeripheralDevice &dev, int &memMapFd),
57 (override));
58 MOCK_METHOD(int, Close, (const ScsiPeripheralDevice &dev), (override));
59 MOCK_METHOD(int, ReadCapacity10, (const ScsiPeripheralDevice &dev, const ScsiPeripheralReadCapacityRequest &request,
60 ScsiPeripheralCapacityInfo &capacityInfo, ScsiPeripheralResponse &response), (override));
61 MOCK_METHOD(int, TestUnitReady, (const ScsiPeripheralDevice &dev, const ScsiPeripheralTestUnitReadyRequest &request,
62 ScsiPeripheralResponse &response), (override));
63 MOCK_METHOD(int, Inquiry, (const ScsiPeripheralDevice &dev, const ScsiPeripheralInquiryRequest &request,
64 ScsiPeripheralInquiryInfo &inquiryInfo, ScsiPeripheralResponse &response), (override));
65 MOCK_METHOD(int, RequestSense, (const ScsiPeripheralDevice &dev, const ScsiPeripheralRequestSenseRequest &request,
66 ScsiPeripheralResponse &response), (override));
67 MOCK_METHOD(int, Read10, (const ScsiPeripheralDevice &dev, const ScsiPeripheralIORequest &request,
68 ScsiPeripheralResponse &response), (override));
69 MOCK_METHOD(int, Write10, (const ScsiPeripheralDevice &dev, const ScsiPeripheralIORequest &request,
70 ScsiPeripheralResponse &response), (override));
71 MOCK_METHOD(int, Verify10, (const ScsiPeripheralDevice &dev, const ScsiPeripheralVerifyRequest &request,
72 ScsiPeripheralResponse &response), (override));
73 MOCK_METHOD(int, SendRequestByCDB, (const ScsiPeripheralDevice &dev, const ScsiPeripheralRequest &request,
74 ScsiPeripheralResponse &response), (override));
75 };
76
77 class ScsiPeripheralTest : public testing::Test {
78 };
79
80 HWTEST_F(ScsiPeripheralTest, ReleaseErrorTest, TestSize.Level1)
81 {
82 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
83 ASSERT_NE(mockDdk, nullptr);
84 EXPECT_CALL(*mockDdk, Release())
85 .Times(TEST_TIMES)
86 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
87 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
88 SetDdk(ddk);
89 ASSERT_EQ(OH_ScsiPeripheral_Release(), SCSIPERIPHERAL_DDK_SERVICE_ERROR);
90 }
91
92 HWTEST_F(ScsiPeripheralTest, OpenErrorTest001, TestSize.Level1)
93 {
94 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
95 ASSERT_NE(mockDdk, nullptr);
96 EXPECT_CALL(*mockDdk, Open(testing::_, testing::_, testing::_, testing::_))
97 .Times(TEST_TIMES)
98 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
99 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
100 SetDdk(ddk);
101 ScsiPeripheral_Device *dev = nullptr;
102 ASSERT_EQ(OH_ScsiPeripheral_Open(0, 0, &dev), SCSIPERIPHERAL_DDK_SERVICE_ERROR);
103 }
104
105 HWTEST_F(ScsiPeripheralTest, OpenErrorTest002, TestSize.Level1)
106 {
107 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
108 ASSERT_NE(mockDdk, nullptr);
109 EXPECT_CALL(*mockDdk, Open(testing::_, testing::_, testing::_, testing::_))
110 .Times(TEST_TIMES)
111 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
112 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
113 SetDdk(ddk);
114 ScsiPeripheral_Device *dev = nullptr;
115 ASSERT_EQ(OH_ScsiPeripheral_Open(0, 0, &dev), SCSIPERIPHERAL_DDK_MEMORY_ERROR);
116 }
117
118 HWTEST_F(ScsiPeripheralTest, OpenErrorTest003, TestSize.Level1)
119 {
120 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
121 ASSERT_NE(mockDdk, nullptr);
122 EXPECT_CALL(*mockDdk, Open(testing::_, testing::_, testing::_, testing::_))
123 .Times(TEST_TIMES)
124 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
125 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
126 SetDdk(ddk);
127 ScsiPeripheral_Device *dev = nullptr;
128 ASSERT_EQ(OH_ScsiPeripheral_Open(0, 0, &dev), SCSIPERIPHERAL_DDK_IO_ERROR);
129 }
130
131 HWTEST_F(ScsiPeripheralTest, CloseErrorTest001, TestSize.Level1)
132 {
133 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
134 ASSERT_NE(mockDdk, nullptr);
135 EXPECT_CALL(*mockDdk, Close(testing::_))
136 .Times(TEST_TIMES)
137 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
138 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
139 SetDdk(ddk);
140 auto dev = NewScsiPeripheralDevice();
141 int ret = OH_ScsiPeripheral_Close(&dev);
142 DeleteScsiPeripheralDevice(&dev);
143 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
144 }
145
146 HWTEST_F(ScsiPeripheralTest, CloseErrorTest002, TestSize.Level1)
147 {
148 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
149 ASSERT_NE(mockDdk, nullptr);
150 EXPECT_CALL(*mockDdk, Close(testing::_))
151 .Times(TEST_TIMES)
152 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
153 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
154 SetDdk(ddk);
155 auto dev = NewScsiPeripheralDevice();
156 int ret = OH_ScsiPeripheral_Close(&dev);
157 DeleteScsiPeripheralDevice(&dev);
158 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
159 }
160
161 HWTEST_F(ScsiPeripheralTest, ReadCapacity10ErrorTest001, TestSize.Level1)
162 {
163 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
164 ASSERT_NE(mockDdk, nullptr);
165 EXPECT_CALL(*mockDdk, ReadCapacity10(testing::_, testing::_, testing::_, testing::_))
166 .Times(TEST_TIMES)
167 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
168 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
169 SetDdk(ddk);
170 auto dev = NewScsiPeripheralDevice();
171 ScsiPeripheral_ReadCapacityRequest request = {0};
172 ScsiPeripheral_CapacityInfo capacityInfo = {0};
173 ScsiPeripheral_Response response = {{0}};
174 int ret = OH_ScsiPeripheral_ReadCapacity10(dev, &request, &capacityInfo, &response);
175 DeleteScsiPeripheralDevice(&dev);
176 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
177 }
178
179 HWTEST_F(ScsiPeripheralTest, ReadCapacity10ErrorTest002, TestSize.Level1)
180 {
181 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
182 ASSERT_NE(mockDdk, nullptr);
183 EXPECT_CALL(*mockDdk, ReadCapacity10(testing::_, testing::_, testing::_, testing::_))
184 .Times(TEST_TIMES)
185 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
186 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
187 SetDdk(ddk);
188 auto dev = NewScsiPeripheralDevice();
189 ScsiPeripheral_ReadCapacityRequest request = {0};
190 ScsiPeripheral_CapacityInfo capacityInfo = {0};
191 ScsiPeripheral_Response response = {{0}};
192 int ret = OH_ScsiPeripheral_ReadCapacity10(dev, &request, &capacityInfo, &response);
193 DeleteScsiPeripheralDevice(&dev);
194 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
195 }
196
197 HWTEST_F(ScsiPeripheralTest, ReadCapacity10ErrorTest003, TestSize.Level1)
198 {
199 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
200 ASSERT_NE(mockDdk, nullptr);
201 EXPECT_CALL(*mockDdk, ReadCapacity10(testing::_, testing::_, testing::_, testing::_))
202 .Times(TEST_TIMES)
203 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
204 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
205 SetDdk(ddk);
206 auto dev = NewScsiPeripheralDevice();
207 ScsiPeripheral_ReadCapacityRequest request = {0};
208 ScsiPeripheral_CapacityInfo capacityInfo = {0};
209 ScsiPeripheral_Response response = {{0}};
210 int ret = OH_ScsiPeripheral_ReadCapacity10(dev, &request, &capacityInfo, &response);
211 DeleteScsiPeripheralDevice(&dev);
212 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
213 }
214
215 HWTEST_F(ScsiPeripheralTest, ReadCapacity10ErrorTest004, TestSize.Level1)
216 {
217 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
218 ASSERT_NE(mockDdk, nullptr);
219 EXPECT_CALL(*mockDdk, ReadCapacity10(testing::_, testing::_, testing::_, testing::_))
220 .Times(TEST_TIMES)
221 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
222 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
223 SetDdk(ddk);
224 auto dev = NewScsiPeripheralDevice();
225 ScsiPeripheral_ReadCapacityRequest request = {0};
226 ScsiPeripheral_CapacityInfo capacityInfo = {0};
227 ScsiPeripheral_Response response = {{0}};
228 int ret = OH_ScsiPeripheral_ReadCapacity10(dev, &request, &capacityInfo, &response);
229 DeleteScsiPeripheralDevice(&dev);
230 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
231 }
232
233 HWTEST_F(ScsiPeripheralTest, TestUnitReadyErrorTest001, TestSize.Level1)
234 {
235 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
236 ASSERT_NE(mockDdk, nullptr);
237 EXPECT_CALL(*mockDdk, TestUnitReady(testing::_, testing::_, testing::_))
238 .Times(TEST_TIMES)
239 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
240 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
241 SetDdk(ddk);
242 auto dev = NewScsiPeripheralDevice();
243 ScsiPeripheral_TestUnitReadyRequest request = {0};
244 ScsiPeripheral_Response response = {{0}};
245 int ret = OH_ScsiPeripheral_TestUnitReady(dev, &request, &response);
246 DeleteScsiPeripheralDevice(&dev);
247 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
248 }
249
250 HWTEST_F(ScsiPeripheralTest, TestUnitReadyErrorTest002, TestSize.Level1)
251 {
252 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
253 ASSERT_NE(mockDdk, nullptr);
254 EXPECT_CALL(*mockDdk, TestUnitReady(testing::_, testing::_, testing::_))
255 .Times(TEST_TIMES)
256 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
257 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
258 SetDdk(ddk);
259 auto dev = NewScsiPeripheralDevice();
260 ScsiPeripheral_TestUnitReadyRequest request = {0};
261 ScsiPeripheral_Response response = {{0}};
262 int ret = OH_ScsiPeripheral_TestUnitReady(dev, &request, &response);
263 DeleteScsiPeripheralDevice(&dev);
264 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
265 }
266
267 HWTEST_F(ScsiPeripheralTest, TestUnitReadyErrorTest003, TestSize.Level1)
268 {
269 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
270 ASSERT_NE(mockDdk, nullptr);
271 EXPECT_CALL(*mockDdk, TestUnitReady(testing::_, testing::_, testing::_))
272 .Times(TEST_TIMES)
273 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
274 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
275 SetDdk(ddk);
276 auto dev = NewScsiPeripheralDevice();
277 ScsiPeripheral_TestUnitReadyRequest request = {0};
278 ScsiPeripheral_Response response = {{0}};
279 int ret = OH_ScsiPeripheral_TestUnitReady(dev, &request, &response);
280 DeleteScsiPeripheralDevice(&dev);
281 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
282 }
283
284 HWTEST_F(ScsiPeripheralTest, TestUnitReadyErrorTest004, TestSize.Level1)
285 {
286 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
287 ASSERT_NE(mockDdk, nullptr);
288 EXPECT_CALL(*mockDdk, TestUnitReady(testing::_, testing::_, testing::_))
289 .Times(TEST_TIMES)
290 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
291 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
292 SetDdk(ddk);
293 auto dev = NewScsiPeripheralDevice();
294 ScsiPeripheral_TestUnitReadyRequest request = {0};
295 ScsiPeripheral_Response response = {{0}};
296 int ret = OH_ScsiPeripheral_TestUnitReady(dev, &request, &response);
297 DeleteScsiPeripheralDevice(&dev);
298 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
299 }
300
301 HWTEST_F(ScsiPeripheralTest, InquiryErrorTest001, TestSize.Level1)
302 {
303 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
304 ASSERT_NE(mockDdk, nullptr);
305 EXPECT_CALL(*mockDdk, Inquiry(testing::_, testing::_, testing::_, testing::_))
306 .Times(TEST_TIMES)
307 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
308 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
309 SetDdk(ddk);
310
311 auto dev = NewScsiPeripheralDevice();
312 ScsiPeripheral_InquiryRequest request = {0};
313 ScsiPeripheral_InquiryInfo inquiryInfo = {0};
314 ScsiPeripheral_DeviceMemMap memMap = {0};
315 inquiryInfo.data = &memMap;
316 ScsiPeripheral_Response response = {{0}};
317
318 int ret = OH_ScsiPeripheral_Inquiry(dev, &request, &inquiryInfo, &response);
319 DeleteScsiPeripheralDevice(&dev);
320 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
321 }
322
323 HWTEST_F(ScsiPeripheralTest, InquiryErrorTest002, TestSize.Level1)
324 {
325 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
326 ASSERT_NE(mockDdk, nullptr);
327 EXPECT_CALL(*mockDdk, Inquiry(testing::_, testing::_, testing::_, testing::_))
328 .Times(TEST_TIMES)
329 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
330 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
331 SetDdk(ddk);
332
333 auto dev = NewScsiPeripheralDevice();
334 ScsiPeripheral_InquiryRequest request = {0};
335 ScsiPeripheral_InquiryInfo inquiryInfo = {0};
336 ScsiPeripheral_DeviceMemMap memMap = {0};
337 inquiryInfo.data = &memMap;
338 ScsiPeripheral_Response response = {{0}};
339
340 int ret = OH_ScsiPeripheral_Inquiry(dev, &request, &inquiryInfo, &response);
341 DeleteScsiPeripheralDevice(&dev);
342 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
343 }
344
345 HWTEST_F(ScsiPeripheralTest, InquiryErrorTest003, TestSize.Level1)
346 {
347 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
348 ASSERT_NE(mockDdk, nullptr);
349 EXPECT_CALL(*mockDdk, Inquiry(testing::_, testing::_, testing::_, testing::_))
350 .Times(TEST_TIMES)
351 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
352 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
353 SetDdk(ddk);
354
355 auto dev = NewScsiPeripheralDevice();
356 ScsiPeripheral_InquiryRequest request = {0};
357 ScsiPeripheral_InquiryInfo inquiryInfo = {0};
358 ScsiPeripheral_DeviceMemMap memMap = {0};
359 inquiryInfo.data = &memMap;
360 ScsiPeripheral_Response response = {{0}};
361
362 int ret = OH_ScsiPeripheral_Inquiry(dev, &request, &inquiryInfo, &response);
363 DeleteScsiPeripheralDevice(&dev);
364 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
365 }
366
367 HWTEST_F(ScsiPeripheralTest, InquiryErrorTest004, TestSize.Level1)
368 {
369 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
370 ASSERT_NE(mockDdk, nullptr);
371 EXPECT_CALL(*mockDdk, Inquiry(testing::_, testing::_, testing::_, testing::_))
372 .Times(TEST_TIMES)
373 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
374 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
375 SetDdk(ddk);
376
377 auto dev = NewScsiPeripheralDevice();
378 ScsiPeripheral_InquiryRequest request = {0};
379 ScsiPeripheral_InquiryInfo inquiryInfo = {0};
380 ScsiPeripheral_DeviceMemMap memMap = {0};
381 inquiryInfo.data = &memMap;
382 ScsiPeripheral_Response response = {{0}};
383
384 int ret = OH_ScsiPeripheral_Inquiry(dev, &request, &inquiryInfo, &response);
385 DeleteScsiPeripheralDevice(&dev);
386 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
387 }
388
389 HWTEST_F(ScsiPeripheralTest, RequestSenseErrorTest001, TestSize.Level1)
390 {
391 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
392 ASSERT_NE(mockDdk, nullptr);
393 EXPECT_CALL(*mockDdk, RequestSense(testing::_, testing::_, testing::_))
394 .Times(TEST_TIMES)
395 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
396 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
397 SetDdk(ddk);
398 auto dev = NewScsiPeripheralDevice();
399 ScsiPeripheral_RequestSenseRequest request = {0};
400 ScsiPeripheral_Response response = {{0}};
401 int ret = OH_ScsiPeripheral_RequestSense(dev, &request, &response);
402 DeleteScsiPeripheralDevice(&dev);
403 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
404 }
405
406 HWTEST_F(ScsiPeripheralTest, RequestSenseErrorTest002, TestSize.Level1)
407 {
408 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
409 ASSERT_NE(mockDdk, nullptr);
410 EXPECT_CALL(*mockDdk, RequestSense(testing::_, testing::_, testing::_))
411 .Times(TEST_TIMES)
412 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
413 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
414 SetDdk(ddk);
415 auto dev = NewScsiPeripheralDevice();
416 ScsiPeripheral_RequestSenseRequest request = {0};
417 ScsiPeripheral_Response response = {{0}};
418 int ret = OH_ScsiPeripheral_RequestSense(dev, &request, &response);
419 DeleteScsiPeripheralDevice(&dev);
420 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
421 }
422
423 HWTEST_F(ScsiPeripheralTest, RequestSenseErrorTest003, TestSize.Level1)
424 {
425 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
426 ASSERT_NE(mockDdk, nullptr);
427 EXPECT_CALL(*mockDdk, RequestSense(testing::_, testing::_, testing::_))
428 .Times(TEST_TIMES)
429 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
430 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
431 SetDdk(ddk);
432 auto dev = NewScsiPeripheralDevice();
433 ScsiPeripheral_RequestSenseRequest request = {0};
434 ScsiPeripheral_Response response = {{0}};
435 int ret = OH_ScsiPeripheral_RequestSense(dev, &request, &response);
436 DeleteScsiPeripheralDevice(&dev);
437 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
438 }
439
440 HWTEST_F(ScsiPeripheralTest, RequestSenseErrorTest004, TestSize.Level1)
441 {
442 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
443 ASSERT_NE(mockDdk, nullptr);
444 EXPECT_CALL(*mockDdk, RequestSense(testing::_, testing::_, testing::_))
445 .Times(TEST_TIMES)
446 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
447 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
448 SetDdk(ddk);
449 auto dev = NewScsiPeripheralDevice();
450 ScsiPeripheral_RequestSenseRequest request = {0};
451 ScsiPeripheral_Response response = {{0}};
452 int ret = OH_ScsiPeripheral_RequestSense(dev, &request, &response);
453 DeleteScsiPeripheralDevice(&dev);
454 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
455 }
456
457 HWTEST_F(ScsiPeripheralTest, Read10ErrorTest001, TestSize.Level1)
458 {
459 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
460 ASSERT_NE(mockDdk, nullptr);
461 EXPECT_CALL(*mockDdk, Read10(testing::_, testing::_, testing::_))
462 .Times(TEST_TIMES)
463 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
464 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
465 SetDdk(ddk);
466 auto dev = NewScsiPeripheralDevice();
467 ScsiPeripheral_IORequest request = {0};
468 ScsiPeripheral_DeviceMemMap memMap = {0};
469 request.data = &memMap;
470 ScsiPeripheral_Response response = {{0}};
471 int ret = OH_ScsiPeripheral_Read10(dev, &request, &response);
472 DeleteScsiPeripheralDevice(&dev);
473 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
474 }
475
476 HWTEST_F(ScsiPeripheralTest, Read10ErrorTest002, TestSize.Level1)
477 {
478 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
479 ASSERT_NE(mockDdk, nullptr);
480 EXPECT_CALL(*mockDdk, Read10(testing::_, testing::_, testing::_))
481 .Times(TEST_TIMES)
482 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
483 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
484 SetDdk(ddk);
485 auto dev = NewScsiPeripheralDevice();
486 ScsiPeripheral_IORequest request = {0};
487 ScsiPeripheral_DeviceMemMap memMap = {0};
488 request.data = &memMap;
489 ScsiPeripheral_Response response = {{0}};
490 int ret = OH_ScsiPeripheral_Read10(dev, &request, &response);
491 DeleteScsiPeripheralDevice(&dev);
492 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
493 }
494
495 HWTEST_F(ScsiPeripheralTest, Read10ErrorTest003, TestSize.Level1)
496 {
497 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
498 ASSERT_NE(mockDdk, nullptr);
499 EXPECT_CALL(*mockDdk, Read10(testing::_, testing::_, testing::_))
500 .Times(TEST_TIMES)
501 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
502 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
503 SetDdk(ddk);
504 auto dev = NewScsiPeripheralDevice();
505 ScsiPeripheral_IORequest request = {0};
506 ScsiPeripheral_DeviceMemMap memMap = {0};
507 request.data = &memMap;
508 ScsiPeripheral_Response response = {{0}};
509 int ret = OH_ScsiPeripheral_Read10(dev, &request, &response);
510 DeleteScsiPeripheralDevice(&dev);
511 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
512 }
513
514 HWTEST_F(ScsiPeripheralTest, Read10ErrorTest004, TestSize.Level1)
515 {
516 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
517 ASSERT_NE(mockDdk, nullptr);
518 EXPECT_CALL(*mockDdk, Read10(testing::_, testing::_, testing::_))
519 .Times(TEST_TIMES)
520 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
521 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
522 SetDdk(ddk);
523 auto dev = NewScsiPeripheralDevice();
524 ScsiPeripheral_IORequest request = {0};
525 ScsiPeripheral_DeviceMemMap memMap = {0};
526 request.data = &memMap;
527 ScsiPeripheral_Response response = {{0}};
528 int ret = OH_ScsiPeripheral_Read10(dev, &request, &response);
529 DeleteScsiPeripheralDevice(&dev);
530 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
531 }
532
533 HWTEST_F(ScsiPeripheralTest, Write10ErrorTest001, TestSize.Level1)
534 {
535 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
536 ASSERT_NE(mockDdk, nullptr);
537 EXPECT_CALL(*mockDdk, Write10(testing::_, testing::_, testing::_))
538 .Times(TEST_TIMES)
539 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
540 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
541 SetDdk(ddk);
542 auto dev = NewScsiPeripheralDevice();
543 ScsiPeripheral_IORequest request = {0};
544 ScsiPeripheral_DeviceMemMap memMap = {0};
545 request.data = &memMap;
546 ScsiPeripheral_Response response = {{0}};
547 int ret = OH_ScsiPeripheral_Write10(dev, &request, &response);
548 DeleteScsiPeripheralDevice(&dev);
549 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
550 }
551
552 HWTEST_F(ScsiPeripheralTest, Write10ErrorTest002, TestSize.Level1)
553 {
554 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
555 ASSERT_NE(mockDdk, nullptr);
556 EXPECT_CALL(*mockDdk, Write10(testing::_, testing::_, testing::_))
557 .Times(TEST_TIMES)
558 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
559 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
560 SetDdk(ddk);
561 auto dev = NewScsiPeripheralDevice();
562 ScsiPeripheral_IORequest request = {0};
563 ScsiPeripheral_DeviceMemMap memMap = {0};
564 request.data = &memMap;
565 ScsiPeripheral_Response response = {{0}};
566 int ret = OH_ScsiPeripheral_Write10(dev, &request, &response);
567 DeleteScsiPeripheralDevice(&dev);
568 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
569 }
570
571 HWTEST_F(ScsiPeripheralTest, Write10ErrorTest003, TestSize.Level1)
572 {
573 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
574 ASSERT_NE(mockDdk, nullptr);
575 EXPECT_CALL(*mockDdk, Write10(testing::_, testing::_, testing::_))
576 .Times(TEST_TIMES)
577 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
578 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
579 SetDdk(ddk);
580 auto dev = NewScsiPeripheralDevice();
581 ScsiPeripheral_IORequest request = {0};
582 ScsiPeripheral_DeviceMemMap memMap = {0};
583 request.data = &memMap;
584 ScsiPeripheral_Response response = {{0}};
585 int ret = OH_ScsiPeripheral_Write10(dev, &request, &response);
586 DeleteScsiPeripheralDevice(&dev);
587 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
588 }
589
590 HWTEST_F(ScsiPeripheralTest, Write10ErrorTest004, TestSize.Level1)
591 {
592 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
593 ASSERT_NE(mockDdk, nullptr);
594 EXPECT_CALL(*mockDdk, Write10(testing::_, testing::_, testing::_))
595 .Times(TEST_TIMES)
596 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
597 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
598 SetDdk(ddk);
599 auto dev = NewScsiPeripheralDevice();
600 ScsiPeripheral_IORequest request = {0};
601 ScsiPeripheral_DeviceMemMap memMap = {0};
602 request.data = &memMap;
603 ScsiPeripheral_Response response = {{0}};
604 int ret = OH_ScsiPeripheral_Write10(dev, &request, &response);
605 DeleteScsiPeripheralDevice(&dev);
606 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
607 }
608
609 HWTEST_F(ScsiPeripheralTest, Verify10ErrorTest001, TestSize.Level1)
610 {
611 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
612 ASSERT_NE(mockDdk, nullptr);
613 EXPECT_CALL(*mockDdk, Verify10(testing::_, testing::_, testing::_))
614 .Times(TEST_TIMES)
615 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
616 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
617 SetDdk(ddk);
618 auto dev = NewScsiPeripheralDevice();
619 ScsiPeripheral_VerifyRequest request = {0};
620 ScsiPeripheral_Response response = {{0}};
621 int ret = OH_ScsiPeripheral_Verify10(dev, &request, &response);
622 DeleteScsiPeripheralDevice(&dev);
623 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
624 }
625
626 HWTEST_F(ScsiPeripheralTest, Verify10ErrorTest002, TestSize.Level1)
627 {
628 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
629 ASSERT_NE(mockDdk, nullptr);
630 EXPECT_CALL(*mockDdk, Verify10(testing::_, testing::_, testing::_))
631 .Times(TEST_TIMES)
632 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
633 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
634 SetDdk(ddk);
635 auto dev = NewScsiPeripheralDevice();
636 ScsiPeripheral_VerifyRequest request = {0};
637 ScsiPeripheral_Response response = {{0}};
638 int ret = OH_ScsiPeripheral_Verify10(dev, &request, &response);
639 DeleteScsiPeripheralDevice(&dev);
640 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
641 }
642
643 HWTEST_F(ScsiPeripheralTest, Verify10ErrorTest003, TestSize.Level1)
644 {
645 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
646 ASSERT_NE(mockDdk, nullptr);
647 EXPECT_CALL(*mockDdk, Verify10(testing::_, testing::_, testing::_))
648 .Times(TEST_TIMES)
649 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
650 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
651 SetDdk(ddk);
652 auto dev = NewScsiPeripheralDevice();
653 ScsiPeripheral_VerifyRequest request = {0};
654 ScsiPeripheral_Response response = {{0}};
655 int ret = OH_ScsiPeripheral_Verify10(dev, &request, &response);
656 DeleteScsiPeripheralDevice(&dev);
657 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
658 }
659
660 HWTEST_F(ScsiPeripheralTest, Verify10ErrorTest004, TestSize.Level1)
661 {
662 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
663 ASSERT_NE(mockDdk, nullptr);
664 EXPECT_CALL(*mockDdk, Verify10(testing::_, testing::_, testing::_))
665 .Times(TEST_TIMES)
666 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
667 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
668 SetDdk(ddk);
669 auto dev = NewScsiPeripheralDevice();
670 ScsiPeripheral_VerifyRequest request = {0};
671 ScsiPeripheral_Response response = {{0}};
672 int ret = OH_ScsiPeripheral_Verify10(dev, &request, &response);
673 DeleteScsiPeripheralDevice(&dev);
674 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
675 }
676
677 HWTEST_F(ScsiPeripheralTest, SendRequestByCDBErrorTest001, TestSize.Level1)
678 {
679 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
680 ASSERT_NE(mockDdk, nullptr);
681 EXPECT_CALL(*mockDdk, SendRequestByCDB(testing::_, testing::_, testing::_))
682 .Times(TEST_TIMES)
683 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_SERVICE_ERROR));
684 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
685 SetDdk(ddk);
686 auto dev = NewScsiPeripheralDevice();
687 ScsiPeripheral_Request request = {{0}};
688 ScsiPeripheral_DeviceMemMap memMap = {0};
689 request.data = &memMap;
690 request.cdbLength = CDB_LENGTH;
691 ScsiPeripheral_Response response = {{0}};
692 int ret = OH_ScsiPeripheral_SendRequestByCdb(dev, &request, &response);
693 DeleteScsiPeripheralDevice(&dev);
694 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_SERVICE_ERROR);
695 }
696
697 HWTEST_F(ScsiPeripheralTest, SendRequestByCDBErrorTest002, TestSize.Level1)
698 {
699 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
700 ASSERT_NE(mockDdk, nullptr);
701 EXPECT_CALL(*mockDdk, SendRequestByCDB(testing::_, testing::_, testing::_))
702 .Times(TEST_TIMES)
703 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_MEMORY_ERROR));
704 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
705 SetDdk(ddk);
706 auto dev = NewScsiPeripheralDevice();
707 ScsiPeripheral_Request request = {{0}};
708 ScsiPeripheral_DeviceMemMap memMap = {0};
709 request.data = &memMap;
710 request.cdbLength = CDB_LENGTH;
711 ScsiPeripheral_Response response = {{0}};
712 int ret = OH_ScsiPeripheral_SendRequestByCdb(dev, &request, &response);
713 DeleteScsiPeripheralDevice(&dev);
714 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_MEMORY_ERROR);
715 }
716
717 HWTEST_F(ScsiPeripheralTest, SendRequestByCDBErrorTest003, TestSize.Level1)
718 {
719 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
720 ASSERT_NE(mockDdk, nullptr);
721 EXPECT_CALL(*mockDdk, SendRequestByCDB(testing::_, testing::_, testing::_))
722 .Times(TEST_TIMES)
723 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_IO_ERROR));
724 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
725 SetDdk(ddk);
726 auto dev = NewScsiPeripheralDevice();
727 ScsiPeripheral_Request request = {{0}};
728 ScsiPeripheral_DeviceMemMap memMap = {0};
729 request.data = &memMap;
730 request.cdbLength = CDB_LENGTH;
731 ScsiPeripheral_Response response = {{0}};
732 int ret = OH_ScsiPeripheral_SendRequestByCdb(dev, &request, &response);
733 DeleteScsiPeripheralDevice(&dev);
734 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_IO_ERROR);
735 }
736
737 HWTEST_F(ScsiPeripheralTest, SendRequestByCDBErrorTest004, TestSize.Level1)
738 {
739 auto mockDdk = OHOS::sptr<MockScsiPeripheralDdk>::MakeSptr();
740 ASSERT_NE(mockDdk, nullptr);
741 EXPECT_CALL(*mockDdk, SendRequestByCDB(testing::_, testing::_, testing::_))
742 .Times(TEST_TIMES)
743 .WillOnce(testing::Return(SCSIPERIPHERAL_DDK_TIMEOUT));
744 auto ddk = OHOS::sptr<IScsiPeripheralDdk>(mockDdk);
745 SetDdk(ddk);
746 auto dev = NewScsiPeripheralDevice();
747 ScsiPeripheral_Request request = {{0}};
748 ScsiPeripheral_DeviceMemMap memMap = {0};
749 request.data = &memMap;
750 request.cdbLength = CDB_LENGTH;
751 ScsiPeripheral_Response response = {{0}};
752 int ret = OH_ScsiPeripheral_SendRequestByCdb(dev, &request, &response);
753 DeleteScsiPeripheralDevice(&dev);
754 ASSERT_EQ(ret, SCSIPERIPHERAL_DDK_TIMEOUT);
755 }
756 } // namespace
757