1 /*
2 * Copyright (c) 2025 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 #include <gmock/gmock.h>
18 #include "ipc_skeleton.h"
19 #include "message_parcel_warp.h"
20 #include "pasteboard_delay_getter_stub.h"
21 #include "pasteboard_hilog.h"
22 #include "pasteboard_observer_stub.h"
23
24 using namespace testing;
25 using namespace testing::ext;
26 using namespace OHOS::MiscServices;
27 namespace OHOS {
28 class PasteboardDelayStubTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31 static void TearDownTestCase(void);
32 void SetUp();
33 void TearDown();
34 };
35
36 class PasteboardObserverImpl : public PasteboardObserverStub {
37 public:
38 PasteboardObserverImpl();
39 ~PasteboardObserverImpl();
40 void OnPasteboardChanged() override;
41 void OnPasteboardEvent(std::string bundleName, int32_t status) override;
42 };
43
PasteboardObserverImpl()44 PasteboardObserverImpl::PasteboardObserverImpl()
45 {
46 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "New Pasteboard Observer.");
47 }
48
~PasteboardObserverImpl()49 PasteboardObserverImpl::~PasteboardObserverImpl()
50 {
51 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "delete Pasteboard Observer.");
52 }
53
OnPasteboardChanged()54 void PasteboardObserverImpl::OnPasteboardChanged()
55 {
56 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "changed callback.");
57 }
58
OnPasteboardEvent(std::string bundleName,int32_t status)59 void PasteboardObserverImpl::OnPasteboardEvent(std::string bundleName, int32_t status)
60 {
61 PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "event callback.");
62 }
63
64 class PasteboardDelayGetterStubTest : public PasteboardDelayGetterStub {
65 public:
66 PasteboardDelayGetterStubTest() = default;
67 virtual ~PasteboardDelayGetterStubTest() = default;
68 MOCK_METHOD(void, GetPasteData, (const std::string &type, PasteData &data), (override));
69 MOCK_METHOD(void, GetUnifiedData, (const std::string &type, UDMF::UnifiedData &data), (override));
70 };
71
SetUpTestCase(void)72 void PasteboardDelayStubTest::SetUpTestCase(void) {}
73
TearDownTestCase(void)74 void PasteboardDelayStubTest::TearDownTestCase(void) {}
75
SetUp(void)76 void PasteboardDelayStubTest::SetUp(void) {}
77
TearDown(void)78 void PasteboardDelayStubTest::TearDown(void) {}
79
80 class PasteboardDelayStubInterface : public MessageParcel {
81 public:
PasteboardDelayStubInterface()82 PasteboardDelayStubInterface(){};
~PasteboardDelayStubInterface()83 virtual ~PasteboardDelayStubInterface(){};
84 virtual std::u16string ReadInterfaceToken() = 0;
85 virtual bool Encode(std::vector<uint8_t> &buffer) const = 0;
86 virtual bool WriteRawData(MessageParcel &parcelPata, const void *data, size_t size) = 0;
87 virtual bool WriteInt64(int64_t value) = 0;
88 };
89
90 class PasteboardDelayStubInterfaceMock : public PasteboardDelayStubInterface {
91 public:
92 PasteboardDelayStubInterfaceMock();
93 ~PasteboardDelayStubInterfaceMock() override;
94 MOCK_METHOD0(ReadInterfaceToken, std::u16string());
95 MOCK_CONST_METHOD1(Encode, bool(std::vector<uint8_t> &buffer));
96 MOCK_METHOD3(WriteRawData, bool(MessageParcel &parcelPata, const void *data, size_t size));
97 MOCK_METHOD1(WriteInt64, bool(int64_t value));
98 };
99
100 static void *g_interface = nullptr;
101
PasteboardDelayStubInterfaceMock()102 PasteboardDelayStubInterfaceMock::PasteboardDelayStubInterfaceMock()
103 {
104 g_interface = reinterpret_cast<void *>(this);
105 }
106
~PasteboardDelayStubInterfaceMock()107 PasteboardDelayStubInterfaceMock::~PasteboardDelayStubInterfaceMock()
108 {
109 g_interface = nullptr;
110 }
111
GetPasteboardDelayStubInterface()112 static PasteboardDelayStubInterface *GetPasteboardDelayStubInterface()
113 {
114 return reinterpret_cast<PasteboardDelayStubInterface *>(g_interface);
115 }
116
117 extern "C" {
ReadInterfaceToken()118 std::u16string MessageParcel::ReadInterfaceToken()
119 {
120 PasteboardDelayStubInterface *interface = GetPasteboardDelayStubInterface();
121 if (interface == nullptr) {
122 return u"";
123 }
124 return interface->ReadInterfaceToken();
125 }
126
Encode(std::vector<uint8_t> & buffer,bool isRemote) const127 bool TLVWriteable::Encode(std::vector<uint8_t> &buffer, bool isRemote) const
128 {
129 (void)isRemote;
130 PasteboardDelayStubInterface *interface = GetPasteboardDelayStubInterface();
131 if (interface == nullptr) {
132 return false;
133 }
134 return interface->Encode(buffer);
135 }
136
WriteInt64(int64_t data)137 bool Parcel::WriteInt64(int64_t data)
138 {
139 PasteboardDelayStubInterface *interface = GetPasteboardDelayStubInterface();
140 if (interface == nullptr) {
141 return false;
142 }
143 return interface->WriteInt64(data);
144 }
145 }
146
147 /* *
148 * @tc.name: OnRemoteRequestTest001
149 * @tc.desc: remoteDescriptor != localDescriptor
150 * @tc.type: FUNC
151 */
152 HWTEST_F(PasteboardDelayStubTest, OnRemoteRequestTest001, TestSize.Level0)
153 {
154 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
155 NiceMock<PasteboardDelayStubInterfaceMock> mock;
156 EXPECT_CALL(mock, ReadInterfaceToken()).WillOnce(Return(u"testing"));
157 uint32_t code = IPasteboardDelayGetter::TRANS_HEAD;
158 MessageParcel data;
159 MessageParcel reply;
160 MessageOption option;
161 int32_t ret = tempDelayGetter->OnRemoteRequest(code, data, reply, option);
162 ASSERT_EQ(ret, -1);
163 }
164
165 /* *
166 * @tc.name: OnRemoteRequestTest002
167 * @tc.desc: code >= TRANS_BUTT
168 * @tc.type: FUNC
169 */
170 HWTEST_F(PasteboardDelayStubTest, OnRemoteRequestTest002, TestSize.Level0)
171 {
172 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
173 std::u16string localDescriptor = tempDelayGetter->GetDescriptor();
174 NiceMock<PasteboardDelayStubInterfaceMock> mock;
175 EXPECT_CALL(mock, ReadInterfaceToken()).WillOnce(Return(localDescriptor));
176 uint32_t code = IPasteboardDelayGetter::TRANS_BUTT;
177 MessageParcel data;
178 MessageParcel reply;
179 MessageOption option;
180 int32_t ret = tempDelayGetter->OnRemoteRequest(code, data, reply, option);
181 ASSERT_EQ(ret, -1);
182 }
183
184 /* *
185 * @tc.name: OnRemoteRequestTest003
186 * @tc.desc: code >= TRANS_BUTT
187 * @tc.type: FUNC
188 */
189 HWTEST_F(PasteboardDelayStubTest, OnRemoteRequestTest003, TestSize.Level0)
190 {
191 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
192 std::u16string localDescriptor = tempDelayGetter->GetDescriptor();
193 NiceMock<PasteboardDelayStubInterfaceMock> mock;
194 EXPECT_CALL(mock, ReadInterfaceToken()).WillOnce(Return(localDescriptor));
195 uint32_t code = 1;
196 MessageParcel data;
197 MessageParcel reply;
198 MessageOption option;
199 int32_t ret = tempDelayGetter->OnRemoteRequest(code, data, reply, option);
200 ASSERT_EQ(ret, ERR_OK);
201 }
202
203 /* *
204 * @tc.name: OnRemoteRequestTest004
205 * @tc.desc: code >= TRANS_BUTT
206 * @tc.type: FUNC
207 */
208 HWTEST_F(PasteboardDelayStubTest, OnRemoteRequestTest004, TestSize.Level0)
209 {
210 auto pasteboardObserverStub = std::make_shared<PasteboardObserverImpl>();
211 NiceMock<PasteboardDelayStubInterfaceMock> mock;
212 EXPECT_CALL(mock, ReadInterfaceToken()).WillOnce(Return(u"testing"));
213 uint32_t code = 2;
214 MessageParcel data;
215 MessageParcel reply;
216 MessageOption option;
217 int32_t ret = pasteboardObserverStub->OnRemoteRequest(code, data, reply, option);
218 ASSERT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
219 }
220
221 /* *
222 * @tc.name: OnRemoteRequestTest005
223 * @tc.desc: code >= TRANS_BUTT
224 * @tc.type: FUNC
225 */
226 HWTEST_F(PasteboardDelayStubTest, OnRemoteRequestTest005, TestSize.Level0)
227 {
228 auto pasteboardObserverStub = std::make_shared<PasteboardObserverImpl>();
229 std::u16string myDescriptor = pasteboardObserverStub->GetDescriptor();
230 NiceMock<PasteboardDelayStubInterfaceMock> mock;
231 EXPECT_CALL(mock, ReadInterfaceToken()).WillOnce(Return(myDescriptor));
232 uint32_t code = 2;
233 MessageParcel data;
234 MessageParcel reply;
235 MessageOption option;
236 int32_t ret = pasteboardObserverStub->OnRemoteRequest(code, data, reply, option);
237 ASSERT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
238 }
239
240 /* *
241 * @tc.name: OnRemoteRequestTest006
242 * @tc.desc: code >= TRANS_BUTT
243 * @tc.type: FUNC
244 */
245 HWTEST_F(PasteboardDelayStubTest, OnRemoteRequestTest006, TestSize.Level0)
246 {
247 auto pasteboardObserverStub = std::make_shared<PasteboardObserverImpl>();
248 std::u16string myDescriptor = pasteboardObserverStub->GetDescriptor();
249 pasteboardObserverStub->memberFuncMap_[2] = nullptr;
250 NiceMock<PasteboardDelayStubInterfaceMock> mock;
251 EXPECT_CALL(mock, ReadInterfaceToken()).WillOnce(Return(myDescriptor));
252 uint32_t code = 2;
253 MessageParcel data;
254 MessageParcel reply;
255 MessageOption option;
256 int32_t ret = pasteboardObserverStub->OnRemoteRequest(code, data, reply, option);
257 ASSERT_EQ(ret, IPC_STUB_UNKNOW_TRANS_ERR);
258 }
259
260 /* *
261 * @tc.name: OnGetPasteDataTest001
262 * @tc.desc: pasteData.Encode(pasteDataTlv) return error
263 * @tc.type: FUNC
264 */
265 HWTEST_F(PasteboardDelayStubTest, OnGetPasteDataTest001, TestSize.Level0)
266 {
267 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
268 MessageParcel data;
269 MessageParcel reply;
270 NiceMock<PasteboardDelayStubInterfaceMock> mock;
271 EXPECT_CALL(mock, Encode(testing::_)).WillOnce(Return(false));
272 int32_t ret = tempDelayGetter->OnGetPasteData(data, reply);
273 ASSERT_EQ(ret, ERR_INVALID_VALUE);
274 }
275
276 /* *
277 * @tc.name: OnGetPasteDataTest002
278 * @tc.desc: WriteInt64 return error
279 * @tc.type: FUNC
280 */
281 HWTEST_F(PasteboardDelayStubTest, OnGetPasteDataTest002, TestSize.Level0)
282 {
283 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
284 MessageParcel data;
285 MessageParcel reply;
286 NiceMock<PasteboardDelayStubInterfaceMock> mock;
287 EXPECT_CALL(mock, Encode(testing::_)).WillOnce(Return(true));
288 EXPECT_CALL(mock, WriteInt64(testing::_)).WillRepeatedly(Return(false));
289 int32_t ret = tempDelayGetter->OnGetPasteData(data, reply);
290 ASSERT_EQ(ret, ERR_INVALID_VALUE);
291 }
292
293 /* *
294 * @tc.name: OnGetPasteDataTest003
295 * @tc.desc: reply.WriteInt64 return error
296 * @tc.type: FUNC
297 */
298 HWTEST_F(PasteboardDelayStubTest, OnGetPasteDataTest003, TestSize.Level0)
299 {
300 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
301 MessageParcel data;
302 MessageParcel reply;
303 NiceMock<PasteboardDelayStubInterfaceMock> mock;
304 EXPECT_CALL(mock, Encode(testing::_)).WillOnce(Return(true));
305 EXPECT_CALL(mock, WriteInt64(testing::_)).WillRepeatedly(Return(true));
306 EXPECT_CALL(mock, WriteRawData(testing::_, testing::_, testing::_)).WillRepeatedly(Return(false));
307 int32_t ret = tempDelayGetter->OnGetPasteData(data, reply);
308 ASSERT_EQ(ret, ERR_INVALID_VALUE);
309 }
310
311 /* *
312 * @tc.name: OnGetUnifiedDataTest001
313 * @tc.desc: OnGetUnifiedData
314 * @tc.type: FUNC
315 */
316 HWTEST_F(PasteboardDelayStubTest, OnGetUnifiedDataTest001, TestSize.Level0)
317 {
318 auto tempDelayGetter = std::make_shared<PasteboardDelayGetterStubTest>();
319 MessageParcel data;
320 MessageParcel reply;
321 int32_t ret = tempDelayGetter->OnGetUnifiedData(data, reply);
322 ASSERT_EQ(ret, ERR_OK);
323 }
324 } // namespace OHOS