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 #define LOG_TAG "NdkDataConversionTest"
17
18 #include "ndk_data_conversion.h"
19 #include <gtest/gtest.h>
20 #include <memory>
21 #include "token_setproc.h"
22 #include "accesstoken_kit.h"
23 #include "nativetoken_kit.h"
24 #include "logger.h"
25 #include "application_defined_record.h"
26 #include "error_code.h"
27 #include "html.h"
28 #include "udmf.h"
29 #include "udmf_capi_common.h"
30 #include "udmf_client.h"
31 #include "udmf_meta.h"
32 #include "uds.h"
33 #include "unified_data.h"
34 #include "pixelmap_native_impl.h"
35 #include "system_defined_pixelmap.h"
36
37 using namespace testing::ext;
38 using namespace OHOS::Security::AccessToken;
39 using namespace OHOS::UDMF;
40 using namespace OHOS;
41
42 namespace OHOS::Test {
43 class NdkDataConversionTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47 void SetUp();
48 void TearDown();
49 static void AllocHapToken1();
50 static void AllocHapToken2();
51 void SetHapToken1();
52 static constexpr int USER_ID = 100;
53 static constexpr int INST_INDEX = 0;
54 };
55
SetUpTestCase()56 void NdkDataConversionTest::SetUpTestCase()
57 {
58 AllocHapToken1();
59 AllocHapToken2();
60 }
61
TearDownTestCase()62 void NdkDataConversionTest::TearDownTestCase()
63 {
64 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
65 AccessTokenKit::DeleteToken(tokenId);
66 tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo2", INST_INDEX);
67 AccessTokenKit::DeleteToken(tokenId);
68 }
69
SetUp()70 void NdkDataConversionTest::SetUp()
71 {
72 SetHapToken1();
73 }
74
TearDown()75 void NdkDataConversionTest::TearDown() {}
76
AllocHapToken1()77 void NdkDataConversionTest::AllocHapToken1()
78 {
79 HapInfoParams info = {
80 .userID = USER_ID,
81 .bundleName = "ohos.test.demo1",
82 .instIndex = INST_INDEX,
83 .appIDDesc = "ohos.test.demo1"
84 };
85
86 HapPolicyParams policy = {
87 .apl = APL_NORMAL,
88 .domain = "test.domain",
89 .permList = { {
90 .permissionName = "ohos.permission.test",
91 .bundleName = "ohos.test.demo1",
92 .grantMode = 1,
93 .availableLevel = APL_NORMAL,
94 .label = "label",
95 .labelId = 1,
96 .description = "test1",
97 .descriptionId = 1 } },
98 .permStateList = { {
99 .permissionName = "ohos.permission.test",
100 .isGeneral = true,
101 .resDeviceID = { "local" },
102 .grantStatus = { PermissionState::PERMISSION_GRANTED },
103 .grantFlags = { 1 } } }
104 };
105 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
106 SetSelfTokenID(tokenID.tokenIDEx);
107 }
108
AllocHapToken2()109 void NdkDataConversionTest::AllocHapToken2()
110 {
111 HapInfoParams info = {
112 .userID = USER_ID,
113 .bundleName = "ohos.test.demo2",
114 .instIndex = INST_INDEX,
115 .appIDDesc = "ohos.test.demo2"
116 };
117
118 HapPolicyParams policy = {
119 .apl = APL_NORMAL,
120 .domain = "test.domain",
121 .permList = { {
122 .permissionName = "ohos.permission.test",
123 .bundleName = "ohos.test.demo2",
124 .grantMode = 1,
125 .availableLevel = APL_NORMAL,
126 .label = "label",
127 .labelId = 1,
128 .description = "test2",
129 .descriptionId = 1 } },
130 .permStateList = { {
131 .permissionName = "ohos.permission.test",
132 .isGeneral = true,
133 .resDeviceID = { "local" },
134 .grantStatus = { PermissionState::PERMISSION_GRANTED },
135 .grantFlags = { 1 } } }
136 };
137 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
138 SetSelfTokenID(tokenID.tokenIDEx);
139 }
140
SetHapToken1()141 void NdkDataConversionTest::SetHapToken1()
142 {
143 auto tokenId = AccessTokenKit::GetHapTokenID(USER_ID, "ohos.test.demo1", INST_INDEX);
144 SetSelfTokenID(tokenId);
145 }
146
147 /* *
148 * @tc.name: GetNativeUnifiedData_001
149 * @tc.desc: Normal testcase of GetNativeUnifiedData
150 * @tc.type: FUNC
151 */
152 HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_001, TestSize.Level1)
153 {
154 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_001 begin.");
155 auto unifiedRecord = std::make_shared<UnifiedRecord>();
156 const std::string uid("typeId");
157 unifiedRecord->SetUid(uid);
158 OH_UdmfData *ndkData = OH_UdmfData_Create();
159 ndkData->unifiedData_->AddRecord(unifiedRecord);
160 auto data = std::make_shared<UnifiedData>();
161
162 Status status = NdkDataConversion::GetNativeUnifiedData(ndkData, data);
163 ASSERT_EQ(E_OK, status);
164 EXPECT_EQ("typeId", data->GetRecordAt(0)->GetUid());
165
166 OH_UdmfData *ndkDataNull = nullptr;
167 status = NdkDataConversion::GetNativeUnifiedData(ndkDataNull, data);
168 ASSERT_EQ(E_INVALID_PARAMETERS, status);
169
170 std::shared_ptr<UnifiedData> dataNull;
171 status = NdkDataConversion::GetNativeUnifiedData(ndkData, dataNull);
172 OH_UdmfData_Destroy(ndkData);
173 ASSERT_EQ(E_INVALID_PARAMETERS, status);
174 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_001 end.");
175 }
176
177 /* *
178 * @tc.name: GetNativeUnifiedData_002
179 * @tc.desc: Normal testcase of GetNativeUnifiedData
180 * @tc.type: FUNC
181 */
182 HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_002, TestSize.Level1)
183 {
184 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_002 begin.");
185 auto plainText = OH_UdsPlainText_Create();
186 OH_UdmfData *fakeNdkData = reinterpret_cast<OH_UdmfData *>(plainText);
187 auto data = std::make_shared<UnifiedData>();
188 Status status = NdkDataConversion::GetNativeUnifiedData(fakeNdkData, data);
189 OH_UdsPlainText_Destroy(plainText);
190 ASSERT_EQ(E_INVALID_PARAMETERS, status);
191 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_002 end.");
192 }
193
194 /* *
195 * @tc.name: GetNdkUnifiedData_001
196 * @tc.desc: Error testcase of GetNdkUnifiedData
197 * @tc.type: FUNC
198 */
199 HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_001, TestSize.Level1)
200 {
201 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_001 begin.");
202 auto unifiedRecord = std::make_shared<UnifiedRecord>();
203 const std::string uid("typeId");
204 unifiedRecord->SetUid(uid);
205 auto data = std::make_shared<UnifiedData>();
206 data->AddRecord(unifiedRecord);
207 OH_UdmfData *ndkData = OH_UdmfData_Create();
208 Status status = NdkDataConversion::GetNdkUnifiedData(data, ndkData);
209 ASSERT_EQ(E_OK, status);
210 EXPECT_EQ("typeId", ndkData->unifiedData_->GetRecordAt(0)->GetUid());
211
212 OH_UdmfData *ndkDataNull = nullptr;
213 status = NdkDataConversion::GetNdkUnifiedData(data, ndkDataNull);
214 ASSERT_EQ(E_INVALID_PARAMETERS, status);
215
216 std::shared_ptr<UnifiedData> dataNull;
217 status = NdkDataConversion::GetNdkUnifiedData(dataNull, ndkData);
218 OH_UdmfData_Destroy(ndkData);
219 ASSERT_EQ(E_INVALID_PARAMETERS, status);
220 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_001 end.");
221 }
222
223 /* *
224 * @tc.name: GetNdkUnifiedData_002
225 * @tc.desc: Error testcase of GetNdkUnifiedData
226 * @tc.type: FUNC
227 */
228 HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_002, TestSize.Level1)
229 {
230 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_002 begin.");
231 auto plainText = OH_UdsPlainText_Create();
232 OH_UdmfData *fakeNdkData = reinterpret_cast<OH_UdmfData *>(plainText);
233 auto data = std::make_shared<UnifiedData>();
234 Status status = NdkDataConversion::GetNdkUnifiedData(data, fakeNdkData);
235 OH_UdsPlainText_Destroy(plainText);
236 ASSERT_EQ(E_INVALID_PARAMETERS, status);
237 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_002 end.");
238 }
239
240 /* *
241 * @tc.name: ConvertPixelMap_001
242 * @tc.desc: test pixel-map conversion between JS and C-API
243 * @tc.type: FUNC
244 */
245 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_001, TestSize.Level1)
246 {
247 LOG_INFO(UDMF_TEST, "ConvertPixelMap_001 begin.");
248 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
249 OHOS::Media::InitializationOptions opts = { { 5, 7 },
250 Media::PixelFormat::ARGB_8888,
251 Media::PixelFormat::ARGB_8888 };
252 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
253 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
254 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
255
256 auto pixelMapUds = OH_UdsPixelMap_Create();
257 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(pixelMapIn);
258 OH_UdsPixelMap_SetPixelMap(pixelMapUds, ohPixelmapNative);
259 auto record = OH_UdmfRecord_Create();
260 OH_UdmfRecord_AddPixelMap(record, pixelMapUds);
261 auto data = OH_UdmfData_Create();
262 OH_UdmfData_AddRecord(data, record);
263 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
264 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(data, unifiedData);
265 EXPECT_EQ(conversionStatus, E_OK);
266 std::string key;
267 CustomOption option = {
268 .intention = UD_INTENTION_DRAG
269 };
270 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
271 EXPECT_EQ(setRet, E_OK);
272
273 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
274 QueryOption query = {
275 .key = key
276 };
277 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
278 EXPECT_EQ(getRet, E_OK);
279
280 auto readRecord = readData->GetRecordAt(0);
281 auto systemDefinedPixelMap = std::static_pointer_cast<SystemDefinedPixelMap>(readRecord);
282 auto rawData = systemDefinedPixelMap->GetRawData();
283 EXPECT_GT(rawData.size(), 0);
284
285 OH_UdsPixelMap_Destroy(pixelMapUds);
286 OH_UdmfRecord_Destroy(record);
287 OH_UdmfData_Destroy(data);
288 delete ohPixelmapNative;
289 LOG_INFO(UDMF_TEST, "ConvertPixelMap_001 end.");
290 }
291
292 /* *
293 * @tc.name: ConvertPixelMap_002
294 * @tc.desc: test pixel-map conversion between JS and C-API
295 * @tc.type: FUNC
296 */
297 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_002, TestSize.Level1)
298 {
299 LOG_INFO(UDMF_TEST, "ConvertPixelMap_002 begin.");
300 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
301 OHOS::Media::InitializationOptions opts = { { 5, 7 },
302 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
303 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
304 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
305 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
306
307 std::shared_ptr<SystemDefinedPixelMap> systemDefinedPixelMap =
308 std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, pixelMapIn);
309 UnifiedData data;
310 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
311 data.SetRecords(records);
312
313 std::string key;
314 CustomOption option = { .intention = UD_INTENTION_DRAG };
315 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
316 EXPECT_EQ(setRet, E_OK);
317
318 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
319 QueryOption query = { .key = key };
320 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
321 EXPECT_EQ(getRet, E_OK);
322
323 auto ndkData = OH_UdmfData_Create();
324 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
325 unsigned int count;
326 OH_UdmfData_GetRecords(ndkData, &count);
327 EXPECT_EQ(1, count);
328 auto record = OH_UdmfData_GetRecord(ndkData, 0);
329 auto pixelMapUds = OH_UdsPixelMap_Create();
330 OH_UdmfRecord_GetPixelMap(record, pixelMapUds);
331 auto type = OH_UdsPixelMap_GetType(pixelMapUds);
332 EXPECT_EQ(std::string(type), std::string(UDMF_META_OPENHARMONY_PIXEL_MAP));
333
334 OHOS::Media::InitializationOptions opts2 = { { 10, 10 },
335 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
336 std::unique_ptr<OHOS::Media::PixelMap> pixelMap2 =
337 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts2);
338
339 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(std::move(pixelMap2));
340 OH_UdsPixelMap_GetPixelMap(pixelMapUds, ohPixelmapNative);
341 auto resultPixelMap = ohPixelmapNative->GetInnerPixelmap();
342 auto height = resultPixelMap->GetHeight();
343 EXPECT_EQ(height, 7);
344
345 OH_UdsPixelMap_Destroy(pixelMapUds);
346 OH_UdmfData_Destroy(ndkData);
347 delete ohPixelmapNative;
348 LOG_INFO(UDMF_TEST, "ConvertPixelMap_002 end.");
349 }
350
351 /* *
352 * @tc.name: ConvertPixelMap_003
353 * @tc.desc: test pixel-map conversion between JS and C-API
354 * @tc.type: FUNC
355 */
356 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_003, TestSize.Level1)
357 {
358 LOG_INFO(UDMF_TEST, "ConvertPixelMap_003 begin.");
359 uint32_t color[35] = { 3, 7, 9, 9, 7, 6 };
360 OHOS::Media::InitializationOptions opts = { { 5, 7 },
361 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
362 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
363 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
364 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
365 auto systemDefinedPixelMap = std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, pixelMapIn);
366
367 UnifiedData data;
368 data.AddRecord(systemDefinedPixelMap);
369
370 std::string key;
371 CustomOption option = { .intention = UD_INTENTION_DRAG };
372 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
373 EXPECT_EQ(setRet, E_OK);
374 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
375 QueryOption query = { .key = key };
376 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
377 EXPECT_EQ(getRet, E_OK);
378
379 auto ndkData = OH_UdmfData_Create();
380 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
381 unsigned int count;
382 OH_UdmfData_GetRecords(ndkData, &count);
383 EXPECT_EQ(1, count);
384 auto record = OH_UdmfData_GetRecord(ndkData, 0);
385 auto pixelMapUds = OH_UdsPixelMap_Create();
386 OH_UdmfRecord_GetPixelMap(record, pixelMapUds);
387 auto type = OH_UdsPixelMap_GetType(pixelMapUds);
388 EXPECT_EQ(std::string(type), std::string(UDMF_META_OPENHARMONY_PIXEL_MAP));
389
390 uint32_t color2[100] = { 3, 7, 9, 9, 7, 6 };
391 OHOS::Media::InitializationOptions opts2 = { { 10, 10 },
392 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
393 auto pixelMap2 = OHOS::Media::PixelMap::Create(color2, sizeof(color) / sizeof(color[0]), opts2);
394 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(std::move(pixelMap2));
395 OH_UdsPixelMap_GetPixelMap(pixelMapUds, ohPixelmapNative);
396 auto resultPixelMap = ohPixelmapNative->GetInnerPixelmap();
397 EXPECT_EQ(resultPixelMap->GetHeight(), 7);
398
399 OH_UdsPixelMap_Destroy(pixelMapUds);
400 OH_UdmfData_Destroy(ndkData);
401 delete ohPixelmapNative;
402 LOG_INFO(UDMF_TEST, "ConvertPixelMap_003 end.");
403 }
404
405 /* *
406 * @tc.name: ConvertPixelMap_004
407 * @tc.desc: test pixel-map conversion between UDS and C-API
408 * @tc.type: FUNC
409 */
410 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_004, TestSize.Level1)
411 {
412 LOG_INFO(UDMF_TEST, "ConvertPixelMap_004 begin.");
413 uint32_t color[35] = { 3, 7, 9, 9, 7, 6 };
414 OHOS::Media::InitializationOptions opts = { { 5, 7 },
415 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
416 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
417 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
418 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
419
420 auto pixelMapUds = OH_UdsPixelMap_Create();
421 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(pixelMapIn);
422 OH_UdsPixelMap_SetPixelMap(pixelMapUds, ohPixelmapNative);
423 auto record = OH_UdmfRecord_Create();
424 OH_UdmfRecord_AddPixelMap(record, pixelMapUds);
425 auto data = OH_UdmfData_Create();
426 OH_UdmfData_AddRecord(data, record);
427 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
428 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(data, unifiedData);
429 EXPECT_EQ(conversionStatus, E_OK);
430 std::string key;
431 CustomOption option = {.intention = UD_INTENTION_DRAG};
432 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
433 EXPECT_EQ(setRet, E_OK);
434 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
435 QueryOption query = {.key = key};
436 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
437 EXPECT_EQ(getRet, E_OK);
438
439 auto readRecord = readData->GetRecordAt(0);
440 auto value = readRecord->GetEntry(UDMF_META_OPENHARMONY_PIXEL_MAP);
441 ASSERT_TRUE(std::holds_alternative<std::shared_ptr<Object>>(value));
442 auto obj = std::get<std::shared_ptr<Object>>(value);
443 std::shared_ptr<Media::PixelMap> getPixelMap = nullptr;
444 ASSERT_TRUE(obj->GetValue(PIXEL_MAP, getPixelMap));
445 ASSERT_NE(getPixelMap, nullptr);
446 ASSERT_EQ(getPixelMap->GetHeight(), pixelMapIn->GetHeight());
447 ASSERT_EQ(getPixelMap->GetByteCount(), pixelMapIn->GetByteCount());
448 OH_UdsPixelMap_Destroy(pixelMapUds);
449 OH_UdmfRecord_Destroy(record);
450 OH_UdmfData_Destroy(data);
451 delete ohPixelmapNative;
452 LOG_INFO(UDMF_TEST, "ConvertPixelMap_004 end.");
453 }
454
455 /* *
456 * @tc.name: ConvertApplicationDefined_001
457 * @tc.desc: test application defined record conversion between JS and C-API
458 * @tc.type: FUNC
459 */
460 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_001, TestSize.Level1)
461 {
462 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_001 begin.");
463 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
464 std::string definedTypeId = "person_app_demo";
465 std::shared_ptr<ApplicationDefinedRecord> systemDefinedPixelMap =
466 std::make_shared<ApplicationDefinedRecord>(definedTypeId, dataBytes);
467 UnifiedData data;
468 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
469 data.SetRecords(records);
470
471 std::string key;
472 CustomOption option = {
473 .intention = UD_INTENTION_DRAG
474 };
475 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
476 EXPECT_EQ(setRet, E_OK);
477
478 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
479 QueryOption query = {
480 .key = key
481 };
482 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
483 EXPECT_EQ(getRet, E_OK);
484
485 auto ndkData = OH_UdmfData_Create();
486 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
487 unsigned int count;
488 OH_UdmfData_GetRecords(ndkData, &count);
489 EXPECT_EQ(1, count);
490 auto record = OH_UdmfData_GetRecord(ndkData, 0);
491 unsigned int getCount = 0;
492 unsigned char *getEntry;
493 auto result = OH_UdmfRecord_GetGeneralEntry(record, definedTypeId.c_str(), &getEntry, &getCount);
494 EXPECT_EQ(0, result);
495 EXPECT_EQ(6, getCount);
496 dataBytes = { '1', '2', '3', '4', '5', '6' };
497 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(reinterpret_cast<const char *>(getEntry)));
498
499 OH_UdmfData_Destroy(ndkData);
500 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_001 end.");
501 }
502
503 /* *
504 * @tc.name: ConvertApplicationDefined_002
505 * @tc.desc: test application defined record conversion between JS and C-API
506 * @tc.type: FUNC
507 */
508 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_002, TestSize.Level1)
509 {
510 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_002 begin.");
511 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
512 std::string definedTypeId = "person_app_demo";
513 std::shared_ptr<ApplicationDefinedRecord> systemDefinedPixelMap =
514 std::make_shared<ApplicationDefinedRecord>(definedTypeId, dataBytes);
515 UnifiedData data;
516 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
517 data.SetRecords(records);
518
519 std::string key;
520 CustomOption option = {
521 .intention = UD_INTENTION_DRAG
522 };
523 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
524 EXPECT_EQ(setRet, E_OK);
525
526 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
527 QueryOption query = {
528 .key = key
529 };
530 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
531 EXPECT_EQ(getRet, E_OK);
532
533 auto ndkData = OH_UdmfData_Create();
534 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
535 unsigned int count;
536 OH_UdmfData_GetRecords(ndkData, &count);
537 EXPECT_EQ(1, count);
538 auto record = OH_UdmfData_GetRecord(ndkData, 0);
539 auto arrayBuffer = OH_UdsArrayBuffer_Create();
540 auto result = OH_UdmfRecord_GetArrayBuffer(record, definedTypeId.c_str(), arrayBuffer);
541 EXPECT_EQ(0, result);
542 unsigned int getCount = 0;
543 unsigned char *getEntry;
544 OH_UdsArrayBuffer_GetData(arrayBuffer, &getEntry, &getCount);
545 EXPECT_EQ(6, getCount);
546 dataBytes = { '1', '2', '3', '4', '5', '6' };
547 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(reinterpret_cast<const char *>(getEntry)));
548
549 OH_UdsArrayBuffer_Destroy(arrayBuffer);
550 OH_UdmfData_Destroy(ndkData);
551 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_002 end.");
552 }
553
554 /* *
555 * @tc.name: ConvertApplicationDefined_003
556 * @tc.desc: test application defined record conversion between JS and C-API
557 * @tc.type: FUNC
558 */
559 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_003, TestSize.Level1)
560 {
561 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_003 begin.");
562 auto arrayBuffer = OH_UdsArrayBuffer_Create();
563 unsigned char data[] = {'1', '2', '3', '4', '5', '6'};
564 OH_UdsArrayBuffer_SetData(arrayBuffer, data, 6);
565 auto record = OH_UdmfRecord_Create();
566 OH_UdmfRecord_AddArrayBuffer(record, "person_demo", arrayBuffer);
567 auto ndkData = OH_UdmfData_Create();
568 OH_UdmfData_AddRecord(ndkData, record);
569 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
570 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
571 EXPECT_EQ(conversionStatus, E_OK);
572 std::string key;
573 CustomOption option = {
574 .intention = UD_INTENTION_DRAG
575 };
576 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
577 EXPECT_EQ(setRet, E_OK);
578
579 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
580 QueryOption query = {
581 .key = key
582 };
583 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
584 EXPECT_EQ(getRet, E_OK);
585
586 auto readRecord = readData->GetRecordAt(0);
587 auto definedRecord = std::static_pointer_cast<ApplicationDefinedRecord>(readRecord);
588 auto type = definedRecord->GetApplicationDefinedType();
589 EXPECT_EQ("person_demo", type);
590 auto rawData = definedRecord->GetRawData();
591 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
592 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(rawData.begin(), rawData.end()));
593
594 OH_UdsArrayBuffer_Destroy(arrayBuffer);
595 OH_UdmfRecord_Destroy(record);
596 OH_UdmfData_Destroy(ndkData);
597 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_003 end.");
598 }
599
600 /* *
601 * @tc.name: ConvertApplicationDefined_004
602 * @tc.desc: test application defined record conversion between JS and C-API
603 * @tc.type: FUNC
604 */
605 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_004, TestSize.Level1)
606 {
607 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_004 begin.");
608 unsigned char data[] = {'1', '2', '3', '4', '5', '6'};
609 auto record = OH_UdmfRecord_Create();
610 OH_UdmfRecord_AddGeneralEntry(record, "person_demo", data, 6);
611 auto ndkData = OH_UdmfData_Create();
612 OH_UdmfData_AddRecord(ndkData, record);
613 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
614 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
615 EXPECT_EQ(conversionStatus, E_OK);
616 std::string key;
617 CustomOption option = {
618 .intention = UD_INTENTION_DRAG
619 };
620 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
621 EXPECT_EQ(setRet, E_OK);
622
623 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
624 QueryOption query = {
625 .key = key
626 };
627 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
628 EXPECT_EQ(getRet, E_OK);
629
630 auto readRecord = readData->GetRecordAt(0);
631 auto definedRecord = std::static_pointer_cast<ApplicationDefinedRecord>(readRecord);
632 auto type = definedRecord->GetApplicationDefinedType();
633 EXPECT_EQ("person_demo", type);
634 auto rawData = definedRecord->GetRawData();
635 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
636 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(rawData.begin(), rawData.end()));
637
638 OH_UdmfRecord_Destroy(record);
639 OH_UdmfData_Destroy(ndkData);
640 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_004 end.");
641 }
642
643 /* *
644 * @tc.name: ConvertOhtherUds_001
645 * @tc.desc: test other conversion between JS and C-API
646 * @tc.type: FUNC
647 */
648 HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_001, TestSize.Level1)
649 {
650 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_001 begin.");
651 std::string definedTypeId = "person_app_demo";
652 std::shared_ptr<Html> html = std::make_shared<Html>("htmlContent", "plainContent");
653 std::map<std::string, ValueType> value;
654 std::vector<uint8_t> thumbData = {1, 2, 3, 4, 5};
655 auto obj = std::make_shared<Object>();
656 obj->value_.emplace(UNIFORM_DATA_TYPE, "general.content-form");
657 obj->value_.emplace(TITLE, "title");
658 obj->value_.emplace(THUMB_DATA, thumbData);
659 std::shared_ptr<UnifiedRecord> contentForm = std::make_shared<UnifiedRecord>(UDType::CONTENT_FORM, obj);
660 UnifiedData data;
661 std::vector<std::shared_ptr<UnifiedRecord>> records = { html, contentForm };
662 data.SetRecords(records);
663
664 std::string key;
665 CustomOption option = { .intention = UD_INTENTION_DRAG };
666 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
667 EXPECT_EQ(setRet, E_OK);
668
669 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
670 QueryOption query = { .key = key };
671 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
672 EXPECT_EQ(getRet, E_OK);
673
674 auto ndkData = OH_UdmfData_Create();
675 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
676 unsigned int count;
677 OH_UdmfData_GetRecords(ndkData, &count);
678 EXPECT_EQ(2, count);
679 auto record = OH_UdmfData_GetRecord(ndkData, 0);
680 auto htmlNdk = OH_UdsHtml_Create();
681 auto result = OH_UdmfRecord_GetHtml(record, htmlNdk);
682 EXPECT_EQ(0, result);
683 EXPECT_EQ("general.html", std::string(OH_UdsHtml_GetType(htmlNdk)));
684 EXPECT_EQ("htmlContent", std::string(OH_UdsHtml_GetContent(htmlNdk)));
685 EXPECT_EQ("plainContent", std::string(OH_UdsHtml_GetPlainContent(htmlNdk)));
686
687 auto contentFormRecord = OH_UdmfData_GetRecord(ndkData, 1);
688 auto contentFormNdk = OH_UdsContentForm_Create();
689 result = OH_UdmfRecord_GetContentForm(contentFormRecord, contentFormNdk);
690 EXPECT_EQ(0, result);
691 EXPECT_EQ("general.content-form", std::string(OH_UdsContentForm_GetType(contentFormNdk)));
692 EXPECT_EQ("title", std::string(OH_UdsContentForm_GetTitle(contentFormNdk)));
693 unsigned char *readThumbData;
694 unsigned int thumbDataLen = 0;
695 EXPECT_EQ(0, OH_UdsContentForm_GetThumbData(contentFormNdk, &readThumbData, &thumbDataLen));
696 EXPECT_EQ(5, thumbDataLen);
697 OH_UdsHtml_Destroy(htmlNdk);
698 OH_UdsContentForm_Destroy(contentFormNdk);
699 OH_UdmfData_Destroy(ndkData);
700 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_001 end.");
701 }
702
703 /* *
704 * @tc.name: ConvertOhtherUds_002
705 * @tc.desc: test html conversion between JS and C-API
706 * @tc.type: FUNC
707 */
708 HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_002, TestSize.Level1)
709 {
710 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_002 begin.");
711 auto htmlNdk = OH_UdsHtml_Create();
712 OH_UdsHtml_SetContent(htmlNdk, "htmlContent");
713 OH_UdsHtml_SetPlainContent(htmlNdk, "plainContent");
714 auto record = OH_UdmfRecord_Create();
715 OH_UdmfRecord_AddHtml(record, htmlNdk);
716 auto ndkData = OH_UdmfData_Create();
717 OH_UdmfData_AddRecord(ndkData, record);
718 auto record2 = OH_UdmfRecord_Create();
719 auto contentFormNdk = OH_UdsContentForm_Create();
720 OH_UdsContentForm_SetTitle(contentFormNdk, "title");
721 unsigned char thumbData[] = {0, 1, 2, 3, 4};
722 OH_UdsContentForm_SetThumbData(contentFormNdk, thumbData, 5);
723 OH_UdmfRecord_AddContentForm(record2, contentFormNdk);
724 OH_UdmfData_AddRecord(ndkData, record2);
725
726 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
727 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
728 EXPECT_EQ(conversionStatus, E_OK);
729 std::string key;
730 CustomOption option = { .intention = UD_INTENTION_DRAG };
731 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
732 EXPECT_EQ(setRet, E_OK);
733
734 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
735 QueryOption query = { .key = key };
736 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
737 EXPECT_EQ(getRet, E_OK);
738
739 auto readRecord = readData->GetRecordAt(0);
740 auto html = std::static_pointer_cast<Html>(readRecord);
741 EXPECT_EQ("htmlContent", html->GetHtmlContent());
742 EXPECT_EQ("plainContent", html->GetPlainContent());
743
744 auto contentForm = readData->GetRecordAt(1);
745 auto value = contentForm->GetValue();
746 auto obj = std::get<std::shared_ptr<Object>>(value);
747 EXPECT_EQ("general.content-form", std::get<std::string>(obj->value_[UNIFORM_DATA_TYPE]));
748 EXPECT_EQ(5, std::get<int>(obj->value_[THUMB_DATA_LENGTH]));
749 auto readThumbData = std::get<std::vector<uint8_t>>(obj->value_[THUMB_DATA]);
750 EXPECT_EQ(4, readThumbData.at(4));
751
752 OH_UdsHtml_Destroy(htmlNdk);
753 OH_UdsContentForm_Destroy(contentFormNdk);
754 OH_UdmfRecord_Destroy(record);
755 OH_UdmfRecord_Destroy(record2);
756 OH_UdmfData_Destroy(ndkData);
757 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_002 end.");
758 }
759 }
760