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 "UdsTest"
17
18 #include <gtest/gtest.h>
19 #include <unistd.h>
20
21 #include "token_setproc.h"
22 #include "accesstoken_kit.h"
23 #include "nativetoken_kit.h"
24 #include "logger.h"
25 #include "pixelmap_native_impl.h"
26 #include "uds.h"
27 #include "udmf_capi_common.h"
28 #include "udmf_meta.h"
29 #include "udmf_err_code.h"
30
31 using namespace testing::ext;
32 using namespace OHOS::Security::AccessToken;
33 using namespace OHOS::UDMF;
34 using namespace OHOS;
35
36 namespace OHOS::Test {
37 class UdsTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 static bool CheckUnsignedChar(unsigned char* dst, unsigned char* src, int size);
44 };
45
SetUpTestCase(void)46 void UdsTest::SetUpTestCase(void) {}
47
TearDownTestCase(void)48 void UdsTest::TearDownTestCase(void) {}
49
SetUp(void)50 void UdsTest::SetUp(void) {}
51
TearDown(void)52 void UdsTest::TearDown(void) {}
53
CheckUnsignedChar(unsigned char * dst,unsigned char * src,int size)54 bool UdsTest::CheckUnsignedChar(unsigned char* dst, unsigned char* src, int size)
55 {
56 EXPECT_NE(dst, nullptr);
57 EXPECT_NE(src, nullptr);
58 for (int i = 0; i < size; ++i) {
59 if (dst[i] != src[i]) {
60 return false;
61 }
62 }
63 return true;
64 }
65
66 /**
67 * @tc.name: OH_UdsPlainText_Create_001
68 * @tc.desc: Normal testcase of OH_UdsPlainText_Create
69 * @tc.type: FUNC
70 */
71 HWTEST_F(UdsTest, OH_UdsPlainText_Create_001, TestSize.Level1)
72 {
73 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_Create_001 begin.");
74 auto plainText = OH_UdsPlainText_Create();
75 EXPECT_EQ(UDMF_META_PLAIN_TEXT, *(std::get_if<std::string>(&(plainText->obj->value_[UNIFORM_DATA_TYPE]))));
76 OH_UdsPlainText_Destroy(plainText);
77 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_Create_001 end.");
78 }
79
80 /**
81 * @tc.name: OH_UdsPlainText_GetType_001
82 * @tc.desc: Normal testcase of OH_UdsPlainText_GetType
83 * @tc.type: FUNC
84 */
85 HWTEST_F(UdsTest, OH_UdsPlainText_GetType_001, TestSize.Level1)
86 {
87 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetType_001 begin.");
88 auto plainText = OH_UdsPlainText_Create();
89 EXPECT_EQ(UDMF_META_PLAIN_TEXT, std::string(OH_UdsPlainText_GetType(plainText)));
90 OH_UdsPlainText_Destroy(plainText);
91
92 OH_UdsPlainText* plainTextNullptr = nullptr;
93 EXPECT_EQ(nullptr, OH_UdsPlainText_GetType(plainTextNullptr));
94
95 plainTextNullptr = new OH_UdsPlainText;
96 EXPECT_EQ(nullptr, OH_UdsPlainText_GetType(plainTextNullptr));
97 OH_UdsPlainText_Destroy(plainTextNullptr);
98 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetType_001 end.");
99 }
100
101 /**
102 * @tc.name: OH_UdsPlainText_GetContent_001
103 * @tc.desc: Normal testcase of OH_UdsPlainText_GetContent
104 * @tc.type: FUNC
105 */
106 HWTEST_F(UdsTest, OH_UdsPlainText_GetContent_001, TestSize.Level1)
107 {
108 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetContent_001 begin.");
109 auto plainText = OH_UdsPlainText_Create();
110 plainText->obj->value_[CONTENT] = "doing something";
111 EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetContent(plainText)));
112 OH_UdsPlainText_Destroy(plainText);
113
114 OH_UdsPlainText* plainTextNullptr = nullptr;
115 EXPECT_EQ(nullptr, OH_UdsPlainText_GetContent(plainTextNullptr));
116
117 plainTextNullptr = new OH_UdsPlainText;
118 EXPECT_EQ(nullptr, OH_UdsPlainText_GetContent(plainTextNullptr));
119 OH_UdsPlainText_Destroy(plainTextNullptr);
120 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetContent_001 end.");
121 }
122
123 /**
124 * @tc.name: OH_UdsPlainText_GetAbstract_001
125 * @tc.desc: Normal testcase of OH_UdsPlainText_GetAbstract
126 * @tc.type: FUNC
127 */
128 HWTEST_F(UdsTest, OH_UdsPlainText_GetAbstract_001, TestSize.Level1)
129 {
130 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetAbstract_001 begin.");
131 auto plainText = OH_UdsPlainText_Create();
132 plainText->obj->value_[ABSTRACT] = "doing something";
133 EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetAbstract(plainText)));
134 OH_UdsPlainText_Destroy(plainText);
135
136 OH_UdsPlainText* plainTextNullptr = nullptr;
137 EXPECT_EQ(nullptr, OH_UdsPlainText_GetAbstract(plainTextNullptr));
138
139 plainTextNullptr = new OH_UdsPlainText;
140 EXPECT_EQ(nullptr, OH_UdsPlainText_GetAbstract(plainTextNullptr));
141 OH_UdsPlainText_Destroy(plainTextNullptr);
142 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_GetAbstract_001 end.");
143 }
144
145 /**
146 * @tc.name: OH_UdsPlainText_SetContent_001
147 * @tc.desc: Normal testcase of OH_UdsPlainText_SetContent
148 * @tc.type: FUNC
149 */
150 HWTEST_F(UdsTest, OH_UdsPlainText_SetContent_001, TestSize.Level1)
151 {
152 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetContent_001 begin.");
153 auto plainText = OH_UdsPlainText_Create();
154 int result = OH_UdsPlainText_SetContent(plainText, "doing something");
155 EXPECT_EQ(UDMF_E_OK, result);
156 EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetContent(plainText)));
157
158 result = OH_UdsPlainText_SetContent(nullptr, "doing something");
159 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
160
161 result = OH_UdsPlainText_SetContent(plainText, nullptr);
162 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
163
164 plainText->obj = nullptr;
165 result = OH_UdsPlainText_SetContent(plainText, "doing something");
166 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
167 OH_UdsPlainText_Destroy(plainText);
168 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetContent_001 end.");
169 }
170
171 /**
172 * @tc.name: OH_UdsPlainText_SetAbstract_001
173 * @tc.desc: Normal testcase of OH_UdsPlainText_SetAbstract
174 * @tc.type: FUNC
175 */
176 HWTEST_F(UdsTest, OH_UdsPlainText_SetAbstract_001, TestSize.Level1)
177 {
178 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetAbstract_001 begin.");
179 auto plainText = OH_UdsPlainText_Create();
180 int result = OH_UdsPlainText_SetAbstract(plainText, "doing something");
181 EXPECT_EQ(UDMF_E_OK, result);
182 EXPECT_EQ("doing something", std::string(OH_UdsPlainText_GetAbstract(plainText)));
183
184 result = OH_UdsPlainText_SetAbstract(nullptr, "doing something");
185 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
186
187 result = OH_UdsPlainText_SetAbstract(plainText, nullptr);
188 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
189
190 plainText->obj = nullptr;
191 result = OH_UdsPlainText_SetAbstract(plainText, "doing something");
192 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
193 OH_UdsPlainText_Destroy(plainText);
194 LOG_INFO(UDMF_TEST, "OH_UdsPlainText_SetAbstract_001 end.");
195 }
196
197 /**
198 * @tc.name: OH_UdsHyperlink_Create_001
199 * @tc.desc: Normal testcase of OH_UdsHyperlink_Create
200 * @tc.type: FUNC
201 */
202 HWTEST_F(UdsTest, OH_UdsHyperlink_Create_001, TestSize.Level1)
203 {
204 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_Create_001 begin.");
205 auto hyperlink = OH_UdsHyperlink_Create();
206 EXPECT_EQ(UDMF_META_HYPERLINK, *(std::get_if<std::string>(&(hyperlink->obj)->value_[UNIFORM_DATA_TYPE])));
207 OH_UdsHyperlink_Destroy(hyperlink);
208 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_Create_001 end.");
209 }
210
211 /**
212 * @tc.name: OH_UdsHyperlink_GetType_001
213 * @tc.desc: Normal testcase of OH_UdsHyperlink_GetType
214 * @tc.type: FUNC
215 */
216 HWTEST_F(UdsTest, OH_UdsHyperlink_GetType_001, TestSize.Level1)
217 {
218 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetType_001 begin.");
219 auto hyperlink = OH_UdsHyperlink_Create();
220 EXPECT_EQ(UDMF_META_HYPERLINK, std::string(OH_UdsHyperlink_GetType(hyperlink)));
221 OH_UdsHyperlink_Destroy(hyperlink);
222
223 OH_UdsHyperlink* hyperlinkNullptr = nullptr;
224 EXPECT_EQ(nullptr, OH_UdsHyperlink_GetType(hyperlinkNullptr));
225
226 hyperlinkNullptr = new OH_UdsHyperlink;
227 EXPECT_EQ(nullptr, OH_UdsHyperlink_GetType(hyperlinkNullptr));
228 OH_UdsHyperlink_Destroy(hyperlinkNullptr);
229 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetType_001 end.");
230 }
231
232 /**
233 * @tc.name: OH_UdsHyperlink_GetUrl_001
234 * @tc.desc: Normal testcase of OH_UdsHyperlink_GetUrl
235 * @tc.type: FUNC
236 */
237 HWTEST_F(UdsTest, OH_UdsHyperlink_GetUrl_001, TestSize.Level1)
238 {
239 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetUrl_001 begin.");
240 auto hyperlink = OH_UdsHyperlink_Create();
241 hyperlink->obj->value_[URL] = "www.xxx.com";
242 EXPECT_EQ("www.xxx.com", std::string(OH_UdsHyperlink_GetUrl(hyperlink)));
243 OH_UdsHyperlink_Destroy(hyperlink);
244
245 OH_UdsHyperlink* hyperlinkNullptr = nullptr;
246 EXPECT_EQ(nullptr, OH_UdsHyperlink_GetUrl(hyperlinkNullptr));
247
248 hyperlinkNullptr = new OH_UdsHyperlink;
249 EXPECT_EQ(nullptr, OH_UdsHyperlink_GetUrl(hyperlinkNullptr));
250 OH_UdsHyperlink_Destroy(hyperlinkNullptr);
251 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetUrl_001 end.");
252 }
253
254 /**
255 * @tc.name: OH_UdsHyperlink_GetDescription_001
256 * @tc.desc: Normal testcase of OH_UdsHyperlink_GetDescription
257 * @tc.type: FUNC
258 */
259 HWTEST_F(UdsTest, OH_UdsHyperlink_GetDescription_001, TestSize.Level1)
260 {
261 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetDescription_001 begin.");
262 auto hyperlink = OH_UdsHyperlink_Create();
263 hyperlink->obj->value_[DESCRIPTION] = "do something";
264 EXPECT_EQ("do something", std::string(OH_UdsHyperlink_GetDescription(hyperlink)));
265 OH_UdsHyperlink_Destroy(hyperlink);
266
267 OH_UdsHyperlink* hyperlinkNullptr = nullptr;
268 EXPECT_EQ(nullptr, OH_UdsHyperlink_GetDescription(hyperlinkNullptr));
269
270 hyperlinkNullptr = new OH_UdsHyperlink;
271 EXPECT_EQ(nullptr, OH_UdsHyperlink_GetDescription(hyperlinkNullptr));
272 OH_UdsHyperlink_Destroy(hyperlinkNullptr);
273 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_GetDescription_001 end.");
274 }
275
276 /**
277 * @tc.name: OH_UdsHyperlink_SetUrl_001
278 * @tc.desc: Normal testcase of OH_UdsHyperlink_SetUrl
279 * @tc.type: FUNC
280 */
281 HWTEST_F(UdsTest, OH_UdsHyperlink_SetUrl_001, TestSize.Level1)
282 {
283 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetUrl_001 begin.");
284 auto hyperlink = OH_UdsHyperlink_Create();
285 int result = OH_UdsHyperlink_SetUrl(hyperlink, "www.xxx.com");
286 EXPECT_EQ(UDMF_E_OK, result);
287 EXPECT_EQ("www.xxx.com", std::string(OH_UdsHyperlink_GetUrl(hyperlink)));
288
289 result = OH_UdsHyperlink_SetUrl(nullptr, "www.xxx.com");
290 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
291
292 result = OH_UdsHyperlink_SetUrl(hyperlink, nullptr);
293 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
294
295 hyperlink->obj = nullptr;
296 result = OH_UdsHyperlink_SetUrl(hyperlink, "www.xxx.com");
297 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
298 OH_UdsHyperlink_Destroy(hyperlink);
299 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetUrl_001 end.");
300 }
301
302 /**
303 * @tc.name: OH_UdsHyperlink_SetDescription_001
304 * @tc.desc: Normal testcase of OH_UdsHyperlink_SetDescription
305 * @tc.type: FUNC
306 */
307 HWTEST_F(UdsTest, OH_UdsHyperlink_SetDescription_001, TestSize.Level1)
308 {
309 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetDescription_001 begin.");
310 auto hyperlink = OH_UdsHyperlink_Create();
311 int result = OH_UdsHyperlink_SetDescription(hyperlink, "doing something");
312 EXPECT_EQ(UDMF_E_OK, result);
313 EXPECT_EQ("doing something", std::string(OH_UdsHyperlink_GetDescription(hyperlink)));
314
315 result = OH_UdsHyperlink_SetDescription(nullptr, "doing something");
316 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
317
318 result = OH_UdsHyperlink_SetDescription(hyperlink, nullptr);
319 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
320
321 hyperlink->obj = nullptr;
322 result = OH_UdsHyperlink_SetDescription(hyperlink, "doing something");
323 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
324 OH_UdsHyperlink_Destroy(hyperlink);
325 LOG_INFO(UDMF_TEST, "OH_UdsHyperlink_SetDescription_001 end.");
326 }
327
328 /**
329 * @tc.name: OH_UdsHtml_Create_001
330 * @tc.desc: Normal testcase of OH_UdsHtml_Create
331 * @tc.type: FUNC
332 */
333 HWTEST_F(UdsTest, OH_UdsHtml_Create_001, TestSize.Level1)
334 {
335 LOG_INFO(UDMF_TEST, "OH_UdsHtml_Create_001 begin.");
336 auto html = OH_UdsHtml_Create();
337 EXPECT_EQ(UDMF_META_HTML, *(std::get_if<std::string>(&(html->obj)->value_[UNIFORM_DATA_TYPE])));
338 OH_UdsHtml_Destroy(html);
339 LOG_INFO(UDMF_TEST, "OH_UdsHtml_Create_001 end.");
340 }
341
342 /**
343 * @tc.name: OH_UdsHtml_GetType_001
344 * @tc.desc: Normal testcase of OH_UdsHtml_GetType
345 * @tc.type: FUNC
346 */
347 HWTEST_F(UdsTest, OH_UdsHtml_GetType_001, TestSize.Level1)
348 {
349 LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetType_001 begin.");
350 auto html = OH_UdsHtml_Create();
351 EXPECT_EQ(UDMF_META_HTML, std::string(OH_UdsHtml_GetType(html)));
352 OH_UdsHtml_Destroy(html);
353
354 OH_UdsHtml* htmlNullptr = nullptr;
355 EXPECT_EQ(nullptr, OH_UdsHtml_GetType(htmlNullptr));
356
357 htmlNullptr = new OH_UdsHtml;
358 EXPECT_EQ(nullptr, OH_UdsHtml_GetType(htmlNullptr));
359 OH_UdsHtml_Destroy(htmlNullptr);
360 LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetType_001 end.");
361 }
362
363 /**
364 * @tc.name: OH_UdsHtml_GetContent_001
365 * @tc.desc: Normal testcase of OH_UdsHtml_GetContent
366 * @tc.type: FUNC
367 */
368 HWTEST_F(UdsTest, OH_UdsHtml_GetContent_001, TestSize.Level1)
369 {
370 LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetContent_001 begin.");
371 auto html = OH_UdsHtml_Create();
372 html->obj->value_[HTML_CONTENT] = "htmlxxxxx";
373 EXPECT_EQ("htmlxxxxx", std::string(OH_UdsHtml_GetContent(html)));
374 OH_UdsHtml_Destroy(html);
375
376 OH_UdsHtml* htmlNullptr = nullptr;
377 EXPECT_EQ(nullptr, OH_UdsHtml_GetContent(htmlNullptr));
378
379 htmlNullptr = new OH_UdsHtml;
380 EXPECT_EQ(nullptr, OH_UdsHtml_GetContent(htmlNullptr));
381 OH_UdsHtml_Destroy(htmlNullptr);
382 LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetContent_001 end.");
383 }
384
385 /**
386 * @tc.name: OH_UdsHtml_GetPlainContent_001
387 * @tc.desc: Normal testcase of OH_UdsHtml_GetPlainContent
388 * @tc.type: FUNC
389 */
390 HWTEST_F(UdsTest, OH_UdsHtml_GetPlainContent_001, TestSize.Level1)
391 {
392 LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetPlainContent_001 begin.");
393 auto html = OH_UdsHtml_Create();
394 html->obj->value_[PLAIN_CONTENT] = "do something";
395 EXPECT_EQ("do something", std::string(OH_UdsHtml_GetPlainContent(html)));
396 OH_UdsHtml_Destroy(html);
397
398 OH_UdsHtml* htmlNullptr = nullptr;
399 EXPECT_EQ(nullptr, OH_UdsHtml_GetPlainContent(htmlNullptr));
400
401 htmlNullptr = new OH_UdsHtml;
402 EXPECT_EQ(nullptr, OH_UdsHtml_GetPlainContent(htmlNullptr));
403 OH_UdsHtml_Destroy(htmlNullptr);
404 LOG_INFO(UDMF_TEST, "OH_UdsHtml_GetPlainContent_001 end.");
405 }
406
407 /**
408 * @tc.name: OH_UdsHtml_SetContent_001
409 * @tc.desc: Normal testcase of OH_UdsHtml_SetContent
410 * @tc.type: FUNC
411 */
412 HWTEST_F(UdsTest, OH_UdsHtml_SetContent_001, TestSize.Level1)
413 {
414 LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetContent_001 begin.");
415 auto html = OH_UdsHtml_Create();
416 int result = OH_UdsHtml_SetContent(html, "htmlxxx");
417 EXPECT_EQ(UDMF_E_OK, result);
418 EXPECT_EQ("htmlxxx", std::string(OH_UdsHtml_GetContent(html)));
419
420 result = OH_UdsHtml_SetContent(nullptr, "htmlxxx");
421 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
422
423 result = OH_UdsHtml_SetContent(html, nullptr);
424 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
425
426 html->obj = nullptr;
427 result = OH_UdsHtml_SetContent(html, "htmlxxx");
428 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
429 OH_UdsHtml_Destroy(html);
430 LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetContent_001 end.");
431 }
432
433 /**
434 * @tc.name: OH_UdsHtml_SetPlainContent_001
435 * @tc.desc: Normal testcase of OH_UdsHtml_SetPlainContent
436 * @tc.type: FUNC
437 */
438 HWTEST_F(UdsTest, OH_UdsHtml_SetPlainContent_001, TestSize.Level1)
439 {
440 LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetPlainContent_001 begin.");
441 auto html = OH_UdsHtml_Create();
442 int result = OH_UdsHtml_SetPlainContent(html, "doing something");
443 EXPECT_EQ(UDMF_E_OK, result);
444 EXPECT_EQ("doing something", std::string(OH_UdsHtml_GetPlainContent(html)));
445
446 result = OH_UdsHtml_SetPlainContent(nullptr, "doing something");
447 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
448
449 result = OH_UdsHtml_SetPlainContent(html, nullptr);
450 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
451
452 html->obj = nullptr;
453 result = OH_UdsHtml_SetPlainContent(html, "doing something");
454 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
455 OH_UdsHtml_Destroy(html);
456 LOG_INFO(UDMF_TEST, "OH_UdsHtml_SetPlainContent_001 end.");
457 }
458
459 /**
460 * @tc.name: OH_UdsAppItem_Create_001
461 * @tc.desc: Normal testcase of OH_UdsAppItem_Create
462 * @tc.type: FUNC
463 */
464 HWTEST_F(UdsTest, OH_UdsAppItem_Create_001, TestSize.Level1)
465 {
466 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_Create_001 begin.");
467 auto appItem = OH_UdsAppItem_Create();
468 EXPECT_EQ(UDMF_META_OPENHARMONY_APP_ITEM, *(std::get_if<std::string>(&(appItem->obj)->value_[UNIFORM_DATA_TYPE])));
469 OH_UdsAppItem_Destroy(appItem);
470 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_Create_001 end.");
471 }
472
473 /**
474 * @tc.name: OH_UdsAppItem_GetType_001
475 * @tc.desc: Normal testcase of OH_UdsAppItem_GetType
476 * @tc.type: FUNC
477 */
478 HWTEST_F(UdsTest, OH_UdsAppItem_GetType_001, TestSize.Level1)
479 {
480 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetType_001 begin.");
481 auto appItem = OH_UdsAppItem_Create();
482 EXPECT_EQ(UDMF_META_OPENHARMONY_APP_ITEM, std::string(OH_UdsAppItem_GetType(appItem)));
483 OH_UdsAppItem_Destroy(appItem);
484
485 OH_UdsAppItem* appItemNullptr = nullptr;
486 EXPECT_EQ(nullptr, OH_UdsAppItem_GetType(appItemNullptr));
487
488 appItemNullptr = new OH_UdsAppItem;
489 EXPECT_EQ(nullptr, OH_UdsAppItem_GetType(appItemNullptr));
490 OH_UdsAppItem_Destroy(appItemNullptr);
491 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetType_001 end.");
492 }
493
494 /**
495 * @tc.name: OH_UdsAppItem_GetId_001
496 * @tc.desc: Normal testcase of OH_UdsAppItem_GetId
497 * @tc.type: FUNC
498 */
499 HWTEST_F(UdsTest, OH_UdsAppItem_GetId_001, TestSize.Level1)
500 {
501 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetId_001 begin.");
502 auto appItem = OH_UdsAppItem_Create();
503 appItem->obj->value_[APP_ID] = "com.xxx";
504 EXPECT_EQ("com.xxx", std::string(OH_UdsAppItem_GetId(appItem)));
505 OH_UdsAppItem_Destroy(appItem);
506
507 OH_UdsAppItem* appItemNullptr = nullptr;
508 EXPECT_EQ(nullptr, OH_UdsAppItem_GetId(appItemNullptr));
509
510 appItemNullptr = new OH_UdsAppItem;
511 EXPECT_EQ(nullptr, OH_UdsAppItem_GetId(appItemNullptr));
512 OH_UdsAppItem_Destroy(appItemNullptr);
513 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetId_001 end.");
514 }
515
516 /**
517 * @tc.name: OH_UdsAppItem_GetName_001
518 * @tc.desc: Normal testcase of OH_UdsAppItem_GetName
519 * @tc.type: FUNC
520 */
521 HWTEST_F(UdsTest, OH_UdsAppItem_GetName_001, TestSize.Level1)
522 {
523 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetName_001 begin.");
524 auto appItem = OH_UdsAppItem_Create();
525 appItem->obj->value_[APP_NAME] = "OH";
526 EXPECT_EQ("OH", std::string(OH_UdsAppItem_GetName(appItem)));
527 OH_UdsAppItem_Destroy(appItem);
528
529 OH_UdsAppItem* appItemNullptr = nullptr;
530 EXPECT_EQ(nullptr, OH_UdsAppItem_GetName(appItemNullptr));
531
532 appItemNullptr = new OH_UdsAppItem;
533 EXPECT_EQ(nullptr, OH_UdsAppItem_GetName(appItemNullptr));
534 OH_UdsAppItem_Destroy(appItemNullptr);
535 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetName_001 end.");
536 }
537
538 /**
539 * @tc.name: OH_UdsAppItem_GetIconId_001
540 * @tc.desc: Normal testcase of OH_UdsAppItem_GetIconId
541 * @tc.type: FUNC
542 */
543 HWTEST_F(UdsTest, OH_UdsAppItem_GetIconId_001, TestSize.Level1)
544 {
545 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetIconId_001 begin.");
546 auto appItem = OH_UdsAppItem_Create();
547 appItem->obj->value_[APP_ICON_ID] = "icon";
548 EXPECT_EQ("icon", std::string(OH_UdsAppItem_GetIconId(appItem)));
549 OH_UdsAppItem_Destroy(appItem);
550
551 OH_UdsAppItem* appItemNullptr = nullptr;
552 EXPECT_EQ(nullptr, OH_UdsAppItem_GetIconId(appItemNullptr));
553
554 appItemNullptr = new OH_UdsAppItem;
555 EXPECT_EQ(nullptr, OH_UdsAppItem_GetIconId(appItemNullptr));
556 OH_UdsAppItem_Destroy(appItemNullptr);
557 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetIconId_001 end.");
558 }
559
560 /**
561 * @tc.name: OH_UdsAppItem_GetLabelId_001
562 * @tc.desc: Normal testcase of OH_UdsAppItem_GetLabelId
563 * @tc.type: FUNC
564 */
565 HWTEST_F(UdsTest, OH_UdsAppItem_GetLabelId_001, TestSize.Level1)
566 {
567 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetLabelId_001 begin.");
568 auto appItem = OH_UdsAppItem_Create();
569 appItem->obj->value_[APP_LABEL_ID] = "label";
570 EXPECT_EQ("label", std::string(OH_UdsAppItem_GetLabelId(appItem)));
571 OH_UdsAppItem_Destroy(appItem);
572
573 OH_UdsAppItem* appItemNullptr = nullptr;
574 EXPECT_EQ(nullptr, OH_UdsAppItem_GetLabelId(appItemNullptr));
575
576 appItemNullptr = new OH_UdsAppItem;
577 EXPECT_EQ(nullptr, OH_UdsAppItem_GetLabelId(appItemNullptr));
578 OH_UdsAppItem_Destroy(appItemNullptr);
579 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetLabelId_001 end.");
580 }
581
582 /**
583 * @tc.name: OH_UdsAppItem_GetBundleName_001
584 * @tc.desc: Normal testcase of OH_UdsAppItem_GetBundleName
585 * @tc.type: FUNC
586 */
587 HWTEST_F(UdsTest, OH_UdsAppItem_GetBundleName_001, TestSize.Level1)
588 {
589 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetBundleName_001 begin.");
590 auto appItem = OH_UdsAppItem_Create();
591 appItem->obj->value_[BUNDLE_NAME] = "bundle";
592 EXPECT_EQ("bundle", std::string(OH_UdsAppItem_GetBundleName(appItem)));
593 OH_UdsAppItem_Destroy(appItem);
594
595 OH_UdsAppItem* appItemNullptr = nullptr;
596 EXPECT_EQ(nullptr, OH_UdsAppItem_GetBundleName(appItemNullptr));
597
598 appItemNullptr = new OH_UdsAppItem;
599 EXPECT_EQ(nullptr, OH_UdsAppItem_GetBundleName(appItemNullptr));
600 OH_UdsAppItem_Destroy(appItemNullptr);
601 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetBundleName_001 end.");
602 }
603
604 /**
605 * @tc.name: OH_UdsAppItem_GetAbilityName_001
606 * @tc.desc: Normal testcase of OH_UdsAppItem_GetAbilityName
607 * @tc.type: FUNC
608 */
609 HWTEST_F(UdsTest, OH_UdsAppItem_GetAbilityName_001, TestSize.Level1)
610 {
611 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetAbilityName_001 begin.");
612 auto appItem = OH_UdsAppItem_Create();
613 appItem->obj->value_[ABILITY_NAME] = "ability";
614 EXPECT_EQ("ability", std::string(OH_UdsAppItem_GetAbilityName(appItem)));
615 OH_UdsAppItem_Destroy(appItem);
616
617 OH_UdsAppItem* appItemNullptr = nullptr;
618 EXPECT_EQ(nullptr, OH_UdsAppItem_GetAbilityName(appItemNullptr));
619
620 appItemNullptr = new OH_UdsAppItem;
621 EXPECT_EQ(nullptr, OH_UdsAppItem_GetAbilityName(appItemNullptr));
622 OH_UdsAppItem_Destroy(appItemNullptr);
623 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_GetAbilityName_001 end.");
624 }
625
626 /**
627 * @tc.name: OH_UdsAppItem_SetId_001
628 * @tc.desc: Normal testcase of OH_UdsAppItem_SetId
629 * @tc.type: FUNC
630 */
631 HWTEST_F(UdsTest, OH_UdsAppItem_SetId_001, TestSize.Level1)
632 {
633 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetId_001 begin.");
634 auto appItem = OH_UdsAppItem_Create();
635 int result = OH_UdsAppItem_SetId(appItem, "com.xxx");
636 EXPECT_EQ(UDMF_E_OK, result);
637 EXPECT_EQ("com.xxx", std::string(OH_UdsAppItem_GetId(appItem)));
638
639 result = OH_UdsAppItem_SetId(nullptr, "com.xxx");
640 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
641
642 result = OH_UdsAppItem_SetId(appItem, nullptr);
643 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
644
645 appItem->obj = nullptr;
646 result = OH_UdsAppItem_SetId(appItem, "com.xxx");
647 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
648 OH_UdsAppItem_Destroy(appItem);
649 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetId_001 end.");
650 }
651
652 /**
653 * @tc.name: OH_UdsAppItem_SetName_001
654 * @tc.desc: Normal testcase of OH_UdsAppItem_SetName
655 * @tc.type: FUNC
656 */
657 HWTEST_F(UdsTest, OH_UdsAppItem_SetName_001, TestSize.Level1)
658 {
659 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetName_001 begin.");
660 auto appItem = OH_UdsAppItem_Create();
661 int result = OH_UdsAppItem_SetName(appItem, "OH");
662 EXPECT_EQ(UDMF_E_OK, result);
663 EXPECT_EQ("OH", std::string(OH_UdsAppItem_GetName(appItem)));
664
665 result = OH_UdsAppItem_SetName(nullptr, "OH");
666 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
667
668 result = OH_UdsAppItem_SetName(appItem, nullptr);
669 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
670
671 appItem->obj = nullptr;
672 result = OH_UdsAppItem_SetName(appItem, "OH");
673 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
674 OH_UdsAppItem_Destroy(appItem);
675 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetName_001 end.");
676 }
677
678 /**
679 * @tc.name: OH_UdsAppItem_SetIconId_001
680 * @tc.desc: Normal testcase of OH_UdsAppItem_SetIconId
681 * @tc.type: FUNC
682 */
683 HWTEST_F(UdsTest, OH_UdsAppItem_SetIconId_001, TestSize.Level1)
684 {
685 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetIconId_001 begin.");
686 auto appItem = OH_UdsAppItem_Create();
687 int result = OH_UdsAppItem_SetIconId(appItem, "icon");
688 EXPECT_EQ(UDMF_E_OK, result);
689 EXPECT_EQ("icon", std::string(OH_UdsAppItem_GetIconId(appItem)));
690
691 result = OH_UdsAppItem_SetIconId(nullptr, "icon");
692 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
693
694 result = OH_UdsAppItem_SetIconId(appItem, nullptr);
695 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
696
697 appItem->obj = nullptr;
698 result = OH_UdsAppItem_SetIconId(appItem, "icon");
699 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
700 OH_UdsAppItem_Destroy(appItem);
701 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetIconId_001 end.");
702 }
703
704 /**
705 * @tc.name: OH_UdsAppItem_SetLabelId_001
706 * @tc.desc: Normal testcase of OH_UdsAppItem_SetLabelId
707 * @tc.type: FUNC
708 */
709 HWTEST_F(UdsTest, OH_UdsAppItem_SetLabelId_001, TestSize.Level1)
710 {
711 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetLabelId_001 begin.");
712 auto appItem = OH_UdsAppItem_Create();
713 int result = OH_UdsAppItem_SetLabelId(appItem, "label");
714 EXPECT_EQ(UDMF_E_OK, result);
715 EXPECT_EQ("label", std::string(OH_UdsAppItem_GetLabelId(appItem)));
716
717 result = OH_UdsAppItem_SetLabelId(nullptr, "label");
718 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
719
720 result = OH_UdsAppItem_SetLabelId(appItem, nullptr);
721 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
722
723 appItem->obj = nullptr;
724 result = OH_UdsAppItem_SetLabelId(appItem, "label");
725 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
726 OH_UdsAppItem_Destroy(appItem);
727 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetLabelId_001 end.");
728 }
729
730 /**
731 * @tc.name: OH_UdsAppItem_SetBundleName_001
732 * @tc.desc: Normal testcase of OH_UdsAppItem_SetBundleName
733 * @tc.type: FUNC
734 */
735 HWTEST_F(UdsTest, OH_UdsAppItem_SetBundleName_001, TestSize.Level1)
736 {
737 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetBundleName_001 begin.");
738 auto appItem = OH_UdsAppItem_Create();
739 int result = OH_UdsAppItem_SetBundleName(appItem, "bundle");
740 EXPECT_EQ(UDMF_E_OK, result);
741 EXPECT_EQ("bundle", std::string(OH_UdsAppItem_GetBundleName(appItem)));
742
743 result = OH_UdsAppItem_SetBundleName(nullptr, "bundle");
744 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
745
746 result = OH_UdsAppItem_SetBundleName(appItem, nullptr);
747 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
748
749 appItem->obj = nullptr;
750 result = OH_UdsAppItem_SetBundleName(appItem, "bundle");
751 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
752 OH_UdsAppItem_Destroy(appItem);
753 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetBundleName_001 end.");
754 }
755
756 /**
757 * @tc.name: OH_UdsAppItem_SetAbilityName_001
758 * @tc.desc: Normal testcase of OH_UdsAppItem_SetAbilityName
759 * @tc.type: FUNC
760 */
761 HWTEST_F(UdsTest, OH_UdsAppItem_SetAbilityName_001, TestSize.Level1)
762 {
763 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetAbilityName_001 begin.");
764 auto appItem = OH_UdsAppItem_Create();
765 int result = OH_UdsAppItem_SetAbilityName(appItem, "ability");
766 EXPECT_EQ(UDMF_E_OK, result);
767 EXPECT_EQ("ability", std::string(OH_UdsAppItem_GetAbilityName(appItem)));
768
769 result = OH_UdsAppItem_SetAbilityName(nullptr, "ability");
770 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
771
772 result = OH_UdsAppItem_SetAbilityName(appItem, nullptr);
773 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
774
775 appItem->obj = nullptr;
776 result = OH_UdsAppItem_SetAbilityName(appItem, "ability");
777 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
778 OH_UdsAppItem_Destroy(appItem);
779 LOG_INFO(UDMF_TEST, "OH_UdsAppItem_SetAbilityName_001 end.");
780 }
781
782 /**
783 * @tc.name: OH_UdsFileUri_Create_001
784 * @tc.desc: Normal testcase of OH_UdsFileUri_Create
785 * @tc.type: FUNC
786 */
787 HWTEST_F(UdsTest, OH_UdsFileUri_Create_001, TestSize.Level1)
788 {
789 auto fileUri = OH_UdsFileUri_Create();
790 EXPECT_EQ(UDMF_META_GENERAL_FILE_URI, *(std::get_if<std::string>(&(fileUri->obj)->value_[UNIFORM_DATA_TYPE])));
791 OH_UdsFileUri_Destroy(fileUri);
792 }
793
794 /**
795 * @tc.name: OH_UdsFileUri_GetType_001
796 * @tc.desc: Normal testcase of OH_UdsFileUri_GetType
797 * @tc.type: FUNC
798 */
799 HWTEST_F(UdsTest, OH_UdsFileUri_GetType_001, TestSize.Level1)
800 {
801 auto fileUri = OH_UdsFileUri_Create();
802 EXPECT_EQ(UDMF_META_GENERAL_FILE_URI, std::string(OH_UdsFileUri_GetType(fileUri)));
803 OH_UdsFileUri_Destroy(fileUri);
804
805 OH_UdsFileUri* fileUriNullptr = nullptr;
806 EXPECT_EQ(nullptr, OH_UdsFileUri_GetType(fileUriNullptr));
807
808 fileUriNullptr = new OH_UdsFileUri;
809 EXPECT_EQ(nullptr, OH_UdsFileUri_GetType(fileUriNullptr));
810 OH_UdsFileUri_Destroy(fileUriNullptr);
811 }
812
813 /**
814 * @tc.name: OH_UdsFileUri_GetFileUri_001
815 * @tc.desc: Normal testcase of OH_UdsFileUri_GetFileUri
816 * @tc.type: FUNC
817 */
818 HWTEST_F(UdsTest, OH_UdsFileUri_GetFileUri_001, TestSize.Level1)
819 {
820 auto fileUri = OH_UdsFileUri_Create();
821 fileUri->obj->value_[FILE_URI_PARAM] = "fileUri";
822 EXPECT_EQ("fileUri", std::string(OH_UdsFileUri_GetFileUri(fileUri)));
823 OH_UdsFileUri_Destroy(fileUri);
824
825 OH_UdsFileUri* fileUriNullptr = nullptr;
826 EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileUri(fileUriNullptr));
827
828 fileUriNullptr = new OH_UdsFileUri;
829 EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileUri(fileUriNullptr));
830 OH_UdsFileUri_Destroy(fileUriNullptr);
831 }
832
833 /**
834 * @tc.name: OH_UdsFileUri_GetFileType_001
835 * @tc.desc: Normal testcase of OH_UdsFileUri_GetFileType
836 * @tc.type: FUNC
837 */
838 HWTEST_F(UdsTest, OH_UdsFileUri_GetFileType_001, TestSize.Level1)
839 {
840 auto fileUri = OH_UdsFileUri_Create();
841 fileUri->obj->value_[FILE_TYPE] = "fileType";
842 EXPECT_EQ("fileType", std::string(OH_UdsFileUri_GetFileType(fileUri)));
843 OH_UdsFileUri_Destroy(fileUri);
844
845 OH_UdsFileUri* fileUriNullptr = nullptr;
846 EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileType(fileUriNullptr));
847
848 fileUriNullptr = new OH_UdsFileUri;
849 EXPECT_EQ(nullptr, OH_UdsFileUri_GetFileType(fileUriNullptr));
850 OH_UdsFileUri_Destroy(fileUriNullptr);
851 }
852
853 /**
854 * @tc.name: OH_UdsFileUri_SetFileUri_001
855 * @tc.desc: Normal testcase of OH_UdsFileUri_SetFileUri
856 * @tc.type: FUNC
857 */
858 HWTEST_F(UdsTest, OH_UdsFileUri_SetFileUri_001, TestSize.Level1)
859 {
860 auto fileUri = OH_UdsFileUri_Create();
861 int result = OH_UdsFileUri_SetFileUri(fileUri, "file uri");
862 EXPECT_EQ(UDMF_E_OK, result);
863 EXPECT_EQ("file uri", std::string(OH_UdsFileUri_GetFileUri(fileUri)));
864
865 result = OH_UdsFileUri_SetFileUri(nullptr, "file uri");
866 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
867
868 result = OH_UdsFileUri_SetFileUri(fileUri, nullptr);
869 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
870
871 fileUri->obj = nullptr;
872 result = OH_UdsFileUri_SetFileUri(fileUri, "file uri");
873 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
874 OH_UdsFileUri_Destroy(fileUri);
875 }
876
877 /**
878 * @tc.name: OH_UdsFileUri_SetFileUri_001
879 * @tc.desc: Normal testcase of OH_UdsFileUri_SetFileUri
880 * @tc.type: FUNC
881 */
882 HWTEST_F(UdsTest, OH_UdsFileUri_SetFileType_001, TestSize.Level1)
883 {
884 auto fileUri = OH_UdsFileUri_Create();
885 int result = OH_UdsFileUri_SetFileType(fileUri, "file type");
886 EXPECT_EQ(UDMF_E_OK, result);
887 EXPECT_EQ("file type", std::string(OH_UdsFileUri_GetFileType(fileUri)));
888
889 result = OH_UdsFileUri_SetFileType(nullptr, "file type");
890 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
891
892 result = OH_UdsFileUri_SetFileType(fileUri, nullptr);
893 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
894
895 fileUri->obj = nullptr;
896 result = OH_UdsFileUri_SetFileType(fileUri, "file type");
897 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
898 OH_UdsFileUri_Destroy(fileUri);
899 }
900
901 /**
902 * @tc.name: OH_UdsPixelMap_Create_001
903 * @tc.desc: Normal testcase of OH_UdsPixelMap_Create
904 * @tc.type: FUNC
905 */
906 HWTEST_F(UdsTest, OH_UdsPixelMap_Create_001, TestSize.Level1)
907 {
908 auto pixelMap = OH_UdsPixelMap_Create();
909 EXPECT_EQ(UDMF_META_OPENHARMONY_PIXEL_MAP,
910 *(std::get_if<std::string>(&(pixelMap->obj)->value_[UNIFORM_DATA_TYPE])));
911 OH_UdsPixelMap_Destroy(pixelMap);
912 }
913
914 /**
915 * @tc.name: OH_UdsPixelMap_GetType_001
916 * @tc.desc: Normal testcase of OH_UdsPixelMap_GetType
917 * @tc.type: FUNC
918 */
919 HWTEST_F(UdsTest, OH_UdsPixelMap_GetType_001, TestSize.Level1)
920 {
921 auto pixelMap = OH_UdsPixelMap_Create();
922 EXPECT_EQ(UDMF_META_OPENHARMONY_PIXEL_MAP, std::string(OH_UdsPixelMap_GetType(pixelMap)));
923 OH_UdsPixelMap_Destroy(pixelMap);
924
925 OH_UdsPixelMap* pixelMapNullptr = nullptr;
926 EXPECT_EQ(nullptr, OH_UdsPixelMap_GetType(pixelMapNullptr));
927
928 pixelMapNullptr = new OH_UdsPixelMap;
929 EXPECT_EQ(nullptr, OH_UdsPixelMap_GetType(pixelMapNullptr));
930 OH_UdsPixelMap_Destroy(pixelMapNullptr);
931 }
932
933 /**
934 * @tc.name: OH_UdsPixelMap_GetPixelMap_001
935 * @tc.desc: Normal testcase of OH_UdsPixelMap_GetPixelMap
936 * @tc.type: FUNC
937 */
938 HWTEST_F(UdsTest, OH_UdsPixelMap_GetPixelMap_001, TestSize.Level1)
939 {
940 auto pixelMap = OH_UdsPixelMap_Create();
941 std::shared_ptr<OHOS::Media::PixelMap> pixelMapPtr = std::make_shared<OHOS::Media::PixelMap>();
942 pixelMapPtr->SetTransformered(true);
943 pixelMap->obj->value_[PIXEL_MAP] = pixelMapPtr;
944 OH_PixelmapNative* pixelMapResult = new OH_PixelmapNative(nullptr);
945 OH_UdsPixelMap_GetPixelMap(pixelMap, pixelMapResult);
946 auto innerPixelMap = pixelMapResult->GetInnerPixelmap();
947 EXPECT_NE(nullptr, innerPixelMap);
948 EXPECT_TRUE(innerPixelMap->IsTransformered());
949 OH_UdsPixelMap_Destroy(pixelMap);
950 delete pixelMapResult;
951
952 OH_PixelmapNative* ohPixelMapNull = new OH_PixelmapNative(nullptr);
953 OH_UdsPixelMap* pixelMapNullptr = nullptr;
954 OH_UdsPixelMap_GetPixelMap(pixelMapNullptr, ohPixelMapNull);
955 EXPECT_EQ(nullptr, ohPixelMapNull->GetInnerPixelmap());
956 delete pixelMapNullptr;
957
958 pixelMapNullptr = new OH_UdsPixelMap;
959 OH_UdsPixelMap_GetPixelMap(pixelMapNullptr, ohPixelMapNull);
960 EXPECT_EQ(nullptr, ohPixelMapNull->GetInnerPixelmap());
961 delete ohPixelMapNull;
962 OH_UdsPixelMap_Destroy(pixelMapNullptr);
963 }
964
965 /**
966 * @tc.name: OH_UdsPixelMap_SetPixelMap_001
967 * @tc.desc: Normal testcase of OH_UdsPixelMap_SetPixelMap
968 * @tc.type: FUNC
969 */
970 HWTEST_F(UdsTest, OH_UdsPixelMap_SetPixelMap_001, TestSize.Level1)
971 {
972 auto pixelMap = OH_UdsPixelMap_Create();
973 std::shared_ptr<OHOS::Media::PixelMap> pixelMapPtr = std::make_shared<OHOS::Media::PixelMap>();
974 pixelMapPtr->SetTransformered(true);
975 OH_PixelmapNative* ohPixelmapNative = new OH_PixelmapNative(pixelMapPtr);
976 int result = OH_UdsPixelMap_SetPixelMap(pixelMap, ohPixelmapNative);
977 EXPECT_EQ(UDMF_E_OK, result);
978 OH_PixelmapNative* pixelMapResult = new OH_PixelmapNative(nullptr);
979 OH_UdsPixelMap_GetPixelMap(pixelMap, pixelMapResult);
980 auto innerPixelMap = pixelMapResult->GetInnerPixelmap();
981 EXPECT_NE(nullptr, innerPixelMap);
982 EXPECT_TRUE(innerPixelMap->IsTransformered());
983
984 result = OH_UdsPixelMap_SetPixelMap(nullptr, ohPixelmapNative);
985 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
986
987 result = OH_UdsPixelMap_SetPixelMap(pixelMap, nullptr);
988 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
989
990 pixelMap->obj = nullptr;
991 result = OH_UdsPixelMap_SetPixelMap(pixelMap, ohPixelmapNative);
992 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
993 delete pixelMapResult;
994 delete ohPixelmapNative;
995 OH_UdsPixelMap_Destroy(pixelMap);
996 }
997 /**
998 * @tc.name: OH_UdsArrayBuffer_Create_001
999 * @tc.desc: Normal testcase of OH_UdsArrayBuffer_Create
1000 * @tc.type: FUNC
1001 */
1002 HWTEST_F(UdsTest, OH_UdsArrayBuffer_Create_001, TestSize.Level1)
1003 {
1004 LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_Create_001 begin.");
1005 auto buffer = OH_UdsArrayBuffer_Create();
1006 EXPECT_NE(buffer, nullptr);
1007 int ret = OH_UdsArrayBuffer_Destroy(buffer);
1008 EXPECT_EQ(UDMF_E_OK, ret);
1009 LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_Create_001 end.");
1010 }
1011
1012 /**
1013 * @tc.name: OH_UdsArrayBuffer_GetData_001
1014 * @tc.desc: Normal testcase of OH_UdsArrayBuffer_GetData
1015 * @tc.type: FUNC
1016 */
1017 HWTEST_F(UdsTest, OH_UdsArrayBuffer_GetData_001, TestSize.Level1)
1018 {
1019 LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_GetData_001 begin.");
1020 auto buffer = OH_UdsArrayBuffer_Create();
1021
1022 unsigned char data[] = "doing something";
1023 int len = sizeof(data);
1024
1025 std::vector<uint8_t> bufferData(data, data + len);
1026 buffer->obj->value_[ARRAY_BUFFER] = bufferData;
1027 buffer->obj->value_[ARRAY_BUFFER_LENGTH] = len;
1028
1029 unsigned char *getData;
1030 unsigned int getLen;
1031 int ret = OH_UdsArrayBuffer_GetData(buffer, &getData, &getLen);
1032 ASSERT_EQ(UDMF_E_OK, ret);
1033 ASSERT_EQ(len, getLen);
1034 ASSERT_TRUE(CheckUnsignedChar(data, getData, getLen));
1035 OH_UdsArrayBuffer_Destroy(buffer);
1036
1037 OH_UdsArrayBuffer* bufferNullptr = nullptr;
1038 EXPECT_EQ(UDMF_E_INVALID_PARAM, OH_UdsArrayBuffer_GetData(bufferNullptr, &getData, &getLen));
1039 delete bufferNullptr;
1040
1041 bufferNullptr = new OH_UdsArrayBuffer;
1042 EXPECT_EQ(UDMF_E_INVALID_PARAM, OH_UdsArrayBuffer_GetData(bufferNullptr, &getData, &getLen));
1043 OH_UdsArrayBuffer_Destroy(bufferNullptr);
1044 LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_GetContent_001 end.");
1045 }
1046
1047 /**
1048 * @tc.name: OH_UdsArrayBuffer_SetData_001
1049 * @tc.desc: Normal testcase of OH_UdsArrayBuffer_SetData
1050 * @tc.type: FUNC
1051 */
1052 HWTEST_F(UdsTest, OH_UdsArrayBuffer_SetData_001, TestSize.Level1)
1053 {
1054 LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_SetData_001 begin.");
1055 int result = OH_UdsArrayBuffer_SetData(nullptr, nullptr, 0);
1056 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
1057
1058 auto buffer = OH_UdsArrayBuffer_Create();
1059 result = OH_UdsArrayBuffer_SetData(buffer, nullptr, 0);
1060 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
1061
1062 unsigned char data[] = "doing something";
1063 unsigned int len = sizeof(data);
1064 result = OH_UdsArrayBuffer_SetData(buffer, data, 0);
1065 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
1066
1067 result = OH_UdsArrayBuffer_SetData(buffer, data, 100 * 1024 * 1024 + 1);
1068 EXPECT_EQ(UDMF_E_INVALID_PARAM, result);
1069
1070 result = OH_UdsArrayBuffer_SetData(buffer, data, len);
1071 EXPECT_EQ(UDMF_E_OK, result);
1072
1073 unsigned char *getData;
1074 unsigned int getLen;
1075 int ret = OH_UdsArrayBuffer_GetData(buffer, &getData, &getLen);
1076 ASSERT_EQ(UDMF_E_OK, ret);
1077 ASSERT_EQ(len, getLen);
1078 ASSERT_TRUE(CheckUnsignedChar(data, getData, getLen));
1079
1080 OH_UdsArrayBuffer_Destroy(buffer);
1081 LOG_INFO(UDMF_TEST, "OH_UdsArrayBuffer_SetData_001 end.");
1082 }
1083
1084 /**
1085 * @tc.name: OH_UdsContentForm_SetAndGetParm_001
1086 * @tc.desc: Normal testcase of OH_UdsContentForm's interface
1087 * @tc.type: FUNC
1088 */
1089 HWTEST_F(UdsTest, OH_UdsContentForm_SetAndGetParm_001, TestSize.Level1)
1090 {
1091 LOG_INFO(UDMF_TEST, "OH_UdsContentForm_SetAndGetParm_001 begin.");
1092 auto contentForm = OH_UdsContentForm_Create();
1093 EXPECT_EQ(UDMF_METE_GENERAL_CONTENT_FORM, std::string(OH_UdsContentForm_GetType(contentForm)));
1094 unsigned char thumbData[] = {0, 1, 2, 3, 4};
1095 unsigned char appIcon[] = {5, 6, 7, 8, 9};
1096 auto result = OH_UdsContentForm_SetThumbData(contentForm, thumbData, 5);
1097 result = (result == UDMF_E_OK) && OH_UdsContentForm_SetDescription(contentForm, "description");
1098 result = (result == UDMF_E_OK) && OH_UdsContentForm_SetTitle(contentForm, "title");
1099 result = (result == UDMF_E_OK) && OH_UdsContentForm_SetAppIcon(contentForm, appIcon, 5);
1100 result = (result == UDMF_E_OK) && OH_UdsContentForm_SetAppName(contentForm, "appName");
1101 result = (result == UDMF_E_OK) && OH_UdsContentForm_SetLinkUri(contentForm, "link url");
1102 EXPECT_EQ(UDMF_E_OK, result);
1103 EXPECT_EQ("description", std::string(OH_UdsContentForm_GetDescription(contentForm)));
1104 EXPECT_EQ("title", std::string(OH_UdsContentForm_GetTitle(contentForm)));
1105 EXPECT_EQ("appName", std::string(OH_UdsContentForm_GetAppName(contentForm)));
1106 EXPECT_EQ("link url", std::string(OH_UdsContentForm_GetLinkUri(contentForm)));
1107
1108 unsigned char *readThumbData;
1109 unsigned int thumbDataLen = 0;
1110 result = OH_UdsContentForm_GetThumbData(contentForm, &readThumbData, &thumbDataLen);
1111 ASSERT_EQ(5, thumbDataLen);
1112 ASSERT_TRUE(CheckUnsignedChar(thumbData, readThumbData, thumbDataLen));
1113
1114 unsigned char *readAppIcon;
1115 unsigned int appIconLen = 0;
1116 result = OH_UdsContentForm_GetAppIcon(contentForm, &readAppIcon, &appIconLen);
1117 ASSERT_EQ(5, thumbDataLen);
1118 ASSERT_TRUE(CheckUnsignedChar(thumbData, readThumbData, thumbDataLen));
1119
1120 OH_UdsContentForm_Destroy(contentForm);
1121 LOG_INFO(UDMF_TEST, "OH_UdsContentForm_SetAndGetParm_001 end.");
1122 }
1123
1124 }
1125