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 
31 using namespace testing::ext;
32 using namespace OHOS::Security::AccessToken;
33 using namespace OHOS::UDMF;
34 using namespace OHOS;
35 
36 constexpr const char *REFERENCE_URL = "https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/"\
37                                       "apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype";
38 
39 namespace OHOS::Test {
40 
41 OH_Utd* utd = nullptr;
42 
43 class UtdTest : public testing::Test {
44 public:
45     static void SetUpTestCase(void);
46     static void TearDownTestCase(void);
47     void SetUp();
48     void TearDown();
49 };
50 
SetUpTestCase(void)51 void UtdTest::SetUpTestCase(void) {}
52 
TearDownTestCase(void)53 void UtdTest::TearDownTestCase(void) {}
54 
SetUp(void)55 void 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 
TearDown(void)61 void 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  */
73 HWTEST_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  */
93 HWTEST_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  */
110 HWTEST_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  */
127 HWTEST_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  */
144 HWTEST_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  */
161 HWTEST_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  */
185 HWTEST_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  */
209 HWTEST_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  */
233 HWTEST_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  */
258 HWTEST_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  */
283 HWTEST_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  */
295 HWTEST_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  */
307 HWTEST_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  */
320 HWTEST_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  */
332 HWTEST_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  */
344 HWTEST_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  */
357 HWTEST_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  */
369 HWTEST_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  */
381 HWTEST_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  */
394 HWTEST_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  */
409 HWTEST_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  */
424 HWTEST_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 
432 std::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  */
575 HWTEST_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