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[100] = { 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 std::vector<uint8_t> buff;
366 pixelMapIn->EncodeTlv(buff);
367
368 std::shared_ptr<SystemDefinedPixelMap> systemDefinedPixelMap =
369 std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, buff);
370 UnifiedData data;
371 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
372 data.SetRecords(records);
373
374 std::string key;
375 CustomOption option = { .intention = UD_INTENTION_DRAG };
376 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
377 EXPECT_EQ(setRet, E_OK);
378
379 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
380 QueryOption query = { .key = key };
381 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
382 EXPECT_EQ(getRet, E_OK);
383
384 auto ndkData = OH_UdmfData_Create();
385 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
386 unsigned int count;
387 OH_UdmfData_GetRecords(ndkData, &count);
388 EXPECT_EQ(1, count);
389 auto record = OH_UdmfData_GetRecord(ndkData, 0);
390 auto pixelMapUds = OH_UdsPixelMap_Create();
391 OH_UdmfRecord_GetPixelMap(record, pixelMapUds);
392 auto type = OH_UdsPixelMap_GetType(pixelMapUds);
393 EXPECT_EQ(std::string(type), std::string(UDMF_META_OPENHARMONY_PIXEL_MAP));
394
395 OHOS::Media::InitializationOptions opts2 = { { 10, 10 },
396 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
397 std::unique_ptr<OHOS::Media::PixelMap> pixelMap2 =
398 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts2);
399
400 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(std::move(pixelMap2));
401 OH_UdsPixelMap_GetPixelMap(pixelMapUds, ohPixelmapNative);
402 auto resultPixelMap = ohPixelmapNative->GetInnerPixelmap();
403 auto height = resultPixelMap->GetHeight();
404 EXPECT_EQ(height, 7);
405
406 OH_UdsPixelMap_Destroy(pixelMapUds);
407 OH_UdmfData_Destroy(ndkData);
408 delete ohPixelmapNative;
409 LOG_INFO(UDMF_TEST, "ConvertPixelMap_003 end.");
410 }
411
412 /* *
413 * @tc.name: ConvertApplicationDefined_001
414 * @tc.desc: test application defined record conversion between JS and C-API
415 * @tc.type: FUNC
416 */
417 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_001, TestSize.Level1)
418 {
419 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_001 begin.");
420 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
421 std::string definedTypeId = "person_app_demo";
422 std::shared_ptr<ApplicationDefinedRecord> systemDefinedPixelMap =
423 std::make_shared<ApplicationDefinedRecord>(definedTypeId, dataBytes);
424 UnifiedData data;
425 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
426 data.SetRecords(records);
427
428 std::string key;
429 CustomOption option = {
430 .intention = UD_INTENTION_DRAG
431 };
432 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
433 EXPECT_EQ(setRet, E_OK);
434
435 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
436 QueryOption query = {
437 .key = key
438 };
439 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
440 EXPECT_EQ(getRet, E_OK);
441
442 auto ndkData = OH_UdmfData_Create();
443 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
444 unsigned int count;
445 OH_UdmfData_GetRecords(ndkData, &count);
446 EXPECT_EQ(1, count);
447 auto record = OH_UdmfData_GetRecord(ndkData, 0);
448 unsigned int getCount = 0;
449 unsigned char *getEntry;
450 auto result = OH_UdmfRecord_GetGeneralEntry(record, definedTypeId.c_str(), &getEntry, &getCount);
451 EXPECT_EQ(0, result);
452 EXPECT_EQ(6, getCount);
453 dataBytes = { '1', '2', '3', '4', '5', '6' };
454 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(reinterpret_cast<const char *>(getEntry)));
455
456 OH_UdmfData_Destroy(ndkData);
457 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_001 end.");
458 }
459
460 /* *
461 * @tc.name: ConvertApplicationDefined_002
462 * @tc.desc: test application defined record conversion between JS and C-API
463 * @tc.type: FUNC
464 */
465 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_002, TestSize.Level1)
466 {
467 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_002 begin.");
468 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
469 std::string definedTypeId = "person_app_demo";
470 std::shared_ptr<ApplicationDefinedRecord> systemDefinedPixelMap =
471 std::make_shared<ApplicationDefinedRecord>(definedTypeId, dataBytes);
472 UnifiedData data;
473 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
474 data.SetRecords(records);
475
476 std::string key;
477 CustomOption option = {
478 .intention = UD_INTENTION_DRAG
479 };
480 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
481 EXPECT_EQ(setRet, E_OK);
482
483 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
484 QueryOption query = {
485 .key = key
486 };
487 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
488 EXPECT_EQ(getRet, E_OK);
489
490 auto ndkData = OH_UdmfData_Create();
491 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
492 unsigned int count;
493 OH_UdmfData_GetRecords(ndkData, &count);
494 EXPECT_EQ(1, count);
495 auto record = OH_UdmfData_GetRecord(ndkData, 0);
496 auto arrayBuffer = OH_UdsArrayBuffer_Create();
497 auto result = OH_UdmfRecord_GetArrayBuffer(record, definedTypeId.c_str(), arrayBuffer);
498 EXPECT_EQ(0, result);
499 unsigned int getCount = 0;
500 unsigned char *getEntry;
501 OH_UdsArrayBuffer_GetData(arrayBuffer, &getEntry, &getCount);
502 EXPECT_EQ(6, getCount);
503 dataBytes = { '1', '2', '3', '4', '5', '6' };
504 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(reinterpret_cast<const char *>(getEntry)));
505
506 OH_UdsArrayBuffer_Destroy(arrayBuffer);
507 OH_UdmfData_Destroy(ndkData);
508 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_002 end.");
509 }
510
511 /* *
512 * @tc.name: ConvertApplicationDefined_003
513 * @tc.desc: test application defined record conversion between JS and C-API
514 * @tc.type: FUNC
515 */
516 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_003, TestSize.Level1)
517 {
518 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_003 begin.");
519 auto arrayBuffer = OH_UdsArrayBuffer_Create();
520 unsigned char data[] = {'1', '2', '3', '4', '5', '6'};
521 OH_UdsArrayBuffer_SetData(arrayBuffer, data, 6);
522 auto record = OH_UdmfRecord_Create();
523 OH_UdmfRecord_AddArrayBuffer(record, "person_demo", arrayBuffer);
524 auto ndkData = OH_UdmfData_Create();
525 OH_UdmfData_AddRecord(ndkData, record);
526 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
527 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
528 EXPECT_EQ(conversionStatus, E_OK);
529 std::string key;
530 CustomOption option = {
531 .intention = UD_INTENTION_DRAG
532 };
533 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
534 EXPECT_EQ(setRet, E_OK);
535
536 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
537 QueryOption query = {
538 .key = key
539 };
540 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
541 EXPECT_EQ(getRet, E_OK);
542
543 auto readRecord = readData->GetRecordAt(0);
544 auto definedRecord = std::static_pointer_cast<ApplicationDefinedRecord>(readRecord);
545 auto type = definedRecord->GetApplicationDefinedType();
546 EXPECT_EQ("person_demo", type);
547 auto rawData = definedRecord->GetRawData();
548 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
549 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(rawData.begin(), rawData.end()));
550
551 OH_UdsArrayBuffer_Destroy(arrayBuffer);
552 OH_UdmfRecord_Destroy(record);
553 OH_UdmfData_Destroy(ndkData);
554 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_003 end.");
555 }
556
557 /* *
558 * @tc.name: ConvertApplicationDefined_004
559 * @tc.desc: test application defined record conversion between JS and C-API
560 * @tc.type: FUNC
561 */
562 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_004, TestSize.Level1)
563 {
564 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_004 begin.");
565 unsigned char data[] = {'1', '2', '3', '4', '5', '6'};
566 auto record = OH_UdmfRecord_Create();
567 OH_UdmfRecord_AddGeneralEntry(record, "person_demo", data, 6);
568 auto ndkData = OH_UdmfData_Create();
569 OH_UdmfData_AddRecord(ndkData, record);
570 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
571 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
572 EXPECT_EQ(conversionStatus, E_OK);
573 std::string key;
574 CustomOption option = {
575 .intention = UD_INTENTION_DRAG
576 };
577 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
578 EXPECT_EQ(setRet, E_OK);
579
580 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
581 QueryOption query = {
582 .key = key
583 };
584 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
585 EXPECT_EQ(getRet, E_OK);
586
587 auto readRecord = readData->GetRecordAt(0);
588 auto definedRecord = std::static_pointer_cast<ApplicationDefinedRecord>(readRecord);
589 auto type = definedRecord->GetApplicationDefinedType();
590 EXPECT_EQ("person_demo", type);
591 auto rawData = definedRecord->GetRawData();
592 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
593 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(rawData.begin(), rawData.end()));
594
595 OH_UdmfRecord_Destroy(record);
596 OH_UdmfData_Destroy(ndkData);
597 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_004 end.");
598 }
599
600 /* *
601 * @tc.name: ConvertOhtherUds_001
602 * @tc.desc: test other conversion between JS and C-API
603 * @tc.type: FUNC
604 */
605 HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_001, TestSize.Level1)
606 {
607 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_001 begin.");
608 std::string definedTypeId = "person_app_demo";
609 std::shared_ptr<Html> html = std::make_shared<Html>("htmlContent", "plainContent");
610 std::map<std::string, ValueType> value;
611 std::vector<uint8_t> thumbData = {1, 2, 3, 4, 5};
612 auto obj = std::make_shared<Object>();
613 obj->value_.emplace(UNIFORM_DATA_TYPE, "general.content-form");
614 obj->value_.emplace(TITLE, "title");
615 obj->value_.emplace(THUMB_DATA, thumbData);
616 std::shared_ptr<UnifiedRecord> contentForm = std::make_shared<UnifiedRecord>(UDType::CONTENT_FORM, obj);
617 UnifiedData data;
618 std::vector<std::shared_ptr<UnifiedRecord>> records = { html, contentForm };
619 data.SetRecords(records);
620
621 std::string key;
622 CustomOption option = { .intention = UD_INTENTION_DRAG };
623 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
624 EXPECT_EQ(setRet, E_OK);
625
626 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
627 QueryOption query = { .key = key };
628 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
629 EXPECT_EQ(getRet, E_OK);
630
631 auto ndkData = OH_UdmfData_Create();
632 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
633 unsigned int count;
634 OH_UdmfData_GetRecords(ndkData, &count);
635 EXPECT_EQ(2, count);
636 auto record = OH_UdmfData_GetRecord(ndkData, 0);
637 auto htmlNdk = OH_UdsHtml_Create();
638 auto result = OH_UdmfRecord_GetHtml(record, htmlNdk);
639 EXPECT_EQ(0, result);
640 EXPECT_EQ("general.html", std::string(OH_UdsHtml_GetType(htmlNdk)));
641 EXPECT_EQ("htmlContent", std::string(OH_UdsHtml_GetContent(htmlNdk)));
642 EXPECT_EQ("plainContent", std::string(OH_UdsHtml_GetPlainContent(htmlNdk)));
643
644 auto contentFormRecord = OH_UdmfData_GetRecord(ndkData, 1);
645 auto contentFormNdk = OH_UdsContentForm_Create();
646 result = OH_UdmfRecord_GetContentForm(contentFormRecord, contentFormNdk);
647 EXPECT_EQ(0, result);
648 EXPECT_EQ("general.content-form", std::string(OH_UdsContentForm_GetType(contentFormNdk)));
649 EXPECT_EQ("title", std::string(OH_UdsContentForm_GetTitle(contentFormNdk)));
650 unsigned char *readThumbData;
651 unsigned int thumbDataLen = 0;
652 EXPECT_EQ(0, OH_UdsContentForm_GetThumbData(contentFormNdk, &readThumbData, &thumbDataLen));
653 EXPECT_EQ(5, thumbDataLen);
654 OH_UdsHtml_Destroy(htmlNdk);
655 OH_UdsContentForm_Destroy(contentFormNdk);
656 OH_UdmfData_Destroy(ndkData);
657 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_001 end.");
658 }
659
660 /* *
661 * @tc.name: ConvertOhtherUds_002
662 * @tc.desc: test html conversion between JS and C-API
663 * @tc.type: FUNC
664 */
665 HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_002, TestSize.Level1)
666 {
667 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_002 begin.");
668 auto htmlNdk = OH_UdsHtml_Create();
669 OH_UdsHtml_SetContent(htmlNdk, "htmlContent");
670 OH_UdsHtml_SetPlainContent(htmlNdk, "plainContent");
671 auto record = OH_UdmfRecord_Create();
672 OH_UdmfRecord_AddHtml(record, htmlNdk);
673 auto ndkData = OH_UdmfData_Create();
674 OH_UdmfData_AddRecord(ndkData, record);
675 auto record2 = OH_UdmfRecord_Create();
676 auto contentFormNdk = OH_UdsContentForm_Create();
677 OH_UdsContentForm_SetTitle(contentFormNdk, "title");
678 unsigned char thumbData[] = {0, 1, 2, 3, 4};
679 OH_UdsContentForm_SetThumbData(contentFormNdk, thumbData, 5);
680 OH_UdmfRecord_AddContentForm(record2, contentFormNdk);
681 OH_UdmfData_AddRecord(ndkData, record2);
682
683 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
684 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
685 EXPECT_EQ(conversionStatus, E_OK);
686 std::string key;
687 CustomOption option = { .intention = UD_INTENTION_DRAG };
688 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
689 EXPECT_EQ(setRet, E_OK);
690
691 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
692 QueryOption query = { .key = key };
693 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
694 EXPECT_EQ(getRet, E_OK);
695
696 auto readRecord = readData->GetRecordAt(0);
697 auto html = std::static_pointer_cast<Html>(readRecord);
698 EXPECT_EQ("htmlContent", html->GetHtmlContent());
699 EXPECT_EQ("plainContent", html->GetPlainContent());
700
701 auto contentForm = readData->GetRecordAt(1);
702 auto value = contentForm->GetValue();
703 auto obj = std::get<std::shared_ptr<Object>>(value);
704 EXPECT_EQ("general.content-form", std::get<std::string>(obj->value_[UNIFORM_DATA_TYPE]));
705 EXPECT_EQ(5, std::get<int>(obj->value_[THUMB_DATA_LENGTH]));
706 auto readThumbData = std::get<std::vector<uint8_t>>(obj->value_[THUMB_DATA]);
707 EXPECT_EQ(4, readThumbData.at(4));
708
709 OH_UdsHtml_Destroy(htmlNdk);
710 OH_UdsContentForm_Destroy(contentFormNdk);
711 OH_UdmfRecord_Destroy(record);
712 OH_UdmfRecord_Destroy(record2);
713 OH_UdmfData_Destroy(ndkData);
714 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_002 end.");
715 }
716 }
717