1 /*
2  * Copyright (c) 2023 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 #define LOG_TAG "UtdClientTest"
16 #include <gtest/gtest.h>
17 
18 #include <unistd.h>
19 
20 #include "token_setproc.h"
21 #include "accesstoken_kit.h"
22 #include "nativetoken_kit.h"
23 
24 #include "logger.h"
25 #include "utd_client.h"
26 #include "type_descriptor.h"
27 #include "preset_type_descriptors.h"
28 #include "utd_graph.h"
29 
30 using namespace testing::ext;
31 using namespace OHOS::Security::AccessToken;
32 using namespace OHOS::UDMF;
33 using namespace OHOS;
34 
35 namespace OHOS::Test {
36 class UtdClientTest : public testing::Test {
37 public:
38     static void SetUpTestCase();
39     static void TearDownTestCase();
40     void SetUp() override;
41     void TearDown() override;
42 };
43 
SetUpTestCase()44 void UtdClientTest::SetUpTestCase()
45 {
46 }
47 
TearDownTestCase()48 void UtdClientTest::TearDownTestCase()
49 {
50 }
51 
SetUp()52 void UtdClientTest::SetUp()
53 {
54 }
55 
TearDown()56 void UtdClientTest::TearDown()
57 {
58 }
59 
60 /**
61 * @tc.name: GetTypeDescriptor001
62 * @tc.desc: Normal testcase of GetTypeDescriptor
63 * @tc.type: FUNC
64 */
65 HWTEST_F(UtdClientTest, GetTypeDescriptor001, TestSize.Level1)
66 {
67     LOG_INFO(UDMF_TEST, "GetTypeDescriptor001 begin.");
68 
69     std::shared_ptr<TypeDescriptor> descriptor;
70     std::string typeId = "com.amazon.azw3";
71     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
72     EXPECT_EQ(status, E_OK);
73     EXPECT_EQ(descriptor->GetTypeId(), typeId);
74     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.ebook");
75     EXPECT_EQ(descriptor->GetDescription(), "AZW3 ebook.");
76     EXPECT_EQ(descriptor->GetIconFile(), "");
77     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".azw3");
78     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "application/vnd.amazon.mobi8-ebook");
79     LOG_INFO(UDMF_TEST, "GetTypeDescriptor001 end.");
80 }
81 
82 /**
83 * @tc.name: GetTypeDescriptor002
84 * @tc.desc: Negative test case, invalid typeId argument, returns nullptr
85 * @tc.type: FUNC
86 */
87 HWTEST_F(UtdClientTest, GetTypeDescriptor002, TestSize.Level1)
88 {
89     LOG_INFO(UDMF_TEST, "GetTypeDescriptor002 begin.");
90 
91     std::shared_ptr<TypeDescriptor> descriptor;
92     std::string typeId = "";
93     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
94     EXPECT_EQ(status, E_OK);
95     EXPECT_EQ(descriptor, nullptr);
96     LOG_INFO(UDMF_TEST, "GetTypeDescriptor002 end.");
97 }
98 
99 /**
100 * @tc.name: GetTypeDescriptor003
101 * @tc.desc: Negative test case, invalid typeId argument, returns nullptr
102 * @tc.type: FUNC
103 */
104 HWTEST_F(UtdClientTest, GetTypeDescriptor003, TestSize.Level1)
105 {
106     LOG_INFO(UDMF_TEST, "GetTypeDescriptor003 begin.");
107 
108     std::shared_ptr<TypeDescriptor> descriptor;
109     std::string typeId = "12345";
110     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
111     EXPECT_EQ(status, E_OK);
112     EXPECT_EQ(descriptor, nullptr);
113     LOG_INFO(UDMF_TEST, "GetTypeDescriptor003 end.");
114 }
115 
116 /**
117 * @tc.name: GetTypeDescriptor004
118 * @tc.desc: Normal testcase of GetTypeDescriptor
119 * @tc.type: FUNC
120 */
121 HWTEST_F(UtdClientTest, GetTypeDescriptor004, TestSize.Level1)
122 {
123     LOG_INFO(UDMF_TEST, "GetTypeDescriptor004 begin.");
124 
125     std::shared_ptr<TypeDescriptor> descriptor;
126     std::string typeId = "org.gnu.gnu-zip-archive";
127     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
128     EXPECT_EQ(status, E_OK);
129     EXPECT_EQ(descriptor->GetTypeId(), typeId);
130     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.archive");
131     EXPECT_EQ(descriptor->GetDescription(), "Gzip archive.");
132     EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_compress");
133     LOG_INFO(UDMF_TEST, "GetTypeDescriptor004 end.");
134 }
135 
136 /**
137 * @tc.name: GetTypeDescriptor005
138 * @tc.desc: Negative test case, invalid typeId argument, returns nullptr
139 * @tc.type: FUNC
140 */
141 HWTEST_F(UtdClientTest, GetTypeDescriptor005, TestSize.Level1)
142 {
143     LOG_INFO(UDMF_TEST, "GetTypeDescriptor005 begin.");
144 
145     std::shared_ptr<TypeDescriptor> descriptor;
146     std::string typeId = "...";
147     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
148     EXPECT_EQ(status, E_OK);
149     EXPECT_EQ(descriptor, nullptr);
150     LOG_INFO(UDMF_TEST, "GetTypeDescriptor005 end.");
151 }
152 
153 /**
154 * @tc.name: GetTypeDescriptor006
155 * @tc.desc: Normal testcase of GetTypeDescriptor
156 * @tc.type: FUNC
157 */
158 HWTEST_F(UtdClientTest, GetTypeDescriptor006, TestSize.Level1)
159 {
160     LOG_INFO(UDMF_TEST, "GetTypeDescriptor006 begin.");
161 
162     std::shared_ptr<TypeDescriptor> descriptor;
163     std::string typeId = "general.fax";
164     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
165     EXPECT_EQ(status, E_OK);
166     EXPECT_EQ(descriptor->GetTypeId(), typeId);
167     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.image");
168     EXPECT_EQ(descriptor->GetDescription(), "Base type for fax images.");
169     EXPECT_EQ(descriptor->GetIconFile(), "");
170     EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
171     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
172     LOG_INFO(UDMF_TEST, "GetTypeDescriptor006 end.");
173 }
174 
175 /**
176 * @tc.name: GetUniformDataTypeByFilenameExtension001
177 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
178 * @tc.type: FUNC
179 */
180 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension001, TestSize.Level1)
181 {
182     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension001 begin.");
183     std::string filenameExtension = ".azw3";
184     std::string blongsToType = "general.ebook";
185     std::string currType;
186     auto status =
187         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
188     EXPECT_EQ(status, E_OK);
189     EXPECT_EQ(currType, "com.amazon.azw3");
190     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension001 end.");
191 }
192 
193 /**
194 * @tc.name: GetUniformDataTypeByFilenameExtension002
195 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
196 * @tc.type: FUNC
197 */
198 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension002, TestSize.Level1)
199 {
200     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension002 begin.");
201     std::string filenameExtension = ".png";
202     std::string blongsToType = "general.image";
203     std::string currType;
204     auto status =
205         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
206     EXPECT_EQ(status, E_OK);
207     EXPECT_EQ(currType, "general.png");
208     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension002 end.");
209 }
210 
211 /**
212 * @tc.name: GetUniformDataTypeByFilenameExtension003
213 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
214 * @tc.type: FUNC
215 */
216 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension003, TestSize.Level1)
217 {
218     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension003 begin.");
219     std::string filenameExtension = ".cpp";
220     std::string blongsToType = "general.source-code";
221     std::string currType;
222     auto status =
223         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
224     EXPECT_EQ(status, E_OK);
225     EXPECT_EQ(currType, "general.c-plus-plus-source");
226     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension003 end.");
227 }
228 
229 /**
230 * @tc.name: GetUniformDataTypeByFilenameExtension004
231 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension,
232 * para empty string, return E_INVALID_PARAMETERS
233 * @tc.type: FUNC
234 */
235 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension004, TestSize.Level1)
236 {
237     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension004 begin.");
238     std::string filenameExtension = "";
239     std::string blongsToType = "general.plain-text";
240     std::string currType;
241     auto status =
242         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
243     EXPECT_EQ(status, E_INVALID_PARAMETERS);
244     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension004 end.");
245 }
246 
247 /**
248 * @tc.name: GetUniformDataTypeByFilenameExtension005
249 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, return invalid parameter
250 * @tc.type: FUNC
251 */
252 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension005, TestSize.Level1)
253 {
254     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension005 begin.");
255     std::string filenameExtension = ".test";
256     std::string blongsToType = "general.test";
257     std::string currType;
258     auto status =
259         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
260     EXPECT_EQ(status, E_INVALID_PARAMETERS);
261     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension005 end.");
262 }
263 
264 /**
265 * @tc.name: GetUniformDataTypeByFilenameExtension006
266 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
267 * @tc.type: FUNC
268 */
269 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension006, TestSize.Level1)
270 {
271     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension006 begin.");
272     std::string filenameExtension = ".mp3";
273     std::string blongsToType = "general.object";
274     std::string currType;
275     auto status =
276         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
277     EXPECT_EQ(status, E_OK);
278     EXPECT_EQ(currType, "general.mp3");
279     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension006 end.");
280 }
281 
282 /**
283 * @tc.name: GetUniformDataTypeByFilenameExtension007
284 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, return invalid parameter
285 * @tc.type: FUNC
286 */
287 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension007, TestSize.Level1)
288 {
289     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension007 begin.");
290     std::string filenameExtension = ".mp3";
291     std::string blongsToType = "test";
292     std::string currType;
293     auto status =
294         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
295     EXPECT_EQ(status, E_INVALID_PARAMETERS);
296     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension007 end.");
297 }
298 
299 
300 /**
301 * @tc.name: GetUniformDataTypeByFilenameExtension008
302 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, return flexible type.
303 * @tc.type: FUNC
304 */
305 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension008, TestSize.Level1)
306 {
307     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension008 begin.");
308     std::string filenameExtension = ".auto-image";
309     std::string blongsToType = "general.image";
310     std::string currType;
311     auto status =
312         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
313     EXPECT_EQ(status, E_OK);
314     std::shared_ptr<TypeDescriptor> descriptor;
315     status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
316     EXPECT_EQ(status, E_OK);
317     EXPECT_EQ(descriptor->GetTypeId(), currType);
318     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.image");
319     EXPECT_EQ(descriptor->GetDescription().empty(), true);
320     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
321     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".auto-image");
322     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
323     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension008 end.");
324 }
325 
326 /**
327 * @tc.name: GetUniformDataTypeByMIMEType001
328 * @tc.desc: Normal testcase of GetUniformDataTypeByMIMEType
329 * @tc.type: FUNC
330 */
331 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType001, TestSize.Level1)
332 {
333     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType001 begin.");
334     std::string mimeType = "application/x-mobi8-ebook";
335     std::string blongsToType = "general.ebook";
336     std::string currType;
337     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
338     EXPECT_EQ(status, E_OK);
339     EXPECT_EQ(currType, "com.amazon.azw3");
340     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType001 end.");
341 }
342 
343 /**
344 * @tc.name: GetUniformDataTypeByMIMEType002
345 * @tc.desc: Normal testcase of GetUniformDataTypeByMIMEType
346 * @tc.type: FUNC
347 */
348 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType002, TestSize.Level1)
349 {
350     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType002 begin.");
351     std::string mimeType = "application/vnd.ms-powerpoint";
352     std::string blongsToType = "general.composite-object";
353     std::string currType;
354     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
355     EXPECT_EQ(status, E_OK);
356     EXPECT_EQ(currType, "com.microsoft.powerpoint.ppt");
357     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType002 end.");
358 }
359 
360 /**
361 * @tc.name: GetUniformDataTypeByMIMEType003
362 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType, return invalid parameter
363 * @tc.type: FUNC
364 */
365 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType003, TestSize.Level1)
366 {
367     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType003 begin.");
368     std::string mimeType = "test01";
369     std::string blongsToType = "";
370     std::string currType;
371     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
372     EXPECT_EQ(status, E_INVALID_PARAMETERS);
373     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType003 end.");
374 }
375 
376 /**
377 * @tc.name: GetUniformDataTypeByMIMEType004
378 * @tc.desc: BelongsTo is invalid, return invalid parameter
379 * @tc.type: FUNC
380 */
381 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType004, TestSize.Level1)
382 {
383     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType004 begin.");
384     std::string mimeType = "";
385     std::string blongsToType = "test02";
386     std::string currType;
387     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
388     EXPECT_EQ(status, E_INVALID_PARAMETERS);
389     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType004 end.");
390 }
391 
392 /**
393 * @tc.name: GetUniformDataTypeByMIMEType005
394 * @tc.desc: BelongsTo is invalid, return invalid parameter
395 * @tc.type: FUNC
396 */
397 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType005, TestSize.Level1)
398 {
399     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType005 begin.");
400     std::string mimeType = ".pm";
401     std::string blongsToType = "test03";
402     std::string currType;
403     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
404     EXPECT_EQ(status, E_INVALID_PARAMETERS);
405     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType005 end.");
406 }
407 
408 /**
409 * @tc.name: GetUniformDataTypeByMIMEType006
410 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType,
411 * para empty string, return E_INVALID_PARAMETERS
412 * @tc.type: FUNC
413 */
414 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType006, TestSize.Level1)
415 {
416     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType006 begin.");
417     std::string mimeType = "";
418     std::string blongsToType = "general.entity";
419     std::string currType;
420     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
421     EXPECT_EQ(status, E_INVALID_PARAMETERS);
422     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType006 end.");
423 }
424 
425 /**
426 * @tc.name: GetUniformDataTypeByMIMEType007
427 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType, return flexible type.
428 * @tc.type: FUNC
429 */
430 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType007, TestSize.Level1)
431 {
432     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType007 begin.");
433     std::string mimeType = "image/auto-image";
434     std::string blongsToType = "general.image";
435     std::string currType;
436     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
437     EXPECT_EQ(status, E_OK);
438     std::shared_ptr<TypeDescriptor> descriptor;
439     status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
440     EXPECT_EQ(status, E_OK);
441     EXPECT_EQ(descriptor->GetTypeId(), currType);
442     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.image");
443     EXPECT_EQ(descriptor->GetDescription().empty(), true);
444     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
445     EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
446     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "image/auto-image");
447     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType007 end.");
448 }
449 
450 
451 /**
452 * @tc.name: BelongsTo001
453 * @tc.desc: Normal testcase of BelongsTo
454 * @tc.type: FUNC
455 */
456 HWTEST_F(UtdClientTest, BelongsTo001, TestSize.Level1)
457 {
458     LOG_INFO(UDMF_TEST, "BelongsTo001 begin.");
459     std::shared_ptr<TypeDescriptor> descriptor;
460     std::string typeId = "com.amazon.azw3";
461     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
462     EXPECT_EQ(status, E_OK);
463     bool checkRet = false;
464     ASSERT_NE(descriptor, nullptr);
465     status = descriptor->BelongsTo("general.composite-object", checkRet);
466     EXPECT_EQ(status, E_OK);
467     EXPECT_EQ(checkRet, true);
468     LOG_INFO(UDMF_TEST, "BelongsTo001 end.");
469 }
470 
471 /**
472 * @tc.name: BelongsTo002
473 * @tc.desc: Normal testcase of BelongsTo
474 * @tc.type: FUNC
475 */
476 HWTEST_F(UtdClientTest, BelongsTo002, TestSize.Level1)
477 {
478     LOG_INFO(UDMF_TEST, "BelongsTo002 begin.");
479     std::shared_ptr<TypeDescriptor> descriptor;
480     std::string typeId = "com.amazon.azw3";
481     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
482     EXPECT_EQ(status, E_OK);
483     bool checkRet = false;
484     ASSERT_NE(descriptor, nullptr);
485     status = descriptor->BelongsTo(typeId, checkRet);
486     EXPECT_EQ(status, E_OK);
487     EXPECT_EQ(checkRet, true);
488     LOG_INFO(UDMF_TEST, "BelongsTo002 end.");
489 }
490 
491 /**
492 * @tc.name: BelongsTo003
493 * @tc.desc: Normal testcase of BelongsTo
494 * @tc.type: FUNC
495 */
496 HWTEST_F(UtdClientTest, BelongsTo003, TestSize.Level1)
497 {
498     LOG_INFO(UDMF_TEST, "BelongsTo003 begin.");
499     std::shared_ptr<TypeDescriptor> descriptor;
500     std::string typeId = "general.tiff";
501     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
502     EXPECT_EQ(status, E_OK);
503     bool checkRet = false;
504     ASSERT_NE(descriptor, nullptr);
505     status = descriptor->BelongsTo("general.media", checkRet);
506     EXPECT_EQ(status, E_OK);
507     EXPECT_EQ(checkRet, true);
508     LOG_INFO(UDMF_TEST, "BelongsTo003 end.");
509 }
510 
511 /**
512 * @tc.name: BelongsTo004
513 * @tc.desc: Normal testcase of BelongsTo
514 * @tc.type: FUNC
515 */
516 HWTEST_F(UtdClientTest, BelongsTo004, TestSize.Level1)
517 {
518     LOG_INFO(UDMF_TEST, "BelongsTo004 begin.");
519     std::shared_ptr<TypeDescriptor> descriptor;
520     std::string typeId = "general.tiff";
521     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
522     EXPECT_EQ(status, E_OK);
523     bool checkRet = false;
524     ASSERT_NE(descriptor, nullptr);
525     status = descriptor->BelongsTo("general.object", checkRet);
526     EXPECT_EQ(status, E_OK);
527     EXPECT_EQ(checkRet, true);
528     LOG_INFO(UDMF_TEST, "BelongsTo004 end.");
529 }
530 
531 /**
532 * @tc.name: BelongsTo005
533 * @tc.desc: Abnormal testcase of BelongsTo
534 * @tc.type: FUNC
535 */
536 HWTEST_F(UtdClientTest, BelongsTo005, TestSize.Level1)
537 {
538     LOG_INFO(UDMF_TEST, "BelongsTo005 begin.");
539     std::shared_ptr<TypeDescriptor> descriptor;
540     std::string typeId = "general.c-header";
541     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
542     EXPECT_EQ(status, E_OK);
543     bool checkRet = false;
544     ASSERT_NE(descriptor, nullptr);
545     status = descriptor->BelongsTo("general.script", checkRet);
546     EXPECT_EQ(status, E_OK);
547     EXPECT_EQ(checkRet, false);
548     LOG_INFO(UDMF_TEST, "BelongsTo005 end.");
549 }
550 
551 /**
552 * @tc.name: BelongsTo006
553 * @tc.desc: BelongsTo is invalid, return invalid parameter
554 * @tc.type: FUNC
555 */
556 HWTEST_F(UtdClientTest, BelongsTo006, TestSize.Level1)
557 {
558     LOG_INFO(UDMF_TEST, "BelongsTo006 begin.");
559     std::shared_ptr<TypeDescriptor> descriptor;
560     std::string typeId = "general.mpeg";
561     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
562     EXPECT_EQ(status, E_OK);
563     bool checkRet = false;
564     ASSERT_NE(descriptor, nullptr);
565     status = descriptor->BelongsTo("test04", checkRet);
566     EXPECT_EQ(status, E_INVALID_PARAMETERS);
567     EXPECT_EQ(checkRet, false);
568     LOG_INFO(UDMF_TEST, "BelongsTo006 end.");
569 }
570 
571 /**
572 * @tc.name: IsLowerLevelType001
573 * @tc.desc: Normal testcase of IsLowerLevelType
574 * @tc.type: FUNC
575 */
576 HWTEST_F(UtdClientTest, IsLowerLevelType001, TestSize.Level1)
577 {
578     LOG_INFO(UDMF_TEST, "IsLowerLevelType001 begin.");
579     std::shared_ptr<TypeDescriptor> descriptor;
580     std::string typeId = "com.amazon.azw3";
581     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
582     EXPECT_EQ(status, E_OK);
583     bool checkRet = false;
584     ASSERT_NE(descriptor, nullptr);
585     status = descriptor->IsLowerLevelType("general.composite-object", checkRet);
586     EXPECT_EQ(status, E_OK);
587     EXPECT_EQ(checkRet, true);
588     LOG_INFO(UDMF_TEST, "IsLowerLevelType001 end.");
589 }
590 
591 /**
592 * @tc.name: IsLowerLevelType002
593 * @tc.desc: TypeId is "', return invalid parameter
594 * @tc.type: FUNC
595 */
596 HWTEST_F(UtdClientTest, IsLowerLevelType002, TestSize.Level1)
597 {
598     LOG_INFO(UDMF_TEST, "IsLowerLevelType002 begin.");
599     std::shared_ptr<TypeDescriptor> descriptor;
600     std::string typeId = "general.object";
601     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
602     EXPECT_EQ(status, E_OK);
603     bool checkRet = false;
604     ASSERT_NE(descriptor, nullptr);
605     status = descriptor->IsLowerLevelType("", checkRet);
606     EXPECT_EQ(status, Status::E_INVALID_PARAMETERS);
607     EXPECT_EQ(checkRet, false);
608     LOG_INFO(UDMF_TEST, "IsLowerLevelType002 end.");
609 }
610 
611 /**
612 * @tc.name: IsLowerLevelType003
613 * @tc.desc: Normal testcase of IsLowerLevelType
614 * @tc.type: FUNC
615 */
616 HWTEST_F(UtdClientTest, IsLowerLevelType003, TestSize.Level1)
617 {
618     LOG_INFO(UDMF_TEST, "IsLowerLevelType003 begin.");
619     std::shared_ptr<TypeDescriptor> descriptor;
620     std::string typeId = "com.microsoft.bmp";
621     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
622     EXPECT_EQ(status, E_OK);
623     bool checkRet = false;
624     ASSERT_NE(descriptor, nullptr);
625     status = descriptor->IsLowerLevelType("general.object", checkRet);
626     EXPECT_EQ(status, E_OK);
627     EXPECT_EQ(checkRet, true);
628     LOG_INFO(UDMF_TEST, "IsLowerLevelType003 end.");
629 }
630 
631 /**
632 * @tc.name: IsLowerLevelType004
633 * @tc.desc: Abnormal testcase of IsLowerLevelType, the two values are equal
634 * @tc.type: FUNC
635 */
636 HWTEST_F(UtdClientTest, IsLowerLevelType004, TestSize.Level1)
637 {
638     LOG_INFO(UDMF_TEST, "IsLowerLevelType004 begin.");
639     std::shared_ptr<TypeDescriptor> descriptor;
640     std::string typeId = "com.amazon.azw3";
641     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
642     EXPECT_EQ(status, E_OK);
643     bool checkRet = false;
644     ASSERT_NE(descriptor, nullptr);
645     status = descriptor->IsLowerLevelType("com.amazon.azw3", checkRet);
646     EXPECT_EQ(status, E_OK);
647     EXPECT_EQ(checkRet, false);
648     LOG_INFO(UDMF_TEST, "IsLowerLevelType004 end.");
649 }
650 
651 /**
652 * @tc.name: IsHigherLevelType001
653 * @tc.desc: Normal testcase of IsHigherLevelType
654 * @tc.type: FUNC
655 */
656 HWTEST_F(UtdClientTest, IsHigherLevelType001, TestSize.Level1)
657 {
658     LOG_INFO(UDMF_TEST, "IsHigherLevelType001 begin.");
659     std::shared_ptr<TypeDescriptor> descriptor;
660     std::string typeId = "general.composite-object";
661     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
662     EXPECT_EQ(status, E_OK);
663     bool checkRet = false;
664     ASSERT_NE(descriptor, nullptr);
665     status = descriptor->IsHigherLevelType("com.amazon.azw3", checkRet);
666     EXPECT_EQ(status, E_OK);
667     EXPECT_EQ(checkRet, true);
668     LOG_INFO(UDMF_TEST, "IsHigherLevelType001 end.");
669 }
670 
671 /**
672 * @tc.name: IsHigherLevelType002
673 * @tc.desc: Abnormal testcase of IsHigherLevelType, the two values are equal
674 * @tc.type: FUNC
675 */
676 HWTEST_F(UtdClientTest, IsHigherLevelType002, TestSize.Level1)
677 {
678     LOG_INFO(UDMF_TEST, "IsHigherLevelType002 begin.");
679     std::shared_ptr<TypeDescriptor> descriptor;
680     std::string typeId = "com.amazon.azw3";
681     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
682     EXPECT_EQ(status, E_OK);
683     bool checkRet = false;
684     ASSERT_NE(descriptor, nullptr);
685     status = descriptor->IsHigherLevelType("com.amazon.azw3", checkRet);
686     EXPECT_EQ(status, E_OK);
687     EXPECT_EQ(checkRet, false);
688     LOG_INFO(UDMF_TEST, "IsHigherLevelType002 end.");
689 }
690 
691 /**
692 * @tc.name: IsHigherLevelType003
693 * @tc.desc: Abnormal testcase of IsHigherLevelType
694 * @tc.type: FUNC
695 */
696 HWTEST_F(UtdClientTest, IsHigherLevelType003, TestSize.Level1)
697 {
698     LOG_INFO(UDMF_TEST, "IsHigherLevelType003 begin.");
699     std::shared_ptr<TypeDescriptor> descriptor;
700     std::string typeId = "general.image";
701     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
702     EXPECT_EQ(status, E_OK);
703     bool checkRet = false;
704     ASSERT_NE(descriptor, nullptr);
705     status = descriptor->IsHigherLevelType("general.object", checkRet);
706     EXPECT_EQ(status, E_OK);
707     EXPECT_EQ(checkRet, false);
708     LOG_INFO(UDMF_TEST, "IsHigherLevelType003 end.");
709 }
710 
711 /**
712 * @tc.name: Equals001
713 * @tc.desc: Abnormal testcase of Equals, two values are different
714 * @tc.type: FUNC
715 */
716 HWTEST_F(UtdClientTest, Equals001, TestSize.Level1)
717 {
718     LOG_INFO(UDMF_TEST, "Equals001 begin.");
719     std::shared_ptr<TypeDescriptor> descriptor1;
720     std::string typeId1 =  "com.amazon.azw3";
721     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId1, descriptor1);
722     EXPECT_EQ(status, E_OK);
723     std::string typeId2 = "general.composite-object";
724     std::shared_ptr<TypeDescriptor> descriptor2;
725     status = UtdClient::GetInstance().GetTypeDescriptor(typeId2, descriptor2);
726     EXPECT_EQ(status, E_OK);
727     bool ret = descriptor1->Equals(descriptor2);
728     EXPECT_EQ(ret, false);
729     LOG_INFO(UDMF_TEST, "Equals001 end.");
730 }
731 
732 /**
733 * @tc.name: Equals002
734 * @tc.desc: Normal testcase of Equals
735 * @tc.type: FUNC
736 */
737 HWTEST_F(UtdClientTest, Equals002, TestSize.Level1)
738 {
739     LOG_INFO(UDMF_TEST, "Equals002 begin.");
740     std::shared_ptr<TypeDescriptor> descriptor1;
741     std::string typeId1 =  "com.amazon.azw3";
742     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId1, descriptor1);
743     EXPECT_EQ(status, E_OK);
744     std::string typeId2 =  "com.amazon.azw3";
745     std::shared_ptr<TypeDescriptor> descriptor2;
746     status = UtdClient::GetInstance().GetTypeDescriptor(typeId2, descriptor2);
747     EXPECT_EQ(status, E_OK);
748     bool ret = descriptor1->Equals(descriptor2);
749     EXPECT_EQ(ret, true);
750     LOG_INFO(UDMF_TEST, "Equals002 end.");
751 }
752 
753 /**
754 * @tc.name: TypeDescriptorGetAttr001
755 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
756 * @tc.type: FUNC
757 */
758 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr001, TestSize.Level1)
759 {
760     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr001 begin.");
761     std::shared_ptr<TypeDescriptor> descriptor;
762     std::string typeId = "com.amazon.azw3";
763     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
764     EXPECT_EQ(status, E_OK);
765     EXPECT_EQ(descriptor->GetTypeId(), typeId);
766     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.ebook");
767     EXPECT_EQ(descriptor->GetDescription(), "AZW3 ebook.");
768     EXPECT_EQ(descriptor->GetIconFile(), "");
769     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".azw3");
770     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "application/vnd.amazon.mobi8-ebook");
771 
772     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr001 end.");
773 }
774 
775 /**
776 * @tc.name: TypeDescriptorGetAttr002
777 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
778 * @tc.type: FUNC
779 */
780 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr002, TestSize.Level1)
781 {
782     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr002 begin.");
783     std::shared_ptr<TypeDescriptor> descriptor;
784     std::string typeId = "general.text";
785     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
786     EXPECT_EQ(status, E_OK);
787     EXPECT_EQ(descriptor->GetTypeId(), typeId);
788     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.object");
789     EXPECT_EQ(descriptor->GetDescription(), "Base type for all text.");
790     EXPECT_EQ(descriptor->GetIconFile(), "");
791     EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
792     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "text/*");
793 
794     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr002 end.");
795 }
796 
797 /**
798 * @tc.name: TypeDescriptorGetAttr003
799 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
800 * @tc.type: FUNC
801 */
802 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr003, TestSize.Level1)
803 {
804     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr003 begin.");
805     std::shared_ptr<TypeDescriptor> descriptor;
806     std::string typeId = "general.image";
807     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
808     EXPECT_EQ(status, E_OK);
809     EXPECT_EQ(descriptor->GetTypeId(), typeId);
810     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.media");
811     EXPECT_EQ(descriptor->GetDescription(), "Base type for images.");
812     EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_image");
813     EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
814     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "image/*");
815 
816     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr003 end.");
817 }
818 
819 /**
820 * @tc.name: TypeDescriptorGetAttr004
821 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
822 * @tc.type: FUNC
823 */
824 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr004, TestSize.Level1)
825 {
826     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr004 begin.");
827     std::shared_ptr<TypeDescriptor> descriptor;
828     std::string typeId = "general.video";
829     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
830     EXPECT_EQ(status, E_OK);
831     EXPECT_EQ(descriptor->GetTypeId(), typeId);
832     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.media");
833     EXPECT_EQ(descriptor->GetDescription(), "Base type for video.");
834     EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_video");
835     EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
836     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "video/*");
837 
838     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr004 end.");
839 }
840 
841 /**
842 * @tc.name: TypeDescriptorGetAttr005
843 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
844 * @tc.type: FUNC
845 */
846 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr005, TestSize.Level1)
847 {
848     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr005 begin.");
849     std::shared_ptr<TypeDescriptor> descriptor;
850     std::string typeId = "general.audio";
851     auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
852     EXPECT_EQ(status, E_OK);
853     EXPECT_EQ(descriptor->GetTypeId(), typeId);
854     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.media");
855     EXPECT_EQ(descriptor->GetDescription(), "Base type for audio.");
856     EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_audio");
857     EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
858     EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "audio/*");
859 
860     LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr005 end.");
861 }
862 
863 /**
864 * @tc.name: FlexibleType001
865 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
866 * @tc.type: FUNC
867 */
868 HWTEST_F(UtdClientTest, FlexibleType001, TestSize.Level1)
869 {
870     LOG_INFO(UDMF_TEST, "FlexibleType001 begin.");
871     std::string filenameExtension = ".mytext";
872     std::string blongsToType = "general.plain-text";
873     std::string flexTypeId;
874     auto status =
875         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
876     EXPECT_EQ(status, E_OK);
877     LOG_INFO(UDMF_TEST, "FlexibleType001, flexTypeId = %{public}s.", flexTypeId.c_str());
878     std::shared_ptr<TypeDescriptor> descriptor;
879     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
880     EXPECT_EQ(status, E_OK);
881     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
882     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
883     EXPECT_EQ(descriptor->GetDescription().empty(), true);
884     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
885     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
886     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
887     bool checkRet = false;
888     ASSERT_NE(descriptor, nullptr);
889     status = descriptor->IsHigherLevelType("general.object", checkRet);    //  cmp with gengral type.
890     EXPECT_EQ(status, E_OK);
891     EXPECT_EQ(checkRet, false);
892     LOG_INFO(UDMF_TEST, "FlexibleType001 end.");
893 }
894 
895 /**
896 * @tc.name: FlexibleType002
897 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
898 * @tc.type: FUNC
899 */
900 HWTEST_F(UtdClientTest, FlexibleType002, TestSize.Level1)
901 {
902     LOG_INFO(UDMF_TEST, "FlexibleType002 begin.");
903     std::string filenameExtension = ".mytext";
904     std::string blongsToType = "general.plain-text";
905     std::string flexTypeId1;
906     auto status =
907         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId1, blongsToType);
908     EXPECT_EQ(status, E_OK);
909     LOG_INFO(UDMF_TEST, "FlexibleType002, flexTypeId1 = %{public}s.", flexTypeId1.c_str());
910     std::shared_ptr<TypeDescriptor> descriptor1;
911     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId1, descriptor1);
912     EXPECT_EQ(status, E_OK);
913 
914     std::string filenameExtension2 = ".myvideo";
915     std::string blongsToType2 = "general.video";
916     std::string flexTypeId2;
917     status =
918         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension2, flexTypeId2, blongsToType2);
919     EXPECT_EQ(status, E_OK);
920     LOG_INFO(UDMF_TEST, "FlexibleType002, flexTypeId2 = %{public}s.", flexTypeId2.c_str());
921     std::shared_ptr<TypeDescriptor> descriptor2;
922     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId2, descriptor2);
923     EXPECT_EQ(status, E_OK);
924     EXPECT_EQ(descriptor2->GetTypeId(), flexTypeId2);
925     EXPECT_EQ(*(descriptor2->GetBelongingToTypes().begin()), "general.video");
926     EXPECT_EQ(descriptor2->GetDescription().empty(), true);
927     EXPECT_EQ(descriptor2->GetIconFile().empty(), true);
928     EXPECT_EQ(descriptor2->GetMimeTypes().empty(), true);
929     EXPECT_EQ(*(descriptor2->GetFilenameExtensions().begin()), ".myvideo");
930     bool checkRet = false;
931     ASSERT_NE(descriptor2, nullptr);
932     status = descriptor2->IsHigherLevelType(flexTypeId2, checkRet);   //  cmp with flexbile type.
933     EXPECT_EQ(status, E_OK);
934     EXPECT_EQ(checkRet, false);
935     LOG_INFO(UDMF_TEST, "FlexibleType002 end.");
936 }
937 
938 /**
939 * @tc.name: FlexibleType001
940 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
941 * @tc.type: FUNC
942 */
943 HWTEST_F(UtdClientTest, FlexibleType003, TestSize.Level1)
944 {
945     LOG_INFO(UDMF_TEST, "FlexibleType003 begin.");
946     std::string filenameExtension = ".mytext";
947     std::string blongsToType = "general.plain-text";
948     std::string flexTypeId;
949     auto status =
950         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
951     EXPECT_EQ(status, E_OK);
952     LOG_INFO(UDMF_TEST, "FlexibleType003, flexTypeId = %{public}s.", flexTypeId.c_str());
953     std::shared_ptr<TypeDescriptor> descriptor;
954     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
955     EXPECT_EQ(status, E_OK);
956     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
957     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
958     EXPECT_EQ(descriptor->GetDescription().empty(), true);
959     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
960     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
961     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
962     bool checkRet = false;
963     ASSERT_NE(descriptor, nullptr);
964     status = descriptor->IsHigherLevelType("general.invildType", checkRet);    //  cmp with invildType type.
965     EXPECT_EQ(status, E_INVALID_PARAMETERS);
966     EXPECT_EQ(checkRet, false);
967     LOG_INFO(UDMF_TEST, "FlexibleType003 end.");
968 }
969 
970 
971 /**
972 * @tc.name: FlexibleType011
973 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
974 * @tc.type: FUNC
975 */
976 HWTEST_F(UtdClientTest, FlexibleType011, TestSize.Level1)
977 {
978     LOG_INFO(UDMF_TEST, "FlexibleType011 begin.");
979     std::string filenameExtension = ".mytext";
980     std::string blongsToType = "general.plain-text";
981     std::string flexTypeId;
982     auto status =
983         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
984     EXPECT_EQ(status, E_OK);
985     LOG_INFO(UDMF_TEST, "FlexibleType011, flexTypeId = %{public}s.", flexTypeId.c_str());
986     std::shared_ptr<TypeDescriptor> descriptor;
987     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
988     EXPECT_EQ(status, E_OK);
989     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
990     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
991     EXPECT_EQ(descriptor->GetDescription().empty(), true);
992     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
993     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
994     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
995     bool checkRet = false;
996     ASSERT_NE(descriptor, nullptr);
997     status = descriptor->IsLowerLevelType("general.object", checkRet);
998     EXPECT_EQ(status, E_OK);
999     EXPECT_EQ(checkRet, true);
1000     LOG_INFO(UDMF_TEST, "FlexibleType011 end.");
1001 }
1002 
1003 /**
1004 * @tc.name: FlexibleType012
1005 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1006 * @tc.type: FUNC
1007 */
1008 HWTEST_F(UtdClientTest, FlexibleType012, TestSize.Level1)
1009 {
1010     LOG_INFO(UDMF_TEST, "FlexibleType012 begin.");
1011     std::string filenameExtension = ".mytext";
1012     std::string blongsToType = "general.plain-text";
1013     std::string flexTypeId;
1014     auto status =
1015         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1016     EXPECT_EQ(status, E_OK);
1017     LOG_INFO(UDMF_TEST, "FlexibleType012, flexTypeId = %{public}s.", flexTypeId.c_str());
1018     std::shared_ptr<TypeDescriptor> descriptor;
1019     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1020     EXPECT_EQ(status, E_OK);
1021     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1022     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1023     EXPECT_EQ(descriptor->GetDescription().empty(), true);
1024     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1025     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1026     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1027     bool checkRet = false;
1028     ASSERT_NE(descriptor, nullptr);
1029     status = descriptor->IsLowerLevelType("general.video", checkRet);
1030     EXPECT_EQ(status, E_OK);
1031     EXPECT_EQ(checkRet, false);
1032     LOG_INFO(UDMF_TEST, "FlexibleType012 end.");
1033 }
1034 
1035 /**
1036 * @tc.name: FlexibleType013
1037 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1038 * @tc.type: FUNC
1039 */
1040 HWTEST_F(UtdClientTest, FlexibleType013, TestSize.Level1)
1041 {
1042     LOG_INFO(UDMF_TEST, "FlexibleType013 begin.");
1043     std::string filenameExtension = ".mytext";
1044     std::string blongsToType = "general.plain-text";
1045     std::string flexTypeId1;
1046     auto status =
1047         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId1, blongsToType);
1048     EXPECT_EQ(status, E_OK);
1049     LOG_INFO(UDMF_TEST, "FlexibleType013, flexTypeId1 = %{public}s.", flexTypeId1.c_str());
1050     std::shared_ptr<TypeDescriptor> descriptor1;
1051     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId1, descriptor1);
1052     EXPECT_EQ(status, E_OK);
1053 
1054     std::string filenameExtension2 = ".myvideo";
1055     std::string blongsToType2 = "general.video";
1056     std::string flexTypeId2;
1057     status =
1058         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension2, flexTypeId2, blongsToType2);
1059     EXPECT_EQ(status, E_OK);
1060     LOG_INFO(UDMF_TEST, "FlexibleType013, flexTypeId2 = %{public}s.", flexTypeId2.c_str());
1061     bool checkRet = false;
1062     ASSERT_NE(descriptor1, nullptr);
1063     status = descriptor1->IsLowerLevelType(flexTypeId2, checkRet);   //  cmp with flexbile type.
1064     EXPECT_EQ(status, E_OK);
1065     EXPECT_EQ(checkRet, false);
1066     LOG_INFO(UDMF_TEST, "FlexibleType013 end.");
1067 }
1068 
1069 /**
1070 * @tc.name: FlexibleType014
1071 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1072 * @tc.type: FUNC
1073 */
1074 HWTEST_F(UtdClientTest, FlexibleType014, TestSize.Level1)
1075 {
1076     LOG_INFO(UDMF_TEST, "FlexibleType014 begin.");
1077     std::string filenameExtension = ".mytext";
1078     std::string blongsToType = "general.plain-text";
1079     std::string flexTypeId;
1080     auto status =
1081         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1082     EXPECT_EQ(status, E_OK);
1083     LOG_INFO(UDMF_TEST, "FlexibleType014, flexTypeId = %{public}s.", flexTypeId.c_str());
1084     std::shared_ptr<TypeDescriptor> descriptor;
1085     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1086     EXPECT_EQ(status, E_OK);
1087     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1088     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1089     EXPECT_EQ(descriptor->GetDescription().empty(), true);
1090     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1091     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1092     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1093     bool checkRet = false;
1094     ASSERT_NE(descriptor, nullptr);
1095     status = descriptor->IsLowerLevelType("general.invaildType", checkRet);   // cmp with invaild type.
1096     EXPECT_EQ(status, E_INVALID_PARAMETERS);
1097     EXPECT_EQ(checkRet, false);
1098     LOG_INFO(UDMF_TEST, "FlexibleType014 end.");
1099 }
1100 
1101 /**
1102 * @tc.name: FlexibleType021
1103 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1104 * @tc.type: FUNC
1105 */
1106 HWTEST_F(UtdClientTest, FlexibleType021, TestSize.Level1)
1107 {
1108     LOG_INFO(UDMF_TEST, "FlexibleType021 begin.");
1109     std::string filenameExtension = ".mytext";
1110     std::string blongsToType = "general.plain-text";
1111     std::string flexTypeId;
1112     auto status =
1113         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1114     EXPECT_EQ(status, E_OK);
1115     LOG_INFO(UDMF_TEST, "FlexibleType021, flexTypeId = %{public}s.", flexTypeId.c_str());
1116     std::shared_ptr<TypeDescriptor> descriptor;
1117     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1118     EXPECT_EQ(status, E_OK);
1119     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1120     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1121     EXPECT_EQ(descriptor->GetDescription().empty(), true);
1122     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1123     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1124     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1125     bool checkRet = false;
1126     ASSERT_NE(descriptor, nullptr);
1127     status = descriptor->BelongsTo("general.object", checkRet);
1128     EXPECT_EQ(status, E_OK);
1129     EXPECT_EQ(checkRet, true);
1130     LOG_INFO(UDMF_TEST, "FlexibleType021 end.");
1131 }
1132 
1133 /**
1134 * @tc.name: FlexibleType022
1135 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1136 * @tc.type: FUNC
1137 */
1138 HWTEST_F(UtdClientTest, FlexibleType022, TestSize.Level1)
1139 {
1140     LOG_INFO(UDMF_TEST, "FlexibleType022 begin.");
1141     std::string filenameExtension = ".mytext";
1142     std::string blongsToType = "general.plain-text";
1143     std::string flexTypeId;
1144     auto status =
1145         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1146     EXPECT_EQ(status, E_OK);
1147     LOG_INFO(UDMF_TEST, "FlexibleType022, flexTypeId = %{public}s.", flexTypeId.c_str());
1148     std::shared_ptr<TypeDescriptor> descriptor;
1149     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1150     EXPECT_EQ(status, E_OK);
1151     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1152     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1153     EXPECT_EQ(descriptor->GetDescription().empty(), true);
1154     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1155     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1156     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1157     bool checkRet = false;
1158     ASSERT_NE(descriptor, nullptr);
1159     status = descriptor->BelongsTo(flexTypeId, checkRet);   // cmp with self.
1160     EXPECT_EQ(status, E_OK);
1161     EXPECT_EQ(checkRet, true);
1162     LOG_INFO(UDMF_TEST, "FlexibleType022 end.");
1163 }
1164 
1165 /**
1166 * @tc.name: FlexibleType023
1167 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1168 * @tc.type: FUNC
1169 */
1170 HWTEST_F(UtdClientTest, FlexibleType023, TestSize.Level1)
1171 {
1172     LOG_INFO(UDMF_TEST, "FlexibleType023 begin.");
1173     std::string filenameExtension = ".mytext";
1174     std::string blongsToType = "general.plain-text";
1175     std::string flexTypeId1;
1176     auto status =
1177         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId1, blongsToType);
1178     EXPECT_EQ(status, E_OK);
1179     LOG_INFO(UDMF_TEST, "FlexibleType023, flexTypeId1 = %{public}s.", flexTypeId1.c_str());
1180     std::shared_ptr<TypeDescriptor> descriptor1;
1181     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId1, descriptor1);
1182     EXPECT_EQ(status, E_OK);
1183 
1184     std::string filenameExtension2 = ".myvideo";
1185     std::string blongsToType2 = "general.video";
1186     std::string flexTypeId2;
1187     status =
1188         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension2, flexTypeId2, blongsToType2);
1189     EXPECT_EQ(status, E_OK);
1190     LOG_INFO(UDMF_TEST, "FlexibleType023, flexTypeId2 = %{public}s.", flexTypeId2.c_str());
1191     bool checkRet = false;
1192     ASSERT_NE(descriptor1, nullptr);
1193     status = descriptor1->BelongsTo(flexTypeId2, checkRet);   //  cmp with flexbile type.
1194     EXPECT_EQ(status, E_OK);
1195     EXPECT_EQ(checkRet, false);
1196     LOG_INFO(UDMF_TEST, "FlexibleType023 end.");
1197 }
1198 
1199 
1200 /**
1201 * @tc.name: FlexibleType024
1202 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1203 * @tc.type: FUNC
1204 */
1205 HWTEST_F(UtdClientTest, FlexibleType024, TestSize.Level1)
1206 {
1207     LOG_INFO(UDMF_TEST, "FlexibleType024 begin.");
1208     std::string filenameExtension = ".mytext";
1209     std::string blongsToType = "general.plain-text";
1210     std::string flexTypeId;
1211     auto status =
1212         UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1213     EXPECT_EQ(status, E_OK);
1214     LOG_INFO(UDMF_TEST, "FlexibleType024, flexTypeId = %{public}s.", flexTypeId.c_str());
1215     std::shared_ptr<TypeDescriptor> descriptor;
1216     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1217     EXPECT_EQ(status, E_OK);
1218     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1219     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1220     EXPECT_EQ(descriptor->GetDescription().empty(), true);
1221     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1222     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1223     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1224     bool checkRet = false;
1225     ASSERT_NE(descriptor, nullptr);
1226     status = descriptor->BelongsTo("general.invaildType", checkRet);   // cmp with invaild type.
1227     EXPECT_EQ(status, E_INVALID_PARAMETERS);
1228     LOG_INFO(UDMF_TEST, "FlexibleType024 end.");
1229 }
1230 
1231 /**
1232 * @tc.name: IsUtd001
1233 * @tc.desc: IsUtd
1234 * @tc.type: FUNC
1235 */
1236 HWTEST_F(UtdClientTest, IsUtd001, TestSize.Level1)
1237 {
1238     LOG_INFO(UDMF_TEST, "IsUtd001 begin.");
1239     bool result = false;
1240     auto status = UtdClient::GetInstance().IsUtd("general.mp3", result);
1241     EXPECT_EQ(status, E_OK);
1242     EXPECT_EQ(result, true);
1243     status = UtdClient::GetInstance().IsUtd("com.amazon.azw3", result);
1244     EXPECT_EQ(status, E_OK);
1245     EXPECT_EQ(result, true);
1246     status = UtdClient::GetInstance().IsUtd("general.cer-certificate", result);
1247     EXPECT_EQ(status, E_OK);
1248     EXPECT_EQ(result, true);
1249     status = UtdClient::GetInstance().IsUtd("general.system", result);
1250     EXPECT_EQ(status, E_OK);
1251     EXPECT_EQ(result, true);
1252     status = UtdClient::GetInstance().IsUtd("com.example.demo.mytype-azw3", result);
1253     EXPECT_EQ(status, E_OK);
1254     EXPECT_EQ(result, true);
1255     status = UtdClient::GetInstance().IsUtd("com.example.demo.mytype", result);
1256     EXPECT_EQ(status, E_OK);
1257     EXPECT_EQ(result, true);
1258     status = UtdClient::GetInstance().IsUtd("com.example.demo.mytype3", result);
1259     EXPECT_EQ(status, E_OK);
1260     EXPECT_EQ(result, true);
1261     status = UtdClient::GetInstance().IsUtd("com.example.demo2.mytype3", result);
1262     EXPECT_EQ(status, E_OK);
1263     EXPECT_EQ(result, true);
1264     status = UtdClient::GetInstance().IsUtd("system.haha", result);
1265     EXPECT_EQ(status, E_OK);
1266     EXPECT_EQ(result, false);
1267     status = UtdClient::GetInstance().IsUtd("hello.text", result);
1268     EXPECT_EQ(status, E_OK);
1269     EXPECT_EQ(result, false);
1270     std::vector<TypeDescriptorCfg> allUTD = PresetTypeDescriptors::GetInstance().GetPresetTypes();
1271     for (auto item : allUTD) {
1272         status = UtdClient::GetInstance().IsUtd(item.typeId, result);
1273         EXPECT_EQ(status, E_OK);
1274         if (!result) {
1275             LOG_ERROR(UDMF_TEST, "IsUtd001 item is %{public}s is check fail. ", item.typeId.c_str());
1276         }
1277         EXPECT_EQ(result, true);
1278     }
1279     LOG_INFO(UDMF_TEST, "IsUtd001 end.");
1280 }
1281 
1282 /**
1283 * @tc.name: IsUtd002
1284 * @tc.desc: IsUtd
1285 * @tc.type: FUNC
1286 */
1287 HWTEST_F(UtdClientTest, IsUtd002, TestSize.Level1)
1288 {
1289     LOG_INFO(UDMF_TEST, "IsUtd002 begin.");
1290     bool result = false;
1291     auto status = UtdClient::GetInstance().IsUtd("BROWSER", result);
1292     EXPECT_EQ(status, E_OK);
1293     EXPECT_EQ(result, false);
1294     status = UtdClient::GetInstance().IsUtd("IMAGE", result);
1295     EXPECT_EQ(status, E_OK);
1296     EXPECT_EQ(result, false);
1297     status = UtdClient::GetInstance().IsUtd("AUDIO", result);
1298     EXPECT_EQ(status, E_OK);
1299     EXPECT_EQ(result, false);
1300     status = UtdClient::GetInstance().IsUtd("VIDEO", result);
1301     EXPECT_EQ(status, E_OK);
1302     EXPECT_EQ(result, false);
1303     status = UtdClient::GetInstance().IsUtd("PDF", result);
1304     EXPECT_EQ(status, E_OK);
1305     EXPECT_EQ(result, false);
1306     status = UtdClient::GetInstance().IsUtd("WORD", result);
1307     EXPECT_EQ(status, E_OK);
1308     EXPECT_EQ(result, false);
1309     status = UtdClient::GetInstance().IsUtd("EXCEL", result);
1310     EXPECT_EQ(status, E_OK);
1311     EXPECT_EQ(result, false);
1312     status = UtdClient::GetInstance().IsUtd("PPT", result);
1313     EXPECT_EQ(status, E_OK);
1314     EXPECT_EQ(result, false);
1315     status = UtdClient::GetInstance().IsUtd("EMAIL", result);
1316     EXPECT_EQ(status, E_OK);
1317     EXPECT_EQ(result, false);
1318     status = UtdClient::GetInstance().IsUtd("txt", result);
1319     EXPECT_EQ(status, E_OK);
1320     EXPECT_EQ(result, false);
1321     status = UtdClient::GetInstance().IsUtd("abcdef", result);
1322     EXPECT_EQ(status, E_OK);
1323     EXPECT_EQ(result, false);
1324     LOG_INFO(UDMF_TEST, "IsUtd002 end.");
1325 }
1326 
1327 /**
1328 * @tc.name: IsUtd003
1329 * @tc.desc: IsUtd
1330 * @tc.type: FUNC
1331 */
1332 HWTEST_F(UtdClientTest, IsUtd003, TestSize.Level1)
1333 {
1334     LOG_INFO(UDMF_TEST, "IsUtd003 begin.");
1335     bool result = false;
1336     auto status = UtdClient::GetInstance().IsUtd("*/*", result);
1337     EXPECT_EQ(status, E_OK);
1338     EXPECT_EQ(result, false);
1339     status = UtdClient::GetInstance().IsUtd("text/*", result);
1340     EXPECT_EQ(status, E_OK);
1341     EXPECT_EQ(result, false);
1342     status = UtdClient::GetInstance().IsUtd("image/*", result);
1343     EXPECT_EQ(status, E_OK);
1344     EXPECT_EQ(result, false);
1345     status = UtdClient::GetInstance().IsUtd("video/*", result);
1346     EXPECT_EQ(status, E_OK);
1347     EXPECT_EQ(result, false);
1348     status = UtdClient::GetInstance().IsUtd("audio/*", result);
1349     EXPECT_EQ(status, E_OK);
1350     EXPECT_EQ(result, false);
1351     status = UtdClient::GetInstance().IsUtd("audio/aiff", result);
1352     EXPECT_EQ(status, E_OK);
1353     EXPECT_EQ(result, false);
1354     LOG_INFO(UDMF_TEST, "IsUtd001 end.");
1355 }
1356 
1357 /**
1358 * @tc.name: IsUtd004
1359 * @tc.desc: IsUtd
1360 * @tc.type: FUNC
1361 */
1362 HWTEST_F(UtdClientTest, IsUtd004, TestSize.Level1)
1363 {
1364     LOG_INFO(UDMF_TEST, "IsUtd004 begin.");
1365     bool result = false;
1366     auto status = UtdClient::GetInstance().IsUtd(".TXT", result);
1367     EXPECT_EQ(status, E_OK);
1368     EXPECT_EQ(result, false);
1369     status = UtdClient::GetInstance().IsUtd(".MP3", result);
1370     EXPECT_EQ(status, E_OK);
1371     EXPECT_EQ(result, false);
1372     status = UtdClient::GetInstance().IsUtd(".3gp", result);
1373     EXPECT_EQ(status, E_OK);
1374     EXPECT_EQ(result, false);
1375     status = UtdClient::GetInstance().IsUtd(".txt", result);
1376     EXPECT_EQ(status, E_OK);
1377     EXPECT_EQ(result, false);
1378     status = UtdClient::GetInstance().IsUtd(".TXT", result);
1379     EXPECT_EQ(status, E_OK);
1380     EXPECT_EQ(result, false);
1381     status = UtdClient::GetInstance().IsUtd(".MP3", result);
1382     EXPECT_EQ(status, E_OK);
1383     EXPECT_EQ(result, false);
1384     status = UtdClient::GetInstance().IsUtd(".3gp", result);
1385     EXPECT_EQ(status, E_OK);
1386     EXPECT_EQ(result, false);
1387     status = UtdClient::GetInstance().IsUtd("abcdef", result);
1388     EXPECT_EQ(status, E_OK);
1389     EXPECT_EQ(result, false);
1390     LOG_INFO(UDMF_TEST, "IsUtd004 end.");
1391 }
1392 
1393 /**
1394 * @tc.name: GetUniformDataTypeByMIMETypeByPrefix001
1395 * @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
1396 * @tc.type: FUNC
1397 */
1398 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix001, TestSize.Level1)
1399 {
1400     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix001 begin.");
1401     std::string mimeType = "application/vnd.openxmlformats-officedocument.*";
1402     std::string currType;
1403     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
1404     EXPECT_EQ(status, E_OK);
1405     std::shared_ptr<TypeDescriptor> descriptor;
1406     status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
1407     EXPECT_EQ(status, E_OK);
1408     EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1409     EXPECT_EQ(descriptor->GetTypeId(), currType);
1410 
1411     std::string mimeType2 = "application/vnd.openxmlformats-officedocument.wordprocessingml.*";
1412     std::string currType2;
1413     status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType2, currType2);
1414     EXPECT_EQ(status, E_OK);
1415     status = UtdClient::GetInstance().GetTypeDescriptor(currType2, descriptor);
1416     EXPECT_EQ(status, E_OK);
1417     EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1418     EXPECT_EQ(descriptor->GetTypeId(), currType2);
1419     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix001 end.");
1420 }
1421 
1422 /**
1423 * @tc.name: GetUniformDataTypeByMIMETypeByPrefix002
1424 * @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
1425 * @tc.type: FUNC
1426 */
1427 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix002, TestSize.Level1)
1428 {
1429     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix002 begin.");
1430     std::string mimeType = "application/vnd.openxmlformats-OFFICEdocument.*";
1431     std::string currType;
1432     auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
1433     EXPECT_EQ(status, E_OK);
1434     std::shared_ptr<TypeDescriptor> descriptor;
1435     status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
1436     EXPECT_EQ(status, E_OK);
1437     EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1438     EXPECT_EQ(descriptor->GetTypeId(), currType);
1439 
1440     std::string mimeType2 = "application/vnd.openxmlformats-OFFICEdocument.wordprocessingml.*";
1441     std::string currType2;
1442     status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType2, currType2);
1443     EXPECT_EQ(status, E_OK);
1444     status = UtdClient::GetInstance().GetTypeDescriptor(currType2, descriptor);
1445     EXPECT_EQ(status, E_OK);
1446     EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1447     EXPECT_EQ(descriptor->GetTypeId(), currType2);
1448     LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix002 end.");
1449 }
1450 
1451 /**
1452 * @tc.name: GetUniformDataTypesByFilenameExtension001
1453 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, if filtered by blongsToType
1454 * @tc.type: FUNC
1455 */
1456 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension001, TestSize.Level1)
1457 {
1458     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension001 begin.");
1459     std::string filenameExtension = ".azw3";
1460     std::string blongsToType = "general.ebook";
1461     std::vector<std::string> currTypes;
1462     auto status =
1463         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes);
1464     ASSERT_EQ(status, E_OK);
1465     ASSERT_EQ(currTypes.size(), 1);
1466     ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1467 
1468     status =
1469         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1470     ASSERT_EQ(status, E_OK);
1471     ASSERT_EQ(currTypes.size(), 1);
1472     ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1473     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension001 end.");
1474 }
1475 
1476 /**
1477 * @tc.name: GetUniformDataTypesByFilenameExtension002
1478 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension
1479 * @tc.type: FUNC
1480 */
1481 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension002, TestSize.Level1)
1482 {
1483     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension002 begin.");
1484     std::string filenameExtension = ".ts";
1485     std::vector<std::string> currTypes;
1486     auto status =
1487         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes);
1488     ASSERT_EQ(status, E_OK);
1489     ASSERT_EQ(currTypes.size(), 2);
1490     auto find1 = std::find(currTypes.begin(), currTypes.end(), "general.type-script") != currTypes.end();
1491     auto find2 = std::find(currTypes.begin(), currTypes.end(), "general.ts") != currTypes.end();
1492     ASSERT_EQ(find1, true);
1493     ASSERT_EQ(find2, true);
1494     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension002 end.");
1495 }
1496 
1497 /**
1498 * @tc.name: GetUniformDataTypesByFilenameExtension003
1499 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, if filtered by blongsToType
1500 * @tc.type: FUNC
1501 */
1502 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension003, TestSize.Level1)
1503 {
1504     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension003 begin.");
1505     std::string filenameExtension = ".ts";
1506     std::vector<std::string> currTypes;
1507     std::string blongsToType = "general.text";
1508     auto status =
1509         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1510     ASSERT_EQ(status, E_OK);
1511     ASSERT_EQ(currTypes.size(), 1);
1512     ASSERT_EQ(currTypes[0], "general.type-script");
1513 
1514     blongsToType = "general.video";
1515     status =
1516         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1517     ASSERT_EQ(status, E_OK);
1518     ASSERT_EQ(currTypes.size(), 1);
1519     ASSERT_EQ(currTypes[0], "general.ts");
1520 
1521     blongsToType = "general.shell-script";
1522     status =
1523         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1524     ASSERT_EQ(status, E_OK);
1525     ASSERT_EQ(currTypes.size(), 1);
1526     ASSERT_EQ(currTypes[0].rfind("flex.z", 0), 0);
1527     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension003 end.");
1528 }
1529 
1530 /**
1531 * @tc.name: GetUniformDataTypesByFilenameExtension004
1532 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension with flexibleType
1533 * @tc.type: FUNC
1534 */
1535 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension004, TestSize.Level1)
1536 {
1537     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004 begin.");
1538     std::string filenameExtension = ".mytext";
1539     std::string blongsToType = "general.plain-text";
1540     std::vector<std::string> flexTypeIds;
1541     auto status =
1542         UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, flexTypeIds, blongsToType);
1543     EXPECT_EQ(status, E_OK);
1544     ASSERT_EQ(flexTypeIds.size(), 1);
1545     std::string flexTypeId = flexTypeIds[0];
1546     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004, flexTypeId = %{public}s.", flexTypeId.c_str());
1547     std::shared_ptr<TypeDescriptor> descriptor;
1548     status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1549     EXPECT_EQ(status, E_OK);
1550     EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1551     EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1552     EXPECT_EQ(descriptor->GetDescription().empty(), true);
1553     EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1554     EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1555     EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1556     bool checkRet = false;
1557     ASSERT_NE(descriptor, nullptr);
1558     status = descriptor->IsHigherLevelType("general.object", checkRet);    //  cmp with gengral type.
1559     EXPECT_EQ(status, E_OK);
1560     EXPECT_EQ(checkRet, false);
1561     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004 end.");
1562 }
1563 
1564 /**
1565 * @tc.name: GetUniformDataTypesByMIMEType001
1566 * @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
1567 * @tc.type: FUNC
1568 */
1569 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType001, TestSize.Level1)
1570 {
1571     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType001 begin.");
1572     std::string mimeType = "application/x-mobi8-ebook";
1573     std::string blongsToType = "general.ebook";
1574     std::vector<std::string> currTypes;
1575     auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
1576     ASSERT_EQ(status, E_OK);
1577     ASSERT_EQ(currTypes.size(), 1);
1578     ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1579 
1580     status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1581     ASSERT_EQ(status, E_OK);
1582     ASSERT_EQ(currTypes.size(), 1);
1583     ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1584     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType001 end.");
1585 }
1586 
1587 /**
1588 * @tc.name: GetUniformDataTypesByMIMEType002
1589 * @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
1590 * @tc.type: FUNC
1591 */
1592 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType002, TestSize.Level1)
1593 {
1594     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType002 begin.");
1595     std::string mimeType = "application/msword";
1596     std::vector<std::string> currTypes;
1597     std::string blongsToType = "general.composite-object";
1598     auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
1599     ASSERT_EQ(status, E_OK);
1600     ASSERT_EQ(currTypes.size(), 2);
1601     auto find1 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.doc") != currTypes.end();
1602     auto find2 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.dot") != currTypes.end();
1603     ASSERT_EQ(find1, true);
1604     ASSERT_EQ(find2, true);
1605 
1606     status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1607     ASSERT_EQ(status, E_OK);
1608     ASSERT_EQ(currTypes.size(), 2);
1609     find1 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.doc") != currTypes.end();
1610     find2 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.dot") != currTypes.end();
1611     ASSERT_EQ(find1, true);
1612     ASSERT_EQ(find2, true);
1613     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType002 end.");
1614 }
1615 
1616 /**
1617 * @tc.name: GetUniformDataTypesByMIMEType003
1618 * @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
1619 * @tc.type: FUNC
1620 */
1621 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType003, TestSize.Level1)
1622 {
1623     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType003 begin.");
1624     std::string mimeType = "video/x-ms-asf";
1625     std::vector<std::string> currTypes;
1626     std::string blongsToType = "general.media";
1627     auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1628     ASSERT_EQ(status, E_OK);
1629     ASSERT_EQ(currTypes.size(), 2);
1630     auto find1 = std::find(currTypes.begin(), currTypes.end(),
1631                            "com.microsoft.advanced-systems-format") != currTypes.end();
1632     auto find2 = std::find(currTypes.begin(), currTypes.end(),
1633                            "com.microsoft.advanced-stream-redirector") != currTypes.end();
1634     ASSERT_EQ(find1, true);
1635     ASSERT_EQ(find2, true);
1636 
1637     blongsToType = "general.video";
1638     status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1639     ASSERT_EQ(status, E_OK);
1640     ASSERT_EQ(currTypes.size(), 1);
1641     ASSERT_EQ(currTypes[0], "com.microsoft.advanced-stream-redirector");
1642 
1643     blongsToType = "general.text";
1644     status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1645     ASSERT_EQ(status, E_OK);
1646     ASSERT_EQ(currTypes.size(), 1);
1647     ASSERT_EQ(currTypes[0].rfind("flex.z", 0), 0);
1648     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType003 end.");
1649 }
1650 
1651 /**
1652 * @tc.name: GetUniformDataTypesByMIMETypeByPrefix001
1653 * @tc.desc: normal testcase of GetUniformDatasTypeByMIMEType by prefix.
1654 * @tc.type: FUNC
1655 */
1656 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMETypeByPrefix001, TestSize.Level1)
1657 {
1658     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeByPrefix001 begin.");
1659     std::string mimeType = "model/*";
1660     std::vector<std::string> currTypes;
1661     auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
1662     ASSERT_EQ(status, E_OK);
1663     ASSERT_EQ(currTypes.size(), 3);
1664     auto find1 = std::find(currTypes.begin(), currTypes.end(), "general.iges") != currTypes.end();
1665     auto find2 = std::find(currTypes.begin(), currTypes.end(), "general.mesh-model") != currTypes.end();
1666     auto find3 = std::find(currTypes.begin(), currTypes.end(), "com.autodesk.dwf") != currTypes.end();
1667     ASSERT_EQ(find1, true);
1668     ASSERT_EQ(find2, true);
1669     ASSERT_EQ(find3, true);
1670     LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeByPrefix001 end.");
1671 }
1672 } // OHOS::Test