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 "UtdTest" 17 18#include <gtest/gtest.h> 19#include <unistd.h> 20#include <map> 21 22#include "token_setproc.h" 23#include "accesstoken_kit.h" 24#include "nativetoken_kit.h" 25 26#include "logger.h" 27#include "utd.h" 28#include "udmf_capi_common.h" 29#include "udmf_meta.h" 30 31using namespace testing::ext; 32using namespace OHOS::Security::AccessToken; 33using namespace OHOS::UDMF; 34using namespace OHOS; 35 36constexpr const char *REFERENCE_URL = "https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/"\ 37 "apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype"; 38 39namespace OHOS::Test { 40 41OH_Utd* utd = nullptr; 42 43class UtdTest : public testing::Test { 44public: 45 static void SetUpTestCase(void); 46 static void TearDownTestCase(void); 47 void SetUp(); 48 void TearDown(); 49}; 50 51void UtdTest::SetUpTestCase(void) {} 52 53void UtdTest::TearDownTestCase(void) {} 54 55void UtdTest::SetUp(void) 56{ 57 LOG_INFO(UDMF_TEST, "test case will be start"); 58 utd = OH_Utd_Create(UDMF_META_PLAIN_TEXT); 59} 60 61void UtdTest::TearDown(void) 62{ 63 OH_Utd_Destroy(utd); 64 utd = nullptr; 65 LOG_INFO(UDMF_TEST, "test case is complete"); 66} 67 68/** 69 * @tc.name: OH_Utd_Create_001 70 * @tc.desc: Normal testcase of OH_Utd_Create 71 * @tc.type: FUNC 72 */ 73HWTEST_F(UtdTest, OH_Utd_Create_001, TestSize.Level1) 74{ 75 LOG_INFO(UDMF_TEST, "OH_Utd_Create_001 begin."); 76 EXPECT_EQ(utd->typeId, UDMF_META_PLAIN_TEXT); 77 EXPECT_EQ(utd->belongingToTypesCount, 1); 78 std::string belongingToType((utd->belongingToTypes)[0]); 79 EXPECT_EQ(belongingToType, UDMF_META_TEXT); 80 EXPECT_EQ(utd->description, "Text of unspecified encoding, with no markup."); 81 82 char* typeId = nullptr; 83 OH_Utd* utdNullptr = OH_Utd_Create(typeId); 84 EXPECT_EQ(nullptr, utdNullptr); 85 LOG_INFO(UDMF_TEST, "OH_Utd_Create_001 end."); 86} 87 88/** 89 * @tc.name: OH_Utd_GetTypeId_001 90 * @tc.desc: Normal testcase of OH_Utd_GetTypeId 91 * @tc.type: FUNC 92 */ 93HWTEST_F(UtdTest, OH_Utd_GetTypeId_001, TestSize.Level1) 94{ 95 LOG_INFO(UDMF_TEST, "OH_Utd_GetTypeId_001 begin."); 96 std::string actualTypeId(OH_Utd_GetTypeId(utd)); 97 EXPECT_EQ(UDMF_META_PLAIN_TEXT, actualTypeId); 98 99 OH_Utd* utdNullptr = nullptr; 100 const char* typeIdNullptr = OH_Utd_GetTypeId(utdNullptr); 101 EXPECT_EQ(nullptr, typeIdNullptr); 102 LOG_INFO(UDMF_TEST, "OH_Utd_GetTypeId_001 end."); 103} 104 105/** 106 * @tc.name: OH_Utd_GetDescription_001 107 * @tc.desc: Normal testcase of OH_Utd_GetDescription 108 * @tc.type: FUNC 109 */ 110HWTEST_F(UtdTest, OH_Utd_GetDescription_001, TestSize.Level1) 111{ 112 LOG_INFO(UDMF_TEST, "OH_Utd_GetDescription_001 begin."); 113 std::string description(OH_Utd_GetDescription(utd)); 114 EXPECT_EQ("Text of unspecified encoding, with no markup.", description); 115 116 OH_Utd* utdNullptr = nullptr; 117 const char* descriptionNullptr = OH_Utd_GetDescription(utdNullptr); 118 EXPECT_EQ(nullptr, descriptionNullptr); 119 LOG_INFO(UDMF_TEST, "OH_Utd_GetDescription_001 end."); 120} 121 122/** 123 * @tc.name: OH_Utd_GetReferenceUrl_001 124 * @tc.desc: Normal testcase of OH_Utd_GetReferenceUrl 125 * @tc.type: FUNC 126 */ 127HWTEST_F(UtdTest, OH_Utd_GetReferenceUrl_001, TestSize.Level1) 128{ 129 LOG_INFO(UDMF_TEST, "OH_Utd_GetReferenceUrl_001 begin."); 130 std::string url(OH_Utd_GetReferenceUrl(utd)); 131 EXPECT_EQ(REFERENCE_URL, url); 132 133 OH_Utd* utdNullptr = nullptr; 134 const char* urlNullptr = OH_Utd_GetReferenceUrl(utdNullptr); 135 EXPECT_EQ(nullptr, urlNullptr); 136 LOG_INFO(UDMF_TEST, "OH_Utd_GetReferenceUrl_001 end."); 137} 138 139/** 140 * @tc.name: OH_Utd_GetIconFile_001 141 * @tc.desc: Normal testcase of OH_Utd_GetIconFile 142 * @tc.type: FUNC 143 */ 144HWTEST_F(UtdTest, OH_Utd_GetIconFile_001, TestSize.Level1) 145{ 146 LOG_INFO(UDMF_TEST, "OH_Utd_GetIconFile_001 begin."); 147 std::string iconFile(OH_Utd_GetIconFile(utd)); 148 EXPECT_EQ("sys.media.ohos_ic_normal_white_grid_txt", iconFile); 149 150 OH_Utd* utdNullptr = nullptr; 151 const char* iconFileNullptr = OH_Utd_GetIconFile(utdNullptr); 152 EXPECT_EQ(nullptr, iconFileNullptr); 153 LOG_INFO(UDMF_TEST, "OH_Utd_GetIconFile_001 end."); 154} 155 156/** 157 * @tc.name: OH_Utd_GetBelongingToTypes_001 158 * @tc.desc: Normal testcase of OH_Utd_GetBelongingToTypes 159 * @tc.type: FUNC 160 */ 161HWTEST_F(UtdTest, OH_Utd_GetBelongingToTypes_001, TestSize.Level1) 162{ 163 LOG_INFO(UDMF_TEST, "OH_Utd_GetBelongingToTypes_001 begin."); 164 unsigned int count = 0; 165 auto belongingToTypes = OH_Utd_GetBelongingToTypes(utd, &count); 166 std::string belongingToType(belongingToTypes[0]); 167 EXPECT_EQ(UDMF_META_TEXT, belongingToType); 168 EXPECT_EQ(1, count); 169 170 OH_Utd* utdNullptr = nullptr; 171 auto belongingToTypeNullptr = OH_Utd_GetBelongingToTypes(utdNullptr, &count); 172 EXPECT_EQ(nullptr, belongingToTypeNullptr); 173 174 unsigned int* countNullptr = nullptr; 175 auto belongingToTypeNullptr2 = OH_Utd_GetBelongingToTypes(utd, countNullptr); 176 EXPECT_EQ(nullptr, belongingToTypeNullptr2); 177 LOG_INFO(UDMF_TEST, "OH_Utd_GetBelongingToTypes_001 end."); 178} 179 180/** 181 * @tc.name: OH_Utd_GetFilenameExtensions_001 182 * @tc.desc: Normal testcase of OH_Utd_GetFilenameExtensions 183 * @tc.type: FUNC 184 */ 185HWTEST_F(UtdTest, OH_Utd_GetFilenameExtensions_001, TestSize.Level1) 186{ 187 LOG_INFO(UDMF_TEST, "OH_Utd_GetFilenameExtensions_001 begin."); 188 unsigned int count = 0; 189 auto filenameExtensions = OH_Utd_GetFilenameExtensions(utd, &count); 190 std::string filenameExtension(filenameExtensions[0]); 191 EXPECT_EQ(".txt", filenameExtension); 192 EXPECT_EQ(2, count); 193 194 OH_Utd* utdNullptr = nullptr; 195 auto filenameExtensionsNullptr = OH_Utd_GetFilenameExtensions(utdNullptr, &count); 196 EXPECT_EQ(nullptr, filenameExtensionsNullptr); 197 198 unsigned int* countNullptr = nullptr; 199 auto filenameExtensionsNullptr2 = OH_Utd_GetFilenameExtensions(utd, countNullptr); 200 EXPECT_EQ(nullptr, filenameExtensionsNullptr2); 201 LOG_INFO(UDMF_TEST, "OH_Utd_GetFilenameExtensions_001 end."); 202} 203 204/** 205 * @tc.name: OH_Utd_GetMimeTypes_001 206 * @tc.desc: Normal testcase of OH_Utd_GetMimeTypes 207 * @tc.type: FUNC 208 */ 209HWTEST_F(UtdTest, OH_Utd_GetMimeTypes_001, TestSize.Level1) 210{ 211 LOG_INFO(UDMF_TEST, "OH_Utd_GetMimeTypes_001 begin."); 212 unsigned int count = 0; 213 auto mimeTypes = OH_Utd_GetMimeTypes(utd, &count); 214 std::string mimeType(mimeTypes[0]); 215 EXPECT_EQ("text/plain", mimeType); 216 EXPECT_EQ(1, count); 217 218 OH_Utd* utdNullptr = nullptr; 219 auto mimeTypeNullptr = OH_Utd_GetMimeTypes(utdNullptr, &count); 220 EXPECT_EQ(nullptr, mimeTypeNullptr); 221 222 unsigned int* countNullptr = nullptr; 223 auto mimeTypeNullptr2 = OH_Utd_GetMimeTypes(utd, countNullptr); 224 EXPECT_EQ(nullptr, mimeTypeNullptr2); 225 LOG_INFO(UDMF_TEST, "OH_Utd_GetMimeTypes_001 end."); 226} 227 228/** 229 * @tc.name: OH_Utd_GetTypesByFilenameExtension_001 230 * @tc.desc: Normal testcase of OH_Utd_GetTypesByFilenameExtension 231 * @tc.type: FUNC 232 */ 233HWTEST_F(UtdTest, OH_Utd_GetTypesByFilenameExtension_001, TestSize.Level1) 234{ 235 LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByFilenameExtension_001 begin."); 236 unsigned int count = 0; 237 auto typeIds = OH_Utd_GetTypesByFilenameExtension(".txt", &count); 238 std::string typeId(typeIds[0]); 239 EXPECT_EQ(UDMF_META_PLAIN_TEXT, typeId); 240 EXPECT_EQ(1, count); 241 OH_Utd_DestroyStringList(typeIds, count); 242 243 const char* extensionNullptr = nullptr; 244 auto typeIdsNullptr = OH_Utd_GetTypesByFilenameExtension(extensionNullptr, &count); 245 EXPECT_EQ(nullptr, typeIdsNullptr); 246 247 unsigned int* countNullptr = nullptr; 248 typeIds = OH_Utd_GetTypesByFilenameExtension(".txt", countNullptr); 249 EXPECT_EQ(nullptr, typeIds); 250 LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByFilenameExtension_001 end."); 251} 252 253/** 254 * @tc.name: OH_Utd_GetTypesByMimeType_001 255 * @tc.desc: Normal testcase of OH_Utd_GetTypesByMimeType 256 * @tc.type: FUNC 257 */ 258HWTEST_F(UtdTest, OH_Utd_GetTypesByMimeType_001, TestSize.Level1) 259{ 260 LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByMimeType_001 begin."); 261 unsigned int count = 0; 262 auto typeIds = OH_Utd_GetTypesByMimeType("text/plain", &count); 263 std::string typeId(typeIds[0]); 264 EXPECT_EQ(UDMF_META_PLAIN_TEXT, typeId); 265 EXPECT_EQ(1, count); 266 OH_Utd_DestroyStringList(typeIds, count); 267 268 const char* extensionNullptr = nullptr; 269 auto typeIdsNullptr = OH_Utd_GetTypesByMimeType(extensionNullptr, &count); 270 EXPECT_EQ(nullptr, typeIdsNullptr); 271 272 unsigned int* countNullptr = nullptr; 273 auto typeIdsNullptr2 = OH_Utd_GetTypesByMimeType("text/plain", countNullptr); 274 EXPECT_EQ(nullptr, typeIdsNullptr2); 275 LOG_INFO(UDMF_TEST, "OH_Utd_GetTypesByMimeType_001 end."); 276} 277 278/** 279 * @tc.name: OH_Utd_BelongsTo_001 280 * @tc.desc: test typeId1 belong to typeId2 281 * @tc.type: FUNC 282 */ 283HWTEST_F(UtdTest, OH_Utd_BelongsTo_001, TestSize.Level1) 284{ 285 LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_001 begin."); 286 EXPECT_TRUE(OH_Utd_BelongsTo(UDMF_META_PLAIN_TEXT, UDMF_META_TEXT)); 287 LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_001 end."); 288} 289 290/** 291 * @tc.name: OH_Utd_BelongsTo_002 292 * @tc.desc: test typeId1 don't belong to typeId2 293 * @tc.type: FUNC 294 */ 295HWTEST_F(UtdTest, OH_Utd_BelongsTo_002, TestSize.Level1) 296{ 297 LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_002 begin."); 298 EXPECT_FALSE(OH_Utd_BelongsTo(UDMF_META_PLAIN_TEXT, UDMF_META_HTML)); 299 LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_002 end."); 300} 301 302/** 303 * @tc.name: OH_Utd_BelongsTo_003 304 * @tc.desc: test param is nullptr 305 * @tc.type: FUNC 306 */ 307HWTEST_F(UtdTest, OH_Utd_BelongsTo_003, TestSize.Level1) 308{ 309 LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_003 begin."); 310 EXPECT_FALSE(OH_Utd_BelongsTo(UDMF_META_PLAIN_TEXT, nullptr)); 311 EXPECT_FALSE(OH_Utd_BelongsTo(nullptr, UDMF_META_PLAIN_TEXT)); 312 LOG_INFO(UDMF_TEST, "OH_Utd_BelongsTo_003 end."); 313} 314 315/** 316 * @tc.name: OH_Utd_IsLower_001 317 * @tc.desc: test typeId1 is lower level of typeId2 318 * @tc.type: FUNC 319 */ 320HWTEST_F(UtdTest, OH_Utd_IsLower_001, TestSize.Level1) 321{ 322 LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_001 begin."); 323 EXPECT_TRUE(OH_Utd_IsLower(UDMF_META_PLAIN_TEXT, UDMF_META_TEXT)); 324 LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_001 end."); 325} 326 327/** 328 * @tc.name: OH_Utd_IsLower_002 329 * @tc.desc: test typeId1 isn't lower level of typeId2 330 * @tc.type: FUNC 331 */ 332HWTEST_F(UtdTest, OH_Utd_IsLower_002, TestSize.Level1) 333{ 334 LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_002 begin."); 335 EXPECT_FALSE(OH_Utd_IsLower(UDMF_META_PLAIN_TEXT, UDMF_META_HTML)); 336 LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_002 end."); 337} 338 339/** 340 * @tc.name: OH_Utd_IsLower_003 341 * @tc.desc: test param is nullptr 342 * @tc.type: FUNC 343 */ 344HWTEST_F(UtdTest, OH_Utd_IsLower_003, TestSize.Level1) 345{ 346 LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_003 begin."); 347 EXPECT_FALSE(OH_Utd_IsLower(UDMF_META_PLAIN_TEXT, nullptr)); 348 EXPECT_FALSE(OH_Utd_IsLower(nullptr, UDMF_META_PLAIN_TEXT)); 349 LOG_INFO(UDMF_TEST, "OH_Utd_IsLower_003 end."); 350} 351 352/** 353 * @tc.name: OH_Utd_IsHigher_001 354 * @tc.desc: test typeId1 is higher level of typeId2 355 * @tc.type: FUNC 356 */ 357HWTEST_F(UtdTest, OH_Utd_IsHigher_001, TestSize.Level1) 358{ 359 LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_001 begin."); 360 EXPECT_TRUE(OH_Utd_IsHigher(UDMF_META_TEXT, UDMF_META_PLAIN_TEXT)); 361 LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_001 end."); 362} 363 364/** 365 * @tc.name: OH_Utd_IsHigher_002 366 * @tc.desc: test typeId1 isn't higher level of typeId2 367 * @tc.type: FUNC 368 */ 369HWTEST_F(UtdTest, OH_Utd_IsHigher_002, TestSize.Level1) 370{ 371 LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_002 begin."); 372 EXPECT_FALSE(OH_Utd_IsHigher(UDMF_META_PLAIN_TEXT, UDMF_META_HTML)); 373 LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_002 end."); 374} 375 376/** 377 * @tc.name: OH_Utd_IsHigher_003 378 * @tc.desc: test param is nullptr 379 * @tc.type: FUNC 380 */ 381HWTEST_F(UtdTest, OH_Utd_IsHigher_003, TestSize.Level1) 382{ 383 LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_003 begin."); 384 EXPECT_FALSE(OH_Utd_IsHigher(UDMF_META_PLAIN_TEXT, nullptr)); 385 EXPECT_FALSE(OH_Utd_IsHigher(nullptr, UDMF_META_PLAIN_TEXT)); 386 LOG_INFO(UDMF_TEST, "OH_Utd_IsHigher_003 end."); 387} 388 389/** 390 * @tc.name: OH_Utd_Equals_001 391 * @tc.desc: test case1 is equals case2 392 * @tc.type: FUNC 393 */ 394HWTEST_F(UtdTest, OH_Utd_Equals_001, TestSize.Level1) 395{ 396 LOG_INFO(UDMF_TEST, "OH_Utd_Equals_001 begin."); 397 auto utd2 = OH_Utd_Create(UDMF_META_PLAIN_TEXT); 398 EXPECT_TRUE(OH_Utd_Equals(utd, utd2)); 399 OH_Utd_Destroy(utd2); 400 utd2 = nullptr; 401 LOG_INFO(UDMF_TEST, "OH_Utd_Equals_001 end."); 402} 403 404/** 405 * @tc.name: OH_Utd_Equals_002 406 * @tc.desc: test case1 is not equals case2 407 * @tc.type: FUNC 408 */ 409HWTEST_F(UtdTest, OH_Utd_Equals_002, TestSize.Level1) 410{ 411 LOG_INFO(UDMF_TEST, "OH_Utd_Equals_002 begin."); 412 auto utd2 = OH_Utd_Create(UDMF_META_TEXT); 413 EXPECT_FALSE(OH_Utd_Equals(utd, utd2)); 414 OH_Utd_Destroy(utd2); 415 utd2 = nullptr; 416 LOG_INFO(UDMF_TEST, "OH_Utd_Equals_002 end."); 417} 418 419/** 420 * @tc.name: OH_Utd_Equals_003 421 * @tc.desc: test param is nullptr 422 * @tc.type: FUNC 423 */ 424HWTEST_F(UtdTest, OH_Utd_Equals_003, TestSize.Level1) 425{ 426 LOG_INFO(UDMF_TEST, "OH_Utd_Equals_003 begin."); 427 EXPECT_FALSE(OH_Utd_Equals(utd, nullptr)); 428 EXPECT_FALSE(OH_Utd_Equals(nullptr, utd)); 429 LOG_INFO(UDMF_TEST, "OH_Utd_Equals_003 end."); 430} 431 432std::map<std::string, std::string> typeIdMap = { 433 {UDMF_META_ENTITY, "general.entity"}, 434 {UDMF_META_OBJECT, "general.object"}, 435 {UDMF_META_COMPOSITE_OBJECT, "general.composite-object"}, 436 {UDMF_META_TEXT, "general.text"}, 437 {UDMF_META_PLAIN_TEXT, "general.plain-text"}, 438 {UDMF_META_HTML, "general.html"}, 439 {UDMF_META_HYPERLINK, "general.hyperlink"}, 440 {UDMF_META_XML, "general.xml"}, 441 {UDMF_META_SOURCE_CODE, "general.source-code"}, 442 {UDMF_META_SCRIPT, "general.script"}, 443 {UDMF_META_SHELL_SCRIPT, "general.shell-script"}, 444 {UDMF_META_CSH_SCRIPT, "general.csh-script"}, 445 {UDMF_META_PERL_SCRIPT, "general.perl-script"}, 446 {UDMF_META_PHP_SCRIPT, "general.php-script"}, 447 {UDMF_META_PYTHON_SCRIPT, "general.python-script"}, 448 {UDMF_META_RUBY_SCRIPT, "general.ruby-script"}, 449 {UDMF_META_TYPE_SCRIPT, "general.type-script"}, 450 {UDMF_META_JAVA_SCRIPT, "general.java-script"}, 451 {UDMF_META_C_HEADER, "general.c-header"}, 452 {UDMF_META_C_SOURCE, "general.c-source"}, 453 {UDMF_META_C_PLUS_PLUS_HEADER, "general.c-plus-plus-header"}, 454 {UDMF_META_C_PLUS_PLUS_SOURCE, "general.c-plus-plus-source"}, 455 {UDMF_META_JAVA_SOURCE, "general.java-source"}, 456 {UDMF_META_EBOOK, "general.ebook"}, 457 {UDMF_META_EPUB, "general.epub"}, 458 {UDMF_META_AZW, "com.amazon.azw"}, 459 {UDMF_META_AZW3, "com.amazon.azw3"}, 460 {UDMF_META_KFX, "com.amazon.kfx"}, 461 {UDMF_META_MOBI, "com.amazon.mobi"}, 462 {UDMF_META_MEDIA, "general.media"}, 463 {UDMF_META_IMAGE, "general.image"}, 464 {UDMF_META_JPEG, "general.jpeg"}, 465 {UDMF_META_PNG, "general.png"}, 466 {UDMF_META_RAW_IMAGE, "general.raw-image"}, 467 {UDMF_META_TIFF, "general.tiff"}, 468 {UDMF_META_BMP, "com.microsoft.bmp"}, 469 {UDMF_META_ICO, "com.microsoft.ico"}, 470 {UDMF_META_PHOTOSHOP_IMAGE, "com.adobe.photoshop-image"}, 471 {UDMF_META_AI_IMAGE, "com.adobe.illustrator.ai-image"}, 472 {UDMF_META_WORD_DOC, "com.microsoft.word.doc"}, 473 {UDMF_META_EXCEL, "com.microsoft.excel.xls"}, 474 {UDMF_META_PPT, "com.microsoft.powerpoint.ppt"}, 475 {UDMF_META_PDF, "com.adobe.pdf"}, 476 {UDMF_META_POSTSCRIPT, "com.adobe.postscript"}, 477 {UDMF_META_ENCAPSULATED_POSTSCRIPT, "com.adobe.encapsulated-postscript"}, 478 {UDMF_META_VIDEO, "general.video"}, 479 {UDMF_META_AVI, "general.avi"}, 480 {UDMF_META_MPEG, "general.mpeg"}, 481 {UDMF_META_MPEG4, "general.mpeg-4"}, 482 {UDMF_META_VIDEO_3GPP, "general.3gpp"}, 483 {UDMF_META_VIDEO_3GPP2, "general.3gpp2"}, 484 {UDMF_META_WINDOWS_MEDIA_WM, "com.microsoft.windows-media-wm"}, 485 {UDMF_META_WINDOWS_MEDIA_WMV, "com.microsoft.windows-media-wmv"}, 486 {UDMF_META_WINDOWS_MEDIA_WMP, "com.microsoft.windows-media-wmp"}, 487 {UDMF_META_AUDIO, "general.audio"}, 488 {UDMF_META_AAC, "general.aac"}, 489 {UDMF_META_AIFF, "general.aiff"}, 490 {UDMF_META_ALAC, "general.alac"}, 491 {UDMF_META_FLAC, "general.flac"}, 492 {UDMF_META_MP3, "general.mp3"}, 493 {UDMF_META_OGG, "general.ogg"}, 494 {UDMF_META_PCM, "general.pcm"}, 495 {UDMF_META_WINDOWS_MEDIA_WMA, "com.microsoft.windows-media-wma"}, 496 {UDMF_META_WAVEFORM_AUDIO, "com.microsoft.waveform-audio"}, 497 {UDMF_META_WINDOWS_MEDIA_WMX, "com.microsoft.windows-media-wmx"}, 498 {UDMF_META_WINDOWS_MEDIA_WVX, "com.microsoft.windows-media-wvx"}, 499 {UDMF_META_WINDOWS_MEDIA_WAX, "com.microsoft.windows-media-wax"}, 500 {UDMF_META_GENERAL_FILE, "general.file"}, 501 {UDMF_META_DIRECTORY, "general.directory"}, 502 {UDMF_META_FOLDER, "general.folder"}, 503 {UDMF_META_SYMLINK, "general.symlink"}, 504 {UDMF_META_ARCHIVE, "general.archive"}, 505 {UDMF_META_BZ2_ARCHIVE, "general.bz2-archive"}, 506 {UDMF_META_DISK_IMAGE, "general.disk-image"}, 507 {UDMF_META_TAR_ARCHIVE, "general.tar-archive"}, 508 {UDMF_META_ZIP_ARCHIVE, "general.zip-archive"}, 509 {UDMF_META_JAVA_ARCHIVE, "com.sun.java-archive"}, 510 {UDMF_META_GNU_TAR_ARCHIVE, "org.gnu.gnu-tar-archive"}, 511 {UDMF_META_GNU_ZIP_ARCHIVE, "org.gnu.gnu-zip-archive"}, 512 {UDMF_META_GNU_ZIP_TAR_ARCHIVE, "org.gnu.gnu-zip-tar-archive"}, 513 {UDMF_META_CALENDAR, "general.calendar"}, 514 {UDMF_META_CONTACT, "general.contact"}, 515 {UDMF_META_DATABASE, "general.database"}, 516 {UDMF_META_MESSAGE, "general.message"}, 517 {UDMF_META_VCARD, "general.vcard"}, 518 {UDMF_META_NAVIGATION, "general.navigation"}, 519 {UDMF_META_LOCATION, "general.location"}, 520 {UDMF_META_OPENHARMONY_FORM, "openharmony.form"}, 521 {UDMF_META_OPENHARMONY_APP_ITEM, "openharmony.app-item"}, 522 {UDMF_META_OPENHARMONY_PIXEL_MAP, "openharmony.pixel-map"}, 523 {UDMF_META_OPENHARMONY_ATOMIC_SERVICE, "openharmony.atomic-service"}, 524 {UDMF_META_OPENHARMONY_PACKAGE, "openharmony.package"}, 525 {UDMF_META_OPENHARMONY_HAP, "openharmony.hap"}, 526 {UDMF_META_SMIL, "com.real.smil"}, 527 {UDMF_META_MARKDOWN, "general.markdown"}, 528 {UDMF_META_FAX, "general.fax"}, 529 {UDMF_META_JFX_FAX, "com.j2.jfx-fax"}, 530 {UDMF_META_EFX_FAX, "com.js.efx-fax"}, 531 {UDMF_META_XBITMAP_IMAGE, "general.xbitmap-image"}, 532 {UDMF_META_TGA_IMAGE, "com.truevision.tga-image"}, 533 {UDMF_META_SGI_IMAGE, "com.sgi.sgi-image"}, 534 {UDMF_META_OPENEXR_IMAGE, "com.ilm.openexr-image"}, 535 {UDMF_META_FLASHPIX_IMAGE, "com.kodak.flashpix.image"}, 536 {UDMF_META_REALMEDIA, "com.real.realmedia"}, 537 {UDMF_META_AU_AUDIO, "general.au-audio"}, 538 {UDMF_META_AIFC_AUDIO, "general.aifc-audio"}, 539 {UDMF_META_SD2_AUDIO, "com.digidesign.sd2-audio"}, 540 {UDMF_META_REALAUDIO, "com.real.realaudio"}, 541 {UDMF_META_OPENXML, "org.openxmlformats.openxml"}, 542 {UDMF_META_WORDPROCESSINGML_DOCUMENT, "org.openxmlformats.wordprocessingml.document"}, 543 {UDMF_META_SPREADSHEETML_SHEET, "org.openxmlformats.spreadsheetml.sheet"}, 544 {UDMF_META_PRESENTATIONML_PRESENTATION, "org.openxmlformats.presentationml.presentation"}, 545 {UDMF_META_OPENDOCUMENT, "org.oasis.opendocument"}, 546 {UDMF_META_OPENDOCUMENT_TEXT, "org.oasis.opendocument.text"}, 547 {UDMF_META_OPENDOCUMENT_SPREADSHEET, "org.oasis.opendocument.spreadsheet"}, 548 {UDMF_META_OPENDOCUMENT_PRESENTATION, "org.oasis.opendocument.presentation"}, 549 {UDMF_META_OPENDOCUMENT_GRAPHICS, "org.oasis.opendocument.graphics"}, 550 {UDMF_META_OPENDOCUMENT_FORMULA, "org.oasis.opendocument.formula"}, 551 {UDMF_META_STUFFIT_ARCHIVE, "com.allume.stuffit-archive"}, 552 {UDMF_META_VCS, "general.vcs"}, 553 {UDMF_META_ICS, "general.ics"}, 554 {UDMF_META_EXECUTABLE, "general.executable"}, 555 {UDMF_META_PORTABLE_EXECUTABLE, "com.microsoft.portable-executable"}, 556 {UDMF_META_SUN_JAVA_CLASS, "com.sun.java-class"}, 557 {UDMF_META_FONT, "general.font"}, 558 {UDMF_META_TRUETYPE_FONT, "general.truetype-font"}, 559 {UDMF_META_TRUETYPE_COLLECTION_FONT, "general.truetype-collection-font"}, 560 {UDMF_META_OPENTYPE_FONT, "general.opentype-font"}, 561 {UDMF_META_POSTSCRIPT_FONT, "com.adobe.postscript-font"}, 562 {UDMF_META_POSTSCRIPT_PFB_FONT, "com.adobe.postscript-pfb-font"}, 563 {UDMF_META_POSTSCRIPT_PFA_FONT, "com.adobe.postscript-pfa-font"}, 564 {UDMF_META_OPENHARMONY_HDOC, "openharmony.hdoc"}, 565 {UDMF_META_OPENHARMONY_HINOTE, "openharmony.hinote"}, 566 {UDMF_META_OPENHARMONY_STYLED_STRING, "openharmony.styled-string"}, 567 {UDMF_META_OPENHARMONY_WANT, "openharmony.want"} 568}; 569 570/** 571 * @tc.name: OH_Utd_Create_002 572 * @tc.desc: traverse enum for UTD 573 * @tc.type: FUNC 574 */ 575HWTEST_F(UtdTest, OH_Utd_Create_002, TestSize.Level1) 576{ 577 LOG_INFO(UDMF_TEST, "OH_Utd_Create_002 begin."); 578 OH_Utd* utd1; 579 for (const auto& pair : typeIdMap) { 580 utd1 = OH_Utd_Create(pair.first.c_str()); 581 std::string typeId(OH_Utd_GetTypeId(utd1)); 582 EXPECT_EQ(pair.second, typeId); 583 OH_Utd_Destroy(utd1); 584 } 585 LOG_INFO(UDMF_TEST, "OH_Utd_Create_002 end."); 586} 587 588} 589