1 /*
2 * Copyright (c) 2022-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 "long_wrapper.h"
19 #include "pasteboard_client.h"
20 #include "pasteboard_hilog.h"
21
22 namespace OHOS::MiscServices {
23 using namespace testing::ext;
24 using namespace OHOS::AAFwk;
25 class TLVObjectTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31
32 static std::shared_ptr<PasteDataRecord> GenRecord(std::uint32_t index);
33 };
34
SetUpTestCase(void)35 void TLVObjectTest::SetUpTestCase(void) { }
36
TearDownTestCase(void)37 void TLVObjectTest::TearDownTestCase(void) { }
38
SetUp(void)39 void TLVObjectTest::SetUp(void) { }
40
TearDown(void)41 void TLVObjectTest::TearDown(void) { }
42
GenRecord(std::uint32_t index)43 std::shared_ptr<PasteDataRecord> TLVObjectTest::GenRecord(std::uint32_t index)
44 {
45 std::string indexStr = "";
46 auto plainText = std::make_shared<std::string>("hello" + indexStr);
47 auto htmlText = std::make_shared<std::string>("<span>hello" + indexStr + "</span>");
48 auto uri = std::make_shared<OHOS::Uri>("dataability://hello" + indexStr + ".txt");
49 std::shared_ptr<Want> want = std::make_shared<Want>();
50 std::string key = "id";
51 int32_t id = 456;
52 want->SetParam(key, id);
53
54 PasteDataRecord::Builder builder(MIMETYPE_TEXT_HTML);
55 auto record1 = builder.SetPlainText(plainText).SetHtmlText(htmlText).SetUri(uri).SetWant(want).Build();
56 return record1;
57 }
58
59 /**
60 * @tc.name: TLVOjbectTest001
61 * @tc.desc: test tlv coder.
62 * @tc.type: FUNC
63 * @tc.require:AR000H5I1D
64 * @tc.author: baoyayong
65 */
66 HWTEST_F(TLVObjectTest, TLVOjbectTest001, TestSize.Level0)
67 {
68 PasteData pasteData1;
69 for (uint32_t i = 0; i < 10; ++i) {
70 pasteData1.AddRecord(TLVObjectTest::GenRecord(i));
71 }
72
73 std::vector<uint8_t> buffer;
74 auto ret = pasteData1.Encode(buffer);
75 ASSERT_TRUE(ret);
76 ASSERT_EQ(buffer.size(), pasteData1.CountTLV());
77
78 PasteData pasteData2;
79 ret = pasteData2.Decode(buffer);
80 EXPECT_TRUE(ret);
81 EXPECT_EQ(pasteData2.GetRecordCount(), pasteData1.GetRecordCount());
82
83 for (uint32_t i = 0; i < 10; ++i) {
84 auto record2 = pasteData2.GetRecordAt(i);
85 auto record1 = pasteData1.GetRecordAt(i);
86 EXPECT_EQ(*(record2->GetHtmlText()), *(record1->GetHtmlText()));
87 EXPECT_EQ(*(record2->GetPlainText()), *(record1->GetPlainText()));
88 EXPECT_TRUE(record2->GetUri()->ToString() == record1->GetUri()->ToString());
89 EXPECT_EQ(record2->GetWant()->OperationEquals(*(record1->GetWant())), true);
90 }
91 }
92
93 /**
94 * @tc.name: TLVOjbectTest002
95 * @tc.desc: test tlv coder.
96 * @tc.type: FUNC
97 * @tc.require:AR000H5I1D
98 * @tc.author: baoyayong
99 */
100 HWTEST_F(TLVObjectTest, TLVOjbectTest002, TestSize.Level0)
101 {
102 std::shared_ptr<Want> want = std::make_shared<Want>();
103 std::string key = "id";
104 int32_t id = 456;
105 Want wantIn = want->SetParam(key, id);
106 auto pasteData1 = PasteboardClient::GetInstance()->CreateWantData(std::make_shared<Want>(wantIn));
107
108 std::vector<uint8_t> buffer;
109 auto ret = pasteData1->Encode(buffer);
110 ASSERT_TRUE(ret);
111 ASSERT_EQ(buffer.size(), pasteData1->CountTLV());
112
113 PasteData pasteData2;
114 ret = pasteData2.Decode(buffer);
115 EXPECT_TRUE(ret);
116 EXPECT_EQ(pasteData2.GetRecordCount(), pasteData1->GetRecordCount());
117
118 auto record2 = pasteData2.GetRecordAt(0);
119 auto record1 = pasteData1->GetRecordAt(0);
120 EXPECT_EQ(record2->GetWant()->OperationEquals(*(record1->GetWant())), true);
121 }
122
123 /**
124 * @tc.name: TLVOjbectTest003
125 * @tc.desc: test tlv coder map.
126 * @tc.type: FUNC
127 * @tc.require:AR000H5I1D
128 * @tc.author: baoyayong
129 */
130 HWTEST_F(TLVObjectTest, TLVOjbectTest003, TestSize.Level0)
131 {
132 std::string plainText = "plain text";
133 auto pasteData1 = PasteboardClient::GetInstance()->CreatePlainTextData(plainText);
134 std::vector<uint8_t> arrayBuffer(46);
135 arrayBuffer = { 2, 7, 6, 8, 9 };
136 std::string mimeType1 = "image/jpg";
137 std::shared_ptr<MineCustomData> customData = std::make_shared<MineCustomData>();
138 customData->AddItemData(mimeType1, arrayBuffer);
139 PasteDataRecord::Builder builder(MIMETYPE_TEXT_PLAIN);
140 std::shared_ptr<PasteDataRecord> pasteDataRecord = builder.SetCustomData(customData).Build();
141 pasteData1->AddRecord(pasteDataRecord);
142
143 std::vector<uint8_t> buffer;
144 auto ret = pasteData1->Encode(buffer);
145 ASSERT_TRUE(ret);
146 ASSERT_EQ(buffer.size(), pasteData1->CountTLV());
147
148 PasteData pasteData2;
149 ret = pasteData2.Decode(buffer);
150 EXPECT_TRUE(ret);
151 EXPECT_EQ(pasteData2.GetRecordCount(), pasteData1->GetRecordCount());
152 EXPECT_EQ(pasteData2.GetRecordCount(), pasteData1->GetRecordCount());
153
154 auto record1 = pasteData1->GetRecordAt(0);
155 auto record2 = pasteData2.GetRecordAt(0);
156 ASSERT_TRUE(record2 != nullptr);
157 auto custom2 = record2->GetCustomData();
158 auto custom1 = record1->GetCustomData();
159 ASSERT_TRUE(custom1 != nullptr && custom2 != nullptr);
160 EXPECT_EQ(custom2->GetItemData().size(), custom1->GetItemData().size());
161 }
162
163 /**
164 * @tc.name: TestPasteDataProperty
165 * @tc.desc: PasteDataProperty
166 * @tc.type: FUNC
167 */
168 HWTEST_F(TLVObjectTest, TestPasteDataProperty, TestSize.Level0)
169 {
170 PasteDataProperty obj1;
171 obj1.mimeTypes = {
172 MIMETYPE_PIXELMAP, MIMETYPE_TEXT_HTML, MIMETYPE_TEXT_PLAIN, MIMETYPE_TEXT_URI, MIMETYPE_TEXT_WANT,
173 };
174 obj1.additions.SetParam("key", AAFwk::Long::Box(1));
175 obj1.tag = "tag";
176 obj1.timestamp = 1;
177 obj1.localOnly = true;
178 obj1.shareOption = ShareOption::CrossDevice;
179 obj1.tokenId = 1;
180 obj1.isRemote = true;
181 obj1.bundleName = "bundleName";
182 obj1.setTime = "setTime";
183 obj1.screenStatus = ScreenEvent::ScreenUnlocked;
184
185 std::vector<uint8_t> buffer;
186 bool ret = obj1.Encode(buffer);
187 ASSERT_TRUE(ret);
188
189 PasteDataProperty obj2;
190 ret = obj2.Decode(buffer);
191 ASSERT_TRUE(ret);
192
193 EXPECT_TRUE(obj1.additions == obj2.additions);
194 EXPECT_EQ(obj1.mimeTypes, obj2.mimeTypes);
195 EXPECT_EQ(obj1.tag, obj2.tag);
196 EXPECT_EQ(obj1.timestamp, obj2.timestamp);
197 EXPECT_EQ(obj1.localOnly, obj2.localOnly);
198 EXPECT_EQ(obj1.shareOption, obj2.shareOption);
199 EXPECT_EQ(obj1.tokenId, obj2.tokenId);
200 EXPECT_EQ(obj1.isRemote, obj2.isRemote);
201 EXPECT_EQ(obj1.bundleName, obj2.bundleName);
202 EXPECT_EQ(obj1.setTime, obj2.setTime);
203 EXPECT_EQ(obj1.screenStatus, obj2.screenStatus);
204 }
205
206 /**
207 * @tc.name: TestMineCustomData
208 * @tc.desc: MineCustomData
209 * @tc.type: FUNC
210 */
211 HWTEST_F(TLVObjectTest, TestMineCustomData, TestSize.Level0)
212 {
213 MineCustomData obj1;
214 obj1.AddItemData("key", {1, 1, 1, 1});
215
216 std::vector<uint8_t> buffer;
217 bool ret = obj1.Encode(buffer);
218 ASSERT_TRUE(ret);
219
220 MineCustomData obj2;
221 ret = obj2.Decode(buffer);
222 ASSERT_TRUE(ret);
223
224 EXPECT_EQ(obj1.GetItemData(), obj2.GetItemData());
225 }
226
227 /**
228 * @tc.name: TestPasteDataEntry
229 * @tc.desc: PasteDataEntry
230 * @tc.type: FUNC
231 */
232 HWTEST_F(TLVObjectTest, TestPasteDataEntry, TestSize.Level0)
233 {
234 PasteDataEntry obj1;
235 obj1.SetUtdId("utdId");
236 obj1.SetMimeType("mimeType");
237 auto udmfObject = std::make_shared<Object>();
238 udmfObject->value_["key"] = "value";
239 obj1.SetValue(udmfObject);
240
241 std::vector<uint8_t> buffer;
242 bool ret = obj1.Encode(buffer);
243 ASSERT_TRUE(ret);
244
245 PasteDataEntry obj2;
246 ret = obj2.Decode(buffer);
247 ASSERT_TRUE(ret);
248
249 EXPECT_EQ(obj1.GetUtdId(), obj2.GetUtdId());
250 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
251
252 auto entryValue = obj2.GetValue();
253 ASSERT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(entryValue));
254 auto udmfObject2 = std::get<std::shared_ptr<Object>>(entryValue);
255 ASSERT_NE(udmfObject2, nullptr);
256 EXPECT_EQ(udmfObject->value_, udmfObject2->value_);
257 }
258
259 /**
260 * @tc.name: TestPasteDataRecord
261 * @tc.desc: PasteDataRecord
262 * @tc.type: FUNC
263 */
264 HWTEST_F(TLVObjectTest, TestPasteDataRecord, TestSize.Level0)
265 {
266 PasteDataRecord obj1;
267 auto udmfObject = std::make_shared<Object>();
268 std::string utdId = UDMF::UtdUtils::GetUtdIdFromUtdEnum(UDMF::PLAIN_TEXT);
269 udmfObject->value_[UDMF::UNIFORM_DATA_TYPE] = utdId;
270 udmfObject->value_[UDMF::CONTENT] = "content";
271 auto entry1 = std::make_shared<PasteDataEntry>();
272 entry1->SetValue(udmfObject);
273 entry1->SetUtdId(utdId);
274 entry1->SetMimeType(MIMETYPE_TEXT_PLAIN);
275 obj1.AddEntry(utdId, entry1);
276
277 std::vector<uint8_t> buffer;
278 bool ret = obj1.Encode(buffer);
279 ASSERT_TRUE(ret);
280
281 PasteDataRecord obj2;
282 ret = obj2.Decode(buffer);
283 ASSERT_TRUE(ret);
284
285 EXPECT_EQ(obj1.GetMimeType(), obj2.GetMimeType());
286 auto entry2 = obj2.GetEntry(utdId);
287 ASSERT_NE(entry2, nullptr);
288 auto entryValue = entry2->GetValue();
289 ASSERT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(entryValue));
290 auto udmfObject2 = std::get<std::shared_ptr<Object>>(entryValue);
291 ASSERT_NE(udmfObject2, nullptr);
292 EXPECT_EQ(udmfObject->value_, udmfObject2->value_);
293 }
294 } // namespace OHOS::MiscServices
295