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 "convert_utils.h"
17 #include <gtest/gtest.h>
18 #include "unified_meta.h"
19
20 namespace OHOS::MiscServices {
21 using namespace testing::ext;
22 using namespace testing;
23 using namespace OHOS::Media;
24 class PasteDataEntryTest : public testing::Test {
25 public:
26 static void SetUpTestCase(void);
27 static void TearDownTestCase(void);
28 void SetUp();
29 void TearDown();
30
31 protected:
32 PasteDataEntry InitPlaintTextEntry();
33 PasteDataEntry InitPixelMapEntry();
34 PasteDataEntry InitUriEntry();
35 PasteDataEntry InitWantEntry();
36 PasteDataEntry InitHtmlEntry();
37 void CheckPlainUds(std::shared_ptr<PasteDataEntry> entry);
38 void CheckPixelMapUds(std::shared_ptr<PasteDataEntry> entry);
39 std::string text_ = "test_string";
40 std::string uri_ = "file://test_uri";
41 std::string html_ = "<div class='disable'>helloWorld</div>";
42 int32_t width_ = 5;
43 int32_t height_ = 7;
44 };
45
SetUpTestCase(void)46 void PasteDataEntryTest::SetUpTestCase(void) {}
47
TearDownTestCase(void)48 void PasteDataEntryTest::TearDownTestCase(void) {}
49
SetUp(void)50 void PasteDataEntryTest::SetUp(void) {}
51
TearDown(void)52 void PasteDataEntryTest::TearDown(void) {}
53
InitPlaintTextEntry()54 PasteDataEntry PasteDataEntryTest::InitPlaintTextEntry()
55 {
56 auto udsObject = std::make_shared<Object>();
57 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
58 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
59 udsObject->value_[UDMF::CONTENT] = text_;
60 return {utdId, udsObject};
61 }
62
InitUriEntry()63 PasteDataEntry PasteDataEntryTest::InitUriEntry()
64 {
65 auto udsObject = std::make_shared<Object>();
66 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::FILE_URI);
67 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
68 udsObject->value_[UDMF::FILE_URI_PARAM] = uri_;
69 udsObject->value_[UDMF::FILE_TYPE] = "";
70 return {utdId, udsObject};
71 }
72
InitWantEntry()73 PasteDataEntry PasteDataEntryTest::InitWantEntry()
74 {
75 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::OPENHARMONY_WANT);
76 using namespace OHOS::AAFwk;
77 std::shared_ptr<Want> want = std::make_shared<Want>();
78 std::string idKey = "id";
79 int32_t idValue = 123;
80 std::string deviceKey = "deviceId_key";
81 want->SetParam(idKey, idValue);
82 return {utdId, want};
83 }
84
InitHtmlEntry()85 PasteDataEntry PasteDataEntryTest::InitHtmlEntry()
86 {
87 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::HTML);
88 auto udsObject = std::make_shared<Object>();
89 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
90 udsObject->value_[UDMF::HTML_CONTENT] = html_;
91 return {utdId, udsObject};
92 }
93
InitPixelMapEntry()94 PasteDataEntry PasteDataEntryTest::InitPixelMapEntry()
95 {
96 auto utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::SYSTEM_DEFINED_PIXEL_MAP);
97 auto udsObject = std::make_shared<Object>();
98 udsObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
99 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
100 InitializationOptions opts = { { 5, 7 }, PixelFormat::ARGB_8888, PixelFormat::ARGB_8888 };
101 std::unique_ptr<PixelMap> pixelMap = PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
102 std::shared_ptr<PixelMap> pixelMapIn = move(pixelMap);
103 udsObject->value_[UDMF::PIXEL_MAP] = pixelMapIn;
104 return {utdId, udsObject};
105 }
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 */
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 */
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 */
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 */
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