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.Level1)
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.Level1)
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.Level1)
94 {
95 MockPrintServiceAbility mock;
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 MockPrintServiceAbility mock;
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.Level2)
154 {
155 MockPrintServiceAbility mock;
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 vendorManager.SetConnectingPrinter(ConnectMethod::IP_IPP, printerId);
173 EXPECT_FALSE(vendorManager.IsConnectingPrinter(globalPrinterId, ""));
174 EXPECT_TRUE(vendorManager.IsConnectingPrinter(globalPrinterId, printerId));
175 vendorManager.UnInit();
176 }
177
178 HWTEST_F(VendorManagerTest, VendorManagerTest_0006, TestSize.Level2)
179 {
180 VendorManager vendorManager;
181 EXPECT_TRUE(vendorManager.Init(nullptr, false));
182 EXPECT_FALSE(vendorManager.LoadVendorDriver(nullptr));
183 PrinterInfo printerInfo;
184 std::string ppdDriverVendorName = "driver.ppd";
185 EXPECT_EQ(vendorManager.AddPrinterToDiscovery("", printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
186 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(ppdDriverVendorName, printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
187 EXPECT_EQ(vendorManager.UpdatePrinterToDiscovery("", printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
188 EXPECT_EQ(vendorManager.RemovePrinterFromDiscovery("", ""), EXTENSION_ERROR_CALLBACK_FAIL);
189 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd("", "", ""), EXTENSION_ERROR_CALLBACK_FAIL);
190 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd(ppdDriverVendorName, "", ""), EXTENSION_ERROR_CALLBACK_FAIL);
191 EXPECT_EQ(vendorManager.RemovePrinterFromCups("", ""), EXTENSION_ERROR_CALLBACK_FAIL);
192 EXPECT_FALSE(vendorManager.OnPrinterPpdQueried("", PRINTER_TEST_IP, ""));
193 EXPECT_FALSE(vendorManager.MonitorPrinterStatus(":id", true));
194 EXPECT_FALSE(vendorManager.MonitorPrinterStatus("fwk.driver:", true));
195 EXPECT_FALSE(vendorManager.MonitorPrinterStatus("fwk.:printer.id", true));
196 EXPECT_FALSE(vendorManager.MonitorPrinterStatus("fwk.driver:printer.id", true));
197 PrinterCapability printerCap;
198 EXPECT_FALSE(vendorManager.QueryPrinterCapabilityByUri(PRINTER_TEST_IP, printerCap));
199 PrinterStatus status = PRINTER_STATUS_UNAVAILABLE;
200 EXPECT_FALSE(vendorManager.QueryPrinterStatusByUri(PRINTER_TEST_IP, status));
201 PrinterVendorStatus vendorStatus;
202 EXPECT_TRUE(vendorManager.OnPrinterStatusChanged("vendor", PRINTER_TEST_IP, vendorStatus));
203 EXPECT_FALSE(vendorManager.QueryPrinterInfoByPrinterId("vendor", PRINTER_TEST_IP, printerInfo));
204 char mekeModel[] = "test_makeModel";
205 std::vector<std::string> ppds(1, "test_ppds");
206 EXPECT_FALSE(vendorManager.QueryPPDInformation(mekeModel, ppds));
207 vendorManager.UnInit();
208 }
209
210 HWTEST_F(VendorManagerTest, VendorManagerTest_0007, TestSize.Level2)
211 {
212 MockPrintServiceAbility mock;
213 VendorManager vendorManager;
214 EXPECT_TRUE(vendorManager.Init(&mock, false));
215 auto vendorIppEverywhere = std::make_shared<VendorIppEveryWhere>();
216 ASSERT_NE(vendorIppEverywhere, nullptr);
217 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorIppEverywhere));
218 std::string vendorName = vendorIppEverywhere->GetVendorName();
219 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
220 std::string printerId = PRINTER_TEST_IP;
221 PrinterInfo printerInfo;
222 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
223 EXPECT_CALL(mock, QueryPrinterStatusByUri(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
224 EXPECT_CALL(mock, QueryPrinterCapabilityByUri(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
225 EXPECT_CALL(mock, AddVendorPrinterToCupsWithPpd(_, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
226 EXPECT_CALL(mock, OnVendorStatusUpdate(_, _, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
227 EXPECT_CALL(mock, RemoveVendorPrinterFromCups(_, _)).WillOnce(Return(false)).WillRepeatedly(Return(true));
228 EXPECT_CALL(mock, QueryPrinterInfoByPrinterId(_, _)).WillRepeatedly(Return(true));
229 EXPECT_CALL(mock, QueryPPDInformation(_, _)).WillRepeatedly(Return(true));
230 PrinterStatus status = PRINTER_STATUS_UNAVAILABLE;
231 EXPECT_FALSE(vendorManager.QueryPrinterStatusByUri(PRINTER_TEST_IP, status));
232 EXPECT_TRUE(vendorManager.QueryPrinterStatusByUri(PRINTER_TEST_IP, status));
233 PrinterCapability printerCap;
234 EXPECT_FALSE(vendorManager.QueryPrinterCapabilityByUri(PRINTER_TEST_IP, printerCap));
235 EXPECT_TRUE(vendorManager.QueryPrinterCapabilityByUri(PRINTER_TEST_IP, printerCap));
236 std::string ppdData;
237 EXPECT_FALSE(vendorManager.OnPrinterPpdQueried(vendorName, PRINTER_TEST_IP, ppdData));
238 vendorManager.SetConnectingPrinter(ConnectMethod::ID_AUTO, globalPrinterId);
239 EXPECT_FALSE(vendorManager.OnPrinterPpdQueried(vendorName, PRINTER_TEST_IP, ppdData));
240 EXPECT_TRUE(vendorManager.OnPrinterPpdQueried(vendorName, PRINTER_TEST_IP, 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_TRUE(vendorManager.QueryPrinterInfoByPrinterId("vendor", PRINTER_TEST_IP, printerInfo));
247 char mekeModel[] = "test_makeModel";
248 std::vector<std::string> ppds(1, "test_ppds");
249 EXPECT_TRUE(vendorManager.QueryPPDInformation(mekeModel, ppds));
250 vendorManager.UnInit();
251 }
252
253 HWTEST_F(VendorManagerTest, VendorManagerTest_0008, TestSize.Level2)
254 {
255 MockPrintServiceAbility mock;
256 VendorManager vendorManager;
257 EXPECT_TRUE(vendorManager.Init(&mock, false));
258 auto vendorIppEverywhere = std::make_shared<VendorIppEveryWhere>();
259 ASSERT_NE(vendorIppEverywhere, nullptr);
260 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorIppEverywhere));
261 std::string vendorName = vendorIppEverywhere->GetVendorName();
262 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
263 std::string printerId = PRINTER_TEST_IP;
264 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
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, ppdData),
278 EXTENSION_ERROR_CALLBACK_FAIL);
279 EXPECT_EQ(vendorManager.AddPrinterToCupsWithPpd(vendorName, PRINTER_TEST_IP, ppdData), EXTENSION_ERROR_NONE);
280 vendorManager.UnInit();
281 }
282
283 HWTEST_F(VendorManagerTest, VendorManagerTest_0009, TestSize.Level2)
284 {
285 MockPrintServiceAbility mock;
286 VendorManager vendorManager;
287 EXPECT_TRUE(vendorManager.Init(&mock, true));
288 ThreadSyncWait syncWait;
289 syncWait.Wait(WAIT_TIME_MS);
290 vendorManager.StartDiscovery();
291 vendorManager.UnInit();
292 vendorManager.UnInit();
293 EXPECT_TRUE(vendorManager.Init(&mock, true));
294 syncWait.Wait(WAIT_TIME_MS);
295 vendorManager.UnInit();
296 }
297
298 HWTEST_F(VendorManagerTest, VendorManagerTest_0010, TestSize.Level1)
299 {
300 MockPrintServiceAbility mock;
301 VendorManager vendorManager;
302 EXPECT_TRUE(vendorManager.Init(&mock, false));
303 auto vendorPpdDriver = std::make_shared<VendorPpdDriver>();
304 ASSERT_NE(vendorPpdDriver, nullptr);
305 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorPpdDriver));
306 std::string vendorName = vendorPpdDriver->GetVendorName();
307 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
308 std::string printerId = PRINTER_TEST_IP;
309 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
310 std::string ppdData;
311 PrinterInfo printerInfo;
312 EXPECT_CALL(mock, AddVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(false));
313 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_CALLBACK_FAIL);
314 vendorManager.UnInit();
315 }
316
317 HWTEST_F(VendorManagerTest, VendorManagerTest_0011, TestSize.Level1)
318 {
319 MockPrintServiceAbility mock;
320 MockVendorPpdDriver mockVendorPpdDriver;
321 VendorManager vendorManager;
322 EXPECT_TRUE(vendorManager.Init(&mock, false));
323 auto vendorPpdDriver = std::make_shared<VendorPpdDriver>();
324 ASSERT_NE(vendorPpdDriver, nullptr);
325 EXPECT_TRUE(vendorManager.LoadVendorDriver(vendorPpdDriver));
326 std::string vendorName = "driver.bsuni";
327 std::string globalVendorName = VendorManager::GetGlobalVendorName(vendorName);
328 std::string printerId = PRINTER_TEST_IP;
329 std::string globalPrinterId = VendorManager::GetGlobalPrinterId(globalVendorName, printerId);
330 std::string ppdData;
331 PrinterInfo printerInfo;
332
333 std::string option = "{\"bsunidriverSupport\": \"true\"}";
334 printerInfo.SetOption(option);
335 EXPECT_CALL(mock, AddVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(true));
336 EXPECT_EQ(vendorManager.AddPrinterToDiscovery(vendorName, printerInfo), EXTENSION_ERROR_NONE);
337 vendorManager.UnInit();
338 }
339
340 HWTEST_F(VendorManagerTest, VendorManagerTest_0012, TestSize.Level1)
341 {
342 VendorManager vendorManager;
343 std::string vendorName = "test";
344 EXPECT_FALSE(vendorManager.IsPrivatePpdDriver(vendorName));
345 vendorName = "driver.bsuni";
346 EXPECT_FALSE(vendorManager.IsPrivatePpdDriver(vendorName));
347 EXPECT_TRUE(vendorManager.IsPrivatePpdDriver(VENDOR_PPD_DRIVER));
348 }
349
350 HWTEST_F(VendorManagerTest, VendorManagerTest_0013, TestSize.Level2)
351 {
352 MockPrintServiceAbility mock;
353 VendorManager vendorManager;
354 EXPECT_TRUE(vendorManager.Init(&mock, false));
355 PrinterInfo info;
356 std::string printerId = PRINTER_TEST_IP;
357 PrinterVendorStatus status;
358 vendorManager.AddPrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
359 vendorManager.UpdatePrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
360 vendorManager.RemovePrinterFromDiscovery(VENDOR_BSUNI_DRIVER, printerId);
361 vendorManager.OnPrinterPpdQueried(VENDOR_BSUNI_DRIVER, printerId, "test_ppd_data");
362 vendorManager.OnPrinterStatusChanged(VENDOR_BSUNI_DRIVER, printerId, status);
363
364 vendorManager.wlanGroupDriver = nullptr;
365 vendorManager.AddPrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
366 vendorManager.UpdatePrinterToDiscovery(VENDOR_BSUNI_DRIVER, info);
367 vendorManager.RemovePrinterFromDiscovery(VENDOR_BSUNI_DRIVER, printerId);
368 vendorManager.OnPrinterPpdQueried(VENDOR_BSUNI_DRIVER, printerId, "test_ppd_data");
369 vendorManager.OnPrinterStatusChanged(VENDOR_BSUNI_DRIVER, printerId, status);
370 vendorManager.UnInit();
371 }
372 } // namespace Print
373 } // namespace OHOS