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 #define protected public
19 #include "vendor_wlan_group.h"
20 #include "print_constant.h"
21 #include "print_log.h"
22 #include "mock/mock_print_service_ability.h"
23
24 namespace {
25 const int WAIT_TIME_MS = 100;
26 const std::string PRINTER_TEST_IP = "192.168.2.222";
27 const std::string PRINTER_TEST_GLOBAL_ID = "fwk.driver.wlan.group:192.168.2.222";
28 const std::string PRINTER_TEST_URI = "ipp://192.168.2.222:631";
29 const std::string PRINTER_TEST_PPDDTAT = "test_ppd_data";
30 const std::string PRINTER_TEST_UUID = "test_uuid";
31 }
32 using namespace testing;
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace Print {
37 class VendorWlanGroupTest : 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 VendorWlanGroupTest::SetUpTestCase(void) {}
46
TearDownTestCase(void)47 void VendorWlanGroupTest::TearDownTestCase(void) {}
48
SetUp(void)49 void VendorWlanGroupTest::SetUp(void)
50 {
51 static int32_t testNo = 0;
52 PRINT_HILOGI("VendorWlanGroupTest_%{public}d", ++testNo);
53 }
54
TearDown(void)55 void VendorWlanGroupTest::TearDown(void) {}
56
57 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0001_NeedRename, TestSize.Level1)
58 {
59 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
60 VendorManager vendorManager;
61 EXPECT_TRUE(vendorManager.Init(mock, false));
62 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
63 EXPECT_EQ(vendorWlanGroup->parentVendorManager, &vendorManager);
64 }
65
66 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0002_NeedRename, TestSize.Level2)
67 {
68 std::string printerId = PRINTER_TEST_IP;
69 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
70 VendorManager vendorManager;
71 EXPECT_TRUE(vendorManager.Init(mock, false));
72 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
73 EXPECT_EQ(vendorWlanGroup->OnQueryCapability(printerId, 0), false);
74 vendorWlanGroup->parentVendorManager = nullptr;
75 EXPECT_EQ(vendorWlanGroup->OnQueryCapability(printerId, 0), false);
76 }
77
78 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0003_NeedRename, TestSize.Level2)
79 {
80 std::string printerId = PRINTER_TEST_IP;
81 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
82 VendorManager vendorManager;
83 EXPECT_TRUE(vendorManager.Init(mock, false));
84 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
85 EXPECT_EQ(vendorWlanGroup->OnQueryCapabilityByIp(printerId, "ipp"), false);
86 vendorWlanGroup->parentVendorManager = nullptr;
87 EXPECT_EQ(vendorWlanGroup->OnQueryCapabilityByIp(printerId, "ipp"), false);
88 }
89
90 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0004_NeedRename, TestSize.Level2)
91 {
92 std::string printerId = PRINTER_TEST_IP;
93 PrinterInfo info;
94 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
95 VendorManager vendorManager;
96 EXPECT_TRUE(vendorManager.Init(mock, false));
97 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
98 EXPECT_CALL(*mock, AddVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(true));
99 EXPECT_EQ(vendorWlanGroup->OnPrinterDiscovered(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_NONE);
100 vendorWlanGroup->parentVendorManager = nullptr;
101 EXPECT_EQ(vendorWlanGroup->OnPrinterDiscovered(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_CALLBACK_NULL);
102 }
103
104 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0005_NeedRename, TestSize.Level2)
105 {
106 std::string printerId = PRINTER_TEST_IP;
107 PrinterInfo info;
108 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
109 VendorManager vendorManager;
110 EXPECT_TRUE(vendorManager.Init(mock, false));
111 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
112 EXPECT_CALL(*mock, AddIpPrinterToSystemData(_, _)).WillRepeatedly(Return(true));
113 EXPECT_CALL(*mock, UpdateVendorPrinterToDiscovery(_, _)).WillRepeatedly(Return(true));
114 vendorManager.SetConnectingPrinter(IP_AUTO, PRINTER_TEST_GLOBAL_ID);
115 EXPECT_EQ(vendorWlanGroup->OnUpdatePrinterToDiscovery(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_NONE);
116 vendorManager.SetConnectingPrinter(ID_AUTO, PRINTER_TEST_GLOBAL_ID);
117 EXPECT_EQ(vendorWlanGroup->OnUpdatePrinterToDiscovery(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_NONE);
118 vendorWlanGroup->parentVendorManager = nullptr;
119 EXPECT_EQ(vendorWlanGroup->OnUpdatePrinterToDiscovery(VENDOR_WLAN_GROUP, info), EXTENSION_ERROR_CALLBACK_NULL);
120 }
121
122 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0006_NeedRename, TestSize.Level2)
123 {
124 std::string printerId = PRINTER_TEST_IP;
125 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
126 VendorManager vendorManager;
127 EXPECT_TRUE(vendorManager.Init(mock, false));
128 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
129 EXPECT_EQ(vendorWlanGroup->OnPrinterRemoved(VENDOR_WLAN_GROUP, printerId), EXTENSION_ERROR_CALLBACK_FAIL);
130 vendorWlanGroup->parentVendorManager = nullptr;
131 EXPECT_EQ(vendorWlanGroup->OnPrinterRemoved(VENDOR_WLAN_GROUP, printerId), EXTENSION_ERROR_CALLBACK_NULL);
132 }
133
134 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0007_NeedRename, TestSize.Level2)
135 {
136 std::string printerId = PRINTER_TEST_IP;
137 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
138 VendorManager vendorManager;
139 EXPECT_TRUE(vendorManager.Init(mock, false));
140 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
141 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
142 vendorWlanGroup->parentVendorManager = nullptr;
143 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
144 }
145
146 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0008_NeedRename, TestSize.Level2)
147 {
148 std::string printerId = PRINTER_TEST_IP;
149 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
150 VendorManager vendorManager;
151 EXPECT_TRUE(vendorManager.Init(mock, false));
152 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
153 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
154 vendorWlanGroup->parentVendorManager = nullptr;
155 EXPECT_EQ(vendorWlanGroup->IsConnectingPrinter(printerId, PRINTER_TEST_URI), false);
156 }
157
158 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0009_NeedRename, TestSize.Level2)
159 {
160 std::string printerId = PRINTER_TEST_IP;
161 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
162 VendorManager vendorManager;
163 EXPECT_TRUE(vendorManager.Init(mock, false));
164 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
165 vendorWlanGroup->SetConnectingPrinter(ID_AUTO, printerId);
166 EXPECT_EQ(vendorWlanGroup->parentVendorManager->isConnecting, true);
167 vendorWlanGroup->parentVendorManager = nullptr;
168 vendorWlanGroup->SetConnectingPrinter(ID_AUTO, printerId);
169 }
170
171 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0010_NeedRename, TestSize.Level2)
172 {
173 std::string printerId = PRINTER_TEST_IP;
174 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
175 VendorManager vendorManager;
176 EXPECT_TRUE(vendorManager.Init(mock, false));
177 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
178 EXPECT_EQ(vendorWlanGroup->OnPrinterPpdQueried(VENDOR_WLAN_GROUP, printerId, "", PRINTER_TEST_PPDDTAT), false);
179 vendorWlanGroup->parentVendorManager = nullptr;
180 EXPECT_EQ(vendorWlanGroup->OnPrinterPpdQueried(VENDOR_WLAN_GROUP, printerId, "", PRINTER_TEST_PPDDTAT), false);
181 }
182
183 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0011_NeedRename, TestSize.Level2)
184 {
185 std::string printerId = PRINTER_TEST_IP;
186 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
187 VendorManager vendorManager;
188 EXPECT_TRUE(vendorManager.Init(mock, false));
189 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
190 EXPECT_EQ(vendorWlanGroup->IsGroupDriver(printerId), false);
191 vendorWlanGroup->parentVendorManager = nullptr;
192 EXPECT_EQ(vendorWlanGroup->IsGroupDriver(printerId), false);
193 }
194
195 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0012_NeedRename, TestSize.Level2)
196 {
197 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
198 VendorManager vendorManager;
199 EXPECT_TRUE(vendorManager.Init(mock, false));
200 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
201 std::string printerId = PRINTER_TEST_IP;
202 std::string vendorName = VENDOR_BSUNI_DRIVER;
203 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), false);
204 vendorName = VENDOR_WLAN_GROUP;
205 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), false);
206 vendorWlanGroup->printerVendorGroupList_[printerId] = "";
207 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), false);
208 vendorWlanGroup->printerVendorGroupList_[printerId] = VENDOR_BSUNI_DRIVER;
209 EXPECT_EQ(vendorWlanGroup->ConvertGroupDriver(printerId, vendorName), true);
210 }
211
212 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0013_NeedRename, TestSize.Level2)
213 {
214 std::string printerId = PRINTER_TEST_GLOBAL_ID;
215 auto printerInfo = std::make_shared<PrinterInfo>();
216 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
217 VendorManager vendorManager;
218 EXPECT_TRUE(vendorManager.Init(mock, false));
219 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
220 EXPECT_CALL(*mock, QueryDiscoveredPrinterInfoById(_)).WillOnce(Return(nullptr)).WillRepeatedly(Return(printerInfo));
221 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
222 printerInfo->SetOption("{\"bsunidriverSupport\": \"true\"}");
223 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), true);
224 printerInfo->SetOption("{\"bsunidriverSupport\": \"false\"}");
225 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
226 printerInfo->SetOption("{\"bsunidriverSupport\": \"need_gs\"}");
227 vendorWlanGroup->hasGs = false;
228 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
229 vendorWlanGroup->hasGs = true;
230 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), true);
231 vendorWlanGroup->parentVendorManager = nullptr;
232 EXPECT_EQ(vendorWlanGroup->IsBsunidriverSupport(PRINTER_TEST_GLOBAL_ID), false);
233 }
234
235 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0014_NeedRename, TestSize.Level2)
236 {
237 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
238 VendorManager vendorManager;
239 EXPECT_TRUE(vendorManager.Init(mock, false));
240 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
241 std::string printerId = PRINTER_TEST_GLOBAL_ID;
242 vendorWlanGroup->RemoveGroupPrinterFromVendorGroupList(printerId);
243 vendorWlanGroup->printerVendorGroupList_[printerId] = VENDOR_BSUNI_DRIVER;
244 vendorWlanGroup->RemoveGroupPrinterFromVendorGroupList(printerId);
245 EXPECT_TRUE(vendorWlanGroup->printerVendorGroupList_.empty());
246 }
247
248 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0015_NeedRename, TestSize.Level2)
249 {
250 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
251 VendorManager vendorManager;
252 EXPECT_TRUE(vendorManager.Init(mock, false));
253 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
254 std::string printerId = PRINTER_TEST_GLOBAL_ID;
255 EXPECT_EQ(vendorWlanGroup->QueryVendorDriverByGroupPrinterId(printerId), "");
256 vendorWlanGroup->printerVendorGroupList_[printerId] = VENDOR_BSUNI_DRIVER;
257 EXPECT_EQ(vendorWlanGroup->QueryVendorDriverByGroupPrinterId(printerId), VENDOR_BSUNI_DRIVER);
258 }
259
260 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0016_NeedRename, TestSize.Level2)
261 {
262 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
263 VendorManager vendorManager;
264 EXPECT_TRUE(vendorManager.Init(mock, false));
265 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
266 std::string printerId = PRINTER_TEST_IP;
267 EXPECT_EQ(vendorWlanGroup->GetGroupPrinterId(printerId), PRINTER_TEST_IP);
268 vendorWlanGroup->groupPrinterIdMap_[printerId] = PRINTER_TEST_GLOBAL_ID;
269 EXPECT_EQ(vendorWlanGroup->GetGroupPrinterId(printerId), PRINTER_TEST_GLOBAL_ID);
270 }
271
272 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0017_NeedRename, TestSize.Level2)
273 {
274 std::string printerId = PRINTER_TEST_GLOBAL_ID;
275 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
276 VendorManager vendorManager;
277 EXPECT_TRUE(vendorManager.Init(mock, false));
278 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
279 vendorManager.SetConnectingPrinter(IP_AUTO, PRINTER_TEST_GLOBAL_ID);
280 EXPECT_EQ(vendorWlanGroup->CheckPrinterAddedByIp(printerId), true);
281 vendorManager.SetConnectingPrinter(ID_AUTO, PRINTER_TEST_GLOBAL_ID);
282 EXPECT_EQ(vendorWlanGroup->CheckPrinterAddedByIp(printerId), false);
283 vendorWlanGroup->parentVendorManager = nullptr;
284 EXPECT_EQ(vendorWlanGroup->CheckPrinterAddedByIp(printerId), false);
285 }
286
287 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0018_NeedRename, TestSize.Level2)
288 {
289 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
290 VendorManager vendorManager;
291 EXPECT_TRUE(vendorManager.Init(mock, false));
292 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
293 std::string printerId = PRINTER_TEST_IP;
294 EXPECT_CALL(*mock, RemoveVendorPrinterFromDiscovery(_, _)).WillRepeatedly(Return(true));
295 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_IP);
296 EXPECT_EQ(vendorWlanGroup->groupPrinterIdMap_[printerId], PRINTER_TEST_IP);
297 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_IP);
298 EXPECT_EQ(vendorWlanGroup->groupPrinterIdMap_[printerId], PRINTER_TEST_IP);
299 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_GLOBAL_ID);
300 EXPECT_EQ(vendorWlanGroup->groupPrinterIdMap_[printerId], PRINTER_TEST_GLOBAL_ID);
301 }
302
303 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0019_NeedRename, TestSize.Level2)
304 {
305 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
306 VendorManager vendorManager;
307 EXPECT_TRUE(vendorManager.Init(mock, false));
308 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
309 std::string printerId = PRINTER_TEST_IP;
310 EXPECT_EQ(vendorWlanGroup->HasGroupPrinter(printerId), false);
311 vendorWlanGroup->UpdateGroupPrinter(printerId, PRINTER_TEST_IP);
312 EXPECT_EQ(vendorWlanGroup->HasGroupPrinter(printerId), true);
313 }
314
315 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0020_NeedRename, TestSize.Level2)
316 {
317 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
318 VendorManager vendorManager;
319 EXPECT_TRUE(vendorManager.Init(mock, false));
320 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
321 std::string printerId = PRINTER_TEST_IP;
322 PrinterInfo info;
323 info.SetPrinterId(printerId);
324 EXPECT_CALL(*mock, RemoveVendorPrinterFromDiscovery(_, _)).WillRepeatedly(Return(true));
325 EXPECT_EQ(vendorWlanGroup->ConvertPrinterInfoId(info).GetPrinterId(), PRINTER_TEST_IP);
326 info.SetPrinterUuid(PRINTER_TEST_UUID);
327 EXPECT_EQ(vendorWlanGroup->ConvertPrinterInfoId(info).GetPrinterId(), PRINTER_TEST_UUID);
328 }
329
330 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0021_NeedRename, TestSize.Level2)
331 {
332 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
333 VendorManager vendorManager;
334 EXPECT_TRUE(vendorManager.Init(mock, false));
335 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
336 PrinterInfo info;
337 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
338 info.SetUri("test_uri");
339 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
340 info.SetUri("test_uri://");
341 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
342 info.SetUri("test_uri://");
343 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), "");
344 info.SetUri(PRINTER_TEST_URI);
345 EXPECT_EQ(vendorWlanGroup->ExtractPrinterIdByPrinterInfo(info), PRINTER_TEST_IP);
346 }
347
348 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0022_NeedRename, TestSize.Level2)
349 {
350 std::string printerId = PRINTER_TEST_GLOBAL_ID;
351 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
352 VendorManager vendorManager;
353 EXPECT_TRUE(vendorManager.Init(mock, false));
354 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
355 EXPECT_CALL(*mock, QueryPrinterInfoByPrinterId(_, _))
356 .WillOnce(Return(E_PRINT_SERVER_FAILURE)).WillRepeatedly(Return(E_PRINT_NONE));
357 EXPECT_EQ(vendorWlanGroup->MonitorPrinterStatus(printerId, true), false);
358 EXPECT_EQ(vendorWlanGroup->MonitorPrinterStatus(printerId, true), false);
359 vendorWlanGroup->parentVendorManager = nullptr;
360 EXPECT_EQ(vendorWlanGroup->MonitorPrinterStatus(printerId, true), false);
361 }
362
363 HWTEST_F(VendorWlanGroupTest, VendorWlanGroupTest_0023_NeedRename, TestSize.Level2)
364 {
365 std::string printerId = PRINTER_TEST_GLOBAL_ID;
366 PrinterVendorStatus state;
367 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
368 VendorManager vendorManager;
369 EXPECT_TRUE(vendorManager.Init(mock, false));
370 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
371 EXPECT_CALL(*mock, OnVendorStatusUpdate(_, _, _)).WillRepeatedly(Return(true));
372 EXPECT_EQ(vendorWlanGroup->OnPrinterStatusChanged(VENDOR_WLAN_GROUP, printerId, state), true);
373 vendorWlanGroup->parentVendorManager = nullptr;
374 EXPECT_EQ(vendorWlanGroup->OnPrinterStatusChanged(VENDOR_WLAN_GROUP, printerId, state), false);
375 }
376
377 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnEmpty_WhenUriNotContainScheme, TestSize.Level1)
378 {
379 std::string uri = "aaa";
380 EXPECT_TRUE(PrintUtils::ExtractHostFromUri(uri).empty());
381 }
382
383 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnEmpty_WhenUriNotContainHost, TestSize.Level1)
384 {
385 std::string uri = "aaa://";
386 EXPECT_TRUE(PrintUtils::ExtractHostFromUri(uri).empty());
387 }
388
389 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnHost_WhenUriContainScheme, TestSize.Level1)
390 {
391 std::string uri = "aaa://b";
392 std::string expected = "b";
393 EXPECT_EQ(expected, PrintUtils::ExtractHostFromUri(uri));
394 }
395
396 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnHost_WhenUriContainPort, TestSize.Level1)
397 {
398 std::string uri = "aaa://b:80";
399 std::string expected = "b";
400 EXPECT_EQ(expected, PrintUtils::ExtractHostFromUri(uri));
401 }
402
403 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnHost_WhenUriContainPath, TestSize.Level1)
404 {
405 std::string uri = "aaa://b/path";
406 std::string expected = "b";
407 EXPECT_EQ(expected, PrintUtils::ExtractHostFromUri(uri));
408 }
409
410 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnHost_WhenUriContainQuery, TestSize.Level1)
411 {
412 std::string uri = "aaa://b?query";
413 std::string expected = "b";
414 EXPECT_EQ(expected, PrintUtils::ExtractHostFromUri(uri));
415 }
416
417 HWTEST_F(VendorWlanGroupTest, ExtractHostFromUri_ShouldReturnHost_WhenUriContainFragment, TestSize.Level1)
418 {
419 std::string uri = "aaa://example.cc#fragment";
420 std::string expected = "example.cc";
421 EXPECT_EQ(expected, PrintUtils::ExtractHostFromUri(uri));
422 }
423
424 HWTEST_F(VendorWlanGroupTest, MonitorStatusByBsuniDriver_ShouldReturnFalse_WhenVendorManagerIsNull, TestSize.Level1)
425 {
426 VendorWlanGroup group(nullptr);
427 std::string printerId = "testId";
428 EXPECT_FALSE(group.MonitorStatusByBsuniDriver(printerId, true));
429 }
430
431 HWTEST_F(VendorWlanGroupTest, MonitorStatusByBsuniDriver_ShouldReturnFalse_WhenGetPrinterInfoFailed, TestSize.Level1)
432 {
433 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
434 VendorManager vendorManager;
435 EXPECT_TRUE(vendorManager.Init(mock, false));
436 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
437 std::string printerId = "testId";
438 EXPECT_CALL(*mock, QueryPrinterInfoByPrinterId(_, _)).WillOnce(Return(E_PRINT_GENERIC_FAILURE));
439 EXPECT_FALSE(vendorWlanGroup->MonitorStatusByBsuniDriver(printerId, true));
440 }
441
442 HWTEST_F(VendorWlanGroupTest, MonitorStatusByBsuniDriver_ShouldReturnFalse_WhenGetPrinterIpFailed, TestSize.Level1)
443 {
444 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
445 VendorManager vendorManager;
446 EXPECT_TRUE(vendorManager.Init(mock, false));
447 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
448 std::string printerId = "testId";
449 EXPECT_CALL(*mock, QueryPrinterInfoByPrinterId(_, _)).WillOnce(Return(E_PRINT_NONE));
450 EXPECT_FALSE(vendorWlanGroup->MonitorStatusByBsuniDriver(printerId, true));
451 }
452
453 HWTEST_F(VendorWlanGroupTest, MonitorStatusByBsuniDriver_ShouldReturnFalse_WhenBsuniDriverIsNull, TestSize.Level1)
454 {
455 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
456 VendorManager vendorManager;
457 EXPECT_TRUE(vendorManager.Init(mock, false));
458 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
459 std::string printerId = "testId";
460 PrinterInfo info;
461 info.SetUri(PRINTER_TEST_URI);
462 EXPECT_CALL(*mock, QueryPrinterInfoByPrinterId(_, _)).WillOnce(DoAll(SetArgReferee<1>(info), Return(E_PRINT_NONE)));
463 EXPECT_FALSE(vendorWlanGroup->MonitorStatusByBsuniDriver(printerId, true));
464 }
465
466 HWTEST_F(VendorWlanGroupTest, MonitorStatusByBsuniDriver_ShouldReturnFalse_WhenOtherInMonitor, TestSize.Level1)
467 {
468 sptr<MockPrintServiceAbility> mock = new MockPrintServiceAbility();
469 VendorManager vendorManager;
470 EXPECT_TRUE(vendorManager.Init(mock, false));
471 auto vendorWlanGroup = std::make_shared<VendorWlanGroup>(&vendorManager);
472 std::string printerId = "testId";
473 PrinterInfo info;
474 info.SetPrinterId(printerId);
475 info.SetUri(PRINTER_TEST_URI);
476 std::vector<std::string> printers;
477 printers.push_back("fwk.test.group:" + PRINTER_TEST_IP);
478 printers.push_back(printerId);
479 printers.push_back("fwk.driver.wlan.group:" + PRINTER_TEST_IP);
480 EXPECT_CALL(*mock, QueryPrinterInfoByPrinterId(_, _)).WillOnce(DoAll(SetArgReferee<1>(info), Return(E_PRINT_NONE)));
481 EXPECT_CALL(*mock, QueryAddedPrintersByIp(_)).WillOnce(Return(printers));
482 EXPECT_FALSE(vendorWlanGroup->MonitorStatusByBsuniDriver(printerId, false));
483 }
484
485 } // namespace Print
486 } // namespace OHOS