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