1 /*
2 * Copyright (c) 2021 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 #include <gtest/gtest.h>
16 #include "mock_print_callback_stub.h"
17 #include "iremote_broker.h"
18 #include "print_constant.h"
19 #include "print_job.h"
20 #include "printer_info.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace Print {
27 class PrintCallbackStubTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 };
34
SetUpTestCase(void)35 void PrintCallbackStubTest::SetUpTestCase(void) {}
36
TearDownTestCase(void)37 void PrintCallbackStubTest::TearDownTestCase(void) {}
38
SetUp(void)39 void PrintCallbackStubTest::SetUp(void) {}
40
TearDown(void)41 void PrintCallbackStubTest::TearDown(void) {}
42
43
44 /**
45 * @tc.name: PrintCallbackStubTest_0001
46 * @tc.desc: Verify the capability function.
47 * @tc.type: FUNC
48 * @tc.require:
49 */
50 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0001, TestSize.Level1)
51 {
52 MessageParcel data;
53 MessageParcel reply;
54 MessageOption option(MessageOption::TF_SYNC);
55 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_TASK);
56
57 auto callback = std::make_shared<MockPrintCallbackStub>();
58 EXPECT_NE(callback, nullptr);
59 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_RPC_FAILURE);
60 }
61
62 /**
63 * @tc.name: PrintServiceProxyTest_0002
64 * @tc.desc: Verify the capability function.
65 * @tc.type: FUNC
66 * @tc.require:
67 */
68 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0002, TestSize.Level1)
69 {
70 MessageParcel data;
71 MessageParcel reply;
72 MessageOption option(MessageOption::TF_SYNC);
73 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_TASK + 100);
74
75 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
76 auto callback = std::make_shared<MockPrintCallbackStub>();
77 EXPECT_NE(callback, nullptr);
78 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), OHOS::IPC_STUB_UNKNOW_TRANS_ERR);
79 }
80
81 /**
82 * @tc.name: PrintServiceProxyTest_0003
83 * @tc.desc: Verify the capability function.
84 * @tc.type: FUNC
85 * @tc.require:
86 */
87 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0003, TestSize.Level1)
88 {
89 MessageParcel data;
90 MessageParcel reply;
91 MessageOption option(MessageOption::TF_SYNC);
92 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_TASK);
93
94 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
95 auto callback = std::make_shared<MockPrintCallbackStub>();
96 EXPECT_NE(callback, nullptr);
97 EXPECT_CALL(*callback, OnCallback()).Times(1);
98 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE);
99 }
100
101 MATCHER_P(PrinterInfoMatcher, oParam, "Match Printer Info")
102 {
103 const PrinterInfo& op = (const PrinterInfo&)arg;
104 return op.GetPrinterId() == oParam.GetPrinterId();
105 }
106
107 MATCHER_P(PrintJobMatcher, oParam, "Match Print Job")
108 {
109 const PrintJob& op = (const PrintJob&)arg;
110 return op.GetJobId() == oParam.GetJobId();
111 }
112
113 /**
114 * @tc.name: PrintServiceProxyTest_0004
115 * @tc.desc: Verify the capability function.
116 * @tc.type: FUNC
117 * @tc.require:
118 */
119 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0004, TestSize.Level1)
120 {
121 MessageParcel data;
122 MessageParcel reply;
123 MessageOption option(MessageOption::TF_SYNC);
124 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_PRINTER);
125
126 auto testState = static_cast<uint32_t>(PRINTER_ADDED);
127 PrinterInfo testInfo;
128 std::string testPrinterId = "com.sample.ext:1";
129 testInfo.SetPrinterId(testPrinterId);
130
131 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
132 EXPECT_TRUE(data.WriteUint32(testState));
133 EXPECT_TRUE(testInfo.Marshalling(data));
134 auto callback = std::make_shared<MockPrintCallbackStub>();
135 EXPECT_NE(callback, nullptr);
136 EXPECT_CALL(*callback, OnCallback(testState,
137 Matcher<const PrinterInfo&>(PrinterInfoMatcher(testInfo)))).Times(1).WillOnce(Return(true));
138 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE);
139 EXPECT_TRUE(reply.ReadBool());
140 }
141
142 /**
143 * @tc.name: PrintServiceProxyTest_0005
144 * @tc.desc: Verify the capability function.
145 * @tc.type: FUNC
146 * @tc.require:
147 */
148 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0005, TestSize.Level1)
149 {
150 MessageParcel data;
151 MessageParcel reply;
152 MessageOption option(MessageOption::TF_SYNC);
153 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_PRINT_JOB);
154
155 auto testState = static_cast<uint32_t>(PRINT_JOB_RUNNING);
156 PrintJob testJob;
157 std::string jobId = "job:1234";
158 testJob.SetJobId(jobId);
159
160 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
161 EXPECT_TRUE(data.WriteUint32(testState));
162 EXPECT_TRUE(testJob.Marshalling(data));
163 auto callback = std::make_shared<MockPrintCallbackStub>();
164 EXPECT_NE(callback, nullptr);
165 EXPECT_CALL(*callback, OnCallback(testState,
166 Matcher<const PrintJob&>(PrintJobMatcher(testJob)))).Times(1).WillOnce(Return(true));
167 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE);
168 EXPECT_TRUE(reply.ReadBool());
169 }
170
171 /**
172 * @tc.name: PrintCallbackStubTest_0006
173 * @tc.desc: Verify the capability function.
174 * @tc.type: FUNC
175 * @tc.require:
176 */
177 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0006, TestSize.Level1)
178 {
179 MessageParcel data;
180 MessageParcel reply;
181 MessageOption option(MessageOption::TF_SYNC);
182 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_EXTINFO);
183
184 std::string extensionId = "com.sample.ext";
185 std::string extInfo = "custom extension info";
186 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
187 EXPECT_TRUE(data.WriteString(extensionId));
188 EXPECT_TRUE(data.WriteString(extInfo));
189 auto callback = std::make_shared<MockPrintCallbackStub>();
190 EXPECT_NE(callback, nullptr);
191 EXPECT_CALL(*callback, OnCallback(extensionId, extInfo)).Times(1).WillOnce(Return(true));
192 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE);
193 EXPECT_TRUE(reply.ReadBool());
194 }
195
196 /**
197 * @tc.name: PrintServiceProxyTest_0008
198 * @tc.desc: Verify the capability function.
199 * @tc.type: FUNC
200 * @tc.require:
201 */
202 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0008, TestSize.Level1)
203 {
204 MessageParcel data;
205 MessageParcel reply;
206 MessageOption option(MessageOption::TF_SYNC);
207 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_PRINT_JOB_ADAPTER);
208
209 std::string jobId = "job:1234";
210 PrintAttributes oldAttrs;
211 PrintAttributes newAttrs;
212
213 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
214 auto callback = std::make_shared<MockPrintCallbackStub>();
215 EXPECT_NE(callback, nullptr);
216 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_SERVER_FAILURE);
217 EXPECT_FALSE(reply.ReadBool());
218 }
219
220 /**
221 * @tc.name: PrintServiceProxyTest_0009
222 * @tc.desc: Verify the capability function.
223 * @tc.type: FUNC
224 * @tc.require:
225 */
226 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0009, TestSize.Level1)
227 {
228 MessageParcel data;
229 MessageParcel reply;
230 MessageOption option(MessageOption::TF_SYNC);
231 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_PRINT_JOB_CHANGED_ADAPTER);
232
233 auto testState = static_cast<uint32_t>(PRINT_JOB_RUNNING);
234 auto testSubState = static_cast<uint32_t>(PRINTER_ADDED);
235 std::string jobId = "job:1234";
236
237 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
238 EXPECT_TRUE(data.WriteUint32(testState));
239 EXPECT_TRUE(data.WriteUint32(testSubState));
240 auto callback = std::make_shared<MockPrintCallbackStub>();
241 EXPECT_NE(callback, nullptr);
242 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE);
243 EXPECT_TRUE(reply.ReadBool());
244 }
245
246 /**
247 * @tc.name: PrintCallbackStubTest_0010
248 * @tc.desc: Verify the capability function.
249 * @tc.type: FUNC
250 * @tc.require:
251 */
252 HWTEST_F(PrintCallbackStubTest, PrintCallbackStubTest_0010, TestSize.Level1)
253 {
254 MessageParcel data;
255 MessageParcel reply;
256 MessageOption option(MessageOption::TF_SYNC);
257 uint32_t code = static_cast<uint32_t>(PRINT_CALLBACK_PRINT_GET_FILE_ADAPTER);
258
259 auto testState = static_cast<uint32_t>(PRINT_JOB_RUNNING);
260 EXPECT_TRUE(data.WriteInterfaceToken(IPrintCallback::GetDescriptor()));
261 EXPECT_TRUE(data.WriteUint32(testState));
262 auto callback = std::make_shared<MockPrintCallbackStub>();
263 EXPECT_NE(callback, nullptr);
264 EXPECT_EQ(callback->OnRemoteRequest(code, data, reply, option), E_PRINT_NONE);
265 EXPECT_TRUE(reply.ReadBool());
266 }
267 } // namespace Print
268 } // namespace OHOS
269