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 */
HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_001, TestSize.Level1)152 HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_001, TestSize.Level1)
153 {
154 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_001 begin.");
155 UnifiedRecord unifiedRecord;
156 const std::string uid("typeId");
157 unifiedRecord.SetUid(uid);
158 OH_UdmfData *ndkData = OH_UdmfData_Create();
159 const std::shared_ptr<UnifiedRecord> recordPtr = std::make_shared<UnifiedRecord>(unifiedRecord);
160 ndkData->unifiedData_->AddRecord(recordPtr);
161 auto data = std::make_shared<UnifiedData>();
162
163 Status status = NdkDataConversion::GetNativeUnifiedData(ndkData, data);
164 ASSERT_EQ(E_OK, status);
165 EXPECT_EQ("typeId", data->GetRecordAt(0)->GetUid());
166
167 OH_UdmfData *ndkDataNull = nullptr;
168 status = NdkDataConversion::GetNativeUnifiedData(ndkDataNull, data);
169 ASSERT_EQ(E_INVALID_PARAMETERS, status);
170
171 std::shared_ptr<UnifiedData> dataNull;
172 status = NdkDataConversion::GetNativeUnifiedData(ndkData, dataNull);
173 OH_UdmfData_Destroy(ndkData);
174 ASSERT_EQ(E_INVALID_PARAMETERS, status);
175 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_001 end.");
176 }
177
178 /* *
179 * @tc.name: GetNativeUnifiedData_002
180 * @tc.desc: Normal testcase of GetNativeUnifiedData
181 * @tc.type: FUNC
182 */
HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_002, TestSize.Level1)183 HWTEST_F(NdkDataConversionTest, GetNativeUnifiedData_002, TestSize.Level1)
184 {
185 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_002 begin.");
186 auto plainText = OH_UdsPlainText_Create();
187 OH_UdmfData *fakeNdkData = reinterpret_cast<OH_UdmfData *>(plainText);
188 auto data = std::make_shared<UnifiedData>();
189 Status status = NdkDataConversion::GetNativeUnifiedData(fakeNdkData, data);
190 OH_UdsPlainText_Destroy(plainText);
191 ASSERT_EQ(E_INVALID_PARAMETERS, status);
192 LOG_INFO(UDMF_TEST, "GetNativeUnifiedData_002 end.");
193 }
194
195 /* *
196 * @tc.name: GetNdkUnifiedData_001
197 * @tc.desc: Error testcase of GetNdkUnifiedData
198 * @tc.type: FUNC
199 */
HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_001, TestSize.Level1)200 HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_001, TestSize.Level1)
201 {
202 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_001 begin.");
203 UnifiedRecord unifiedRecord;
204 const std::string uid("typeId");
205 unifiedRecord.SetUid(uid);
206 const std::shared_ptr<UnifiedRecord> recordPtr = std::make_shared<UnifiedRecord>(unifiedRecord);
207 auto data = std::make_shared<UnifiedData>();
208 data->AddRecord(recordPtr);
209 OH_UdmfData *ndkData = OH_UdmfData_Create();
210 Status status = NdkDataConversion::GetNdkUnifiedData(data, ndkData);
211 ASSERT_EQ(E_OK, status);
212 EXPECT_EQ("typeId", ndkData->unifiedData_->GetRecordAt(0)->GetUid());
213
214 OH_UdmfData *ndkDataNull = nullptr;
215 status = NdkDataConversion::GetNdkUnifiedData(data, ndkDataNull);
216 ASSERT_EQ(E_INVALID_PARAMETERS, status);
217
218 std::shared_ptr<UnifiedData> dataNull;
219 status = NdkDataConversion::GetNdkUnifiedData(dataNull, ndkData);
220 OH_UdmfData_Destroy(ndkData);
221 ASSERT_EQ(E_INVALID_PARAMETERS, status);
222 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_001 end.");
223 }
224
225 /* *
226 * @tc.name: GetNdkUnifiedData_002
227 * @tc.desc: Error testcase of GetNdkUnifiedData
228 * @tc.type: FUNC
229 */
HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_002, TestSize.Level1)230 HWTEST_F(NdkDataConversionTest, GetNdkUnifiedData_002, TestSize.Level1)
231 {
232 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_002 begin.");
233 auto plainText = OH_UdsPlainText_Create();
234 OH_UdmfData *fakeNdkData = reinterpret_cast<OH_UdmfData *>(plainText);
235 auto data = std::make_shared<UnifiedData>();
236 Status status = NdkDataConversion::GetNdkUnifiedData(data, fakeNdkData);
237 OH_UdsPlainText_Destroy(plainText);
238 ASSERT_EQ(E_INVALID_PARAMETERS, status);
239 LOG_INFO(UDMF_TEST, "GetNdkUnifiedData_002 end.");
240 }
241
242 /* *
243 * @tc.name: ConvertPixelMap_001
244 * @tc.desc: test pixel-map conversion between JS and C-API
245 * @tc.type: FUNC
246 */
HWTEST_F(NdkDataConversionTest, ConvertPixelMap_001, TestSize.Level1)247 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_001, TestSize.Level1)
248 {
249 LOG_INFO(UDMF_TEST, "ConvertPixelMap_001 begin.");
250 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
251 OHOS::Media::InitializationOptions opts = { { 5, 7 },
252 Media::PixelFormat::ARGB_8888,
253 Media::PixelFormat::ARGB_8888 };
254 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
255 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
256 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
257
258 auto pixelMapUds = OH_UdsPixelMap_Create();
259 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(pixelMapIn);
260 OH_UdsPixelMap_SetPixelMap(pixelMapUds, ohPixelmapNative);
261 auto record = OH_UdmfRecord_Create();
262 OH_UdmfRecord_AddPixelMap(record, pixelMapUds);
263 auto data = OH_UdmfData_Create();
264 OH_UdmfData_AddRecord(data, record);
265 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
266 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(data, unifiedData);
267 EXPECT_EQ(conversionStatus, E_OK);
268 std::string key;
269 CustomOption option = {
270 .intention = UD_INTENTION_DRAG
271 };
272 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
273 EXPECT_EQ(setRet, E_OK);
274
275 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
276 QueryOption query = {
277 .key = key
278 };
279 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
280 EXPECT_EQ(getRet, E_OK);
281
282 auto readRecord = readData->GetRecordAt(0);
283 auto systemDefinedPixelMap = std::static_pointer_cast<SystemDefinedPixelMap>(readRecord);
284 auto rawData = systemDefinedPixelMap->GetRawData();
285 EXPECT_GT(rawData.size(), 0);
286
287 OH_UdsPixelMap_Destroy(pixelMapUds);
288 OH_UdmfRecord_Destroy(record);
289 OH_UdmfData_Destroy(data);
290 delete ohPixelmapNative;
291 LOG_INFO(UDMF_TEST, "ConvertPixelMap_001 end.");
292 }
293
294 /* *
295 * @tc.name: ConvertPixelMap_002
296 * @tc.desc: test pixel-map conversion between JS and C-API
297 * @tc.type: FUNC
298 */
HWTEST_F(NdkDataConversionTest, ConvertPixelMap_002, TestSize.Level1)299 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_002, TestSize.Level1)
300 {
301 LOG_INFO(UDMF_TEST, "ConvertPixelMap_002 begin.");
302 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
303 OHOS::Media::InitializationOptions opts = { { 5, 7 },
304 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
305 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
306 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
307 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
308
309 std::shared_ptr<SystemDefinedPixelMap> systemDefinedPixelMap =
310 std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, pixelMapIn);
311 UnifiedData data;
312 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
313 data.SetRecords(records);
314
315 std::string key;
316 CustomOption option = { .intention = UD_INTENTION_DRAG };
317 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
318 EXPECT_EQ(setRet, E_OK);
319
320 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
321 QueryOption query = { .key = key };
322 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
323 EXPECT_EQ(getRet, E_OK);
324
325 auto ndkData = OH_UdmfData_Create();
326 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
327 unsigned int count;
328 OH_UdmfData_GetRecords(ndkData, &count);
329 EXPECT_EQ(1, count);
330 auto record = OH_UdmfData_GetRecord(ndkData, 0);
331 auto pixelMapUds = OH_UdsPixelMap_Create();
332 OH_UdmfRecord_GetPixelMap(record, pixelMapUds);
333 auto type = OH_UdsPixelMap_GetType(pixelMapUds);
334 EXPECT_EQ(std::string(type), std::string(UDMF_META_OPENHARMONY_PIXEL_MAP));
335
336 OHOS::Media::InitializationOptions opts2 = { { 10, 10 },
337 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
338 std::unique_ptr<OHOS::Media::PixelMap> pixelMap2 =
339 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts2);
340
341 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(std::move(pixelMap2));
342 OH_UdsPixelMap_GetPixelMap(pixelMapUds, ohPixelmapNative);
343 auto resultPixelMap = ohPixelmapNative->GetInnerPixelmap();
344 auto height = resultPixelMap->GetHeight();
345 EXPECT_EQ(height, 7);
346
347 OH_UdsPixelMap_Destroy(pixelMapUds);
348 OH_UdmfData_Destroy(ndkData);
349 delete ohPixelmapNative;
350 LOG_INFO(UDMF_TEST, "ConvertPixelMap_002 end.");
351 }
352
353 /* *
354 * @tc.name: ConvertPixelMap_003
355 * @tc.desc: test pixel-map conversion between JS and C-API
356 * @tc.type: FUNC
357 */
HWTEST_F(NdkDataConversionTest, ConvertPixelMap_003, TestSize.Level1)358 HWTEST_F(NdkDataConversionTest, ConvertPixelMap_003, TestSize.Level1)
359 {
360 LOG_INFO(UDMF_TEST, "ConvertPixelMap_003 begin.");
361 uint32_t color[100] = { 3, 7, 9, 9, 7, 6 };
362 OHOS::Media::InitializationOptions opts = { { 5, 7 },
363 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
364 std::unique_ptr<OHOS::Media::PixelMap> pixelMap =
365 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts);
366 std::shared_ptr<OHOS::Media::PixelMap> pixelMapIn = move(pixelMap);
367 std::vector<uint8_t> buff;
368 pixelMapIn->EncodeTlv(buff);
369
370 std::shared_ptr<SystemDefinedPixelMap> systemDefinedPixelMap =
371 std::make_shared<SystemDefinedPixelMap>(UDType::SYSTEM_DEFINED_PIXEL_MAP, buff);
372 UnifiedData data;
373 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
374 data.SetRecords(records);
375
376 std::string key;
377 CustomOption option = { .intention = UD_INTENTION_DRAG };
378 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
379 EXPECT_EQ(setRet, E_OK);
380
381 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
382 QueryOption query = { .key = key };
383 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
384 EXPECT_EQ(getRet, E_OK);
385
386 auto ndkData = OH_UdmfData_Create();
387 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
388 unsigned int count;
389 OH_UdmfData_GetRecords(ndkData, &count);
390 EXPECT_EQ(1, count);
391 auto record = OH_UdmfData_GetRecord(ndkData, 0);
392 auto pixelMapUds = OH_UdsPixelMap_Create();
393 OH_UdmfRecord_GetPixelMap(record, pixelMapUds);
394 auto type = OH_UdsPixelMap_GetType(pixelMapUds);
395 EXPECT_EQ(std::string(type), std::string(UDMF_META_OPENHARMONY_PIXEL_MAP));
396
397 OHOS::Media::InitializationOptions opts2 = { { 10, 10 },
398 Media::PixelFormat::ARGB_8888, Media::PixelFormat::ARGB_8888 };
399 std::unique_ptr<OHOS::Media::PixelMap> pixelMap2 =
400 OHOS::Media::PixelMap::Create(color, sizeof(color) / sizeof(color[0]), opts2);
401
402 OH_PixelmapNative *ohPixelmapNative = new OH_PixelmapNative(std::move(pixelMap2));
403 OH_UdsPixelMap_GetPixelMap(pixelMapUds, ohPixelmapNative);
404 auto resultPixelMap = ohPixelmapNative->GetInnerPixelmap();
405 auto height = resultPixelMap->GetHeight();
406 EXPECT_EQ(height, 7);
407
408 OH_UdsPixelMap_Destroy(pixelMapUds);
409 OH_UdmfData_Destroy(ndkData);
410 delete ohPixelmapNative;
411 LOG_INFO(UDMF_TEST, "ConvertPixelMap_003 end.");
412 }
413
414 /* *
415 * @tc.name: ConvertApplicationDefined_001
416 * @tc.desc: test application defined record conversion between JS and C-API
417 * @tc.type: FUNC
418 */
HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_001, TestSize.Level1)419 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_001, TestSize.Level1)
420 {
421 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_001 begin.");
422 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
423 std::string definedTypeId = "person_app_demo";
424 std::shared_ptr<ApplicationDefinedRecord> systemDefinedPixelMap =
425 std::make_shared<ApplicationDefinedRecord>(definedTypeId, dataBytes);
426 UnifiedData data;
427 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
428 data.SetRecords(records);
429
430 std::string key;
431 CustomOption option = {
432 .intention = UD_INTENTION_DRAG
433 };
434 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
435 EXPECT_EQ(setRet, E_OK);
436
437 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
438 QueryOption query = {
439 .key = key
440 };
441 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
442 EXPECT_EQ(getRet, E_OK);
443
444 auto ndkData = OH_UdmfData_Create();
445 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
446 unsigned int count;
447 OH_UdmfData_GetRecords(ndkData, &count);
448 EXPECT_EQ(1, count);
449 auto record = OH_UdmfData_GetRecord(ndkData, 0);
450 unsigned int getCount = 0;
451 unsigned char *getEntry;
452 auto result = OH_UdmfRecord_GetGeneralEntry(record, definedTypeId.c_str(), &getEntry, &getCount);
453 EXPECT_EQ(0, result);
454 EXPECT_EQ(6, getCount);
455 dataBytes = { '1', '2', '3', '4', '5', '6' };
456 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(reinterpret_cast<const char *>(getEntry)));
457
458 OH_UdmfData_Destroy(ndkData);
459 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_001 end.");
460 }
461
462 /* *
463 * @tc.name: ConvertApplicationDefined_002
464 * @tc.desc: test application defined record conversion between JS and C-API
465 * @tc.type: FUNC
466 */
HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_002, TestSize.Level1)467 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_002, TestSize.Level1)
468 {
469 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_002 begin.");
470 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
471 std::string definedTypeId = "person_app_demo";
472 std::shared_ptr<ApplicationDefinedRecord> systemDefinedPixelMap =
473 std::make_shared<ApplicationDefinedRecord>(definedTypeId, dataBytes);
474 UnifiedData data;
475 std::vector<std::shared_ptr<UnifiedRecord>> records = { systemDefinedPixelMap };
476 data.SetRecords(records);
477
478 std::string key;
479 CustomOption option = {
480 .intention = UD_INTENTION_DRAG
481 };
482 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
483 EXPECT_EQ(setRet, E_OK);
484
485 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
486 QueryOption query = {
487 .key = key
488 };
489 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
490 EXPECT_EQ(getRet, E_OK);
491
492 auto ndkData = OH_UdmfData_Create();
493 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
494 unsigned int count;
495 OH_UdmfData_GetRecords(ndkData, &count);
496 EXPECT_EQ(1, count);
497 auto record = OH_UdmfData_GetRecord(ndkData, 0);
498 auto arrayBuffer = OH_UdsArrayBuffer_Create();
499 auto result = OH_UdmfRecord_GetArrayBuffer(record, definedTypeId.c_str(), arrayBuffer);
500 EXPECT_EQ(0, result);
501 unsigned int getCount = 0;
502 unsigned char *getEntry;
503 OH_UdsArrayBuffer_GetData(arrayBuffer, &getEntry, &getCount);
504 EXPECT_EQ(6, getCount);
505 dataBytes = { '1', '2', '3', '4', '5', '6' };
506 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(reinterpret_cast<const char *>(getEntry)));
507
508 OH_UdsArrayBuffer_Destroy(arrayBuffer);
509 OH_UdmfData_Destroy(ndkData);
510 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_002 end.");
511 }
512
513 /* *
514 * @tc.name: ConvertApplicationDefined_003
515 * @tc.desc: test application defined record conversion between JS and C-API
516 * @tc.type: FUNC
517 */
HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_003, TestSize.Level1)518 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_003, TestSize.Level1)
519 {
520 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_003 begin.");
521 auto arrayBuffer = OH_UdsArrayBuffer_Create();
522 unsigned char data[] = {'1', '2', '3', '4', '5', '6'};
523 OH_UdsArrayBuffer_SetData(arrayBuffer, data, 6);
524 auto record = OH_UdmfRecord_Create();
525 OH_UdmfRecord_AddArrayBuffer(record, "person_demo", arrayBuffer);
526 auto ndkData = OH_UdmfData_Create();
527 OH_UdmfData_AddRecord(ndkData, record);
528 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
529 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
530 EXPECT_EQ(conversionStatus, E_OK);
531 std::string key;
532 CustomOption option = {
533 .intention = UD_INTENTION_DRAG
534 };
535 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
536 EXPECT_EQ(setRet, E_OK);
537
538 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
539 QueryOption query = {
540 .key = key
541 };
542 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
543 EXPECT_EQ(getRet, E_OK);
544
545 auto readRecord = readData->GetRecordAt(0);
546 auto definedRecord = std::static_pointer_cast<ApplicationDefinedRecord>(readRecord);
547 auto type = definedRecord->GetApplicationDefinedType();
548 EXPECT_EQ("person_demo", type);
549 auto rawData = definedRecord->GetRawData();
550 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
551 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(rawData.begin(), rawData.end()));
552
553 OH_UdsArrayBuffer_Destroy(arrayBuffer);
554 OH_UdmfRecord_Destroy(record);
555 OH_UdmfData_Destroy(ndkData);
556 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_003 end.");
557 }
558
559 /* *
560 * @tc.name: ConvertApplicationDefined_004
561 * @tc.desc: test application defined record conversion between JS and C-API
562 * @tc.type: FUNC
563 */
HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_004, TestSize.Level1)564 HWTEST_F(NdkDataConversionTest, ConvertApplicationDefined_004, TestSize.Level1)
565 {
566 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_004 begin.");
567 unsigned char data[] = {'1', '2', '3', '4', '5', '6'};
568 auto record = OH_UdmfRecord_Create();
569 OH_UdmfRecord_AddGeneralEntry(record, "person_demo", data, 6);
570 auto ndkData = OH_UdmfData_Create();
571 OH_UdmfData_AddRecord(ndkData, record);
572 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
573 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
574 EXPECT_EQ(conversionStatus, E_OK);
575 std::string key;
576 CustomOption option = {
577 .intention = UD_INTENTION_DRAG
578 };
579 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
580 EXPECT_EQ(setRet, E_OK);
581
582 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
583 QueryOption query = {
584 .key = key
585 };
586 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
587 EXPECT_EQ(getRet, E_OK);
588
589 auto readRecord = readData->GetRecordAt(0);
590 auto definedRecord = std::static_pointer_cast<ApplicationDefinedRecord>(readRecord);
591 auto type = definedRecord->GetApplicationDefinedType();
592 EXPECT_EQ("person_demo", type);
593 auto rawData = definedRecord->GetRawData();
594 std::vector<uint8_t> dataBytes = { '1', '2', '3', '4', '5', '6' };
595 EXPECT_EQ(std::string(dataBytes.begin(), dataBytes.end()), std::string(rawData.begin(), rawData.end()));
596
597 OH_UdmfRecord_Destroy(record);
598 OH_UdmfData_Destroy(ndkData);
599 LOG_INFO(UDMF_TEST, "ConvertApplicationDefined_004 end.");
600 }
601
602 /* *
603 * @tc.name: ConvertOhtherUds_001
604 * @tc.desc: test other conversion between JS and C-API
605 * @tc.type: FUNC
606 */
HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_001, TestSize.Level1)607 HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_001, TestSize.Level1)
608 {
609 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_001 begin.");
610 std::string definedTypeId = "person_app_demo";
611 std::shared_ptr<Html> html = std::make_shared<Html>("htmlContent", "plainContent");
612 std::map<std::string, ValueType> value;
613 std::vector<uint8_t> thumbData = {1, 2, 3, 4, 5};
614 auto obj = std::make_shared<Object>();
615 obj->value_.emplace(UNIFORM_DATA_TYPE, "general.content-form");
616 obj->value_.emplace(TITLE, "title");
617 obj->value_.emplace(THUMB_DATA, thumbData);
618 std::shared_ptr<UnifiedRecord> contentForm = std::make_shared<UnifiedRecord>(UDType::CONTENT_FORM, obj);
619 UnifiedData data;
620 std::vector<std::shared_ptr<UnifiedRecord>> records = { html, contentForm };
621 data.SetRecords(records);
622
623 std::string key;
624 CustomOption option = { .intention = UD_INTENTION_DRAG };
625 auto setRet = UdmfClient::GetInstance().SetData(option, data, key);
626 EXPECT_EQ(setRet, E_OK);
627
628 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
629 QueryOption query = { .key = key };
630 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
631 EXPECT_EQ(getRet, E_OK);
632
633 auto ndkData = OH_UdmfData_Create();
634 NdkDataConversion::GetNdkUnifiedData(readData, ndkData);
635 unsigned int count;
636 OH_UdmfData_GetRecords(ndkData, &count);
637 EXPECT_EQ(2, count);
638 auto record = OH_UdmfData_GetRecord(ndkData, 0);
639 auto htmlNdk = OH_UdsHtml_Create();
640 auto result = OH_UdmfRecord_GetHtml(record, htmlNdk);
641 EXPECT_EQ(0, result);
642 EXPECT_EQ("general.html", std::string(OH_UdsHtml_GetType(htmlNdk)));
643 EXPECT_EQ("htmlContent", std::string(OH_UdsHtml_GetContent(htmlNdk)));
644 EXPECT_EQ("plainContent", std::string(OH_UdsHtml_GetPlainContent(htmlNdk)));
645
646 auto contentFormRecord = OH_UdmfData_GetRecord(ndkData, 1);
647 auto contentFormNdk = OH_UdsContentForm_Create();
648 result = OH_UdmfRecord_GetContentForm(contentFormRecord, contentFormNdk);
649 EXPECT_EQ(0, result);
650 EXPECT_EQ("general.content-form", std::string(OH_UdsContentForm_GetType(contentFormNdk)));
651 EXPECT_EQ("title", std::string(OH_UdsContentForm_GetTitle(contentFormNdk)));
652 unsigned char *readThumbData;
653 unsigned int thumbDataLen = 0;
654 EXPECT_EQ(0, OH_UdsContentForm_GetThumbData(contentFormNdk, &readThumbData, &thumbDataLen));
655 EXPECT_EQ(5, thumbDataLen);
656 OH_UdsHtml_Destroy(htmlNdk);
657 OH_UdsContentForm_Destroy(contentFormNdk);
658 OH_UdmfData_Destroy(ndkData);
659 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_001 end.");
660 }
661
662 /* *
663 * @tc.name: ConvertOhtherUds_002
664 * @tc.desc: test html conversion between JS and C-API
665 * @tc.type: FUNC
666 */
HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_002, TestSize.Level1)667 HWTEST_F(NdkDataConversionTest, ConvertOhtherUds_002, TestSize.Level1)
668 {
669 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_002 begin.");
670 auto htmlNdk = OH_UdsHtml_Create();
671 OH_UdsHtml_SetContent(htmlNdk, "htmlContent");
672 OH_UdsHtml_SetPlainContent(htmlNdk, "plainContent");
673 auto record = OH_UdmfRecord_Create();
674 OH_UdmfRecord_AddHtml(record, htmlNdk);
675 auto ndkData = OH_UdmfData_Create();
676 OH_UdmfData_AddRecord(ndkData, record);
677 auto record2 = OH_UdmfRecord_Create();
678 auto contentFormNdk = OH_UdsContentForm_Create();
679 OH_UdsContentForm_SetTitle(contentFormNdk, "title");
680 unsigned char thumbData[] = {0, 1, 2, 3, 4};
681 OH_UdsContentForm_SetThumbData(contentFormNdk, thumbData, 5);
682 OH_UdmfRecord_AddContentForm(record2, contentFormNdk);
683 OH_UdmfData_AddRecord(ndkData, record2);
684
685 std::shared_ptr<UnifiedData> unifiedData = std::make_shared<UnifiedData>();
686 auto conversionStatus = NdkDataConversion::GetNativeUnifiedData(ndkData, unifiedData);
687 EXPECT_EQ(conversionStatus, E_OK);
688 std::string key;
689 CustomOption option = { .intention = UD_INTENTION_DRAG };
690 auto setRet = UdmfClient::GetInstance().SetData(option, *unifiedData, key);
691 EXPECT_EQ(setRet, E_OK);
692
693 std::shared_ptr<UnifiedData> readData = std::make_shared<UnifiedData>();
694 QueryOption query = { .key = key };
695 auto getRet = UdmfClient::GetInstance().GetData(query, *readData);
696 EXPECT_EQ(getRet, E_OK);
697
698 auto readRecord = readData->GetRecordAt(0);
699 auto html = std::static_pointer_cast<Html>(readRecord);
700 EXPECT_EQ("htmlContent", html->GetHtmlContent());
701 EXPECT_EQ("plainContent", html->GetPlainContent());
702
703 auto contentForm = readData->GetRecordAt(1);
704 auto value = contentForm->GetValue();
705 auto obj = std::get<std::shared_ptr<Object>>(value);
706 EXPECT_EQ("general.content-form", std::get<std::string>(obj->value_[UNIFORM_DATA_TYPE]));
707 EXPECT_EQ(5, std::get<int>(obj->value_[THUMB_DATA_LENGTH]));
708 auto readThumbData = std::get<std::vector<uint8_t>>(obj->value_[THUMB_DATA]);
709 EXPECT_EQ(4, readThumbData.at(4));
710
711 OH_UdsHtml_Destroy(htmlNdk);
712 OH_UdsContentForm_Destroy(contentFormNdk);
713 OH_UdmfRecord_Destroy(record);
714 OH_UdmfRecord_Destroy(record2);
715 OH_UdmfData_Destroy(ndkData);
716 LOG_INFO(UDMF_TEST, "ConvertOhtherUds_002 end.");
717 }
718 }
719