• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021-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 #include <chrono>
16 #include <cstdint>
17 #include <gtest/gtest.h>
18 #include <thread>
19 #include <unistd.h>
20 #include <vector>
21 #include <iservice_registry.h>
22 
23 #include "access_token.h"
24 #include "accesstoken_kit.h"
25 #include "hap_token_info.h"
26 #include "os_account_manager.h"
27 #include "pasteboard_client.h"
28 #include "pasteboard_error.h"
29 #include "pasteboard_hilog.h"
30 #include "pasteboard_observer_callback.h"
31 #include "permission_state_full.h"
32 #include "pixel_map.h"
33 #include "token_setproc.h"
34 #include "uri.h"
35 #include "want.h"
36 
37 namespace OHOS::MiscServices {
38 using namespace testing::ext;
39 using namespace OHOS::Media;
40 using namespace OHOS::Security::AccessToken;
41 constexpr const char *CMD = "hidumper -s 3701 -a --data";
42 constexpr const uint16_t EACH_LINE_LENGTH = 50;
43 constexpr const uint16_t TOTAL_LENGTH = 500;
44 constexpr const int32_t EDM_UID = 3057;
45 const uint64_t SYSTEM_APP_MASK = (static_cast<uint64_t>(1) << 32);
46 std::string g_webviewPastedataTag = "WebviewPasteDataTag";
47 class PasteboardServiceTest : public testing::Test {
48 public:
49     static void SetUpTestCase(void);
50     static void TearDownTestCase(void);
51     void SetUp();
52     void TearDown();
53     static bool ExecuteCmd(std::string &result);
54 
55     static void AllocTestAppTokenId();
56     static void DeleteTestTokenId();
57     static void RestoreSelfTokenId();
58     static void CommonTest(PasteData &oldPasteData, PasteData &newPasteData);
59     static sptr<PasteboardObserver> pasteboardObserver_;
60     static sptr<PasteboardObserver> pasteboardEventObserver_;
61     static std::atomic_bool pasteboardChangedFlag_;
62     static std::atomic_int32_t pasteboardEventStatus_;
63     static uint64_t selfTokenId_;
64     static AccessTokenID testAppTokenId_;
65 };
66 std::atomic_bool PasteboardServiceTest::pasteboardChangedFlag_ = false;
67 std::atomic_int32_t PasteboardServiceTest::pasteboardEventStatus_ = -1;
68 sptr<PasteboardObserver> PasteboardServiceTest::pasteboardObserver_ = nullptr;
69 sptr<PasteboardObserver> PasteboardServiceTest::pasteboardEventObserver_ = nullptr;
70 uint64_t PasteboardServiceTest::selfTokenId_ = 0;
71 AccessTokenID PasteboardServiceTest::testAppTokenId_ = 0;
72 
SetUpTestCase(void)73 void PasteboardServiceTest::SetUpTestCase(void)
74 {
75     selfTokenId_ = GetSelfTokenID();
76     AllocTestAppTokenId();
77 }
78 
TearDownTestCase(void)79 void PasteboardServiceTest::TearDownTestCase(void)
80 {
81     DeleteTestTokenId();
82 }
83 
SetUp(void)84 void PasteboardServiceTest::SetUp(void) { }
85 
TearDown(void)86 void PasteboardServiceTest::TearDown(void)
87 {
88     if (PasteboardServiceTest::pasteboardObserver_ != nullptr) {
89         PasteboardClient::GetInstance()->RemovePasteboardEventObserver(PasteboardServiceTest::pasteboardObserver_);
90     }
91     if (PasteboardServiceTest::pasteboardEventObserver_ != nullptr) {
92         PasteboardClient::GetInstance()->RemovePasteboardEventObserver(PasteboardServiceTest::pasteboardEventObserver_);
93     }
94     PasteboardClient::GetInstance()->Clear();
95     PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "TearDown.");
96 }
97 
OnPasteboardChanged()98 void PasteboardObserverCallback::OnPasteboardChanged()
99 {
100     PasteboardServiceTest::pasteboardChangedFlag_ = true;
101     PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "test changed callback.");
102 }
103 
OnPasteboardEvent(std::string bundleName,int32_t status)104 void PasteboardEventObserverCallback::OnPasteboardEvent(std::string bundleName, int32_t status)
105 {
106     PasteboardServiceTest::pasteboardEventStatus_ = status;
107     PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "test event callback bundleName: %{public}s,status:%{public}d",
108         bundleName.c_str(), status);
109 }
110 
ExecuteCmd(std::string & result)111 bool PasteboardServiceTest::ExecuteCmd(std::string &result)
112 {
113     char buff[EACH_LINE_LENGTH] = { 0x00 };
114     char output[TOTAL_LENGTH] = { 0x00 };
115     FILE *ptr = nullptr;
116     if ((ptr = popen(CMD, "r")) != nullptr) {
117         while (fgets(buff, sizeof(buff), ptr) != nullptr) {
118             if (strcat_s(output, sizeof(output), buff) != 0) {
119                 pclose(ptr);
120                 ptr = nullptr;
121                 return false;
122             }
123         }
124         pclose(ptr);
125         ptr = nullptr;
126     } else {
127         return false;
128     }
129     result = std::string(output);
130     return true;
131 }
132 
AllocTestAppTokenId()133 void PasteboardServiceTest::AllocTestAppTokenId()
134 {
135     HapInfoParams infoParams = { .userID = EDM_UID,
136         .bundleName = "ohos.privacy_test.pasteboard",
137         .instIndex = 0,
138         .appIDDesc = "privacy_test.pasteboard" };
139     PermissionStateFull testState = { .permissionName = "ohos.permission.MANAGE_PASTEBOARD_APP_SHARE_OPTION",
140         .isGeneral = true,
141         .resDeviceID = { "local" },
142         .grantStatus = { PermissionState::PERMISSION_GRANTED },
143         .grantFlags = { 1 } };
144     HapPolicyParams policyParams = { .apl = APL_NORMAL,
145         .domain = "test.domain.pasteboard",
146         .permList = {},
147         .permStateList = { testState } };
148 
149     AccessTokenKit::AllocHapToken(infoParams, policyParams);
150     testAppTokenId_ = Security::AccessToken::AccessTokenKit::GetHapTokenID(
151         infoParams.userID, infoParams.bundleName, infoParams.instIndex);
152     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_SERVICE, "userID = %{public}d, testTokenId = 0x%{public}x.", infoParams.userID,
153         testAppTokenId_);
154 }
155 
DeleteTestTokenId()156 void PasteboardServiceTest::DeleteTestTokenId()
157 {
158     AccessTokenKit::DeleteToken(testAppTokenId_);
159 }
160 
RestoreSelfTokenId()161 void PasteboardServiceTest::RestoreSelfTokenId()
162 {
163     auto ret = SetSelfTokenID(selfTokenId_);
164     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_SERVICE, "ret = %{public}d!", ret);
165 }
166 
CommonTest(PasteData & oldPasteData,PasteData & newPasteData)167 void PasteboardServiceTest::CommonTest(PasteData &oldPasteData, PasteData &newPasteData)
168 {
169     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_SERVICE, "start.");
170     PasteboardClient::GetInstance()->Clear();
171     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
172     ASSERT_TRUE(hasPasteData != true);
173     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(oldPasteData);
174     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
175     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
176     ASSERT_TRUE(hasPasteData == true);
177     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
178     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
179     PASTEBOARD_HILOGD(PASTEBOARD_MODULE_SERVICE, "end.");
180 }
181 
GetTime()182 string GetTime()
183 {
184     time_t curtime;
185     time(&curtime);
186     tm *nowtime = localtime(&curtime);
187     std::string targetTime = std::to_string(1900 + nowtime->tm_year) + "-" + std::to_string(1 + nowtime->tm_mon) + "-" +
188         std::to_string(nowtime->tm_mday) + " " + std::to_string(nowtime->tm_hour) + ":" +
189         std::to_string(nowtime->tm_min) + ":" + std::to_string(nowtime->tm_sec);
190     return targetTime;
191 }
192 
193 /**
194  * @tc.name: PasteboardTest001
195  * @tc.desc: Create paste board test.
196  * @tc.type: FUNC
197  */
198 HWTEST_F(PasteboardServiceTest, PasteboardTest001, TestSize.Level0)
199 {
200     auto record = PasteboardClient::GetInstance()->CreatePlainTextRecord("paste record1");
201     ASSERT_TRUE(record != nullptr);
202     std::string plainText = "plain text";
203     auto data = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
204     ASSERT_TRUE(data != nullptr);
205     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
206     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
207     auto has = PasteboardClient::GetInstance()->HasPasteData();
208     ASSERT_TRUE(has == true);
209     PasteData pasteData;
210     ret = PasteboardClient::GetInstance()->GetPasteData(pasteData);
211     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
212     PASTEBOARD_HILOGI(PASTEBOARD_MODULE_SERVICE, "get.");
213     auto primaryText = pasteData.GetPrimaryText();
214     ASSERT_TRUE(primaryText != nullptr);
215     ASSERT_TRUE(*primaryText == plainText);
216 }
217 
218 /**
219  * @tc.name: PasteRecordTest001
220  * @tc.desc: Create paste board record test.
221  * @tc.type: FUNC
222  */
223 HWTEST_F(PasteboardServiceTest, PasteRecordTest001, TestSize.Level0)
224 {
225     std::string plainText = "helloWorld";
226     auto record = PasteboardClient::GetInstance()->CreatePlainTextRecord(plainText);
227     ASSERT_TRUE(record != nullptr);
228     auto newPlainText = record->GetPlainText();
229     ASSERT_TRUE(newPlainText != nullptr);
230     ASSERT_TRUE(*newPlainText == plainText);
231 }
232 
233 /**
234  * @tc.name: PasteRecordTest002
235  * @tc.desc: Create paste board record test.
236  * @tc.type: FUNC
237  */
238 HWTEST_F(PasteboardServiceTest, PasteRecordTest002, TestSize.Level0)
239 {
240     std::string htmlText = "<div class='disabled item tip user-programs'>";
241     auto record = PasteboardClient::GetInstance()->CreateHtmlTextRecord(htmlText);
242     ASSERT_TRUE(record != nullptr);
243     auto newHtmlText = record->GetHtmlText();
244     ASSERT_TRUE(newHtmlText != nullptr);
245     ASSERT_TRUE(*newHtmlText == htmlText);
246 }
247 
248 /**
249  * @tc.name: PasteRecordTest003
250  * @tc.desc: Create paste board record test.
251  * @tc.type: FUNC
252  */
253 HWTEST_F(PasteboardServiceTest, PasteRecordTest003, TestSize.Level0)
254 {
255     using namespace OHOS::AAFwk;
256     std::shared_ptr<Want> want = std::make_shared<Want>();
257     std::string key = "id";
258     int32_t id = 456;
259     Want wantIn = want->SetParam(key, id);
260     auto record = PasteboardClient::GetInstance()->CreateWantRecord(want);
261     ASSERT_TRUE(record != nullptr);
262     auto newWant = record->GetWant();
263     ASSERT_TRUE(newWant != nullptr);
264     int32_t defaultValue = 333;
265     ASSERT_TRUE(newWant->GetIntParam(key, defaultValue) == id);
266 }
267 
268 /**
269  * @tc.name: PasteRecordTest004
270  * @tc.desc: Create paste board record test.
271  * @tc.type: FUNC
272  */
273 HWTEST_F(PasteboardServiceTest, PasteRecordTest004, TestSize.Level0)
274 {
275     OHOS::Uri uri("uri");
276     auto record = PasteboardClient::GetInstance()->CreateUriRecord(uri);
277     ASSERT_TRUE(record != nullptr);
278     auto newUri = record->GetUri();
279     ASSERT_TRUE(newUri != nullptr);
280     ASSERT_TRUE(newUri->ToString() == uri.ToString());
281 }
282 
283 /**
284  * @tc.name: PasteRecordTest005
285  * @tc.desc: Create paste board record test.
286  * @tc.type: FUNC
287  * @tc.require: AR000H5GKU
288  */
289 HWTEST_F(PasteboardServiceTest, PasteRecordTest005, TestSize.Level0)
290 {
291     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
292     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
293     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, 100, opts);
294     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
295     auto pasteDataRecord = PasteboardClient::GetInstance()->CreatePixelMapRecord(pixelMapIn);
296     ASSERT_TRUE(pasteDataRecord != nullptr);
297     auto newPixelMap = pasteDataRecord->GetPixelMap();
298     ASSERT_TRUE(newPixelMap != nullptr);
299     ImageInfo imageInfo = {};
300     newPixelMap->GetImageInfo(imageInfo);
301     ASSERT_TRUE(imageInfo.size.height == opts.size.height);
302     ASSERT_TRUE(imageInfo.size.width == opts.size.width);
303     ASSERT_TRUE(imageInfo.pixelFormat == opts.pixelFormat);
304     pasteDataRecord->ClearPixelMap();
305     ASSERT_TRUE(pasteDataRecord->GetPixelMap() == nullptr);
306 }
307 
308 /**
309  * @tc.name: PasteRecordTest006
310  * @tc.desc: Create paste board record test.
311  * @tc.type: FUNC
312  * @tc.require: AR000H5GKU
313  */
314 HWTEST_F(PasteboardServiceTest, PasteRecordTest006, TestSize.Level0)
315 {
316     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
317     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
318     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
319     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
320     auto pasteDataRecord = PasteboardClient::GetInstance()->CreatePixelMapRecord(pixelMapIn);
321     ASSERT_TRUE(pasteDataRecord != nullptr);
322     InitializationOptions opts1 = { { 6, 9 }, PixelFormat::RGB_565, PixelFormat::RGB_565 };
323     std::unique_ptr<PixelMap> pixelMap1 = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts1);
324     std::shared_ptr<PixelMap> pixelMapIn1 = move(pixelMap1);
325     pasteDataRecord = pasteDataRecord->NewPixelMapRecord(pixelMapIn1);
326     ASSERT_TRUE(pasteDataRecord != nullptr);
327     auto newPixelMap = pasteDataRecord->GetPixelMap();
328     ASSERT_TRUE(newPixelMap != nullptr);
329     ImageInfo imageInfo = {};
330     newPixelMap->GetImageInfo(imageInfo);
331     ASSERT_TRUE(imageInfo.size.height == opts1.size.height);
332     ASSERT_TRUE(imageInfo.size.width == opts1.size.width);
333     ASSERT_TRUE(imageInfo.pixelFormat == opts1.pixelFormat);
334 }
335 
336 /**
337  * @tc.name: PasteRecordTest007
338  * @tc.desc: Create paste board record test.
339  * @tc.type: FUNC
340  * @tc.require: AR000HEECD
341  */
342 HWTEST_F(PasteboardServiceTest, PasteRecordTest007, TestSize.Level0)
343 {
344     std::vector<uint8_t> arrayBuffer(46);
345     arrayBuffer = { 2, 7, 6, 8, 9 };
346     std::string mimeType = "image/jpg";
347     auto pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimeType, arrayBuffer);
348     ASSERT_TRUE(pasteDataRecord != nullptr);
349     auto customData = pasteDataRecord->GetCustomData();
350     ASSERT_TRUE(customData != nullptr);
351     auto itemData = customData->GetItemData();
352     ASSERT_TRUE(itemData.size() == 1);
353     auto item = itemData.find(mimeType);
354     ASSERT_TRUE(item != itemData.end());
355     ASSERT_TRUE(item->second == arrayBuffer);
356 }
357 
358 /**
359  * @tc.name: PasteRecordTest008
360  * @tc.desc: Create paste board record test.
361  * @tc.type: FUNC
362  * @tc.require: AR000HEECD
363  */
364 HWTEST_F(PasteboardServiceTest, PasteRecordTest008, TestSize.Level0)
365 {
366     std::vector<uint8_t> arrayBuffer(46);
367     arrayBuffer = { 2, 7, 6, 8, 9 };
368     std::string mimeType = "image/jpg";
369     auto pasteDataRecord = PasteboardClient::GetInstance()->CreateKvRecord(mimeType, arrayBuffer);
370     ASSERT_TRUE(pasteDataRecord != nullptr);
371     std::string mimeType1 = "img/png";
372     std::vector<uint8_t> arrayBuffer1(46);
373     arrayBuffer1 = { 2, 7, 6, 8, 9 };
374     pasteDataRecord = pasteDataRecord->NewKvRecord(mimeType1, arrayBuffer1);
375     auto customData = pasteDataRecord->GetCustomData();
376     ASSERT_TRUE(customData != nullptr);
377     auto itemData = customData->GetItemData();
378     ASSERT_TRUE(itemData.size() == 1);
379     auto item = itemData.find(mimeType1);
380     ASSERT_TRUE(item != itemData.end());
381     ASSERT_TRUE(item->second == arrayBuffer1);
382 }
383 
384 /**
385  * @tc.name: PasteRecordTest009
386  * @tc.desc: Create paste board html local url
387  * @tc.type: FUNC
388  */
389 HWTEST_F(PasteboardServiceTest, PasteRecordTest009, TestSize.Level0)
390 {
391     std::string htmlText = "<div class='item'><img data-ohos='clipboard' "
392                            "src='file:///com.example.webview/data/storage/el1/base/test.png'></div>";
393     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
394     ASSERT_TRUE(data != nullptr);
395     data->SetTag(g_webviewPastedataTag);
396     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
397     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
398     auto has = PasteboardClient::GetInstance()->HasPasteData();
399     ASSERT_TRUE(has == true);
400     PasteData newPasteData;
401     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
402     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
403     auto record = newPasteData.GetPrimaryHtml();
404     ASSERT_TRUE(record != nullptr);
405 }
406 
407 /**
408  * @tc.name: PasteRecordTest0010
409  * @tc.desc: Create paste board html distributed uri.
410  * @tc.type: FUNC
411  */
412 HWTEST_F(PasteboardServiceTest, PasteRecordTest0010, TestSize.Level0)
413 {
414     std::string htmlText = "<div class='item'><img data-ohos='clipboard' "
415                            "src='file://com.byy.testdpb/data/storage/el2/distributedfiles/"
416                            ".remote_share/data/storage/el2/base/haps/entry/cache/t1.jpg'></div>";
417     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
418     ASSERT_TRUE(data != nullptr);
419     data->SetTag(g_webviewPastedataTag);
420     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
421     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
422     auto has = PasteboardClient::GetInstance()->HasPasteData();
423     ASSERT_TRUE(has == true);
424     PasteData newPasteData2;
425     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData2);
426     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
427     auto record = newPasteData2.GetPrimaryHtml();
428     ASSERT_TRUE(record != nullptr);
429     ASSERT_TRUE(*record == htmlText);
430 }
431 
432 /**
433  * @tc.name: PasteRecordTest0011
434  * @tc.desc: Create paste board html distributed uri.
435  * @tc.type: FUNC
436  */
437 HWTEST_F(PasteboardServiceTest, PasteRecordTest0011, TestSize.Level0)
438 {
439     std::string htmlText = "<div class='item'><img "
440                            "src='file://com.byy.testdpb/data/storage/el2/distributedfiles/"
441                            ".remote_share/data/storage/el2/base/haps/entry/cache/t1.jpg'></div>";
442     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
443     ASSERT_TRUE(data != nullptr);
444     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
445     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
446     auto has = PasteboardClient::GetInstance()->HasPasteData();
447     ASSERT_TRUE(has == true);
448     PasteData newPasteData2;
449     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData2);
450     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
451     auto record = newPasteData2.GetPrimaryHtml();
452     ASSERT_TRUE(record != nullptr);
453     ASSERT_TRUE(*record == htmlText);
454 }
455 
456 /**
457  * @tc.name: PasteRecordTest0012
458  * @tc.desc: Create paste board html local url
459  * @tc.type: FUNC
460  */
461 HWTEST_F(PasteboardServiceTest, PasteRecordTest0012, TestSize.Level0)
462 {
463     std::string htmlText = "<div class='item'><img data-ohos='clipboard' "
464                            "src='file:///com.example.webview/data/storage/el1/base/test.png'></div>";
465     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
466     ASSERT_TRUE(data != nullptr);
467     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
468     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
469     auto has = PasteboardClient::GetInstance()->HasPasteData();
470     ASSERT_TRUE(has == true);
471     PasteData newPasteData;
472     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
473     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
474     auto record = newPasteData.GetPrimaryHtml();
475     ASSERT_TRUE(record != nullptr);
476 }
477 
478 /**
479  * @tc.name: PasteRecordTest0013
480  * @tc.desc: Create paste board html local docs uri
481  * @tc.type: FUNC
482  */
483 HWTEST_F(PasteboardServiceTest, PasteRecordTest0013, TestSize.Level0)
484 {
485     std::string htmlTextIn = "<div class='item'><img data-ohos='clipboard' "
486                              "src='file:///docs/storage/Users/currentUser/VMDocs/test.png'></div>";
487     std::string htmlTextOut = "<div class='item'><img data-ohos='clipboard' "
488                               "src='file:///storage/Users/currentUser/VMDocs/test.png'></div>";
489     std::string rk3568Out = "<div class='item'><img data-ohos='clipboard' "
490                             "src='file:///data/storage/el2/share/r/docs/"
491                             "storage/Users/currentUser/VMDocs/test.png'></div>";
492     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlTextIn);
493     ASSERT_TRUE(data != nullptr);
494     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
495     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
496     auto has = PasteboardClient::GetInstance()->HasPasteData();
497     ASSERT_TRUE(has == true);
498     PasteData newPasteData;
499     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
500     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
501     auto record = newPasteData.GetPrimaryHtml();
502     ASSERT_TRUE(record != nullptr);
503     ASSERT_TRUE(*record == htmlTextOut || *record == rk3568Out);
504 }
505 
506 /**
507  * @tc.name: PasteRecordTest0014
508  * @tc.desc: Create paste board html local docs uri
509  * @tc.type: FUNC
510  */
511 HWTEST_F(PasteboardServiceTest, PasteRecordTest0014, TestSize.Level0)
512 {
513     std::string htmlTextIn = "<div class='item'><img data-ohos='clipboard' "
514                              "src='file:///docs/storage/Users/currentUser/VMDocs/test.png'></div>";
515     std::string htmlUriOut = "file://docs/storage/Users/currentUser/VMDocs/test.png";
516     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlTextIn);
517     ASSERT_TRUE(data != nullptr);
518     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
519     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
520     auto has = PasteboardClient::GetInstance()->HasPasteData();
521     ASSERT_TRUE(has == true);
522 
523     sptr<IPasteboardService> pasteboardServiceProxy_;
524     sptr<ISystemAbilityManager> samgrProxy = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
525     ASSERT_TRUE(samgrProxy != nullptr);
526     const int32_t pasteboardServiceId = 3701;
527     sptr<IRemoteObject> remoteObject = samgrProxy->CheckSystemAbility(pasteboardServiceId);
528     ASSERT_TRUE(remoteObject != nullptr);
529     pasteboardServiceProxy_ = iface_cast<IPasteboardService>(remoteObject);
530     ASSERT_TRUE(pasteboardServiceProxy_ != nullptr);
531 
532     PasteData pasteData;
533     int32_t syncTime = 0;
534     int32_t res = pasteboardServiceProxy_->GetPasteData(pasteData, syncTime);
535     ASSERT_TRUE(res == static_cast<int32_t>(PasteboardError::E_OK));
536     std::string htmlUriConvert = "";
537     for (auto &item : pasteData.AllRecords()) {
538         if (item != nullptr) {
539             std::shared_ptr<Uri> uri = item->GetUri();
540             if (uri != nullptr) {
541                 htmlUriConvert = uri->ToString();
542             }
543         }
544     }
545     ASSERT_TRUE(htmlUriConvert == htmlUriOut);
546 }
547 
548 /**
549  * @tc.name: PasteDataTest001
550  * @tc.desc: Create paste board data test.
551  * @tc.type: FUNC
552  */
553 HWTEST_F(PasteboardServiceTest, PasteDataTest001, TestSize.Level0)
554 {
555     using namespace OHOS::AAFwk;
556     std::shared_ptr<Want> want = std::make_shared<Want>();
557     std::string key = "id";
558     int32_t id = 456;
559     Want wantIn = want->SetParam(key, id);
560     auto data = PasteboardClient::GetInstance()->CreateWantData(std::make_shared<Want>(wantIn));
561     ASSERT_TRUE(data != nullptr);
562     PasteboardClient::GetInstance()->Clear();
563     auto has = PasteboardClient::GetInstance()->HasPasteData();
564     ASSERT_TRUE(has != true);
565     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
566     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
567     has = PasteboardClient::GetInstance()->HasPasteData();
568     ASSERT_TRUE(has == true);
569     PasteData pasteData;
570     ret = PasteboardClient::GetInstance()->GetPasteData(pasteData);
571     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
572     auto record = pasteData.GetPrimaryWant();
573     ASSERT_TRUE(record != nullptr);
574     int32_t defaultValue = 333;
575     ASSERT_TRUE(record->GetIntParam(key, defaultValue) == id);
576 }
577 
578 /**
579  * @tc.name: PasteDataTest002
580  * @tc.desc: Create paste board data test.
581  * @tc.type: FUNC
582  */
583 HWTEST_F(PasteboardServiceTest, PasteDataTest002, TestSize.Level0)
584 {
585     OHOS::Uri uri("uri");
586     auto data = PasteboardClient::GetInstance()->CreateUriData(uri);
587     ASSERT_TRUE(data != nullptr);
588     PasteboardClient::GetInstance()->Clear();
589     auto has = PasteboardClient::GetInstance()->HasPasteData();
590     ASSERT_TRUE(has != true);
591     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
592     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
593     has = PasteboardClient::GetInstance()->HasPasteData();
594     ASSERT_TRUE(has == true);
595     PasteData pasteData;
596     ret = PasteboardClient::GetInstance()->GetPasteData(pasteData);
597     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
598     auto record = pasteData.GetPrimaryUri();
599     ASSERT_TRUE(record != nullptr);
600     ASSERT_TRUE(record->ToString() == uri.ToString());
601 }
602 
603 /**
604  * @tc.name: PasteDataTest003
605  * @tc.desc: Create paste board data test.
606  * @tc.type: FUNC
607  */
608 HWTEST_F(PasteboardServiceTest, PasteDataTest003, TestSize.Level0)
609 {
610     std::string text = "plain text";
611     auto data = PasteboardClient::GetInstance()->CreatePlainTextData(text);
612     ASSERT_TRUE(data != nullptr);
613     PasteboardClient::GetInstance()->Clear();
614     auto has = PasteboardClient::GetInstance()->HasPasteData();
615     ASSERT_TRUE(has != true);
616     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
617     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
618     has = PasteboardClient::GetInstance()->HasPasteData();
619     ASSERT_TRUE(has == true);
620     PasteData pasteData;
621     ret = PasteboardClient::GetInstance()->GetPasteData(pasteData);
622     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
623     auto record = pasteData.GetPrimaryText();
624     ASSERT_TRUE(record != nullptr);
625     ASSERT_TRUE(*record == text);
626 }
627 
628 /**
629  * @tc.name: PasteDataTest004
630  * @tc.desc: Create paste board data test.
631  * @tc.type: FUNC
632  */
633 HWTEST_F(PasteboardServiceTest, PasteDataTest004, TestSize.Level0)
634 {
635     std::string htmlText = "<div class='disabled item tip user-programs'>";
636     auto data = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
637     ASSERT_TRUE(data != nullptr);
638     PasteboardClient::GetInstance()->Clear();
639     auto has = PasteboardClient::GetInstance()->HasPasteData();
640     ASSERT_TRUE(has != true);
641     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*data);
642     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
643     has = PasteboardClient::GetInstance()->HasPasteData();
644     ASSERT_TRUE(has == true);
645     PasteData pasteData;
646     ret = PasteboardClient::GetInstance()->GetPasteData(pasteData);
647     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
648     auto record = pasteData.GetPrimaryHtml();
649     ASSERT_TRUE(record != nullptr);
650     ASSERT_TRUE(*record == htmlText);
651 }
652 
653 /**
654  * @tc.name: PasteDataTest005
655  * @tc.desc: CreateHtmlData test.
656  * @tc.type: FUNC
657  * @tc.require: AR000HEECD
658  */
659 HWTEST_F(PasteboardServiceTest, PasteDataTest005, TestSize.Level0)
660 {
661     std::string htmlText = "<div class='disabled item tip user-programs'>";
662     auto pasteData = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
663     ASSERT_TRUE(pasteData != nullptr);
664     std::string plainText = "plain text";
665     PasteDataRecord::Builder builder(MIMETYPE_TEXT_HTML);
666     std::string mimeType = MIMETYPE_TEXT_PLAIN;
667     std::vector<uint8_t> arrayBuffer(46);
668     arrayBuffer = { 2, 7, 6, 8, 9 };
669     std::string mimeType1 = "image/jpg";
670     std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
671     customData->AddItemData(mimeType1, arrayBuffer);
672     std::shared_ptr<PasteDataRecord> pasteDataRecord = builder.SetMimeType(mimeType)
673                                                            .SetPlainText(std::make_shared<std::string>(plainText))
674                                                            .SetHtmlText(std::make_shared<std::string>(htmlText))
675                                                            .SetCustomData(customData)
676                                                            .Build();
677     pasteData->AddRecord(pasteDataRecord);
678     PasteData newPasteData;
679     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
680     auto primaryHtml = newPasteData.GetPrimaryHtml();
681     ASSERT_TRUE(primaryHtml != nullptr);
682     ASSERT_TRUE(*primaryHtml == htmlText);
683     auto firstRecord = newPasteData.GetRecordAt(0);
684     ASSERT_TRUE(firstRecord != nullptr);
685     ASSERT_TRUE(firstRecord->GetMimeType() == mimeType);
686     auto newPlainText = firstRecord->GetPlainText();
687     ASSERT_TRUE(newPlainText != nullptr);
688     ASSERT_TRUE(*newPlainText == plainText);
689     auto newHtmlText = firstRecord->GetHtmlText();
690     ASSERT_TRUE(newHtmlText != nullptr);
691     ASSERT_TRUE(*newHtmlText == htmlText);
692     customData = pasteDataRecord->GetCustomData();
693     ASSERT_TRUE(customData != nullptr);
694     auto itemData = customData->GetItemData();
695     ASSERT_TRUE(itemData.size() == 1);
696     auto item = itemData.find(mimeType1);
697     ASSERT_TRUE(item != itemData.end());
698     ASSERT_TRUE(item->second == arrayBuffer);
699 }
700 
701 /**
702  * @tc.name: PasteDataTest006
703  * @tc.desc: CreatePlainTextData test.
704  * @tc.type: FUNC
705  */
706 HWTEST_F(PasteboardServiceTest, PasteDataTest006, TestSize.Level0)
707 {
708     using namespace OHOS::AAFwk;
709     std::string plainText = "helloWorld";
710     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
711     ASSERT_TRUE(pasteData != nullptr);
712     std::shared_ptr<Want> want = std::make_shared<Want>();
713     std::string key = "id";
714     int32_t id = 456;
715     Want wantIn = want->SetParam(key, id);
716     PasteDataRecord::Builder builder(MIMETYPE_TEXT_WANT);
717     std::shared_ptr<PasteDataRecord> pasteDataRecord =
718         builder.SetWant(std::make_shared<Want>(wantIn)).SetPlainText(std::make_shared<std::string>(plainText)).Build();
719     pasteData->AddRecord(pasteDataRecord);
720     PasteData newPasteData;
721     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
722     auto firstRecord = newPasteData.GetRecordAt(0);
723     ASSERT_TRUE(firstRecord != nullptr);
724     ASSERT_TRUE(firstRecord->GetMimeType() == MIMETYPE_TEXT_WANT);
725     auto newWant = firstRecord->GetWant();
726     ASSERT_TRUE(newWant != nullptr);
727     int32_t defaultValue = 333;
728     ASSERT_TRUE(newWant->GetIntParam(key, defaultValue) == id);
729     auto newPlainText = firstRecord->GetPlainText();
730     ASSERT_TRUE(newPlainText != nullptr);
731     ASSERT_TRUE(*newPlainText == plainText);
732 }
733 
734 /**
735  * @tc.name: PasteDataTest007
736  * @tc.desc: PixelMap test.
737  * @tc.type: FUNC
738  * @tc.require: AR000H5GKU
739  */
740 HWTEST_F(PasteboardServiceTest, PasteDataTest007, TestSize.Level0)
741 {
742     std::string htmlText = "<div class='disabled item tip user-programs'>";
743     auto pasteData = PasteboardClient::GetInstance()->CreateHtmlData(htmlText);
744     ASSERT_TRUE(pasteData != nullptr);
745     OHOS::Uri uri("uri");
746     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
747     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
748     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
749     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
750     PasteDataRecord::Builder builder(MIMETYPE_TEXT_URI);
751     std::shared_ptr<PasteDataRecord> pasteDataRecord =
752         builder.SetUri(std::make_shared<OHOS::Uri>(uri)).SetPixelMap(pixelMapIn).Build();
753     pasteData->AddRecord(pasteDataRecord);
754     PasteData newPasteData;
755     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
756     auto firstRecord = newPasteData.GetRecordAt(0);
757     ASSERT_TRUE(firstRecord != nullptr);
758     ASSERT_TRUE(firstRecord->GetMimeType() == MIMETYPE_TEXT_URI);
759     auto newUri = firstRecord->GetUri();
760     ASSERT_TRUE(newUri != nullptr);
761     ASSERT_TRUE(newUri->ToString() == uri.ToString());
762     auto newPixelMap = firstRecord->GetPixelMap();
763     ASSERT_TRUE(newPixelMap != nullptr);
764     ImageInfo imageInfo = {};
765     newPixelMap->GetImageInfo(imageInfo);
766     ASSERT_TRUE(imageInfo.size.height == opts.size.height);
767     ASSERT_TRUE(imageInfo.size.width == opts.size.width);
768     ASSERT_TRUE(imageInfo.pixelFormat == opts.pixelFormat);
769 }
770 
771 /**
772  * @tc.name: PasteDataTest008
773  * @tc.desc: Create paste board data test.
774  * @tc.type: FUNC
775  * @tc.require: AR000H5GKU
776  */
777 HWTEST_F(PasteboardServiceTest, PasteDataTest008, TestSize.Level0)
778 {
779     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
780     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
781     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
782     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
783     auto pasteData = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMapIn);
784     ASSERT_TRUE(pasteData != nullptr);
785     PasteData newPasteData;
786     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
787     auto primaryPixelMap = newPasteData.GetPrimaryPixelMap();
788     ASSERT_TRUE(primaryPixelMap != nullptr);
789     ImageInfo imageInfo = {};
790     primaryPixelMap->GetImageInfo(imageInfo);
791     ASSERT_TRUE(imageInfo.size.height == opts.size.height);
792     ASSERT_TRUE(imageInfo.size.width == opts.size.width);
793     ASSERT_TRUE(imageInfo.pixelFormat == opts.pixelFormat);
794 }
795 
796 /**
797  * @tc.name: PasteDataTest009
798  * @tc.desc: Create paste board data test.
799  * @tc.type: FUNC
800  * @tc.require: AR000H5GKU
801  */
802 HWTEST_F(PasteboardServiceTest, PasteDataTest009, TestSize.Level0)
803 {
804     std::string plainText = "plain text";
805     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
806     ASSERT_TRUE(pasteData != nullptr);
807     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
808     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
809     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
810     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
811     pasteData->AddPixelMapRecord(pixelMapIn);
812     PasteData newPasteData;
813     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
814     auto primaryPlainText = newPasteData.GetPrimaryText();
815     ASSERT_TRUE(primaryPlainText != nullptr);
816     ASSERT_TRUE(*primaryPlainText == plainText);
817     auto primaryPixelMap = newPasteData.GetPrimaryPixelMap();
818     ASSERT_TRUE(primaryPixelMap != nullptr);
819     ImageInfo imageInfo = {};
820     primaryPixelMap->GetImageInfo(imageInfo);
821     ASSERT_TRUE(imageInfo.size.height == opts.size.height);
822     ASSERT_TRUE(imageInfo.size.width == opts.size.width);
823     ASSERT_TRUE(imageInfo.pixelFormat == opts.pixelFormat);
824 }
825 
826 /**
827  * @tc.name: PasteDataTest0010
828  * @tc.desc: Create paste board data test.
829  * @tc.type: FUNC
830  * @tc.require: AR000HEECD
831  */
832 HWTEST_F(PasteboardServiceTest, PasteDataTest0010, TestSize.Level0)
833 {
834     std::vector<uint8_t> arrayBuffer(46);
835     arrayBuffer = { 2, 7, 6, 8, 9 };
836     std::string mimeType = "image/jpg";
837     auto pasteData = PasteboardClient::GetInstance()->CreateKvData(mimeType, arrayBuffer);
838     ASSERT_TRUE(pasteData != nullptr);
839     PasteData newPasteData;
840     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
841     auto firstRecord = newPasteData.GetRecordAt(0);
842     auto customData = firstRecord->GetCustomData();
843     ASSERT_TRUE(customData != nullptr);
844     auto itemData = customData->GetItemData();
845     ASSERT_TRUE(itemData.size() == 1);
846     auto item = itemData.find(mimeType);
847     ASSERT_TRUE(item != itemData.end());
848     ASSERT_TRUE(item->second == arrayBuffer);
849 }
850 
851 /**
852  * @tc.name: PasteDataTest0011
853  * @tc.desc: Create paste board data test.
854  * @tc.type: FUNC
855  * @tc.require: AR000HEECD
856  */
857 HWTEST_F(PasteboardServiceTest, PasteDataTest0011, TestSize.Level0)
858 {
859     std::string plainText = "plain text";
860     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
861     ASSERT_TRUE(pasteData != nullptr);
862     std::vector<uint8_t> arrayBuffer(46);
863     arrayBuffer = { 2, 7, 6, 8, 9 };
864     std::string mimeType = "image/jpg";
865     pasteData->AddKvRecord(mimeType, arrayBuffer);
866     PasteData newPasteData;
867     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
868     auto firstRecord = newPasteData.GetRecordAt(0);
869     auto customData = firstRecord->GetCustomData();
870     ASSERT_TRUE(customData != nullptr);
871     auto itemData = customData->GetItemData();
872     ASSERT_TRUE(itemData.size() == 1);
873     auto item = itemData.find(mimeType);
874     ASSERT_TRUE(item != itemData.end());
875     ASSERT_TRUE(item->second == arrayBuffer);
876     auto primaryPlainText = newPasteData.GetPrimaryText();
877     ASSERT_TRUE(primaryPlainText != nullptr);
878     ASSERT_TRUE(*primaryPlainText == plainText);
879 }
880 
881 /**
882  * @tc.name: PasteDataTest0012
883  * @tc.desc: Create paste board data test.
884  * @tc.type: FUNC
885  * @tc.require: AR000HEECD
886  */
887 HWTEST_F(PasteboardServiceTest, PasteDataTest0012, TestSize.Level0)
888 {
889     std::string plainText = "plain text";
890     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
891     ASSERT_TRUE(pasteData != nullptr);
892     std::vector<uint8_t> arrayBuffer(46);
893     arrayBuffer = { 2, 7, 6, 8, 9 };
894     std::string mimeType = "image/jpg";
895     pasteData->AddKvRecord(mimeType, arrayBuffer);
896     auto record = pasteData->GetRecordAt(0);
897     ASSERT_TRUE(record != nullptr);
898     std::string mimeType1 = "img/png";
899     std::vector<uint8_t> arrayBuffer1(54);
900     arrayBuffer1 = { 4, 7, 9, 8, 7 };
901     auto customData = record->GetCustomData();
902     ASSERT_TRUE(customData != nullptr);
903     customData->AddItemData(mimeType1, arrayBuffer1);
904     PasteData newPasteData;
905     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
906     auto firstRecord = newPasteData.GetRecordAt(0);
907     ASSERT_TRUE(firstRecord != nullptr);
908     customData = firstRecord->GetCustomData();
909     ASSERT_TRUE(customData != nullptr);
910     auto itemData = customData->GetItemData();
911     ASSERT_EQ(itemData.size(), 1);
912     auto item = itemData.find(mimeType);
913     ASSERT_TRUE(item != itemData.end());
914     ASSERT_TRUE(item->second == arrayBuffer);
915     item = itemData.find(mimeType1);
916     ASSERT_TRUE(item == itemData.end());
917     auto primaryPlainText = newPasteData.GetPrimaryText();
918     ASSERT_TRUE(primaryPlainText != nullptr);
919     ASSERT_TRUE(*primaryPlainText == plainText);
920     auto secondRecord = newPasteData.GetRecordAt(1);
921     ASSERT_TRUE(secondRecord != nullptr);
922     auto secondRecordMimeType = secondRecord->GetMimeType();
923     ASSERT_TRUE(secondRecordMimeType == MIMETYPE_TEXT_PLAIN);
924 }
925 
926 /**
927  * @tc.name: PasteDataTest0014
928  * @tc.desc: Create paste board data test.
929  * @tc.type: FUNC
930  * @tc.require: AROOOH5R5G
931  */
932 HWTEST_F(PasteboardServiceTest, PasteDataTest0014, TestSize.Level0)
933 {
934     std::string plainText = "plain text";
935     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
936     ASSERT_TRUE(pasteData != nullptr);
937     auto shareOption = pasteData->GetShareOption();
938     ASSERT_TRUE(shareOption == ShareOption::CrossDevice);
939     pasteData->SetShareOption(ShareOption::InApp);
940     auto tokenId = pasteData->GetTokenId();
941     ASSERT_TRUE(tokenId == 0);
942     pasteData->SetTokenId(1);
943     PasteData newPasteData;
944     PasteboardServiceTest::CommonTest(*pasteData, newPasteData);
945     shareOption = newPasteData.GetShareOption();
946     ASSERT_TRUE(shareOption == ShareOption::InApp);
947     tokenId = pasteData->GetTokenId();
948     ASSERT_TRUE(tokenId != 0);
949 }
950 
951 /**
952  * @tc.name: PasteDataTest0015
953  * @tc.desc: isLocalPaste test.
954  * @tc.type: FUNC
955  * @tc.require: AROOOH5R5G
956  */
957 HWTEST_F(PasteboardServiceTest, PasteDataTest0015, TestSize.Level0)
958 {
959     std::string plainText = "plain text";
960     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
961     ASSERT_TRUE(pasteData != nullptr);
962     auto isLocalPaste = pasteData->IsLocalPaste();
963     ASSERT_FALSE(isLocalPaste);
964     pasteData->SetLocalPasteFlag(true);
965     isLocalPaste = pasteData->IsLocalPaste();
966     ASSERT_TRUE(isLocalPaste);
967     pasteData->SetLocalPasteFlag(false);
968     isLocalPaste = pasteData->IsLocalPaste();
969     ASSERT_FALSE(isLocalPaste);
970     PasteboardClient::GetInstance()->Clear();
971     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
972     ASSERT_FALSE(hasPasteData);
973     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
974     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
975     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
976     ASSERT_TRUE(hasPasteData);
977     PasteData newPasteData;
978     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
979     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
980     isLocalPaste = newPasteData.IsLocalPaste();
981     ASSERT_TRUE(isLocalPaste);
982 }
983 
984 /**
985  * @tc.name: PasteDataTest0016
986  * @tc.desc: RemoveRecordAt HasMimeType test.
987  * @tc.type: FUNC
988  * @tc.require: AROOOH5R5G
989  */
990 HWTEST_F(PasteboardServiceTest, PasteDataTest0016, TestSize.Level0)
991 {
992     std::string plainText = "plain text";
993     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
994     ASSERT_TRUE(pasteData != nullptr);
995     std::vector<uint8_t> arrayBuffer(46);
996     arrayBuffer = { 2, 7, 6, 8, 9 };
997     std::string mimeType = "image/jpg";
998     pasteData->AddKvRecord(mimeType, arrayBuffer);
999     pasteData->RemoveRecordAt(1);
1000     PasteboardClient::GetInstance()->Clear();
1001     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1002     ASSERT_FALSE(hasPasteData);
1003     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1004     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1005     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1006     ASSERT_TRUE(hasPasteData);
1007     PasteData newPasteData;
1008     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
1009     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1010     ASSERT_TRUE(newPasteData.HasMimeType(mimeType));
1011     ASSERT_TRUE(newPasteData.GetRecordCount() == 1);
1012     auto record = newPasteData.GetRecordAt(0);
1013     ASSERT_TRUE(record != nullptr);
1014     auto customData = record->GetCustomData();
1015     ASSERT_TRUE(customData != nullptr);
1016     auto itemData = customData->GetItemData();
1017     ASSERT_EQ(itemData.size(), 1);
1018     auto item = itemData.find(mimeType);
1019     ASSERT_TRUE(item != itemData.end());
1020     EXPECT_EQ(item->second, arrayBuffer);
1021 }
1022 
1023 /**
1024  * @tc.name: PasteDataTest0017
1025  * @tc.desc: ReplaceRecordAt GetProperty GetTag test.
1026  * @tc.type: FUNC
1027  * @tc.require: AROOOH5R5G
1028  */
1029 HWTEST_F(PasteboardServiceTest, PasteDataTest0017, TestSize.Level0)
1030 {
1031     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
1032     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
1033     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
1034     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
1035     auto pasteData = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMapIn);
1036     ASSERT_TRUE(pasteData != nullptr);
1037     auto pixelMap1 = pasteData->GetPrimaryPixelMap();
1038     ASSERT_TRUE(pixelMap1 != nullptr);
1039     ImageInfo imageInfo = {};
1040     pixelMap1->GetImageInfo(imageInfo);
1041     ASSERT_EQ(imageInfo.size.height, opts.size.height);
1042     ASSERT_EQ(imageInfo.size.width, opts.size.width);
1043     ASSERT_EQ(imageInfo.pixelFormat, opts.pixelFormat);
1044     std::string plainText = "plain text";
1045     auto record = PasteboardClient::GetInstance()->CreatePlainTextRecord(plainText);
1046     ASSERT_TRUE(record != nullptr);
1047     ASSERT_TRUE(pasteData->ReplaceRecordAt(0, record));
1048     PasteboardClient::GetInstance()->Clear();
1049     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1050     ASSERT_FALSE(hasPasteData);
1051     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1052     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1053     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1054     ASSERT_TRUE(hasPasteData);
1055     PasteData newPasteData;
1056     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
1057     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1058     ASSERT_EQ(newPasteData.GetRecordCount(), 1);
1059     auto record1 = newPasteData.GetRecordAt(0);
1060     ASSERT_TRUE(record1 != nullptr);
1061     auto plainText1 = record1->GetPlainText();
1062     ASSERT_TRUE(plainText1 != nullptr);
1063     EXPECT_EQ(*plainText1, plainText);
1064     auto property = newPasteData.GetProperty();
1065     EXPECT_TRUE(property.additions.IsEmpty());
1066     EXPECT_EQ(property.mimeTypes.size(), 1);
1067     EXPECT_EQ(property.mimeTypes[0], MIMETYPE_TEXT_PLAIN);
1068     EXPECT_TRUE(property.tag.empty());
1069     EXPECT_EQ(property.shareOption, ShareOption::CrossDevice);
1070     EXPECT_TRUE(property.tokenId != 0);
1071     auto tag = newPasteData.GetTag();
1072     EXPECT_TRUE(tag.empty());
1073 }
1074 
1075 /**
1076  * @tc.name: PasteDataTest0018
1077  * @tc.desc: AddPasteboardChangedObserver RemovePasteboardChangedObserver OnRemoteDied OnRemoteSaDied test.
1078  * @tc.type: FUNC
1079  * @tc.require: AROOOH5R5G
1080  */
1081 HWTEST_F(PasteboardServiceTest, PasteDataTest0018, TestSize.Level0)
1082 {
1083     PasteboardClient::GetInstance()->RemovePasteboardChangedObserver(nullptr);
1084     if (PasteboardServiceTest::pasteboardObserver_ == nullptr) {
1085         PasteboardServiceTest::pasteboardObserver_ = new PasteboardObserverCallback();
1086     }
1087     PasteboardServiceTest::pasteboardChangedFlag_ = false;
1088     ASSERT_TRUE(PasteboardServiceTest::pasteboardObserver_ != nullptr);
1089     PasteboardClient::GetInstance()->AddPasteboardChangedObserver(PasteboardServiceTest::pasteboardObserver_);
1090     ASSERT_FALSE(PasteboardServiceTest::pasteboardChangedFlag_);
1091     const wptr<IRemoteObject> object;
1092     PasteboardSaDeathRecipient death;
1093     death.OnRemoteDied(object);
1094     PasteboardClient::GetInstance()->OnRemoteSaDied(object);
1095     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
1096     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
1097     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
1098     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
1099     auto pasteData = PasteboardClient::GetInstance()->CreatePixelMapData(pixelMapIn);
1100     ASSERT_TRUE(pasteData != nullptr);
1101     PasteboardClient::GetInstance()->Clear();
1102     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1103     ASSERT_FALSE(PasteboardServiceTest::pasteboardChangedFlag_);
1104     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1105     ASSERT_FALSE(hasPasteData);
1106     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1107     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1108     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1109     ASSERT_TRUE(PasteboardServiceTest::pasteboardChangedFlag_);
1110     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1111     ASSERT_TRUE(hasPasteData);
1112     PasteData newPasteData;
1113     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
1114     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1115     PasteboardServiceTest::pasteboardChangedFlag_ = false;
1116     PasteboardClient::GetInstance()->RemovePasteboardChangedObserver(PasteboardServiceTest::pasteboardObserver_);
1117     PasteboardClient::GetInstance()->Clear();
1118     ASSERT_FALSE(PasteboardServiceTest::pasteboardChangedFlag_);
1119     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1120     ASSERT_FALSE(hasPasteData);
1121     PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1122     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1123     ASSERT_FALSE(PasteboardServiceTest::pasteboardChangedFlag_);
1124     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1125     ASSERT_TRUE(hasPasteData);
1126 }
1127 
1128 /**
1129  * @tc.name: PasteDataTest0019
1130  * @tc.desc: AddPasteboardEventObserver RemovePasteboardEventObserver test.
1131  * @tc.type: FUNC
1132  * @tc.require: AROOOH5R5G
1133  */
1134 HWTEST_F(PasteboardServiceTest, PasteDataTest0019, TestSize.Level0)
1135 {
1136     PasteboardClient::GetInstance()->RemovePasteboardEventObserver(nullptr);
1137     if (PasteboardServiceTest::pasteboardEventObserver_ == nullptr) {
1138         PasteboardServiceTest::pasteboardEventObserver_ = new PasteboardEventObserverCallback();
1139     }
1140     PasteboardServiceTest::pasteboardEventStatus_ = -1;
1141     ASSERT_TRUE(PasteboardServiceTest::pasteboardEventObserver_ != nullptr);
1142     PasteboardClient::GetInstance()->AddPasteboardEventObserver(PasteboardServiceTest::pasteboardEventObserver_);
1143     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1144     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData("hello");
1145     ASSERT_TRUE(pasteData != nullptr);
1146     PasteboardClient::GetInstance()->Clear();
1147     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1148     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1149     ASSERT_FALSE(hasPasteData);
1150     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1151     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1152     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1153     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1154     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1155     ASSERT_TRUE(hasPasteData);
1156     PasteData newPasteData;
1157     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
1158     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1159     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1160     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1161     PasteboardClient::GetInstance()->Clear();
1162     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1163     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1164     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1165     PasteboardServiceTest::pasteboardEventStatus_ = -1;
1166     PasteboardClient::GetInstance()->RemovePasteboardEventObserver(PasteboardServiceTest::pasteboardEventObserver_);
1167     PasteboardClient::GetInstance()->Clear();
1168     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1169     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1170     PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1171     ASSERT_EQ(PasteboardServiceTest::pasteboardEventStatus_, -1);
1172 }
1173 
1174 /**
1175  * @tc.name: PasteDataTest0020
1176  * @tc.desc: Create paste board test set bundleName and time.
1177  * @tc.type: FUNC
1178  */
1179 HWTEST_F(PasteboardServiceTest, PasteDataTest0020, TestSize.Level0)
1180 {
1181     std::string text = "plain text";
1182     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(text);
1183     ASSERT_TRUE(pasteData != nullptr);
1184     std::string bundleName = "ohos.acts.distributeddatamgr.pasteboard";
1185     pasteData->SetBundleName(bundleName);
1186     std::string time = GetTime();
1187     pasteData->SetTime(time);
1188     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1189     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1190     auto has = PasteboardClient::GetInstance()->HasPasteData();
1191     ASSERT_TRUE(has == true);
1192 }
1193 
1194 /**
1195  * @tc.name: PasteDataTest0021
1196  * @tc.desc: AddPasteboardEventObserver RemovePasteboardEventObserver test.
1197  * @tc.type: FUNC
1198  */
1199 HWTEST_F(PasteboardServiceTest, PasteDataTest0021, TestSize.Level0)
1200 {
1201     PasteboardClient::GetInstance()->AddPasteboardEventObserver(new PasteboardEventObserverCallback());
1202     PasteboardClient::GetInstance()->AddPasteboardEventObserver(new PasteboardEventObserverCallback());
1203     PasteboardClient::GetInstance()->AddPasteboardEventObserver(new PasteboardEventObserverCallback());
1204     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData("hello");
1205     ASSERT_TRUE(pasteData != nullptr);
1206     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1207     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1208     auto hasData = PasteboardClient::GetInstance()->HasPasteData();
1209     ASSERT_TRUE(hasData == true);
1210     PasteData newPasteData;
1211     PasteboardClient::GetInstance()->GetPasteData(newPasteData);
1212     PasteboardClient::GetInstance()->Clear();
1213     std::this_thread::sleep_for(std::chrono::milliseconds(5));
1214     PasteboardClient::GetInstance()->RemovePasteboardEventObserver(nullptr);
1215     hasData = PasteboardClient::GetInstance()->HasPasteData();
1216     ASSERT_TRUE(hasData == false);
1217 }
1218 
1219 /**
1220  * @tc.name: PasteDataTest0022
1221  * @tc.desc: isDraggedData test.
1222  * @tc.type: FUNC
1223  * @tc.require: AROOOH5R5G
1224  */
1225 HWTEST_F(PasteboardServiceTest, PasteDataTest0022, TestSize.Level0)
1226 {
1227     std::string plainText = "plain text";
1228     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
1229     ASSERT_TRUE(pasteData != nullptr);
1230     auto isDraggedData = pasteData->IsDraggedData();
1231     ASSERT_FALSE(isDraggedData);
1232     pasteData->SetDraggedDataFlag(true);
1233     ASSERT_TRUE(pasteData->IsDraggedData());
1234     PasteboardClient::GetInstance()->Clear();
1235     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1236     ASSERT_FALSE(hasPasteData);
1237     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1238     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1239     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1240     ASSERT_FALSE(hasPasteData);
1241     PasteData newPasteData;
1242     ret = PasteboardClient::GetInstance()->GetPasteData(newPasteData);
1243     ASSERT_FALSE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1244     isDraggedData = newPasteData.IsDraggedData();
1245     ASSERT_FALSE(isDraggedData);
1246 }
1247 
1248 /**
1249  * @tc.name: BigPixelMap001
1250  * @tc.desc: paste big pixel map image
1251  * @tc.type: FUNC
1252  * @tc.require:AR000H5I1D
1253  * @tc.author: baoyayong
1254  */
1255 HWTEST_F(PasteboardServiceTest, BigPixelMap001, TestSize.Level1)
1256 {
1257     constexpr uint32_t COLOR_SIZE = 1024 * 1960;
1258     auto color = std::make_unique<uint32_t[]>(COLOR_SIZE);
1259     InitializationOptions opts = { { 1024, 1960 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
1260     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color.get(), COLOR_SIZE, opts);
1261     auto pasteData1 = PasteboardClient::GetInstance()->CreatePixelMapData(std::move(pixelMap));
1262     PasteboardClient::GetInstance()->Clear();
1263     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1264     ASSERT_FALSE(hasPasteData);
1265     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData1);
1266     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1267     hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1268     ASSERT_TRUE(hasPasteData);
1269     PasteData pasteData2;
1270     ret = PasteboardClient::GetInstance()->GetPasteData(pasteData2);
1271     ASSERT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1272     auto pixelMap2 = pasteData2.GetPrimaryPixelMap();
1273     ASSERT_TRUE(pixelMap2 != nullptr);
1274     ImageInfo imageInfo {};
1275     pixelMap2->GetImageInfo(imageInfo);
1276     EXPECT_TRUE(imageInfo.size.height == opts.size.height);
1277     EXPECT_TRUE(imageInfo.size.width == opts.size.width);
1278     EXPECT_TRUE(imageInfo.pixelFormat == opts.pixelFormat);
1279 }
1280 
1281 /**
1282  * @tc.name: GetPastedataFail001
1283  * @tc.desc: get paste data fail - SetValue()
1284  * @tc.type: FUNC
1285  * @tc.require: issuesI5WPTM
1286  * @tc.author: chenyu
1287  */
1288 HWTEST_F(PasteboardServiceTest, GetPastedataFail001, TestSize.Level1)
1289 {
1290     PasteboardClient::GetInstance()->Clear();
1291     PasteData data;
1292     auto ret = PasteboardClient::GetInstance()->GetPasteData(data);
1293     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::NO_DATA_ERROR));
1294 }
1295 
1296 /**
1297  * @tc.name: DumpDataTest001
1298  * @tc.desc: DumpData()-remote, CrossDevice
1299  * @tc.type: FUNC
1300  * @tc.require: issueshI5YDEV
1301  * @tc.author: chenyu
1302  */
1303 HWTEST_F(PasteboardServiceTest, DumpDataTest001, TestSize.Level1)
1304 {
1305     std::string plainText = "plain text";
1306     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
1307     pasteData->SetRemote(true);
1308     pasteData->SetShareOption(ShareOption::CrossDevice);
1309     PasteboardClient::GetInstance()->Clear();
1310     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1311     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1312     std::string result;
1313     ret = PasteboardServiceTest::ExecuteCmd(result);
1314     EXPECT_TRUE(ret);
1315     EXPECT_TRUE(result.find("CrossDevice") != std::string::npos);
1316     EXPECT_TRUE(result.find("remote") != std::string::npos);
1317     PasteboardClient::GetInstance()->Clear();
1318 }
1319 
1320 /**
1321  * @tc.name: DumpDataTest002
1322  * @tc.desc: DumpData()-local, LocalDevice
1323  * @tc.type: FUNC
1324  * @tc.require: issueshI5YDEV
1325  * @tc.author: chenyu
1326  */
1327 HWTEST_F(PasteboardServiceTest, DumpDataTest002, TestSize.Level1)
1328 {
1329     std::string plainText = "plain text";
1330     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
1331     pasteData->SetShareOption(ShareOption::LocalDevice);
1332     PasteboardClient::GetInstance()->Clear();
1333     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1334     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1335     std::string result;
1336     ret = PasteboardServiceTest::ExecuteCmd(result);
1337     EXPECT_TRUE(ret);
1338     EXPECT_TRUE(result.find("LocalDevice") != std::string::npos);
1339     EXPECT_TRUE(result.find("local") != std::string::npos);
1340     PasteboardClient::GetInstance()->Clear();
1341 }
1342 
1343 /**
1344  * @tc.name: DumpDataTest003
1345  * @tc.desc: DumpData()-local, InApp
1346  * @tc.type: FUNC
1347  * @tc.require: issueshI5YDEV
1348  * @tc.author: chenyu
1349  */
1350 HWTEST_F(PasteboardServiceTest, DumpDataTest003, TestSize.Level1)
1351 {
1352     std::string plainText = "plain text";
1353     auto pasteData = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
1354     pasteData->SetShareOption(ShareOption::InApp);
1355     PasteboardClient::GetInstance()->Clear();
1356     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1357     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1358     std::string result;
1359     ret = PasteboardServiceTest::ExecuteCmd(result);
1360     EXPECT_TRUE(ret);
1361     EXPECT_TRUE(result.find("InAPP") != std::string::npos);
1362     EXPECT_TRUE(result.find("local") != std::string::npos);
1363     PasteboardClient::GetInstance()->Clear();
1364 }
1365 
1366 /**
1367  * @tc.name: DumpDataTest004
1368  * @tc.desc: DumpData()-no data
1369  * @tc.type: FUNC
1370  * @tc.require: issueshI5YDEV
1371  * @tc.author: chenyu
1372  */
1373 HWTEST_F(PasteboardServiceTest, DumpDataTest004, TestSize.Level1)
1374 {
1375     PasteboardClient::GetInstance()->Clear();
1376 
1377     std::string result;
1378     auto ret = PasteboardServiceTest::ExecuteCmd(result);
1379     EXPECT_TRUE(ret);
1380     EXPECT_EQ(result.find("Share"), std::string::npos);
1381     EXPECT_EQ(result.find("Option"), std::string::npos);
1382 }
1383 
1384 /**
1385  * @tc.name: HasPasteDataTest001
1386  * @tc.desc: if !pasteData->IsDraggedData()
1387  * @tc.type: FUNC
1388  * @tc.require: issueshI5YDEV
1389  * @tc.author: chenyu
1390  */
1391 HWTEST_F(PasteboardServiceTest, HasPasteDataTest001, TestSize.Level0)
1392 {
1393     std::vector<uint8_t> arrayBuffer(46);
1394     arrayBuffer = { 2, 7, 6, 8, 9 };
1395     std::string mimeType = "image/jpg";
1396     auto pasteData = PasteboardClient::GetInstance()->CreateKvData(mimeType, arrayBuffer);
1397     PasteboardClient::GetInstance()->Clear();
1398     int32_t ret = PasteboardClient::GetInstance()->SetPasteData(*pasteData);
1399     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::E_OK));
1400     auto hasPasteData = PasteboardClient::GetInstance()->HasPasteData();
1401     // not DraggedData, not DefaultIME
1402     EXPECT_TRUE(hasPasteData);
1403     PasteboardClient::GetInstance()->Clear();
1404 }
1405 
1406 /**
1407  * @tc.name: SetAppShareOptions
1408  * @tc.desc: set app share options
1409  * @tc.type: FUNC
1410  * @tc.require: issuesIA7V62
1411  * @tc.author: caozhijun
1412  */
1413 HWTEST_F(PasteboardServiceTest, SetAppShareOptions, TestSize.Level0)
1414 {
1415     uint64_t tempTokenID = testAppTokenId_ | SYSTEM_APP_MASK;
1416     auto result = SetSelfTokenID(tempTokenID);
1417     AccessTokenKit::GrantPermission(
1418         tempTokenID, "ohos.permission.MANAGE_PASTEBOARD_APP_SHARE_OPTION", PERMISSION_USER_SET);
1419     PASTEBOARD_HILOGD(
1420         PASTEBOARD_MODULE_SERVICE, "testTokenId= 0x%{public}x, ret= %{public}d!", testAppTokenId_, result);
1421     ShareOption setting = ShareOption::InApp;
1422     int32_t ret = PasteboardClient::GetInstance()->SetAppShareOptions(setting);
1423     EXPECT_TRUE(ret == 0);
1424     ret = PasteboardClient::GetInstance()->SetAppShareOptions(setting);
1425     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::INVALID_OPERATION_ERROR));
1426     ret = PasteboardClient::GetInstance()->RemoveAppShareOptions();
1427     EXPECT_TRUE(ret == 0);
1428     ret = PasteboardClient::GetInstance()->RemoveAppShareOptions();
1429     EXPECT_TRUE(ret == 0);
1430 
1431     setuid(EDM_UID);
1432     std::map<uint32_t, ShareOption> globalShareOptions;
1433     setting = ShareOption::InApp;
1434     globalShareOptions.insert({tempTokenID, setting});
1435     PasteboardClient::GetInstance()->SetGlobalShareOption(globalShareOptions);
1436     ret = PasteboardClient::GetInstance()->SetAppShareOptions(setting);
1437     EXPECT_TRUE(ret == static_cast<int32_t>(PasteboardError::INVALID_OPERATION_ERROR));
1438     ret = PasteboardClient::GetInstance()->RemoveAppShareOptions();
1439     EXPECT_TRUE(ret == 0);
1440     std::vector<uint32_t> tokenIds;
1441     tokenIds.push_back(tempTokenID);
1442     PasteboardClient::GetInstance()->RemoveGlobalShareOption(tokenIds);
1443 
1444     ret = PasteboardClient::GetInstance()->SetAppShareOptions(setting);
1445     EXPECT_TRUE(ret == 0);
1446     PasteboardClient::GetInstance()->SetGlobalShareOption(globalShareOptions);
1447     ret = PasteboardClient::GetInstance()->RemoveAppShareOptions();
1448     EXPECT_TRUE(ret == 0);
1449     PasteboardServiceTest::RestoreSelfTokenId();
1450 }
1451 
1452 /**
1453  * @tc.name: GetRemoteDeviceNameTest
1454  * @tc.desc: Get Remote Device Name
1455  * @tc.type: FUNC
1456  */
1457 HWTEST_F(PasteboardServiceTest, GetRemoteDeviceNameTest, TestSize.Level0)
1458 {
1459     std::string deviceName = "deviceName";
1460     bool isRemote = false;
1461     int32_t ret = PasteboardClient::GetInstance()->GetRemoteDeviceName(deviceName, isRemote);
1462     EXPECT_EQ(ret, static_cast<int32_t>(PasteboardError::E_OK));
1463     isRemote = true;
1464     ret = PasteboardClient::GetInstance()->GetRemoteDeviceName(deviceName, isRemote);
1465     EXPECT_EQ(ret, static_cast<int32_t>(PasteboardError::E_OK));
1466 }
1467 } // namespace OHOS::MiscServices