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