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