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 #define private public
18 #include "vendor_manager.h"
19 #undef private
20 #include "vendor_ppd_driver.h"
21 #include "print_constant.h"
22 #include "print_log.h"
23 #include "vendor_ipp_everywhere.h"
24 #include "mock/mock_print_service_ability.h"
25 #include "mock/mock_vendor_ppd_driver.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace {
31 const int WAIT_TIME_MS = 100;
32 const std::string PRINTER_TEST_IP = "192.168.2.222";
33 }
34
35 namespace OHOS {
36 namespace Print {
37 class VendorManagerTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase(void)45 void VendorManagerTest::SetUpTestCase(void) {}
46
TearDownTestCase(void)47 void VendorManagerTest::TearDownTestCase(void) {}
48
SetUp(void)49 void VendorManagerTest::SetUp(void)
50 {
51 static int32_t testNo = 0;
52 PRINT_HILOGI("VendorManagerTest_%{public}d", ++testNo);
53 }
54
TearDown(void)55 void VendorManagerTest::TearDown(void) {}
56
57 HWTEST_F(VendorManagerTest, VendorManagerTest_0001, TestSize.Level0)
58 {
59 std::string vendorName = "test.vendor";
60 std::string printerId = "test.printer.id";
61 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
62 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
63 EXPECT_STREQ(VendorManager::ExtractVendorName(globalVendorName).c_str(), vendorName.c_str());
64 EXPECT_STREQ(VendorManager::ExtractGlobalVendorName(globalPrinterId).c_str(), globalVendorName.c_str());
65 EXPECT_STREQ(VendorManager::ExtractPrinterId(globalPrinterId).c_str(), printerId.c_str());
66 EXPECT_TRUE(VendorManager::ExtractPrinterId("").empty());
67 EXPECT_TRUE(VendorManager::ExtractGlobalVendorName("").empty());
68 EXPECT_TRUE(VendorManager::ExtractVendorName("").empty());
69 EXPECT_STREQ(VendorManager::ExtractPrinterId("fwk.test:").c_str(), "fwk.test:");
70 EXPECT_TRUE(VendorManager::ExtractVendorName("test").empty());
71 EXPECT_TRUE(VendorManager::ExtractVendorName("fwk.").empty());
72 }
73
74 HWTEST_F(VendorManagerTest, VendorManagerTest_0002, TestSize.Level0)
75 {
76 VendorManager vendorManager;
77 EXPECT_TRUE(vendorManager.Init(nullptr, false));
78 EXPECT_TRUE(vendorManager.Init(nullptr, false));
79 ThreadSyncWait syncWait;
80 vendorManager.StartDiscovery();
81 syncWait.Wait(WAIT_TIME_MS);
82 vendorManager.StopDiscovery();
83 syncWait.Wait(WAIT_TIME_MS);
84 vendorManager.StartStatusMonitor();
85 vendorManager.StartStatusMonitor();
86 syncWait.Wait(WAIT_TIME_MS);
87 vendorManager.StopStatusMonitor();
88 vendorManager.StopStatusMonitor();
89 syncWait.Wait(WAIT_TIME_MS);
90 vendorManager.UnInit();
91 }
92
93 HWTEST_F(VendorManagerTest, VendorManagerTest_0003, TestSize.Level0)
94 {
95 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
96 VendorManager vendorManager;
97 EXPECT_TRUE(vendorManager.Init(mock, false));
98 ThreadSyncWait syncWait;
99 vendorManager.StartDiscovery();
100 syncWait.Wait(WAIT_TIME_MS);
101 vendorManager.StopDiscovery();
102 syncWait.Wait(WAIT_TIME_MS);
103 vendorManager.StartStatusMonitor();
104 EXPECT_FALSE(vendorManager.ConnectPrinterByIp(PRINTER_TEST_IP, "ipp"));
105 syncWait.Wait(WAIT_TIME_MS);
106 vendorManager.StopStatusMonitor();
107 EXPECT_FALSE(vendorManager.ConnectPrinterByIp("test", ""));
108 EXPECT_FALSE(vendorManager.QueryPrinterInfo("vendor:test", 0));
109 EXPECT_FALSE(vendorManager.QueryPrinterInfo("test:", 0));
110 EXPECT_FALSE(vendorManager.QueryPrinterInfo(":test", 0));
111 syncWait.Wait(WAIT_TIME_MS);
112 vendorManager.UnInit();
113 }
114
115 HWTEST_F(VendorManagerTest, VendorManagerTest_0004, TestSize.Level2)
116 {
117 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
118 VendorManager vendorManager;
119 EXPECT_TRUE(vendorManager.Init(mock, false));
120 auto vendorIppEverywhere = std::make_shared<VendorIppEveryWhere>();
121 ASSERT_NE(vendorIppEverywhere, nullptr);
122 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorIppEverywhere));
123 ThreadSyncWait syncWait;
124 std::string vendorName = vendorIppEverywhere->GetVendorName();
125 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
126 std::string printerId = PRINTER_TEST_IP;
127 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
128 vendorManager.StartDiscovery();
129 syncWait.Wait(WAIT_TIME_MS);
130 vendorManager.StopDiscovery();
131 syncWait.Wait(WAIT_TIME_MS);
132 vendorManager.StartStatusMonitor();
133 syncWait.Wait(WAIT_TIME_MS);
134 vendorManager.MonitorPrinterStatus(globalPrinterId, true);
135 vendorManager.MonitorPrinterStatus(globalPrinterId, true);
136 syncWait.Wait(WAIT_TIME_MS);
137 EXPECT_CALL(*mock, QueryPrinterCapabilityByUri(_, _)).WillRepeatedly(Return(true));
138 EXPECT_CALL(*mock, QueryPrinterStatusByUri(_, _)).WillRepeatedly(Return(true));
139 EXPECT_TRUE(vendorManager.ConnectPrinterByIp(PRINTER_TEST_IP, "ipp"));
140 EXPECT_FALSE(vendorManager.ConnectPrinter(PRINTER_TEST_IP));
141 EXPECT_FALSE(vendorManager.ConnectPrinter(globalPrinterId));
142 EXPECT_TRUE(vendorManager.QueryPrinterInfo(globalPrinterId, 0));
143 vendorManager.UpdateAllPrinterStatus();
144 vendorManager.MonitorPrinterStatus(globalPrinterId, false);
145 vendorManager.MonitorPrinterStatus(globalPrinterId, false);
146 syncWait.Wait(WAIT_TIME_MS);
147 vendorManager.StopStatusMonitor();
148 syncWait.Wait(WAIT_TIME_MS);
149 vendorManager.UnloadVendorDriver(vendorName);
150 vendorManager.UnInit();
151 }
152
153 HWTEST_F(VendorManagerTest, VendorManagerTest_0005, TestSize.Level0)
154 {
155 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
156 VendorManager vendorManager;
157 EXPECT_TRUE(vendorManager.Init(mock, false));
158 auto vendorIppEverywhere = std::make_shared<VendorIppEveryWhere>();
159 ASSERT_NE(vendorIppEverywhere, nullptr);
160 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorIppEverywhere));
161 std::string vendorName = vendorIppEverywhere->GetVendorName();
162 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
163 std::string printerId = PRINTER_TEST_IP;
164 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
165 EXPECT_FALSE(vendorManager.IsConnectingPrinter(globalPrinterId, ""));
166 vendorManager.SetConnectingPrinter(ConnectMethod::ID_AUTO, "");
167 EXPECT_FALSE(vendorManager.IsConnectingPrinter("", ""));
168 vendorManager.SetConnectingPrinter(ConnectMethod::ID_AUTO, globalPrinterId);
169 EXPECT_TRUE(vendorManager.IsConnectingPrinter(globalPrinterId, ""));
170 vendorManager.SetConnectingPrinter(ConnectMethod::IP_AUTO, printerId);
171 EXPECT_TRUE(vendorManager.IsConnectingPrinter(globalPrinterId, ""));
172 EXPECT_TRUE(vendorManager.IsConnectingPrinter(globalPrinterId, printerId));
173 vendorManager.UnInit();
174 }
175
176 HWTEST_F(VendorManagerTest, VendorManagerTest_0006, TestSize.Level1)
177 {
178 VendorManager vendorManager;
179 EXPECT_TRUE(vendorManager.Init(nullptr, false));
180 EXPECT_FALSE(vendorManager.LoadVendorDriver(nullptr));
181 PrinterInfo printerInfo;
182 std::string ppdDriverVendorName = "driver.ppd";
183 EXPECT_EQ(vendorManager.AddPrinterToDiscovery("", printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
184 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(ppdDriverVendorName, printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
185 EXPECT_EQ(vendorManager.UpdatePrinterToDiscovery("", printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
186 EXPECT_EQ(vendorManager.RemovePrinterFromDiscovery("", ""), EXTENSION_ERROR_CALLBACK_FAIL);
187 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd("", "", "", ""), EXTENSION_ERROR_CALLBACK_FAIL);
188 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd(ppdDriverVendorName, "", "", ""), EXTENSION_ERROR_CALLBACK_FAIL);
189 EXPECT_EQ(vendorManager.RemovePrinterFromCups("", ""), EXTENSION_ERROR_CALLBACK_FAIL);
190 EXPECT_FALSE(vendorManager.OnPrinterPpdQueried("", PRINTER_TEST_IP, "", ""));
191 EXPECT_FALSE(vendorManager.MonitorPrinterStatus(":id", true));
192 EXPECT_FALSE(vendorManager.MonitorPrinterStatus("fwk.driver:", true));
193 EXPECT_FALSE(vendorManager.MonitorPrinterStatus("fwk.:printer.id", true));
194 EXPECT_FALSE(vendorManager.MonitorPrinterStatus("fwk.driver:printer.id", true));
195 PrinterCapability printerCap;
196 EXPECT_FALSE(vendorManager.QueryPrinterCapabilityByUri(PRINTER_TEST_IP, printerCap));
197 PrinterStatus status = PRINTER_STATUS_UNAVAILABLE;
198 EXPECT_FALSE(vendorManager.QueryPrinterStatusByUri(PRINTER_TEST_IP, status));
199 PrinterVendorStatus vendorStatus;
200 EXPECT_TRUE(vendorManager.OnPrinterStatusChanged("vendor", PRINTER_TEST_IP, vendorStatus));
201 EXPECT_EQ(vendorManager.QueryPrinterInfoByPrinterId("vendor", PRINTER_TEST_IP, printerInfo),
202 E_PRINT_GENERIC_FAILURE);
203 std::string mekeModel = "test_makeModel";
204 std::string ppdName;
205 EXPECT_FALSE(vendorManager.QueryPPDInformation(mekeModel, ppdName));
206 vendorManager.UnInit();
207 }
208
209 HWTEST_F(VendorManagerTest, VendorManagerTest_0007, TestSize.Level2)
210 {
211 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
212 VendorManager vendorManager;
213 EXPECT_TRUE(vendorManager.Init(mock, false));
214 auto vendorIppEverywhere = std::make_shared<VendorIppEveryWhere>();
215 ASSERT_NE(vendorIppEverywhere, nullptr);
216 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorIppEverywhere));
217 std::string vendorName = vendorIppEverywhere->GetVendorName();
218 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
219 std::string printerId = PRINTER_TEST_IP;
220 PrinterInfo printerInfo;
221 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
222 EXPECT_CALL(*mock, QueryPrinterStatusByUri(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
223 EXPECT_CALL(*mock, QueryPrinterCapabilityByUri(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
224 EXPECT_CALL(*mock, AddVendorPrinterToCupsWithPpd(_, _, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
225 EXPECT_CALL(*mock, OnVendorStatusUpdate(_, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
226 EXPECT_CALL(*mock, RemoveVendorPrinterFromCups(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
227 EXPECT_CALL(*mock, QueryPrinterInfoByPrinterId(_, _)).WillRepeatedly(Return(E_PRINT_NONE));
228 EXPECT_CALL(*mock, QueryPPDInformation(_, _)).WillRepeatedly(Return(true));
229 PrinterStatus status = PRINTER_STATUS_UNAVAILABLE;
230 EXPECT_FALSE(vendorManager.QueryPrinterStatusByUri(PRINTER_TEST_IP, status));
231 EXPECT_TRUE(vendorManager.QueryPrinterStatusByUri(PRINTER_TEST_IP, status));
232 PrinterCapability printerCap;
233 EXPECT_FALSE(vendorManager.QueryPrinterCapabilityByUri(PRINTER_TEST_IP, printerCap));
234 EXPECT_TRUE(vendorManager.QueryPrinterCapabilityByUri(PRINTER_TEST_IP, printerCap));
235 std::string ppdName;
236 std::string ppdData;
237 EXPECT_FALSE(vendorManager.OnPrinterPpdQueried(vendorName, PRINTER_TEST_IP, ppdName, ppdData));
238 vendorManager.SetConnectingPrinter(ConnectMethod::ID_AUTO, globalPrinterId);
239 EXPECT_FALSE(vendorManager.OnPrinterPpdQueried(vendorName, PRINTER_TEST_IP, ppdName, ppdData));
240 EXPECT_TRUE(vendorManager.OnPrinterPpdQueried(vendorName, PRINTER_TEST_IP, ppdName, ppdData));
241 PrinterVendorStatus vendorStatus;
242 EXPECT_FALSE(vendorManager.OnPrinterStatusChanged(vendorName, PRINTER_TEST_IP, vendorStatus));
243 EXPECT_TRUE(vendorManager.OnPrinterStatusChanged(vendorName, PRINTER_TEST_IP, vendorStatus));
244 EXPECT_EQ(vendorManager.RemovePrinterFromCups(vendorName, PRINTER_TEST_IP), EXTENSION_ERROR_CALLBACK_FAIL);
245 EXPECT_EQ(vendorManager.RemovePrinterFromCups(vendorName, PRINTER_TEST_IP), EXTENSION_ERROR_NONE);
246 EXPECT_EQ(vendorManager.QueryPrinterInfoByPrinterId("vendor", PRINTER_TEST_IP, printerInfo), E_PRINT_NONE);
247 std::string makeModel = "test_makeModel";
248 EXPECT_TRUE(vendorManager.QueryPPDInformation(makeModel, ppdName));
249 vendorManager.UnInit();
250 }
251
252 HWTEST_F(VendorManagerTest, VendorManagerTest_0008, TestSize.Level2)
253 {
254 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
255 VendorManager vendorManager;
256 EXPECT_TRUE(vendorManager.Init(mock, false));
257 auto vendorIppEverywhere = std::make_shared<VendorIppEveryWhere>();
258 ASSERT_NE(vendorIppEverywhere, nullptr);
259 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorIppEverywhere));
260 std::string vendorName = vendorIppEverywhere->GetVendorName();
261 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
262 std::string printerId = PRINTER_TEST_IP;
263 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
264 std::string ppdName;
265 std::string ppdData;
266 PrinterInfo printerInfo;
267 EXPECT_CALL(*mock, AddVendorPrinterToDiscovery(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
268 EXPECT_CALL(*mock, UpdateVendorPrinterToDiscovery(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
269 EXPECT_CALL(*mock, RemoveVendorPrinterFromDiscovery(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
270 EXPECT_CALL(*mock, AddVendorPrinterToCupsWithPpd(_, _, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
271 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
272 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_NONE);
273 EXPECT_EQ(vendorManager.UpdatePrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
274 EXPECT_EQ(vendorManager.UpdatePrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_NONE);
275 EXPECT_EQ(vendorManager.RemovePrinterFromDiscovery(vendorName, PRINTER_TEST_IP), EXTENSION_ERROR_CALLBACK_FAIL);
276 EXPECT_EQ(vendorManager.RemovePrinterFromDiscovery(vendorName, PRINTER_TEST_IP), EXTENSION_ERROR_NONE);
277 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd(vendorName, PRINTER_TEST_IP, ppdName, ppdData),
278 EXTENSION_ERROR_CALLBACK_FAIL);
279 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd(vendorName, PRINTER_TEST_IP, ppdName, ppdData),
280 EXTENSION_ERROR_NONE);
281 vendorManager.UnInit();
282 }
283
284 HWTEST_F(VendorManagerTest, VendorManagerTest_0009, TestSize.Level2)
285 {
286 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
287 VendorManager vendorManager;
288 EXPECT_TRUE(vendorManager.Init(mock, true));
289 ThreadSyncWait syncWait;
290 syncWait.Wait(WAIT_TIME_MS);
291 vendorManager.StartDiscovery();
292 vendorManager.UnInit();
293 vendorManager.UnInit();
294 EXPECT_TRUE(vendorManager.Init(mock, true));
295 syncWait.Wait(WAIT_TIME_MS);
296 vendorManager.UnInit();
297 }
298
299 HWTEST_F(VendorManagerTest, VendorManagerTest_0010, TestSize.Level1)
300 {
301 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
302 VendorManager vendorManager;
303 EXPECT_TRUE(vendorManager.Init(mock, false));
304 auto vendorPpdDriver = std::make_shared<VendorPpdDriver>();
305 ASSERT_NE(vendorPpdDriver, nullptr);
306 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorPpdDriver));
307 std::string vendorName = vendorPpdDriver->GetVendorName();
308 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
309 std::string printerId = PRINTER_TEST_IP;
310 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
311 std::string ppdData;
312 PrinterInfo printerInfo;
313 EXPECT_CALL(*mock, AddVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(false));
314 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
315 vendorManager.UnInit();
316 }
317
318 HWTEST_F(VendorManagerTest, VendorManagerTest_0011, TestSize.Level0)
319 {
320 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
321 MockVendorPpdDriver mockVendorPpdDriver;
322 VendorManager vendorManager;
323 EXPECT_TRUE(vendorManager.Init(mock, false));
324 auto vendorPpdDriver = std::make_shared<VendorPpdDriver>();
325 ASSERT_NE(vendorPpdDriver, nullptr);
326 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorPpdDriver));
327 std::string vendorName = "driver.bsuni";
328 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
329 std::string printerId = PRINTER_TEST_IP;
330 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
331 std::string ppdData;
332 PrinterInfo printerInfo;
333
334 std::string option = "{\"bsunidriverSupport\": \"true\"}";
335 printerInfo.SetOption(option);
336 EXPECT_CALL(*mock, AddVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(true));
337 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_NONE);
338 vendorManager.UnInit();
339 }
340
341 HWTEST_F(VendorManagerTest, VendorManagerTest_0012, TestSize.Level1)
342 {
343 VendorManager vendorManager;
344 std::string vendorName = "test";
345 EXPECT_FALSE(vendorManager.IsPrivatePpdDriver(vendorName));
346 vendorName = "driver.bsuni";
347 EXPECT_FALSE(vendorManager.IsPrivatePpdDriver(vendorName));
348 EXPECT_TRUE(vendorManager.IsPrivatePpdDriver(VENDOR_PPD_DRIVER));
349 }
350
351
352 HWTEST_F(VendorManagerTest, DiscoverBackendPrinters_ShouldSuccess, TestSize.Level2)
353 {
354 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
355 VendorManager vendorManager;
356 EXPECT_TRUE(vendorManager.Init(mock, false));
357 std::vector<PrinterInfo> printers;
358 EXPECT_CALL(*mock, DiscoverBackendPrinters(_)).WillRepeatedly(Return(E_PRINT_NONE));
359 EXPECT_EQ(vendorManager.DiscoverBackendPrinters(VENDOR_PPD_DRIVER, printers), EXTENSION_ERROR_NONE);
360 }
361
362 HWTEST_F(VendorManagerTest, DiscoverBackendPrinters_WhenAfterUninit_ShouldFail, TestSize.Level2)
363 {
364 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
365 VendorManager vendorManager;
366 EXPECT_TRUE(vendorManager.Init(mock, false));
367 vendorManager.UnInit();
368 std::vector<PrinterInfo> printers;
369 EXPECT_EQ(vendorManager.DiscoverBackendPrinters(VENDOR_PPD_DRIVER, printers), EXTENSION_ERROR_CALLBACK_FAIL);
370 }
371
372 HWTEST_F(VendorManagerTest, VendorManagerTest_0013, TestSize.Level2)
373 {
374 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
375 VendorManager vendorManager;
376 EXPECT_TRUE(vendorManager.Init(mock, false));
377 PrinterInfo info;
378 std::string printerId = PRINTER_TEST_IP;
379 PrinterVendorStatus status;
380 vendorManager.AddPrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
381 vendorManager.UpdatePrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
382 vendorManager.RemovePrinterFromDiscovery(VENDOR_BSUNI_DRIVER, printerId);
383 vendorManager.OnPrinterPpdQueried(VENDOR_BSUNI_DRIVER, printerId, "test_ppd_name", "test_ppd_data");
384 vendorManager.OnPrinterStatusChanged(VENDOR_BSUNI_DRIVER, printerId, status);
385
386 vendorManager.wlanGroupDriver = nullptr;
387 vendorManager.AddPrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
388 vendorManager.UpdatePrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
389 vendorManager.RemovePrinterFromDiscovery(VENDOR_BSUNI_DRIVER, printerId);
390 vendorManager.OnPrinterPpdQueried(VENDOR_BSUNI_DRIVER, printerId, "test_ppd_name", "test_ppd_data");
391 vendorManager.OnPrinterStatusChanged(VENDOR_BSUNI_DRIVER, printerId, status);
392 vendorManager.UnInit();
393 }
394 } // namespace Print
395 } // namespace OHOS