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