1 /*
2  * Copyright (c) 2024 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 <gtest/gtest.h>
17 #include "print_usb_manager.h"
18 
19 using namespace testing;
20 using namespace testing::ext;
21 namespace OHOS::Print {
22 class PrintUsbManagerTest : public testing::Test {
23 public:
24     PrintUsbManager *printUsbManager;
25     USB::UsbDevice usbDevice;
26     std::string printerName;
27     Operation operation;
28 
SetUp()29     void SetUp() override
30     {
31         printUsbManager = new PrintUsbManager();
32         printerName = "printer";
33         operation = Operation::READ;
34     }
TearDown()35     void TearDown() override
36     {
37         delete printUsbManager;
38         printUsbManager = nullptr;
39     }
GetPrinterName(const std::string & name)40     virtual std::string GetPrinterName(const std::string &name)
41     {
42         return name;
43     }
44 };
45 
TEST_F(PrintUsbManagerTest,isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameIsEmpty)46 TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameIsEmpty)
47 {
48     EXPECT_FALSE(printUsbManager->isExistIppOverUsbPrinter(""));
49 }
50 
TEST_F(PrintUsbManagerTest,isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameIsNull)51 TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameIsNull)
52 {
53     EXPECT_FALSE(printUsbManager->isExistIppOverUsbPrinter(nullptr));
54 }
55 
TEST_F(PrintUsbManagerTest,isExistIppOverUsbPrinter_ShouldReturnTrue_WhenPrinterNameExists)56 TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnTrue_WhenPrinterNameExists)
57 {
58     // Assuming there is a printer named "Printer1" in the system
59     EXPECT_TRUE(printUsbManager->isExistIppOverUsbPrinter("Printer1"));
60 }
61 
TEST_F(PrintUsbManagerTest,isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameDoesNotExist)62 TEST_F(PrintUsbManagerTest, isExistIppOverUsbPrinter_ShouldReturnFalse_WhenPrinterNameDoesNotExist)
63 {
64     // Assuming there is no printer named "NonExistingPrinter" in the system
65     EXPECT_FALSE(printUsbManager->isExistIppOverUsbPrinter("NonExistingPrinter"));
66 }
67 
68 HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnFalse_WhenInterfaceCountIsLessThanTwo, TestSize.Level0)
69 {
70     usbDevice.SetConfigCount(1);
71     usbDevice.GetConfigs()[0].SetInterfaceCount(1);
72     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_CLASS_PRINT);
73     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
74     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
75     EXPECT_FALSE(printUsbManager->isPrintDevice(usbDevice, printerName));
76 }
77 
78 HWTEST_F(PrintUsbManagerTest,
79     isPrintDevice_ShouldReturnTrue_WhenInterfaceCountIsGreaterThanOrEqualToTwo, TestSize.Level0)
80 {
81     usbDevice.SetConfigCount(1);
82     usbDevice.GetConfigs()[0].SetInterfaceCount(2);
83     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT);
84     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
85     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
86     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT);
87     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
88     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
89     EXPECT_TRUE(printUsbManager->isPrintDevice(usbDevice, printerName));
90 }
91 
92 HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0)
93 {
94     usbDevice.SetConfigCount(1);
95     usbDevice.GetConfigs()[0].SetInterfaceCount(2);
96     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT);
97     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
98     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
99     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT);
100     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
101     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
102     printerName = "";
103     EXPECT_FALSE(printUsbManager->isPrintDevice(usbDevice, printerName));
104 }
105 
106 HWTEST_F(PrintUsbManagerTest, isPrintDevice_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0)
107 {
108     usbDevice.SetConfigCount(1);
109     usbDevice.GetConfigs()[0].SetInterfaceCount(2);
110     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT);
111     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
112     usbDevice.GetConfigs()[0].GetInterfaces()[0].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
113     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetClass(USB_DEVICE_DEVICE_CLASS_PRINT);
114     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetSubClass(USB_DEVICE_SUBCLASS_PRINT);
115     usbDevice.GetConfigs()[0].GetInterfaces()[1].SetProtocol(USB_DEVICE_PROTOCOL_PRINT);
116     printerName = "TestPrinter";
117     EXPECT_TRUE(printUsbManager->isPrintDevice(usbDevice, printerName));
118 }
119 
HWTEST_F(PrintUsbManagerTest,GetProductName_ShouldReturnCorrectName_WhenDeviceHasName,Level0)120 HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnCorrectName_WhenDeviceHasName, Level0)
121 {
122     usbDevice.name = "TestDevice";
123     EXPECT_EQ(printUsbManager->GetProductName(usbDevice), "TestDevice");
124 }
125 
HWTEST_F(PrintUsbManagerTest,GetProductName_ShouldReturnEmptyString_WhenDeviceHasNoName,Level0)126 HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnEmptyString_WhenDeviceHasNoName, Level0)
127 {
128     usbDevice.name = "";
129     EXPECT_EQ(printUsbManager->GetProductName(usbDevice), "");
130 }
131 
HWTEST_F(PrintUsbManagerTest,GetProductName_ShouldReturnCorrectName_WhenDeviceHasLongName,Level0)132 HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnCorrectName_WhenDeviceHasLongName, Level0)
133 {
134     usbDevice.name = "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName";
135     EXPECT_EQ(printUsbManager->GetProductName(usbDevice),
136         "ThisIsALongDeviceNameThatExceedsTheMaximumAllowedLengthForTheProductName");
137 }
138 
HWTEST_F(PrintUsbManagerTest,GetProductName_ShouldReturnEmptyString_WhenDeviceIsNull,Level0)139 HWTEST_F(PrintUsbManagerTest, GetProductName_ShouldReturnEmptyString_WhenDeviceIsNull, Level0)
140 {
141     EXPECT_EQ(printUsbManager->GetProductName(nullptr), "");
142 }
143 
TEST_F(nullTest,QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_WhenInputIsNull)144 TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_WhenInputIsNull)
145 {
146     PrintUsbManager manager;
147     std::string result = manager.QueryPrinterInfoFromStringDescriptor(nullptr);
148     EXPECT_EQ(result, "");
149 }
150 
TEST_F(nullTest,QueryPrinterInfoFromStringDescriptor_ShouldReturnNonEmptyString_WhenInputIsNotNull)151 TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnNonEmptyString_WhenInputIsNotNull)
152 {
153     PrintUsbManager manager;
154     std::string descriptor = "some descriptor";
155     std::string result = manager.QueryPrinterInfoFromStringDescriptor(&descriptor);
156     EXPECT_NE(result, "");
157 }
158 
TEST_F(nullTest,QueryPrinterInfoFromStringDescriptor_ShouldReturnSameString_WhenInputIsSameString)159 TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnSameString_WhenInputIsSameString)
160 {
161     PrintUsbManager manager;
162     std::string descriptor = "same descriptor";
163     std::string result = manager.QueryPrinterInfoFromStringDescriptor(&descriptor);
164     EXPECT_EQ(result, "same descriptor");
165 }
166 
TEST_F(nullTest,QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_WhenInputIsEmpty)167 TEST_F(nullTest, QueryPrinterInfoFromStringDescriptor_ShouldReturnEmptyString_WhenInputIsEmpty)
168 {
169     PrintUsbManager manager;
170     std::string descriptor = "";
171     std::string result = manager.QueryPrinterInfoFromStringDescriptor(&descriptor);
172     EXPECT_EQ(result, "");
173 }
174 
175 HWTEST_F(PrintUsbManagerTest,
176     PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenSurfaceProducerIsNull, TestSize.Level0)
177 {
178     printerName = "printer1";
179     usbDevice.surfaceProducer = nullptr;
180     EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false);
181 }
182 HWTEST_F(PrintUsbManagerTest,
183     PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenSurfaceProducerIsNotNull, TestSize.Level0)
184 {
185     printerName = "printer1";
186     usbDevice.surfaceProducer = new SurfaceProducer();
187     EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), true);
188     delete usbDevice.surfaceProducer;
189 }
190 HWTEST_F(PrintUsbManagerTest,
191     PrintUsbManager_AllocateInterface_ShouldReturnFalse_WhenPrinterNameIsEmpty, TestSize.Level0)
192 {
193     printerName = "";
194     usbDevice.surfaceProducer = new SurfaceProducer();
195     EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), false);
196     delete usbDevice.surfaceProducer;
197 }
198 HWTEST_F(PrintUsbManagerTest,
199     PrintUsbManager_AllocateInterface_ShouldReturnTrue_WhenPrinterNameIsNotEmpty, TestSize.Level0)
200 {
201     printerName = "printer1";
202     usbDevice.surfaceProducer = new SurfaceProducer();
203     EXPECT_EQ(printUsbManager->AllocateInterface(printerName, usbDevice), true);
204     delete usbDevice.surfaceProducer;
205 }
206 
TEST_F(PrintUsbManagerTest,ConnectUsbPinter_ShouldReturnTrue_WhenPrinterNameIsValid)207 TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnTrue_WhenPrinterNameIsValid)
208 {
209     // Arrange
210     std::string printerName = "validPrinter";
211     // Act
212     bool result = printUsbManager->ConnectUsbPinter(printerName);
213     // Assert
214     EXPECT_TRUE(result);
215 }
216 
TEST_F(PrintUsbManagerTest,ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsInvalid)217 TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsInvalid)
218 {
219     // Arrange
220     std::string printerName = "invalidPrinter";
221     // Act
222     bool result = printUsbManager->ConnectUsbPinter(printerName);
223     // Assert
224     EXPECT_FALSE(result);
225 }
226 
TEST_F(PrintUsbManagerTest,ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsEmpty)227 TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsEmpty)
228 {
229     // Arrange
230     std::string printerName = "";
231     // Act
232     bool result = printUsbManager->ConnectUsbPinter(printerName);
233     // Assert
234     EXPECT_FALSE(result);
235 }
236 
TEST_F(PrintUsbManagerTest,ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsNull)237 TEST_F(PrintUsbManagerTest, ConnectUsbPinter_ShouldReturnFalse_WhenPrinterNameIsNull)
238 {
239     // Arrange
240     std::string printerName = nullptr;
241     // Act
242     bool result = printUsbManager->ConnectUsbPinter(printerName);
243     // Assert
244     EXPECT_FALSE(result);
245 }
246 
TEST_F(PrintUsbManagerTest,testDisConnectUsbPinter)247 TEST_F(PrintUsbManagerTest, testDisConnectUsbPinter)
248 {
249     PrintUsbManager printUsbManager;
250     std::string printerName = "printer1";
251     printUsbManager.DisConnectUsbPinter(printerName);
252     EXPECT_EQ(printUsbManager.GetPrinterList().find(printerName), printUsbManager.GetPrinterList().end());
253 }
254 
TEST_F(PrintUsbManagerTest,testDisConnectUsbPinterWithNonExistentPrinter)255 TEST_F(PrintUsbManagerTest, testDisConnectUsbPinterWithNonExistentPrinter)
256 {
257     PrintUsbManager printUsbManager;
258     std::string printerName = "non_existent_printer";
259     printUsbManager.DisConnectUsbPinter(printerName);
260     EXPECT_NE(printUsbManager.GetPrinterList().find(printerName), printUsbManager.GetPrinterList().end());
261 }
262 
263 HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnSuccess_WhenSurfaceProducerIsNotNull, TestSize.Level0)
264 {
265     // Arrange
266     operation.surfaceProducer = new SurfaceProducer();
267     // Act
268     int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr);
269 
270     // Assert
271     EXPECT_EQ(result, 0);
272 }
273 
274 HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnFailure_WhenSurfaceProducerIsNull, TestSize.Level0)
275 {
276     // Arrange
277     operation.surfaceProducer = nullptr;
278     // Act
279     int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr);
280 
281     // Assert
282     EXPECT_NE(result, 0);
283 }
284 
285 HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnFailure_WhenOperationIsNull, TestSize.Level0)
286 {
287     // Arrange
288     operation = nullptr;
289     // Act
290     int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr);
291 
292     // Assert
293     EXPECT_NE(result, 0);
294 }
295 
296 HWTEST_F(PrintUsbManagerTest, BulkTransferWrite_ShouldReturnFailure_WhenPrinterNameIsEmpty, TestSize.Level0)
297 {
298     // Arrange
299     printerName = "";
300     // Act
301     int32_t result = printUsbManager->BulkTransferWrite(printerName, operation, nullptr);
302 
303     // Assert
304     EXPECT_NE(result, 0);
305 }
306 
307 HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnSuccess_WhenSurfaceProducerIsNotNull, TestSize.Level0)
308 {
309     // Arrange
310     sptr<IBufferProducer> surfaceProducer = new IBufferProducer();
311     // Act
312     int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer);
313     // Assert
314     EXPECT_EQ(result, 0);
315 }
316 
317 HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnFailure_WhenSurfaceProducerIsNull, TestSize.Level0)
318 {
319     // Arrange
320     sptr<IBufferProducer> surfaceProducer = nullptr;
321     // Act
322     int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer);
323     // Assert
324     EXPECT_NE(result, 0);
325 }
326 
327 HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnFailure_WhenOperationIsNotRead, TestSize.Level0)
328 {
329     // Arrange
330     sptr<IBufferProducer> surfaceProducer = new IBufferProducer();
331     Operation operation = Operation::WRITE;
332     // Act
333     int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer);
334     // Assert
335     EXPECT_NE(result, 0);
336 }
337 
338 HWTEST_F(PrintUsbManagerTest, BulkTransferRead_ShouldReturnFailure_WhenPrinterNameIsEmpty, TestSize.Level0)
339 {
340     // Arrange
341     sptr<IBufferProducer> surfaceProducer = new IBufferProducer();
342     std::string printerName = "";
343     // Act
344     int32_t result = printUsbManager->BulkTransferRead(printerName, operation, surfaceProducer);
345     // Assert
346     EXPECT_NE(result, 0);
347 }
348 
TEST_F(nullTest,DealUsbDevStatusChange_ShouldReturnNull_WhenSurfaceProducerIsNull)349 TEST_F(nullTest, DealUsbDevStatusChange_ShouldReturnNull_WhenSurfaceProducerIsNull)
350 {
351     PrintUsbManager printUsbManager;
352     std::string devStr = "testDevice";
353     bool isAttach = false;
354     printUsbManager.DealUsbDevStatusChange(devStr, isAttach);
355     EXPECT_TRUE(printUsbManager.status);
356 }
357 
TEST_F(nullTest,DealUsbDevStatusChange_ShouldReturnNonNull_WhenSurfaceProducerIsNotNull)358 TEST_F(nullTest, DealUsbDevStatusChange_ShouldReturnNonNull_WhenSurfaceProducerIsNotNull)
359 {
360     PrintUsbManager printUsbManager;
361     std::string devStr = "testDevice";
362     bool isAttach = true;
363     printUsbManager.DealUsbDevStatusChange(devStr, isAttach);
364     EXPECT_FALSE(printUsbManager.status);
365 }
366 
HWTEST_F(PrintUsbManagerTest,GetPrinterName_ShouldReturnName_WhenNameIsGiven,Level0)367 HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenNameIsGiven, Level0)
368 {
369     PrintUsbManager manager;
370     std::string expected = "printer";
371     EXPECT_EQ(manager.GetPrinterName(expected), expected);
372 }
373 
HWTEST_F(PrintUsbManagerTest,GetPrinterName_ShouldReturnEmptyString_WhenEmptyStringIsGiven,Level0)374 HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnEmptyString_WhenEmptyStringIsGiven, Level0)
375 {
376     PrintUsbManager manager;
377     std::string expected = "";
378     EXPECT_EQ(manager.GetPrinterName(expected), expected);
379 }
380 
HWTEST_F(PrintUsbManagerTest,GetPrinterName_ShouldReturnName_WhenSpecialCharactersAreGiven,Level0)381 HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenSpecialCharactersAreGiven, Level0)
382 {
383     PrintUsbManager manager;
384     std::string expected = "!@#$%^&*()";
385     EXPECT_EQ(manager.GetPrinterName(expected), expected);
386 }
387 
HWTEST_F(PrintUsbManagerTest,GetPrinterName_ShouldReturnName_WhenNumbersAreGiven,Level0)388 HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenNumbersAreGiven, Level0)
389 {
390     PrintUsbManager manager;
391     std::string expected = "1234567890";
392     EXPECT_EQ(manager.GetPrinterName(expected), expected);
393 }
394 
HWTEST_F(PrintUsbManagerTest,GetPrinterName_ShouldReturnName_WhenNameIsLong,Level0)395 HWTEST_F(PrintUsbManagerTest, GetPrinterName_ShouldReturnName_WhenNameIsLong, Level0)
396 {
397     PrintUsbManager manager;
398     std::string expected = "ThisIsALongNameForAPrinter";
399     EXPECT_EQ(manager.GetPrinterName(expected), expected);
400 }
401 
402 } // namespace OHOS::Print
403