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_ipp_everywhere.h"
19 #undef private
20 #include "print_constant.h"
21 #include "print_log.h"
22 #include "mock/mock_vendor_manager.h"
23
24 namespace {
25 const int WAIT_TIME_MS = 100;
26 const std::string PRINTER_TEST_IP = "192.168.2.222";
27 }
28 using namespace testing;
29 using namespace testing::ext;
30
31 namespace OHOS {
32 namespace Print {
33 class VendorDriverBaseTest : public VendorDriverBase {
34 public:
GetVendorName()35 std::string GetVendorName() override
36 {
37 return "driver.base.test";
38 }
39 };
40 class VendorIppEverywhereTest : public testing::Test {
41 public:
42 static void SetUpTestCase(void);
43 static void TearDownTestCase(void);
44 void SetUp();
45 void TearDown();
46 };
47
SetUpTestCase(void)48 void VendorIppEverywhereTest::SetUpTestCase(void) {}
49
TearDownTestCase(void)50 void VendorIppEverywhereTest::TearDownTestCase(void) {}
51
SetUp(void)52 void VendorIppEverywhereTest::SetUp(void)
53 {
54 static int32_t testNo = 0;
55 PRINT_HILOGI("VendorIppEverywhereTest_%{public}d", ++testNo);
56 }
57
TearDown(void)58 void VendorIppEverywhereTest::TearDown(void) {}
59
60 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0001, TestSize.Level1)
61 {
62 VendorIppEveryWhere vendorDriver;
63 EXPECT_EQ(vendorDriver.Init(nullptr), false);
64 vendorDriver.OnCreate();
65 ThreadSyncWait syncWait;
66 syncWait.Wait(WAIT_TIME_MS);
67 vendorDriver.OnStartDiscovery();
68 syncWait.Wait(WAIT_TIME_MS);
69 vendorDriver.OnStopDiscovery();
70 syncWait.Wait(WAIT_TIME_MS);
71 vendorDriver.OnDestroy();
72 syncWait.Wait(WAIT_TIME_MS);
73 vendorDriver.UnInit();
74 }
75
76 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0002, TestSize.Level2)
77 {
78 VendorIppEveryWhere vendorDriver;
79 EXPECT_EQ(vendorDriver.Init(nullptr), false);
80 EXPECT_FALSE(vendorDriver.OnQueryCapabilityByIp(PRINTER_TEST_IP, "protocol"));
81 EXPECT_FALSE(vendorDriver.OnQueryCapabilityByIp(PRINTER_TEST_IP, "auto"));
82 EXPECT_FALSE(vendorDriver.OnQueryCapabilityByIp(PRINTER_TEST_IP, "ipp"));
83 std::vector<std::string> propertyKeys;
84 EXPECT_FALSE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
85 propertyKeys.push_back(PRINTER_PROPERTY_KEY_DEVICE_STATE);
86 propertyKeys.push_back(PRINTER_PROPERTY_KEY_DEVICE_SUPPLIES);
87 EXPECT_FALSE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
88 vendorDriver.OnCreate();
89 ThreadSyncWait syncWait;
90 syncWait.Wait(WAIT_TIME_MS);
91 EXPECT_TRUE(vendorDriver.OnQueryCapabilityByIp(PRINTER_TEST_IP, "ipp"));
92 EXPECT_TRUE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
93 EXPECT_FALSE(vendorDriver.OnQueryCapability(PRINTER_TEST_IP, 0));
94 syncWait.Wait(WAIT_TIME_MS);
95 vendorDriver.OnDestroy();
96 vendorDriver.UnInit();
97 }
98
99 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0003, TestSize.Level2)
100 {
101 MockVendorManager mock;
102 VendorIppEveryWhere vendorDriver;
103 EXPECT_TRUE(vendorDriver.Init(&mock));
104 std::vector<std::string> propertyKeys;
105 propertyKeys.push_back(PRINTER_PROPERTY_KEY_DEVICE_STATE);
106 propertyKeys.push_back(PRINTER_PROPERTY_KEY_DEVICE_SUPPLIES);
107 EXPECT_FALSE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
108 vendorDriver.OnCreate();
109 ThreadSyncWait syncWait;
110 syncWait.Wait(WAIT_TIME_MS);
111 EXPECT_CALL(mock, QueryPrinterStatusByUri(_, _)).Times(2).WillOnce(Return(false)).WillRepeatedly(Return(true));
112 EXPECT_CALL(mock, QueryPrinterCapabilityByUri(_, _)).Times(1).WillRepeatedly(Return(false));
113 EXPECT_TRUE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
114 EXPECT_TRUE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
115 EXPECT_TRUE(vendorDriver.OnQueryCapabilityByIp(PRINTER_TEST_IP, "ipp"));
116 EXPECT_FALSE(vendorDriver.OnQueryCapability(PRINTER_TEST_IP, 0));
117 syncWait.Wait(WAIT_TIME_MS);
118 vendorDriver.OnDestroy();
119 vendorDriver.UnInit();
120 }
121
122 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0004, TestSize.Level2)
123 {
124 MockVendorManager mock;
125 VendorIppEveryWhere vendorDriver;
126 EXPECT_TRUE(vendorDriver.Init(&mock));
127 std::vector<std::string> propertyKeys;
128 propertyKeys.push_back(PRINTER_PROPERTY_KEY_DEVICE_STATE);
129 propertyKeys.push_back(PRINTER_PROPERTY_KEY_DEVICE_SUPPLIES);
130 vendorDriver.OnCreate();
131 ThreadSyncWait syncWait;
132 syncWait.Wait(WAIT_TIME_MS);
133 EXPECT_CALL(mock, QueryPrinterStatusByUri(_, _)).WillRepeatedly(Return(true));
134 EXPECT_CALL(mock, OnPrinterStatusChanged(_, _, _)).WillRepeatedly(Return(true));
135 EXPECT_CALL(mock, QueryPrinterCapabilityByUri(_, _)).WillRepeatedly(Return(true));
136 vendorDriver.MonitorPrinterStatus(PRINTER_TEST_IP, true);
137 EXPECT_TRUE(vendorDriver.OnQueryProperties(PRINTER_TEST_IP, propertyKeys));
138 EXPECT_TRUE(vendorDriver.OnQueryCapabilityByIp(PRINTER_TEST_IP, "ipp"));
139 syncWait.Wait(WAIT_TIME_MS);
140 vendorDriver.MonitorPrinterStatus(PRINTER_TEST_IP, false);
141 syncWait.Wait(WAIT_TIME_MS);
142 vendorDriver.OnDestroy();
143 vendorDriver.UnInit();
144 }
145
146 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0005, TestSize.Level2)
147 {
148 VendorIppEveryWhere vendorDriver;
149 PrinterCapability cap;
150 std::string uri;
151 EXPECT_EQ(vendorDriver.ConvertCapabilityToInfo(cap, uri), nullptr);
152 std::string option;
153 cap.SetOption(option);
154 EXPECT_EQ(vendorDriver.ConvertCapabilityToInfo(cap, uri), nullptr);
155 option = "{\"make\":\"maker\"}";
156 cap.SetOption(option);
157 EXPECT_EQ(vendorDriver.ConvertCapabilityToInfo(cap, uri), nullptr);
158 option = "{\"printerName\":\"name\"}";
159 cap.SetOption(option);
160 EXPECT_EQ(vendorDriver.ConvertCapabilityToInfo(cap, uri), nullptr);
161 option = "{\"printerName\":\"name\",\"make\":\"maker\"}";
162 cap.SetOption(option);
163 EXPECT_NE(vendorDriver.ConvertCapabilityToInfo(cap, uri), nullptr);
164 }
165
166 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0006, TestSize.Level2)
167 {
168 MockVendorManager mock;
169 VendorIppEveryWhere vendorDriver;
170 auto printerInfo = std::make_shared<PrinterInfo>();
171 EXPECT_FALSE(vendorDriver.ConnectPrinter(printerInfo));
172 EXPECT_TRUE(vendorDriver.Init(&mock));
173 EXPECT_FALSE(vendorDriver.ConnectPrinter(nullptr));
174 EXPECT_CALL(mock, UpdatePrinterToDiscovery(_, _)).Times(3).WillOnce(Return(1)).WillRepeatedly(Return(0));
175 EXPECT_CALL(mock, AddPrinterToCupsWithPpd(_, _, _, _)).Times(2).WillOnce(Return(1)).WillRepeatedly(Return(0));
176 EXPECT_FALSE(vendorDriver.ConnectPrinter(printerInfo));
177 EXPECT_FALSE(vendorDriver.ConnectPrinter(printerInfo));
178 EXPECT_TRUE(vendorDriver.ConnectPrinter(printerInfo));
179 }
180
181 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0007, TestSize.Level2)
182 {
183 MockVendorManager mock;
184 VendorIppEveryWhere vendorDriver;
185 auto printerInfo = std::make_shared<PrinterInfo>();
186 EXPECT_FALSE(vendorDriver.UpdateCapability(printerInfo));
187 EXPECT_TRUE(vendorDriver.Init(&mock));
188 EXPECT_FALSE(vendorDriver.UpdateCapability(nullptr));
189 EXPECT_CALL(mock, UpdatePrinterToDiscovery(_, _)).Times(2).WillOnce(Return(1)).WillRepeatedly(Return(0));
190 EXPECT_FALSE(vendorDriver.UpdateCapability(printerInfo));
191 EXPECT_TRUE(vendorDriver.UpdateCapability(printerInfo));
192 }
193
194 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0008, TestSize.Level2)
195 {
196 VendorDriverBaseTest vendorDriver;
197 std::string printerId = "test";
198 Print_PrinterState state = Print_PrinterState::PRINTER_UNAVAILABLE;
199 vendorDriver.OnPrinterStateQueried(printerId, state);
200 vendorDriver.UpdateAllPrinterStatus();
201 EXPECT_TRUE(vendorDriver.MonitorPrinterStatus(printerId, true));
202 vendorDriver.UpdateAllPrinterStatus();
203 EXPECT_FALSE(vendorDriver.OnQueryCapability(printerId, 0));
204 EXPECT_FALSE(vendorDriver.OnQueryCapabilityByIp(printerId, ""));
205 std::vector<std::string> propertyKeys;
206 EXPECT_FALSE(vendorDriver.OnQueryProperties(printerId, propertyKeys));
207 }
208
209 HWTEST_F(VendorIppEverywhereTest, VendorIppEverywhereTest_0009, TestSize.Level2)
210 {
211 MockVendorManager mock;
212 VendorDriverBaseTest vendorDriver;
213 std::string printerId = "test";
214 EXPECT_TRUE(vendorDriver.MonitorPrinterStatus(printerId, true));
215 EXPECT_TRUE(vendorDriver.Init(&mock));
216 EXPECT_CALL(mock, OnPrinterStatusChanged(_, _, _)).WillRepeatedly(Return(false));
217 EXPECT_FALSE(vendorDriver.MonitorPrinterStatus(printerId, true));
218 vendorDriver.UpdateAllPrinterStatus();
219 EXPECT_TRUE(vendorDriver.MonitorPrinterStatus(printerId, false));
220 EXPECT_FALSE(vendorDriver.MonitorPrinterStatus(printerId, false));
221 vendorDriver.UnInit();
222 }
223 } // namespace Print
224 } // namespace OHOS