1 /*
2  * Copyright (c) 2023 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 applipcable 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 
18 #include "iservice_registry.h"
19 #include "print_constant.h"
20 #include "print_callback_proxy.h"
21 #include "print_sync_load_callback.h"
22 #include "system_ability_definition.h"
23 #include "mock_remote_object.h"
24 #include "mock_print_callback_stub.h"
25 #include "print_log.h"
26 
27 using namespace testing;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Print {
32 class PrintCallbackProxyTest : public testing::Test {
33 public:
34     static void SetUpTestCase(void);
35     static void TearDownTestCase(void);
36     void SetUp();
37     void TearDown();
38 };
39 
SetUpTestCase(void)40 void PrintCallbackProxyTest::SetUpTestCase(void) {}
41 
TearDownTestCase(void)42 void PrintCallbackProxyTest::TearDownTestCase(void) {}
43 
SetUp(void)44 void PrintCallbackProxyTest::SetUp(void)
45 {
46     static int32_t testNo = 0;
47     PRINT_HILOGI("PrintCallbackProxyTest_%{public}d", ++testNo);
48 }
49 
TearDown(void)50 void PrintCallbackProxyTest::TearDown(void) {}
51 
52 /**
53  * @tc.name: PrintCallbackProxyTest_0001
54  * @tc.desc: printCallbackProxy
55  * @tc.type: FUNC
56  * @tc.require:
57  */
58 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0001, TestSize.Level1)
59 {
60     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
61     EXPECT_NE(obj, nullptr);
62     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
63     EXPECT_NE(proxy, nullptr);
64     auto service = std::make_shared<MockPrintCallbackStub>();
65     EXPECT_NE(service, nullptr);
66     EXPECT_CALL(*service, OnCallback()).Times(Exactly(1)).WillOnce(Return(true));
67     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
68     ON_CALL(*obj, SendRequest)
__anon19cf79710102(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 69         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
70             service->OnRemoteRequest(code, data, reply, option);
71             return E_PRINT_NONE;
72         });
73     EXPECT_TRUE(proxy->OnCallback());
74 }
75 
76 /**
77  * @tc.name: PrintCallbackProxyTest_0002
78  * @tc.desc: printCallbackProxy
79  * @tc.type: FUNC
80  * @tc.require:
81  */
82 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0002, TestSize.Level1)
83 {
84     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
85     EXPECT_NE(obj, nullptr);
86     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
87     EXPECT_NE(proxy, nullptr);
88     auto service = std::make_shared<MockPrintCallbackStub>();
89     EXPECT_NE(service, nullptr);
90     EXPECT_CALL(*service, OnCallback()).Times(Exactly(1)).WillOnce(Return(false));
91     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
92     ON_CALL(*obj, SendRequest)
__anon19cf79710202(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 93         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
94             service->OnRemoteRequest(code, data, reply, option);
95             return E_PRINT_RPC_FAILURE;
96         });
97     EXPECT_FALSE(proxy->OnCallback());
98 }
99 
100 MATCHER_P(PrinterInfoMatcher, oParam, "Match Printer Info")
101 {
102     const PrinterInfo& op = (const PrinterInfo&)arg;
103     return op.GetPrinterId() == oParam.GetPrinterId();
104 }
105 
106 MATCHER_P(PrintJobMatcher, oParam, "Match Print Job")
107 {
108     const PrintJob& op = (const PrintJob&)arg;
109     return op.GetJobId() == oParam.GetJobId();
110 }
111 
112 /**
113  * @tc.name: PrintCallbackProxyTest_0003
114  * @tc.desc: printCallbackProxy
115  * @tc.type: FUNC
116  * @tc.require:
117  */
118 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0003, TestSize.Level1)
119 {
120     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
121     EXPECT_NE(obj, nullptr);
122     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
123     EXPECT_NE(proxy, nullptr);
124     auto service = std::make_shared<MockPrintCallbackStub>();
125     EXPECT_NE(service, nullptr);
126 
127     auto testState = static_cast<uint32_t>(PRINTER_ADDED);
128     PrinterInfo testInfo;
129     std::string testPrinterId = "com.sample.ext:1";
130     testInfo.SetPrinterId(testPrinterId);
131 
132     EXPECT_CALL(*service, OnCallback(testState,
133         Matcher<const PrinterInfo&>(PrinterInfoMatcher(testInfo)))).Times(1).WillOnce(Return(true));
134     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
135     ON_CALL(*obj, SendRequest)
__anon19cf79710302(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 136         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
137             service->OnRemoteRequest(code, data, reply, option);
138             return E_PRINT_NONE;
139         });
140     EXPECT_TRUE(proxy->OnCallback(testState, testInfo));
141 }
142 
143 /**
144  * @tc.name: PrintCallbackProxyTest_0004
145  * @tc.desc: printCallbackProxy
146  * @tc.type: FUNC
147  * @tc.require:
148  */
149 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0004, TestSize.Level1)
150 {
151     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
152     EXPECT_NE(obj, nullptr);
153     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
154     EXPECT_NE(proxy, nullptr);
155     auto service = std::make_shared<MockPrintCallbackStub>();
156     EXPECT_NE(service, nullptr);
157 
158     auto testState = static_cast<uint32_t>(PRINTER_ADDED);
159     PrinterInfo testInfo;
160     std::string testPrinterId = "com.sample.ext:1";
161     testInfo.SetPrinterId(testPrinterId);
162 
163     EXPECT_CALL(*service, OnCallback(testState,
164         Matcher<const PrinterInfo&>(PrinterInfoMatcher(testInfo)))).Times(1).WillOnce(Return(false));
165     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
166     ON_CALL(*obj, SendRequest)
__anon19cf79710402(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 167         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
168             service->OnRemoteRequest(code, data, reply, option);
169             return E_PRINT_RPC_FAILURE;
170         });
171     EXPECT_FALSE(proxy->OnCallback(testState, testInfo));
172 }
173 
174 /**
175  * @tc.name: PrintCallbackProxyTest_0005
176  * @tc.desc: printCallbackProxy
177  * @tc.type: FUNC
178  * @tc.require:
179  */
180 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0005, TestSize.Level1)
181 {
182     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
183     EXPECT_NE(obj, nullptr);
184     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
185     EXPECT_NE(proxy, nullptr);
186     auto service = std::make_shared<MockPrintCallbackStub>();
187     EXPECT_NE(service, nullptr);
188 
189     auto testState = static_cast<uint32_t>(PRINT_JOB_RUNNING);
190     PrintJob testJob;
191     std::string jobId = "job:1234";
192     testJob.SetJobId(jobId);
193 
194     EXPECT_CALL(*service, OnCallback(testState,
195         Matcher<const PrintJob&>(PrintJobMatcher(testJob)))).Times(1).WillOnce(Return(true));
196     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
197     ON_CALL(*obj, SendRequest)
__anon19cf79710502(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 198         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
199             service->OnRemoteRequest(code, data, reply, option);
200             return E_PRINT_NONE;
201         });
202     EXPECT_TRUE(proxy->OnCallback(testState, testJob));
203 }
204 
205 /**
206  * @tc.name: PrintCallbackProxyTest_0006
207  * @tc.desc: printCallbackProxy
208  * @tc.type: FUNC
209  * @tc.require:
210  */
211 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0006, TestSize.Level1)
212 {
213     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
214     EXPECT_NE(obj, nullptr);
215     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
216     EXPECT_NE(proxy, nullptr);
217     auto service = std::make_shared<MockPrintCallbackStub>();
218     EXPECT_NE(service, nullptr);
219 
220     auto testState = static_cast<uint32_t>(PRINT_JOB_RUNNING);
221     PrintJob testJob;
222     std::string jobId = "job:1234";
223     testJob.SetJobId(jobId);
224 
225     EXPECT_CALL(*service, OnCallback(testState,
226         Matcher<const PrintJob&>(PrintJobMatcher(testJob)))).Times(1).WillOnce(Return(true));
227     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
228     ON_CALL(*obj, SendRequest)
__anon19cf79710602(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 229         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
230             service->OnRemoteRequest(code, data, reply, option);
231             return E_PRINT_RPC_FAILURE;
232         });
233     EXPECT_FALSE(proxy->OnCallback(testState, testJob));
234 }
235 
236 
237 /**
238  * @tc.name: PrintCallbackProxyTest_0007
239  * @tc.desc: printCallbackProxy
240  * @tc.type: FUNC
241  * @tc.require:
242  */
243 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0007, TestSize.Level1)
244 {
245     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
246     EXPECT_NE(obj, nullptr);
247     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
248     EXPECT_NE(proxy, nullptr);
249     auto service = std::make_shared<MockPrintCallbackStub>();
250     EXPECT_NE(service, nullptr);
251     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
252     ON_CALL(*obj, SendRequest)
__anon19cf79710702(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 253         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
254             service->OnRemoteRequest(code, data, reply, option);
255             return E_PRINT_RPC_FAILURE;
256         });
257     uint32_t testState = 0;
258     EXPECT_FALSE(proxy->OnCallbackAdapterGetFile(testState));
259 }
260 
261 /**
262  * @tc.name: PrintCallbackProxyTest_0008
263  * @tc.desc: printCallbackProxy
264  * @tc.type: FUNC
265  * @tc.require:
266  */
267 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0008, TestSize.Level1)
268 {
269     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
270     EXPECT_NE(obj, nullptr);
271     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
272     EXPECT_NE(proxy, nullptr);
273     auto service = std::make_shared<MockPrintCallbackStub>();
274     EXPECT_NE(service, nullptr);
275     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
276     ON_CALL(*obj, SendRequest)
__anon19cf79710802(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 277         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
278             service->OnRemoteRequest(code, data, reply, option);
279             return E_PRINT_RPC_FAILURE;
280         });
281     uint32_t testState = 0;
282     uint32_t testSubState = 0;
283     std::string jobId = "job:1234";
284     EXPECT_FALSE(proxy->onCallbackAdapterJobStateChanged(jobId, testState, testSubState));
285 }
286 
287 /**
288  * @tc.name: PrintCallbackProxyTest_0009
289  * @tc.desc: printCallbackProxy
290  * @tc.type: FUNC
291  * @tc.require:
292  */
293 HWTEST_F(PrintCallbackProxyTest, PrintCallbackProxyTest_0009, TestSize.Level1)
294 {
295     sptr<MockRemoteObject> obj = new (std::nothrow) MockRemoteObject();
296     EXPECT_NE(obj, nullptr);
297     auto proxy = std::make_shared<PrintCallbackProxy>(obj);
298     EXPECT_NE(proxy, nullptr);
299     auto service = std::make_shared<MockPrintCallbackStub>();
300     EXPECT_NE(service, nullptr);
301     EXPECT_CALL(*obj, SendRequest(_, _, _, _)).Times(1);
302     ON_CALL(*obj, SendRequest)
__anon19cf79710902(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) 303         .WillByDefault([&service](uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) {
304             service->OnRemoteRequest(code, data, reply, option);
305             return E_PRINT_RPC_FAILURE;
306         });
307     uint32_t testState = 0;
308     uint32_t testSubState = 0;
309     std::string jobId = "job:1234";
310     EXPECT_FALSE(proxy->onCallbackAdapterJobStateChanged(jobId, testState, testSubState));
311 }
312 
313 
314 } // namespace Print
315 } // namespace OHOS
316