1 /*
2 * Copyright (c) 2022-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 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 "copy_uri_handler.h"
17 #include "common/block_object.h"
18 #include "clip/clip_plugin.h"
19 #include "clip_factory.h"
20 #include "int_wrapper.h"
21 #include "paste_uri_handler.h"
22 #include "pasteboard_client.h"
23 #include "remote_file_share.h"
24 #include <gmock/gmock.h>
25 #include <gtest/gtest.h>
26
27 namespace OHOS::MiscServices {
28 using namespace testing::ext;
29 using namespace testing;
30 using namespace OHOS::AAFwk;
31 using namespace OHOS::Media;
32 constexpr const int32_t INVALID_FD = -1;
33 constexpr const char *FILE_URI = "/data/test/resource/pasteboardTest.txt";
34 class PasteDataTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase(void)42 void PasteDataTest::SetUpTestCase(void)
43 {
44 }
45
TearDownTestCase(void)46 void PasteDataTest::TearDownTestCase(void)
47 {
48 }
49
SetUp(void)50 void PasteDataTest::SetUp(void)
51 {
52 }
53
TearDown(void)54 void PasteDataTest::TearDown(void)
55 {
56 }
57
ClipFactory()58 ClipFactory::ClipFactory()
59 {
60 ClipPlugin::RegCreator("distributed_clip", this);
61 }
62
63 class UriHandlerMock : public UriHandler {
64 public:
65 UriHandlerMock() = default;
66 virtual ~UriHandlerMock() = default;
67
68 MOCK_METHOD1(ToUri, std::string(int32_t fd));
69 MOCK_METHOD2(ToFd, int32_t(const std::string &uri, bool isClient));
70 MOCK_CONST_METHOD1(IsFile, bool(const std::string &uri));
71 };
72
73 /**
74 * @tc.name: ReplaceShareUri001
75 * @tc.desc: replace user id in share path
76 * @tc.type: FUNC
77 * @tc.require:AR000H5I1D
78 * @tc.author: baoyayong
79 */
80 HWTEST_F(PasteDataTest, ReplaceShareUri001, TestSize.Level0)
81 {
82 PasteData data;
83 PasteDataRecord::Builder builder(MIMETYPE_TEXT_URI);
84 std::string uriStr = "/data/storage/100/haps/caches/xxx.txt";
85 auto uri = std::make_shared<OHOS::Uri>(uriStr);
86 builder.SetUri(uri);
87 auto record = builder.Build();
88
89 // mock
90 UriHandlerMock mock;
91 std::string mockUri = "/mnt/hmdfs/100/account/merge_view/services/psteboard_service/.share/xxx.txt";
92 EXPECT_CALL(mock, ToUri(_)).WillRepeatedly(Return(mockUri));
93 EXPECT_CALL(mock, ToFd(_, _)).WillRepeatedly(Return(2));
94 EXPECT_CALL(mock, IsFile(_)).WillRepeatedly(Return(true));
95
96 data.AddRecord(record);
97 MessageParcel parcel;
98 data.WriteUriFd(parcel, mock);
99 bool result = data.ReadUriFd(parcel, mock);
100 EXPECT_TRUE(result);
101 EXPECT_EQ(mockUri, data.GetPrimaryUri()->ToString());
102 data.ReplaceShareUri(200);
103 std::string mockUri2 = "/mnt/hmdfs/200/account/merge_view/services/psteboard_service/.share/xxx.txt";
104 EXPECT_EQ(mockUri2, data.GetPrimaryUri()->ToString());
105 }
106
107 /**
108 * @tc.name: uriConvertTest001
109 * @tc.desc: uri convert(in same app)
110 * @tc.type: FUNC
111 * @tc.require:AR000H5I1D
112 * @tc.author: chenyu
113 */
114 HWTEST_F(PasteDataTest, uriConvertTest001, TestSize.Level0)
115 {
116 PasteData data;
117 PasteDataRecord::Builder builder(MIMETYPE_TEXT_URI);
118 std::string uriStr = FILE_URI;
119 auto uri = std::make_shared<OHOS::Uri>(uriStr);
120 builder.SetUri(uri);
121 auto record = builder.Build();
122 data.AddRecord(record);
123
124 MessageParcel parcel;
125 CopyUriHandler copyHandler;
126 data.WriteUriFd(parcel, copyHandler);
127 bool result = data.ReadUriFd(parcel, copyHandler);
128 EXPECT_TRUE(result);
129 auto distributedUri = data.GetPrimaryUri()->ToString();
130 EXPECT_FALSE(uriStr == distributedUri);
131
132 MessageParcel parcel1;
133 PasteUriHandler pasteHandler;
134 int32_t fd = 5;
135 pasteHandler.ToUri(fd);
136
137 data.SetLocalPasteFlag(true);
138 data.WriteUriFd(parcel1, pasteHandler);
139 result = data.ReadUriFd(parcel1, pasteHandler);
140 EXPECT_TRUE(result);
141 ASSERT_TRUE(data.GetPrimaryUri() != nullptr);
142 auto convertedUri = data.GetPrimaryUri()->ToString();
143 EXPECT_EQ(distributedUri, convertedUri);
144 EXPECT_FALSE(uriStr == convertedUri);
145 }
146
147 /**
148 * @tc.name: uriConvertTest002
149 * @tc.desc: uri convert(in same app)
150 * @tc.type: FUNC
151 */
152 HWTEST_F(PasteDataTest, uriConvertTest002, TestSize.Level0)
153 {
154 PasteUriHandler pasteHandler;
155 int32_t fd = -100;
156 std::string convertUri = pasteHandler.ToUri(fd);
157 EXPECT_TRUE(convertUri == "");
158 }
159
160 /**
161 * @tc.name: uriConvertTest003
162 * @tc.desc: uri convert(in same app)
163 * @tc.type: FUNC
164 */
165 HWTEST_F(PasteDataTest, uriConvertTest003, TestSize.Level0)
166 {
167 CopyUriHandler copyHandler;
168 int32_t fd = -100;
169 std::string convertUri = copyHandler.ToUri(fd);
170 EXPECT_TRUE(convertUri == "");
171 }
172
173 /**
174 * @tc.name: AddRecord001
175 * @tc.desc: PasteDataRecord AddRecord
176 * @tc.type: FUNC
177 */
178 HWTEST_F(PasteDataTest, AddRecord001, TestSize.Level0)
179 {
180 PasteData data;
181 PasteDataRecord::Builder builder(MIMETYPE_TEXT_URI);
182 std::string uriStr = FILE_URI;
183 auto uri = std::make_shared<OHOS::Uri>(uriStr);
184 builder.SetUri(uri);
185 auto record = builder.Build();
186 EXPECT_TRUE(record != nullptr);
187 data.AddRecord(nullptr);
188 auto count = data.GetRecordCount();
189 EXPECT_TRUE(count == 0);
190 }
191
192 /**
193 * @tc.name: AddRecord002
194 * @tc.desc: PasteDataRecord AddRecord
195 * @tc.type: FUNC
196 */
197 HWTEST_F(PasteDataTest, AddRecord002, TestSize.Level0)
198 {
199 PasteData data;
200 PasteDataRecord::Builder builder(MIMETYPE_TEXT_URI);
201 std::string uriStr = FILE_URI;
202 auto uri = std::make_shared<OHOS::Uri>(uriStr);
203 builder.SetUri(uri);
204 auto record = builder.Build();
205 data.AddRecord(*record);
206 auto count = data.GetRecordCount();
207 EXPECT_TRUE(count == 1);
208 }
209
210 /**
211 * @tc.name: GetRealPathFailed001
212 * @tc.desc: GetRealPath Failed(realpath(inOriPath.c_str(), realPath) == nullptr)
213 * @tc.type: FUNC
214 * @tc.require: issuesI5Y6PO
215 * @tc.author: chenyu
216 */
217 HWTEST_F(PasteDataTest, GetRealPathFailed001, TestSize.Level0)
218 {
219 std::string uriStr = "/data/storage/100/haps/caches/xxx.txt";
220 PasteUriHandler pasteHandler;
221 auto ret = pasteHandler.ToFd(uriStr, true);
222 EXPECT_EQ(ret, INVALID_FD);
223 }
224
225 /**
226 * @tc.name: GetRealPathFailed002
227 * @tc.desc: GetRealPath Failed(inOriPath.size() > PATH_MAX)
228 * @tc.type: FUNC
229 * @tc.require: issuesI5Y6PO
230 * @tc.author: chenyu
231 */
232 HWTEST_F(PasteDataTest, GetRealPathFailed002, TestSize.Level0)
233 {
234 std::string uriStr(PATH_MAX + 2, '*');
235 PasteUriHandler pasteHandler;
236 auto ret = pasteHandler.ToFd(uriStr, true);
237 EXPECT_EQ(ret, INVALID_FD);
238 }
239
240 /**
241 * @tc.name: ConvertToText001
242 * @tc.desc: PasteDataRecord: ConvertToText htmlText
243 * @tc.type: FUNC
244 * @tc.require: AR000HEECD
245 * @tc.author: chenyu
246 */
247 HWTEST_F(PasteDataTest, ConvertToText001, TestSize.Level0)
248 {
249 std::string htmlText = "<div class='disabled item tip user-programs'>";
250 auto record = PasteboardClient::GetInstance()->CreateHtmlTextRecord(htmlText);
251 ASSERT_TRUE(record != nullptr);
252 auto text = record->ConvertToText();
253 EXPECT_EQ(text, htmlText);
254 }
255
256 /**
257 * @tc.name: ConvertToText002
258 * @tc.desc: PasteDataRecord: ConvertToText plainText
259 * @tc.type: FUNC
260 * @tc.require:
261 * @tc.author:
262 */
263 HWTEST_F(PasteDataTest, ConvertToText002, TestSize.Level0)
264 {
265 std::string plainText = "paste record test";
266 auto record = PasteboardClient::GetInstance()->CreatePlainTextRecord(plainText);
267 ASSERT_TRUE(record != nullptr);
268 auto text = record->ConvertToText();
269 EXPECT_EQ(text, plainText);
270 }
271
272 /**
273 * @tc.name: ConvertToText003
274 * @tc.desc: PasteDataRecord: ConvertToText uri
275 * @tc.type: FUNC
276 * @tc.require:
277 * @tc.author:
278 */
279 HWTEST_F(PasteDataTest, ConvertToText003, TestSize.Level0)
280 {
281 OHOS::Uri uri("uri");
282 auto record = PasteboardClient::GetInstance()->CreateUriRecord(uri);
283 ASSERT_TRUE(record != nullptr);
284 auto text = record->ConvertToText();
285 EXPECT_EQ(text, uri.ToString());
286 }
287
288 /**
289 * @tc.name: ConvertToText004
290 * @tc.desc: PasteDataRecord: ConvertToText uri
291 * @tc.type: FUNC
292 * @tc.require:
293 * @tc.author:
294 */
295 HWTEST_F(PasteDataTest, ConvertToText004, TestSize.Level0)
296 {
297 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
298 InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888 };
299 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, 100, opts);
300 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
301 auto record = PasteboardClient::GetInstance()->CreatePixelMapRecord(pixelMapIn);
302 ASSERT_TRUE(record != nullptr);
303 auto text = record->ConvertToText();
304 EXPECT_EQ(text, "");
305 }
306
307 /**
308 * @tc.name: GetPasteDataMsg001
309 * @tc.desc: PasteData: GetPrimaryMimeType is nullptr and so on
310 * @tc.type: FUNC
311 * @tc.require:
312 * @tc.author:
313 */
314 HWTEST_F(PasteDataTest, GetPasteDataMsg001, TestSize.Level0)
315 {
316 std::string plainText1 = "helloWorld";
317 auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText1);
318 ASSERT_TRUE(pasteData != nullptr);
319 auto newPrimaryPixelMap = pasteData->GetPrimaryPixelMap();
320 ASSERT_TRUE(newPrimaryPixelMap == nullptr);
321 auto newPrimaryMimeType = pasteData->GetPrimaryMimeType();
322 ASSERT_TRUE(newPrimaryMimeType != nullptr);
323 auto newPasteData = std::make_shared<PasteData>();
324 auto newPrimaryMimeType2 = newPasteData->GetPrimaryMimeType();
325 ASSERT_TRUE(newPrimaryMimeType2 == nullptr);
326 std::string plainText2 = "plain text";
327 auto record = PasteboardClient::GetInstance()->CreatePlainTextRecord(plainText2);
328 ASSERT_TRUE(record != nullptr);
329 ASSERT_FALSE(pasteData->ReplaceRecordAt(1000, record));
330 }
331
332 /**
333 * @tc.name: GetPasteDataMsg002
334 * @tc.desc: PasteData: GetPrimaryWant is nullptr and so on
335 * @tc.type: FUNC
336 * @tc.require:
337 * @tc.author:
338 */
339 HWTEST_F(PasteDataTest, GetPasteDataMsg002, TestSize.Level0)
340 {
341 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
342 InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888 };
343 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
344 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
345 auto newPasteData = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMapIn);
346 ASSERT_TRUE(newPasteData != nullptr);
347 auto pixMap = newPasteData->GetPrimaryPixelMap();
348 ASSERT_TRUE(pixMap != nullptr);
349 auto primaryWant = newPasteData->GetPrimaryWant();
350 ASSERT_TRUE(primaryWant == nullptr);
351 auto primaryText = newPasteData->GetPrimaryText();
352 ASSERT_TRUE(primaryText == nullptr);
353 auto primaryUri = newPasteData->GetPrimaryUri();
354 ASSERT_TRUE(primaryUri == nullptr);
355 auto record = newPasteData->GetRecordAt(1);
356 ASSERT_TRUE(record == nullptr);
357 auto res1 = newPasteData->RemoveRecordAt(1);
358 ASSERT_FALSE(res1);
359 std::string mimeType = "text/plain";
360 ASSERT_FALSE(newPasteData->HasMimeType(mimeType));
361 }
362
363 /**
364 * @tc.name: ShareOptionToString001
365 * @tc.desc: PasteData: ShareOptionToString
366 * @tc.type: FUNC
367 * @tc.require:
368 * @tc.author:
369 */
370 HWTEST_F(PasteDataTest, ShareOptionToString001, TestSize.Level0)
371 {
372 std::string shareOption1;
373 PasteData::ShareOptionToString(ShareOption::InApp, shareOption1);
374 ASSERT_TRUE(shareOption1 == "InAPP");
375 std::string shareOption2;
376 PasteData::ShareOptionToString(ShareOption::LocalDevice, shareOption2);
377 ASSERT_TRUE(shareOption2 == "LocalDevice");
378 std::string shareOption3;
379 PasteData::ShareOptionToString(ShareOption::CrossDevice, shareOption3);
380 ASSERT_TRUE(shareOption3 == "CrossDevice");
381 }
382
383 /**
384 * @tc.name: SetInvalid001
385 * @tc.desc: PasteData: SetInvalid001
386 * @tc.type: FUNC
387 * @tc.require:
388 * @tc.author:
389 */
390 HWTEST_F(PasteDataTest, SetInvalid001, TestSize.Level0)
391 {
392 bool result = true;
393 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
394 pasteData->SetInvalid();
395 result = pasteData->IsValid();
396 ASSERT_FALSE(result);
397 }
398
399 /**
400 * @tc.name: SetLocalOnly001
401 * @tc.desc: PasteData: SetLocalOnly
402 * @tc.type: FUNC
403 * @tc.require:
404 * @tc.author:
405 */
406 HWTEST_F(PasteDataTest, SetLocalOnly001, TestSize.Level0)
407 {
408 bool result = false;
409 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
410 pasteData->SetLocalOnly(true);
411 result = pasteData->GetLocalOnly();
412 ASSERT_TRUE(result);
413 }
414
415 /**
416 * @tc.name: SetAddition001
417 * @tc.desc: PasteData: SetAddition
418 * @tc.type: FUNC
419 * @tc.require:
420 * @tc.author:
421 */
422 HWTEST_F(PasteDataTest, SetAddition001, TestSize.Level0)
423 {
424 std::string plainText = "plain text";
425 auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
426 size_t fileSize = 0;
427 pasteData->SetAddition(PasteData::REMOTE_FILE_SIZE, AAFwk::Integer::Box(fileSize));
428 AAFwk::WantParams additions;
429 pasteData->SetAdditions(additions);
430 ASSERT_TRUE(pasteData != nullptr);
431 }
432
433 /**
434 * @tc.name: SetRemote001
435 * @tc.desc: PasteData: SetRemote
436 * @tc.type: FUNC
437 * @tc.require:
438 * @tc.author:
439 */
440 HWTEST_F(PasteDataTest, SetRemote001, TestSize.Level0)
441 {
442 bool isRemote = false;
443 std::string plainText = "plain text";
444 auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
445 isRemote = true;
446 pasteData->SetRemote(isRemote);
447 bool result = pasteData->IsRemote();
448 ASSERT_TRUE(result);
449 }
450
451 /**
452 * @tc.name: SetOrginAuthority001
453 * @tc.desc: PasteData: SetOrginAuthority
454 * @tc.type: FUNC
455 * @tc.require:
456 * @tc.author:
457 */
458 HWTEST_F(PasteDataTest, SetOrginAuthority001, TestSize.Level0)
459 {
460 std::string plainText = "plain text";
461 std::string bundleName = "com.example.myapplication";
462 auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
463 pasteData->SetBundleName(bundleName);
464 pasteData->SetOrginAuthority(bundleName);
465 std::string getBundleName = pasteData->GetBundleName();
466 std::string getOrginAuthority = pasteData->GetOrginAuthority();
467 ASSERT_TRUE(getBundleName == bundleName);
468 ASSERT_TRUE(getOrginAuthority == bundleName);
469 std::string time = "2023-08-09";
470 pasteData->SetTime(time);
471 std::string getTime = pasteData->GetTime();
472 ASSERT_TRUE(getTime == time);
473 }
474
475 /**
476 * @tc.name: GetConvertUri001
477 * @tc.desc: PasteDataRecord: GetConvertUri
478 * @tc.type: FUNC
479 * @tc.require:
480 * @tc.author:
481 */
482 HWTEST_F(PasteDataTest, GetConvertUri001, TestSize.Level0)
483 {
484 std::vector<uint8_t> arrayBuffer(46);
485 arrayBuffer = { 2, 7, 6, 8, 9 };
486 std::string mimeType = "image/jpg";
487 auto pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimeType, arrayBuffer);
488 ASSERT_TRUE(pasteDataRecord != nullptr);
489 std::string convertUri_ = "/mnt/hmdfs/";
490 pasteDataRecord->SetConvertUri(convertUri_);
491 std::string result = pasteDataRecord->GetConvertUri();
492 ASSERT_TRUE(result == convertUri_);
493 std::string newUriStr = "/mnt/hmdfs/test";
494 pasteDataRecord->SetUri(std::make_shared<OHOS::Uri>(newUriStr));
495 std::shared_ptr<Uri> uri = pasteDataRecord->GetUri();
496 ASSERT_TRUE(uri != nullptr);
497 std::shared_ptr<Uri> getOriginUri = pasteDataRecord->GetOrginUri();
498 ASSERT_TRUE(getOriginUri != nullptr);
499 }
500
501 /**
502 * @tc.name: GetConvertUri002
503 * @tc.desc: PasteDataRecord: GetConvertUri
504 * @tc.type: FUNC
505 * @tc.require:
506 * @tc.author:
507 */
508 HWTEST_F(PasteDataTest, GetConvertUri002, TestSize.Level0)
509 {
510 std::vector<uint8_t> arrayBuffer(46);
511 arrayBuffer = { 2, 7, 6, 8, 9 };
512 std::string mimeType = "image/jpg";
513 auto pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimeType, arrayBuffer);
514 ASSERT_TRUE(pasteDataRecord != nullptr);
515 std::string convertUri_ = "";
516 pasteDataRecord->SetConvertUri(convertUri_);
517 std::string result = pasteDataRecord->GetConvertUri();
518 ASSERT_TRUE(result == convertUri_);
519 pasteDataRecord->ReplaceShareUri(200);
520 std::string result2 = pasteDataRecord->GetConvertUri();
521 ASSERT_TRUE(result2 == convertUri_);
522 }
523
524 /**
525 * @tc.name: LoadSystemAbilityFail001
526 * @tc.desc: PasteDataRecord: LoadSystemAbilityFail
527 * @tc.type: FUNC
528 * @tc.require:
529 * @tc.author:
530 */
531 HWTEST_F(PasteDataTest, LoadSystemAbilityFail001, TestSize.Level0)
532 {
533 std::vector<uint8_t> arrayBuffer(46);
534 std::string mimeType = "image/jpg";
535 arrayBuffer = { 1, 2, 3, 4, 6 };
536 PasteboardClient::GetInstance()->LoadSystemAbilityFail();
537 auto pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimeType, arrayBuffer);
538 ASSERT_TRUE(pasteDataRecord != nullptr);
539 }
540
541 /**
542 * @tc.name: LoadSystemAbilitySuccess001
543 * @tc.desc: PasteDataRecord: LoadSystemAbilitySuccess
544 * @tc.type: FUNC
545 * @tc.require:
546 * @tc.author:
547 */
548 HWTEST_F(PasteDataTest, LoadSystemAbilitySuccess001, TestSize.Level0)
549 {
550 std::vector<uint8_t> arrayBuffer(46);
551 std::string mimeType = "image/jpg";
552 arrayBuffer = { 1, 2, 3, 4, 6 };
553 sptr<IRemoteObject> remoteObject = nullptr;
554 PasteboardClient::GetInstance()->LoadSystemAbilitySuccess(remoteObject);
555 auto pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimeType, arrayBuffer);
556 ASSERT_TRUE(pasteDataRecord != nullptr);
557 }
558
559 /**
560 * @tc.name: SetInterval001
561 * @tc.desc: BlockObject: SetInterval
562 * @tc.type: FUNC
563 * @tc.require:
564 * @tc.author:
565 */
566 HWTEST_F(PasteDataTest, SetInterval001, TestSize.Level0)
567 {
568 uint32_t POPUP_INTERVAL = 1;
569 auto block = std::make_shared<BlockObject<std::shared_ptr<PasteData>>>(POPUP_INTERVAL);
570 std::shared_ptr<PasteData> pasteData = std::make_shared<PasteData>();
571 block->SetValue(pasteData);
572 block->SetInterval(POPUP_INTERVAL);
573 auto value = block->GetValue();
574 EXPECT_TRUE(value != nullptr);
575 }
576
577 /**
578 * @tc.name: ClipPlugin001
579 * @tc.desc: API_EXPORT: ClipPlugin
580 * @tc.type: FUNC
581 * @tc.require:
582 * @tc.author:
583 */
584 HWTEST_F(PasteDataTest, ClipPlugin001, TestSize.Level0)
585 {
586 std::string PLUGIN_NAME_VAL = "distributed_clip";
__anon70ced37d0102(ClipPlugin *plugin) 587 auto release = [&PLUGIN_NAME_VAL, this](ClipPlugin *plugin) {
588 ClipPlugin::DestroyPlugin(PLUGIN_NAME_VAL, plugin);
589 };
590 auto clipPlugin_ = std::shared_ptr<ClipPlugin>(ClipPlugin::CreatePlugin(PLUGIN_NAME_VAL), release);
591 ClipPlugin::Factory *factory = nullptr;
592 auto result = ClipPlugin::RegCreator(PLUGIN_NAME_VAL, factory);
593 EXPECT_TRUE(result);
594 auto userId = 10000;
595 auto events1 = clipPlugin_->GetTopEvents(1, userId);
596 EXPECT_TRUE(events1.size() == 0);
597 auto events2 = clipPlugin_->GetTopEvents(1);
598 EXPECT_TRUE(events2.size() == 0);
599 clipPlugin_->Clear();
600 clipPlugin_->Clear(userId);
601 }
602
603 /**
604 * @tc.name: ClipPlugin002
605 * @tc.desc: API_EXPORT: ClipPlugin
606 * @tc.type: FUNC
607 * @tc.require:
608 * @tc.author:
609 */
610 HWTEST_F(PasteDataTest, ClipPlugin002, TestSize.Level0)
611 {
612 std::string PLUGIN_NAME_VAL = "distributed_clip";
__anon70ced37d0202(ClipPlugin *plugin) 613 auto release = [&PLUGIN_NAME_VAL, this](ClipPlugin *plugin) {
614 ClipPlugin::DestroyPlugin(PLUGIN_NAME_VAL, plugin);
615 };
616 auto clipPlugin_ = std::shared_ptr<ClipPlugin>(ClipPlugin::CreatePlugin(PLUGIN_NAME_VAL), release);
617 ClipPlugin::Factory *factory = new ClipFactory();
618 auto result = ClipPlugin::RegCreator(PLUGIN_NAME_VAL, factory);
619 EXPECT_FALSE(result);
620 auto userId = 3701;
621 auto events1 = clipPlugin_->GetTopEvents(1, userId);
622 EXPECT_TRUE(events1.size() == 0);
623 clipPlugin_->Clear(userId);
624 }
625 } // namespace OHOS::MiscServices