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 "paste_data_record.h"
17 
18 #include <gtest/gtest.h>
19 
20 #include "tlv_object.h"
21 #include "unified_meta.h"
22 
23 namespace OHOS::MiscServices {
24 using namespace testing::ext;
25 using namespace testing;
26 using namespace OHOS::Media;
27 class PasteDataRecordTest : public testing::Test {
28 public:
29     static void SetUpTestCase(void);
30     static void TearDownTestCase(void);
31     void SetUp();
32     void TearDown();
33 
34 protected:
35     Details details_;
36     std::vector<uint8_t> rawData_;
37     std::string text_ = "test";
38     std::string extraText_ = "extr";
39     std::string uri_ = "file://123.txt";
40     std::string html_ = "<div class='disable'>helloWorld</div>";
41     std::string link_ = "http://abc.com";
42     int32_t width_ = 5;
43     int32_t height_ = 7;
44 
45     void CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>>& entries);
46     void CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry);
47     void CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry);
48     void CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry);
49     void CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry);
50     void CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry);
51 
52     void AddPlainUdsEntry(PasteDataRecord& record);
53     void AddFileUriUdsEntry(PasteDataRecord& record);
54     void AddHtmlUdsEntry(PasteDataRecord& record);
55     void AddPixelMapUdsEntry(PasteDataRecord& record);
56     void AddLinkUdsEntry(PasteDataRecord& record);
57 };
58 
SetUpTestCase(void)59 void PasteDataRecordTest::SetUpTestCase(void) {}
60 
TearDownTestCase(void)61 void PasteDataRecordTest::TearDownTestCase(void) {}
62 
SetUp(void)63 void PasteDataRecordTest::SetUp(void)
64 {
65     rawData_ = { 1, 2, 3, 4, 5, 6, 7, 8 };
66     details_.insert({ "keyString", "string_test" });
67     details_.insert({ "keyInt32", 1 });
68     details_.insert({ "keyBool", true });
69     details_.insert({ "KeyU8Array", rawData_ });
70     details_.insert({ "KeyDouble", 1.234 });
71 }
72 
TearDown(void)73 void PasteDataRecordTest::TearDown(void) {}
74 
AddPlainUdsEntry(PasteDataRecord & record)75 void PasteDataRecordTest::AddPlainUdsEntry(PasteDataRecord& record)
76 {
77     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
78     auto object = std::make_shared<Object>();
79     object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
80     object->value_[UDMF::CONTENT] = text_;
81     record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
82 }
83 
AddFileUriUdsEntry(PasteDataRecord & record)84 void PasteDataRecordTest::AddFileUriUdsEntry(PasteDataRecord& record)
85 {
86     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
87     auto object = std::make_shared<Object>();
88     object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
89     object->value_[UDMF::FILE_URI_PARAM] = uri_;
90     object->value_[UDMF::FILE_TYPE] = "";
91     record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
92 }
93 
AddHtmlUdsEntry(PasteDataRecord & record)94 void PasteDataRecordTest::AddHtmlUdsEntry(PasteDataRecord& record)
95 {
96     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
97     auto object = std::make_shared<Object>();
98     object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
99     object->value_[UDMF::HTML_CONTENT] = html_;
100     record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
101 }
102 
AddLinkUdsEntry(PasteDataRecord & record)103 void PasteDataRecordTest::AddLinkUdsEntry(PasteDataRecord& record)
104 {
105     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK);
106     auto object = std::make_shared<Object>();
107     object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
108     object->value_[UDMF::URL] = link_;
109     record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
110 }
111 
AddPixelMapUdsEntry(PasteDataRecord & record)112 void PasteDataRecordTest::AddPixelMapUdsEntry(PasteDataRecord& record)
113 {
114     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
115     auto object = std::make_shared<Object>();
116     object->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
117     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
118     InitializationOptions opts = { { width_, height_ }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
119     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
120     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
121     object->value_[UDMF::PIXEL_MAP] = pixelMapIn;
122     record.AddEntry(utdId, std::make_shared<PasteDataEntry>(utdId, object));
123 }
124 
CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>> & entries)125 void PasteDataRecordTest::CheckEntries(const std::vector<std::shared_ptr<PasteDataEntry>>& entries)
126 {
127     for (auto const& entry : entries) {
128         if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT)) {
129             CheckPlainUds(entry);
130         }
131         if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI)) {
132             CheckFileUriUds(entry);
133         }
134         if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP)) {
135             CheckPixelMapUds(entry);
136         }
137         if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK)) {
138             CheckLinkUds(entry);
139         }
140         if (entry->GetUtdId() == UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML)) {
141             CheckHtmlUds(entry);
142         }
143     }
144 }
145 
CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)146 void PasteDataRecordTest::CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)
147 {
148     ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
149     auto decodeValue = entry->GetValue();
150     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
151     ASSERT_NE(object, nullptr);
152     auto objectValue = (*object)->value_;
153     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
154     ASSERT_NE(typeValue, nullptr);
155     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
156     auto value = std::get_if<std::string>(&objectValue[UDMF::CONTENT]);
157     ASSERT_NE(value, nullptr);
158     ASSERT_EQ(*value, text_);
159 }
160 
CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)161 void PasteDataRecordTest::CheckFileUriUds(const std::shared_ptr<PasteDataEntry> entry)
162 {
163     ASSERT_EQ(MIMETYPE_TEXT_URI, entry->GetMimeType());
164     auto decodeValue = entry->GetValue();
165     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
166     ASSERT_NE(object, nullptr);
167     auto objectValue = (*object)->value_;
168     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
169     ASSERT_NE(typeValue, nullptr);
170     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
171     auto value = std::get_if<std::string>(&objectValue[UDMF::FILE_URI_PARAM]);
172     ASSERT_NE(value, nullptr);
173     ASSERT_EQ(*value, uri_);
174 }
175 
CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)176 void PasteDataRecordTest::CheckHtmlUds(const std::shared_ptr<PasteDataEntry> entry)
177 {
178     ASSERT_EQ(MIMETYPE_TEXT_HTML, entry->GetMimeType());
179     auto decodeValue = entry->GetValue();
180     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
181     ASSERT_NE(object, nullptr);
182     auto objectValue = (*object)->value_;
183     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
184     ASSERT_NE(typeValue, nullptr);
185     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
186     auto value = std::get_if<std::string>(&objectValue[UDMF::HTML_CONTENT]);
187     ASSERT_NE(value, nullptr);
188     ASSERT_EQ(*value, html_);
189 }
190 
CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)191 void PasteDataRecordTest::CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)
192 {
193     ASSERT_EQ(MIMETYPE_PIXELMAP, entry->GetMimeType());
194     auto decodeValue = entry->GetValue();
195     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
196     ASSERT_NE(object, nullptr);
197     auto objectValue = (*object)->value_;
198     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
199     ASSERT_NE(typeValue, nullptr);
200     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
201     auto value = std::get_if<std::shared_ptr<PixelMap>>(&objectValue[UDMF::PIXEL_MAP]);
202     ASSERT_NE(value, nullptr);
203     ImageInfo imageInfo = {};
204     (*value)->GetImageInfo(imageInfo);
205     ASSERT_TRUE(imageInfo.size.height == height_);
206     ASSERT_TRUE(imageInfo.size.width == width_);
207     ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
208 }
209 
CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)210 void PasteDataRecordTest::CheckLinkUds(const std::shared_ptr<PasteDataEntry> entry)
211 {
212     ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
213     auto decodeValue = entry->GetValue();
214     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
215     ASSERT_NE(object, nullptr);
216     auto objectValue = (*object)->value_;
217     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
218     ASSERT_NE(typeValue, nullptr);
219     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
220     auto value = std::get_if<std::string>(&objectValue[UDMF::URL]);
221     ASSERT_NE(value, nullptr);
222     ASSERT_EQ(*value, link_);
223 }
224 
225 /**
226 * @tc.name: GetValidTypesTest001
227 * @tc.desc: GetValidTypesTest001;
228 * @tc.type: FUNC
229 * @tc.require:entries
230 * @tc.author: tarowang
231 */
232 HWTEST_F(PasteDataRecordTest, GetValidTypesTest001, TestSize.Level0)
233 {
234     std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
235     AddPlainUdsEntry(*record);
236     AddHtmlUdsEntry(*record);
237 
238     std::vector<std::string> inputTypes;
239     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
240     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
241 
242     auto validTypes = record->GetValidTypes(inputTypes);
243     ASSERT_EQ(validTypes.size(), 1);
244     ASSERT_EQ(validTypes[0], UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
245 }
246 
247 /**
248 * @tc.name: AddEntryTest001
249 * @tc.desc: Add entry test
250 * @tc.type: FUNC
251 * @tc.require:entries
252 * @tc.author: tarowang
253 */
254 HWTEST_F(PasteDataRecordTest, AddEntryTest001, TestSize.Level0)
255 {
256     std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
257     AddPlainUdsEntry(*record);
258     AddHtmlUdsEntry(*record);
259 }
260 
261 /**
262 * @tc.name: GetEntries001
263 * @tc.desc: convert to palinText;
264 * @tc.type: FUNC
265 * @tc.require:entries
266 * @tc.author: tarowang
267 */
268 HWTEST_F(PasteDataRecordTest, GetEntries001, TestSize.Level0)
269 {
270     std::vector<std::string> inputTypes;
271     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
272     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
273     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
274     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
275     inputTypes.emplace_back(UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
276 
277     std::shared_ptr<PasteDataRecord> record = std::make_shared<PasteDataRecord>();
278     AddPlainUdsEntry(*record);
279     auto types = record->GetValidTypes(inputTypes);
280     ASSERT_EQ(types.size(), 0);
281 
282     AddHtmlUdsEntry(*record);
283     types = record->GetValidTypes(inputTypes);
284     auto it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML));
285     ASSERT_NE(it, types.end());
286 
287     AddFileUriUdsEntry(*record);
288     types = record->GetValidTypes(inputTypes);
289     it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI));
290     ASSERT_NE(it, types.end());
291 
292     AddLinkUdsEntry(*record);
293     types = record->GetValidTypes(inputTypes);
294     it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HYPERLINK));
295     ASSERT_NE(it, types.end());
296 
297     AddPixelMapUdsEntry(*record);
298     types = record->GetValidTypes(inputTypes);
299     it = std::find(types.begin(), types.end(), UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
300     ASSERT_NE(it, types.end());
301 
302     auto entries = record->GetEntries();
303     CheckEntries(entries);
304 }
305 
306 } // namespace OHOS::MiscServices