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 "convert_utils.h"
19 #include "unified_meta.h"
20 
21 namespace OHOS::MiscServices {
22 using namespace testing::ext;
23 using namespace testing;
24 using namespace OHOS::Media;
25 class PasteDataEntryTest : public testing::Test {
26 public:
27     static void SetUpTestCase(void);
28     static void TearDownTestCase(void);
29     void SetUp();
30     void TearDown();
31 
32 protected:
33     PasteDataEntry InitPlaintTextEntry();
34     PasteDataEntry InitPixelMapEntry();
35     PasteDataEntry InitUriEntry();
36     PasteDataEntry InitWantEntry();
37     PasteDataEntry InitHtmlEntry();
38     void CheckPlainUds(std::shared_ptr<PasteDataEntry> entry);
39     void CheckPixelMapUds(std::shared_ptr<PasteDataEntry> entry);
40     std::string text_ = "test_string";
41     std::string uri_ = "file://test_uri";
42     std::string html_ = "<div class='disable'>helloWorld</div>";
43     int32_t width_ = 5;
44     int32_t height_ = 7;
45 };
46 
SetUpTestCase(void)47 void PasteDataEntryTest::SetUpTestCase(void) {}
48 
TearDownTestCase(void)49 void PasteDataEntryTest::TearDownTestCase(void) {}
50 
SetUp(void)51 void PasteDataEntryTest::SetUp(void) {}
52 
TearDown(void)53 void PasteDataEntryTest::TearDown(void) {}
54 
InitPlaintTextEntry()55 PasteDataEntry PasteDataEntryTest::InitPlaintTextEntry()
56 {
57     auto udsObject = std::make_shared<Object>();
58     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
59     udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
60     udsObject->value_[UDMF::CONTENT] = text_;
61     return { utdId, udsObject };
62 }
63 
InitUriEntry()64 PasteDataEntry PasteDataEntryTest::InitUriEntry()
65 {
66     auto udsObject = std::make_shared<Object>();
67     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
68     udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
69     udsObject->value_[UDMF::FILE_URI_PARAM] = uri_;
70     udsObject->value_[UDMF::FILE_TYPE] = "";
71     return { utdId, udsObject };
72 }
73 
InitWantEntry()74 PasteDataEntry PasteDataEntryTest::InitWantEntry()
75 {
76     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
77     using namespace OHOS::AAFwk;
78     std::shared_ptr<Want> want = std::make_shared<Want>();
79     std::string idKey = "id";
80     int32_t idValue = 123;
81     std::string deviceKey = "deviceId_key";
82     want->SetParam(idKey, idValue);
83     return { utdId, want };
84 }
85 
InitHtmlEntry()86 PasteDataEntry PasteDataEntryTest::InitHtmlEntry()
87 {
88     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
89     auto udsObject = std::make_shared<Object>();
90     udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
91     udsObject->value_[UDMF::HTML_CONTENT] = html_;
92     return { utdId, udsObject };
93 }
94 
InitPixelMapEntry()95 PasteDataEntry PasteDataEntryTest::InitPixelMapEntry()
96 {
97     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
98     auto udsObject = std::make_shared<Object>();
99     udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
100     uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
101     InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
102     std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
103     std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
104     udsObject->value_[UDMF::PIXEL_MAP] = pixelMapIn;
105     return { utdId, udsObject };
106 }
107 
CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)108 void PasteDataEntryTest::CheckPlainUds(const std::shared_ptr<PasteDataEntry> entry)
109 {
110     ASSERT_NE(entry, nullptr);
111     ASSERT_EQ(MIMETYPE_TEXT_PLAIN, entry->GetMimeType());
112     auto decodeValue = entry->GetValue();
113     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
114     ASSERT_NE(object, nullptr);
115     auto objectValue = (*object)->value_;
116     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
117     ASSERT_NE(typeValue, nullptr);
118     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT));
119     auto value = std::get_if<std::string>(&objectValue[UDMF::CONTENT]);
120     ASSERT_NE(value, nullptr);
121     ASSERT_EQ(*value, text_);
122 }
123 
CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)124 void PasteDataEntryTest::CheckPixelMapUds(const std::shared_ptr<PasteDataEntry> entry)
125 {
126     ASSERT_NE(entry, nullptr);
127     ASSERT_EQ(MIMETYPE_PIXELMAP, entry->GetMimeType());
128     auto decodeValue = entry->GetValue();
129     auto object = std::get_if<std::shared_ptr<Object>>(&decodeValue);
130     ASSERT_NE(object, nullptr);
131     auto objectValue = (*object)->value_;
132     auto typeValue = std::get_if<std::string>(&objectValue[UDMF::UNIFORM_DATA_TYPE]);
133     ASSERT_NE(typeValue, nullptr);
134     ASSERT_EQ(*typeValue, UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP));
135     auto value = std::get_if<std::shared_ptr<PixelMap>>(&objectValue[UDMF::PIXEL_MAP]);
136     ASSERT_NE(value, nullptr);
137     ImageInfo imageInfo = {};
138     (*value)->GetImageInfo(imageInfo);
139     ASSERT_TRUE(imageInfo.size.height == 7);
140     ASSERT_TRUE(imageInfo.size.width == 5);
141     ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
142 }
143 
144 /**
145 * @tc.name: Convert001
146 * @tc.desc: convert to palinText;
147 * @tc.type: FUNC
148 * @tc.require:entries
149 * @tc.author: tarowang
150 */
HWTEST_F(PasteDataEntryTest, Convert001, TestSize.Level0)151 HWTEST_F(PasteDataEntryTest, Convert001, TestSize.Level0)
152 {
153     auto entry = InitPlaintTextEntry();
154     auto str = entry.ConvertToPlianText();
155     ASSERT_NE(nullptr, str);
156     EXPECT_EQ(text_, *str);
157 
158     entry = InitHtmlEntry();
159     auto html = entry.ConvertToHtml();
160     ASSERT_NE(nullptr, html);
161     EXPECT_EQ(html_, *html);
162 
163     entry = InitUriEntry();
164     auto uri = entry.ConvertToUri();
165     ASSERT_NE(nullptr, uri);
166     EXPECT_EQ(uri_, uri->ToString());
167 
168     entry = InitWantEntry();
169     auto want = entry.ConvertToWant();
170     ASSERT_NE(nullptr, want);
171     int32_t idValue1 = want->GetIntParam("id", 0);
172     ASSERT_EQ(idValue1, 123);
173 
174     entry = InitPixelMapEntry();
175     auto pixelMap = entry.ConvertToPixelMap();
176     ASSERT_NE(nullptr, pixelMap);
177     ImageInfo imageInfo = {};
178     pixelMap->GetImageInfo(imageInfo);
179     ASSERT_TRUE(imageInfo.size.height == height_);
180     ASSERT_TRUE(imageInfo.size.width == width_);
181     ASSERT_TRUE(imageInfo.pixelFormat == PixelFormat::ARGB_8888);
182 }
183 
184 /**
185 * @tc.name: EntriesTest001
186 * @tc.desc:
187 * @tc.type: FUNC
188 * @tc.require:
189 * @tc.author:tarowang
190 */
HWTEST_F(PasteDataEntryTest, EntryTlvTest001, TestSize.Level0)191 HWTEST_F(PasteDataEntryTest, EntryTlvTest001, TestSize.Level0)
192 {
193     PasteDataEntry entry;
194     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
195     entry.SetUtdId(utdId);
196     entry.SetMimeType(MIMETYPE_TEXT_PLAIN);
197     entry.SetValue(text_);
198 
199     std::vector<std::uint8_t> buffer;
200     entry.Marshalling(buffer);
201     PasteDataEntry decodePasteEntry;
202     auto ret = decodePasteEntry.Unmarshalling(buffer);
203 
204     ASSERT_EQ(ret, true);
205     ASSERT_EQ(decodePasteEntry.GetUtdId(), utdId);
206     ASSERT_EQ(decodePasteEntry.GetMimeType(), MIMETYPE_TEXT_PLAIN);
207     auto value = decodePasteEntry.GetValue();
208     auto str = std::get_if<std::string>(&value);
209     ASSERT_NE(str, nullptr);
210     ASSERT_EQ(text_, *str);
211 }
212 
213 /**
214 * @tc.name: EntryTlvTest002
215 * @tc.desc:
216 * @tc.type: FUNC
217 * @tc.require:
218 * @tc.author:tarowang
219 */
HWTEST_F(PasteDataEntryTest, EntryTlvTest002, TestSize.Level0)220 HWTEST_F(PasteDataEntryTest, EntryTlvTest002, TestSize.Level0)
221 {
222     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
223     auto entry = InitPlaintTextEntry();
224     std::vector<std::uint8_t> buffer;
225     entry.Marshalling(buffer);
226     PasteDataEntry decodePasteEntry;
227     auto ret = decodePasteEntry.Unmarshalling(buffer);
228     ASSERT_EQ(ret, true);
229     ASSERT_EQ(decodePasteEntry.GetUtdId(), utdId);
230     ASSERT_EQ(decodePasteEntry.GetMimeType(), MIMETYPE_TEXT_PLAIN);
231     CheckPlainUds(std::make_shared<PasteDataEntry>(decodePasteEntry));
232 }
233 
234 /**
235 * @tc.name: EntryTlvTest003
236 * @tc.desc:
237 * @tc.type: EntryTlvTest003 with pixelMap
238 * @tc.require:
239 * @tc.author:tarowang
240 */
HWTEST_F(PasteDataEntryTest, EntryTlvTest003, TestSize.Level0)241 HWTEST_F(PasteDataEntryTest, EntryTlvTest003, TestSize.Level0)
242 {
243     auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
244     auto entry = InitPixelMapEntry();
245     std::vector<std::uint8_t> buffer;
246     entry.Marshalling(buffer);
247     PasteDataEntry decodePasteEntry;
248     auto ret = decodePasteEntry.Unmarshalling(buffer);
249     ASSERT_EQ(ret, true);
250     ASSERT_EQ(decodePasteEntry.GetUtdId(), utdId);
251     ASSERT_EQ(decodePasteEntry.GetMimeType(), MIMETYPE_PIXELMAP);
252     CheckPixelMapUds(std::make_shared<PasteDataEntry>(decodePasteEntry));
253 }
254 } // namespace OHOS::MiscServices