1 /*
2  * Copyright (c) 2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include <variant>
19 
20 #include "pasteboard_hilog.h"
21 #include "pasteboard_client.h"
22 #include "pasteboard_error.h"
23 
24 namespace OHOS::MiscServices {
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace OHOS::UDMF;
28 using namespace OHOS::AAFwk;
29 using namespace OHOS::Media;
30 static std::string text_ = "test";
31 static std::string uri_ = "uri";
32 static std::string fileType_ = "test";
33 static std::string html_ = "<div class='disable'>helloWorld</div>";
34 static std::string link_ = "http://abc.com";
35 static std::string plainTextUtdId_ = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
36 static std::string htmlUtdId_ = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
37 static std::string fileUriUtdId_ = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
38 static std::string pixelMapUtdId_ = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
39 static std::string linkUtdId_ = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK);
40 class PasteboardMultiTypeUnifiedDataDelayTest : public testing::Test {
41 public:
42     static void SetUpTestCase(void);
43     static void TearDownTestCase(void);
44     void SetUp();
45     void TearDown();
46 
47     static UDMF::ValueType InitPlainUds();
48     static UDMF::ValueType InitHtmlUds();
49     static UDMF::ValueType InitFileUriUds();
50     static UDMF::ValueType InitPixelMapUds();
51     static UDMF::ValueType InitLinkUds();
52 
53     void CheckPlainUds(const UDMF::ValueType &value);
54     void CheckHtmlUds(const UDMF::ValueType &value);
55     void CheckFileUriUds(const UDMF::ValueType &value);
56     void CheckPixelMapUds(const UDMF::ValueType &value);
57     void CheckLinkUds(const UDMF::ValueType &value);
58 };
59 
SetUpTestCase(void)60 void PasteboardMultiTypeUnifiedDataDelayTest::SetUpTestCase(void)
61 {
62     PasteboardClient::GetInstance()->Clear();
63 }
64 
TearDownTestCase(void)65 void PasteboardMultiTypeUnifiedDataDelayTest::TearDownTestCase(void)
66 {
67 }
68 
SetUp()69 void PasteboardMultiTypeUnifiedDataDelayTest::SetUp()
70 {
71 }
72 
TearDown()73 void PasteboardMultiTypeUnifiedDataDelayTest::TearDown()
74 {
75 }
76 
InitPlainUds()77 UDMF::ValueType PasteboardMultiTypeUnifiedDataDelayTest::InitPlainUds()
78 {
79     Object plainUds;
80     plainUds.value_[UDMF::UNIFORM_DATA_TYPE] = plainTextUtdId_;
81     plainUds.value_[UDMF::CONTENT] = text_;
82     return std::make_shared<Object>(plainUds);
83 }
84 
InitHtmlUds()85 UDMF::ValueType PasteboardMultiTypeUnifiedDataDelayTest::InitHtmlUds()
86 {
87     Object htmlObject;
88     htmlObject.value_[UDMF::UNIFORM_DATA_TYPE] = htmlUtdId_;
89     htmlObject.value_[UDMF::HTML_CONTENT] = html_;
90     return std::make_shared<Object>(htmlObject);
91 }
92 
InitFileUriUds()93 UDMF::ValueType PasteboardMultiTypeUnifiedDataDelayTest::InitFileUriUds()
94 {
95     Object fileUriObject;
96     fileUriObject.value_[UDMF::UNIFORM_DATA_TYPE] = fileUriUtdId_;
97     fileUriObject.value_[UDMF::FILE_URI_PARAM] = uri_;
98     fileUriObject.value_[UDMF::FILE_TYPE] = fileType_;
99     return std::make_shared<Object>(fileUriObject);
100 }
101 
InitPixelMapUds()102 UDMF::ValueType PasteboardMultiTypeUnifiedDataDelayTest::InitPixelMapUds()
103 {
104     Object object;
105     object.value_[UDMF::UNIFORM_DATA_TYPE] = pixelMapUtdId_;
106     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
107     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
108     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
109     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
110     object.value_[UDMF::PIXEL_MAP] = pixelMapIn;
111     return std::make_shared<Object>(object);
112 }
113 
InitLinkUds()114 UDMF::ValueType PasteboardMultiTypeUnifiedDataDelayTest::InitLinkUds()
115 {
116     Object linkObject;
117     linkObject.value_[UDMF::UNIFORM_DATA_TYPE] = linkUtdId_;
118     linkObject.value_[UDMF::URL] = link_;
119     return std::make_shared<Object>(linkObject);
120 }
121 
122 class EntryGetterImpl : public UDMF::EntryGetter {
123 public:
124     UDMF::ValueType GetValueByType(const std::string& utdId) override;
125 };
126 
GetValueByType(const std::string & utdId)127 UDMF::ValueType EntryGetterImpl::GetValueByType(const std::string& utdId)
128 {
129     if (utdId == plainTextUtdId_) {
130         return PasteboardMultiTypeUnifiedDataDelayTest::InitPlainUds();
131     }
132     if (utdId == htmlUtdId_) {
133         return PasteboardMultiTypeUnifiedDataDelayTest::InitHtmlUds();
134     }
135     if (utdId == fileUriUtdId_) {
136         return PasteboardMultiTypeUnifiedDataDelayTest::InitFileUriUds();
137     }
138     if (utdId == pixelMapUtdId_) {
139         return PasteboardMultiTypeUnifiedDataDelayTest::InitPixelMapUds();
140     }
141     if (utdId == linkUtdId_) {
142         return PasteboardMultiTypeUnifiedDataDelayTest::InitLinkUds();
143     }
144     return nullptr;
145 }
146 
CheckPlainUds(const UDMF::ValueType & value)147 void PasteboardMultiTypeUnifiedDataDelayTest::CheckPlainUds(const UDMF::ValueType &value)
148 {
149     ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
150     auto obj = std::get<std::shared_ptr<Object>>(value);
151     ASSERT_NE(obj, nullptr);
152     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::UNIFORM_DATA_TYPE]), nullptr);
153     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::UNIFORM_DATA_TYPE]), plainTextUtdId_);
154     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::CONTENT]), nullptr);
155     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::CONTENT]), text_);
156 }
157 
CheckHtmlUds(const UDMF::ValueType & value)158 void PasteboardMultiTypeUnifiedDataDelayTest::CheckHtmlUds(const UDMF::ValueType &value)
159 {
160     ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
161     auto obj = std::get<std::shared_ptr<Object>>(value);
162     ASSERT_NE(obj, nullptr);
163     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::UNIFORM_DATA_TYPE]), nullptr);
164     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::UNIFORM_DATA_TYPE]), htmlUtdId_);
165     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::HTML_CONTENT]), nullptr);
166     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::HTML_CONTENT]), html_);
167 }
168 
CheckFileUriUds(const UDMF::ValueType & value)169 void PasteboardMultiTypeUnifiedDataDelayTest::CheckFileUriUds(const UDMF::ValueType &value)
170 {
171     ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
172     auto obj = std::get<std::shared_ptr<Object>>(value);
173     ASSERT_NE(obj, nullptr);
174     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::UNIFORM_DATA_TYPE]), nullptr);
175     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::UNIFORM_DATA_TYPE]), fileUriUtdId_);
176     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::FILE_URI_PARAM]), nullptr);
177     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::FILE_URI_PARAM]), uri_);
178     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::FILE_TYPE]), nullptr);
179     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::FILE_TYPE]), fileType_);
180 }
181 
CheckPixelMapUds(const UDMF::ValueType & value)182 void PasteboardMultiTypeUnifiedDataDelayTest::CheckPixelMapUds(const UDMF::ValueType &value)
183 {
184     ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
185     auto obj = std::get<std::shared_ptr<Object>>(value);
186     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::UNIFORM_DATA_TYPE]), nullptr);
187     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::UNIFORM_DATA_TYPE]), pixelMapUtdId_);
188     auto pixelMap = std::get_if<std::shared_ptr<PixelMap>>(&obj->value_[UDMF::PIXEL_MAP]);
189     ASSERT_NE(pixelMap, nullptr);
190     ImageInfo imageInfo = {};
191     (*pixelMap)->GetImageInfo(imageInfo);
192     ASSERT_EQ(imageInfo.size.height, 7);
193     ASSERT_EQ(imageInfo.size.width, 5);
194     ASSERT_EQ(imageInfo.pixelFormat, PixelFormat::ARGB_8888);
195 }
196 
CheckLinkUds(const UDMF::ValueType & value)197 void PasteboardMultiTypeUnifiedDataDelayTest::CheckLinkUds(const UDMF::ValueType &value)
198 {
199     ASSERT_NE(std::get_if<std::shared_ptr<Object>>(&value), nullptr);
200     auto obj = std::get<std::shared_ptr<Object>>(value);
201     ASSERT_NE(obj, nullptr);
202     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::UNIFORM_DATA_TYPE]), nullptr);
203     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::UNIFORM_DATA_TYPE]), linkUtdId_);
204     ASSERT_NE(std::get_if<std::string>(&obj->value_[UDMF::URL]), nullptr);
205     ASSERT_EQ(std::get<std::string>(obj->value_[UDMF::URL]), link_);
206 }
207 
208 /**
209  * @tc.name: SetMultiTypeUnifiedDataDelayTest001
210  * @tc.desc: add empty entry with entry getter to pasteboard
211  * @tc.type: FUNC
212  */
213 HWTEST_F(PasteboardMultiTypeUnifiedDataDelayTest, SetMultiTypeUnifiedDataDelayTest001, TestSize.Level1)
214 {
215     UnifiedData inputData;
216     std::shared_ptr<UnifiedRecord> inputRecord = std::make_shared<UnifiedRecord>();
217     std::vector<std::string> inputTypes;
218     inputTypes.emplace_back(plainTextUtdId_);
219     inputTypes.emplace_back(htmlUtdId_);
220     inputTypes.emplace_back(fileUriUtdId_);
221     inputTypes.emplace_back(pixelMapUtdId_);
222     inputTypes.emplace_back(linkUtdId_);
223     std::shared_ptr<EntryGetter> entryGetter = std::make_shared<EntryGetterImpl>();
224     inputRecord->SetEntryGetter(inputTypes, entryGetter);
225     inputData.AddRecord(inputRecord);
226     auto status = PasteboardClient::GetInstance()->SetUdsdData(inputData);
227     ASSERT_EQ(status, static_cast<int32_t>(PasteboardError::E_OK));
228 
229     UnifiedData outputData;
230     status = PasteboardClient::GetInstance()->GetUdsdData(outputData);
231     ASSERT_EQ(status, static_cast<int32_t>(PasteboardError::E_OK));
232     auto inputRecords = inputData.GetRecords();
233     auto outputRecords = outputData.GetRecords();
234     ASSERT_EQ(outputRecords.size(), inputRecords.size());
235     auto outputRecord = outputData.GetRecordAt(0);
236     ASSERT_NE(outputRecord, nullptr);
237     auto outputTypes = outputRecord->GetUtdIds();
238     ASSERT_EQ(outputTypes.size(), inputTypes.size());
239 
240     ASSERT_TRUE(outputTypes.find(plainTextUtdId_) != outputTypes.end());
241     CheckPlainUds(outputRecord->GetEntry(plainTextUtdId_));
242 
243     ASSERT_TRUE(outputTypes.find(htmlUtdId_) != outputTypes.end());
244     CheckHtmlUds(outputRecord->GetEntry(htmlUtdId_));
245 
246     ASSERT_TRUE(outputTypes.find(fileUriUtdId_) != outputTypes.end());
247     CheckFileUriUds(outputRecord->GetEntry(fileUriUtdId_));
248 
249     ASSERT_TRUE(outputTypes.find(pixelMapUtdId_) != outputTypes.end());
250     CheckPixelMapUds(outputRecord->GetEntry(pixelMapUtdId_));
251 
252     ASSERT_TRUE(outputTypes.find(linkUtdId_) != outputTypes.end());
253     CheckLinkUds(outputRecord->GetEntry(linkUtdId_));
254 }
255 
256 /**
257  * @tc.name: SetMultiTypeUnifiedDataDelayTest002
258  * @tc.desc: add empty and valid entry with entry getter to pasteboard
259  * @tc.type: FUNC
260  */
261 HWTEST_F(PasteboardMultiTypeUnifiedDataDelayTest, SetMultiTypeUnifiedDataDelayTest002, TestSize.Level1)
262 {
263     UnifiedData inputData;
264     std::shared_ptr<UnifiedRecord> inputRecord = std::make_shared<UnifiedRecord>();
265     inputRecord->AddEntry(plainTextUtdId_, InitPlainUds());
266     inputRecord->AddEntry(pixelMapUtdId_, InitPixelMapUds());
267     std::vector<std::string> inputTypes;
268     inputTypes.emplace_back(htmlUtdId_);
269     inputTypes.emplace_back(fileUriUtdId_);
270     inputTypes.emplace_back(linkUtdId_);
271     std::shared_ptr<EntryGetter> entryGetter = std::make_shared<EntryGetterImpl>();
272     inputRecord->SetEntryGetter(inputTypes, entryGetter);
273     inputData.AddRecord(inputRecord);
274     auto status = PasteboardClient::GetInstance()->SetUdsdData(inputData);
275     ASSERT_EQ(status, static_cast<int32_t>(PasteboardError::E_OK));
276 
277     UnifiedData outputData;
278     status = PasteboardClient::GetInstance()->GetUdsdData(outputData);
279     ASSERT_EQ(status, static_cast<int32_t>(PasteboardError::E_OK));
280     auto inputRecords = inputData.GetRecords();
281     auto outputRecords = outputData.GetRecords();
282     ASSERT_EQ(outputRecords.size(), inputRecords.size());
283     auto outputRecord = outputData.GetRecordAt(0);
284     ASSERT_NE(outputRecord, nullptr);
285     auto outputTypes = outputRecord->GetUtdIds();
286     auto tempTypes = inputRecord->GetUtdIds();
287     ASSERT_EQ(outputTypes.size(), tempTypes.size());
288 
289     ASSERT_TRUE(outputTypes.find(plainTextUtdId_) != outputTypes.end());
290     CheckPlainUds(outputRecord->GetEntry(plainTextUtdId_));
291 
292     ASSERT_TRUE(outputTypes.find(htmlUtdId_) != outputTypes.end());
293     CheckHtmlUds(outputRecord->GetEntry(htmlUtdId_));
294 
295     ASSERT_TRUE(outputTypes.find(fileUriUtdId_) != outputTypes.end());
296     CheckFileUriUds(outputRecord->GetEntry(fileUriUtdId_));
297 
298     ASSERT_TRUE(outputTypes.find(pixelMapUtdId_) != outputTypes.end());
299     CheckPixelMapUds(outputRecord->GetEntry(pixelMapUtdId_));
300 
301     ASSERT_TRUE(outputTypes.find(linkUtdId_) != outputTypes.end());
302     CheckLinkUds(outputRecord->GetEntry(linkUtdId_));
303 }
304 
305 /**
306  * @tc.name: SetMultiTypeUnifiedDataDelayTest003
307  * @tc.desc: add more unified record with entry getter to pasteboard
308  * @tc.type: FUNC
309  */
310 HWTEST_F(PasteboardMultiTypeUnifiedDataDelayTest, SetMultiTypeUnifiedDataDelayTest003, TestSize.Level1)
311 {
312     UnifiedData inputData;
313     std::shared_ptr<UnifiedRecord> inputRecord1 = std::make_shared<UnifiedRecord>();
314     std::vector<std::string> inputTypes1;
315     inputTypes1.emplace_back(plainTextUtdId_);
316     inputTypes1.emplace_back(htmlUtdId_);
317     std::shared_ptr<EntryGetter> entryGetter1 = std::make_shared<EntryGetterImpl>();
318     inputRecord1->SetEntryGetter(inputTypes1, entryGetter1);
319     inputData.AddRecord(inputRecord1);
320     std::shared_ptr<UnifiedRecord> inputRecord2 = std::make_shared<UnifiedRecord>();
321     std::vector<std::string> inputTypes2;
322     inputTypes2.emplace_back(fileUriUtdId_);
323     inputTypes2.emplace_back(pixelMapUtdId_);
324     std::shared_ptr<EntryGetter> entryGetter2 = std::make_shared<EntryGetterImpl>();
325     inputRecord2->SetEntryGetter(inputTypes2, entryGetter2);
326     inputData.AddRecord(inputRecord2);
327     std::shared_ptr<UnifiedRecord> inputRecord3 = std::make_shared<UnifiedRecord>();
328     std::vector<std::string> inputTypes3;
329     inputTypes3.emplace_back(linkUtdId_);
330     std::shared_ptr<EntryGetter> entryGetter3 = std::make_shared<EntryGetterImpl>();
331     inputRecord3->SetEntryGetter(inputTypes3, entryGetter3);
332     inputData.AddRecord(inputRecord3);
333     auto status = PasteboardClient::GetInstance()->SetUdsdData(inputData);
334     ASSERT_EQ(status, static_cast<int32_t>(PasteboardError::E_OK));
335     UnifiedData outputData;
336     status = PasteboardClient::GetInstance()->GetUdsdData(outputData);
337     ASSERT_EQ(status, static_cast<int32_t>(PasteboardError::E_OK));
338     auto inputRecords = inputData.GetRecords();
339     auto outputRecords = outputData.GetRecords();
340     ASSERT_EQ(outputRecords.size(), inputRecords.size());
341     auto outputRecord1 = outputData.GetRecordAt(0);
342     ASSERT_NE(outputRecord1, nullptr);
343     auto outputTypes1 = outputRecord1->GetUtdIds();
344     ASSERT_EQ(outputTypes1.size(), inputTypes1.size());
345     ASSERT_TRUE(outputTypes1.find(plainTextUtdId_) != outputTypes1.end());
346     CheckPlainUds(outputRecord1->GetEntry(plainTextUtdId_));
347     ASSERT_TRUE(outputTypes1.find(htmlUtdId_) != outputTypes1.end());
348     CheckHtmlUds(outputRecord1->GetEntry(htmlUtdId_));
349     auto outputRecord2 = outputData.GetRecordAt(1);
350     ASSERT_NE(outputRecord2, nullptr);
351     auto outputTypes2 = outputRecord2->GetUtdIds();
352     ASSERT_EQ(outputTypes2.size(), inputTypes2.size());
353     ASSERT_TRUE(outputTypes2.find(fileUriUtdId_) != outputTypes2.end());
354     CheckFileUriUds(outputRecord2->GetEntry(fileUriUtdId_));
355     ASSERT_TRUE(outputTypes2.find(pixelMapUtdId_) != outputTypes2.end());
356     CheckPixelMapUds(outputRecord2->GetEntry(pixelMapUtdId_));
357     auto outputRecord3 = outputData.GetRecordAt(2);
358     ASSERT_NE(outputRecord3, nullptr);
359     auto outputTypes3 = outputRecord3->GetUtdIds();
360     ASSERT_EQ(outputTypes3.size(), inputTypes3.size());
361     ASSERT_TRUE(outputTypes3.find(linkUtdId_) != outputTypes3.end());
362     CheckLinkUds(outputRecord3->GetEntry(linkUtdId_));
363 }
364 } // OHOS::MiscServices