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 #include <thread>
20
21 #include "token_setproc.h"
22 #include "accesstoken_kit.h"
23 #include "nativetoken_kit.h"
24
25 #include "logger.h"
26 #include "utd_client.h"
27 #include "type_descriptor.h"
28 #include "preset_type_descriptors.h"
29 #include "utd_graph.h"
30 #include "custom_utd_store.h"
31
32 using namespace testing::ext;
33 using namespace OHOS::Security::AccessToken;
34 using namespace OHOS::UDMF;
35 using namespace OHOS;
36
37 namespace OHOS::Test {
38 constexpr const int64_t SLEEP_INTERVAL = 12;
39 constexpr const int32_t USERID = 100;
40 constexpr const char *FLEXIBLE_TYPE_FLAG = "flex.z";
41 class UtdClientTest : public testing::Test {
42 public:
43 static void SetUpTestCase();
44 static void TearDownTestCase();
45 void SetUp() override;
46 void TearDown() override;
47 static bool TryReloadCustomUtdTest();
48 };
49
SetUpTestCase()50 void UtdClientTest::SetUpTestCase()
51 {
52 }
53
TearDownTestCase()54 void UtdClientTest::TearDownTestCase()
55 {
56 }
57
SetUp()58 void UtdClientTest::SetUp()
59 {
60 }
61
TearDown()62 void UtdClientTest::TearDown()
63 {
64 }
65
66 /**
67 * @tc.name: GetTypeDescriptor001
68 * @tc.desc: Normal testcase of GetTypeDescriptor
69 * @tc.type: FUNC
70 */
71 HWTEST_F(UtdClientTest, GetTypeDescriptor001, TestSize.Level1)
72 {
73 LOG_INFO(UDMF_TEST, "GetTypeDescriptor001 begin.");
74
75 std::shared_ptr<TypeDescriptor> descriptor;
76 std::string typeId = "com.amazon.azw3";
77 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
78 EXPECT_EQ(status, E_OK);
79 EXPECT_EQ(descriptor->GetTypeId(), typeId);
80 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.ebook");
81 EXPECT_EQ(descriptor->GetDescription(), "AZW3 ebook.");
82 EXPECT_EQ(descriptor->GetIconFile(), "");
83 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".azw3");
84 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "application/vnd.amazon.mobi8-ebook");
85 LOG_INFO(UDMF_TEST, "GetTypeDescriptor001 end.");
86 }
87
88 /**
89 * @tc.name: GetTypeDescriptor002
90 * @tc.desc: Negative test case, invalid typeId argument, returns nullptr
91 * @tc.type: FUNC
92 */
93 HWTEST_F(UtdClientTest, GetTypeDescriptor002, TestSize.Level1)
94 {
95 LOG_INFO(UDMF_TEST, "GetTypeDescriptor002 begin.");
96
97 std::shared_ptr<TypeDescriptor> descriptor;
98 std::string typeId = "";
99 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
100 EXPECT_EQ(status, E_OK);
101 EXPECT_EQ(descriptor, nullptr);
102 LOG_INFO(UDMF_TEST, "GetTypeDescriptor002 end.");
103 }
104
105 /**
106 * @tc.name: GetTypeDescriptor003
107 * @tc.desc: Negative test case, invalid typeId argument, returns nullptr
108 * @tc.type: FUNC
109 */
110 HWTEST_F(UtdClientTest, GetTypeDescriptor003, TestSize.Level1)
111 {
112 LOG_INFO(UDMF_TEST, "GetTypeDescriptor003 begin.");
113
114 std::shared_ptr<TypeDescriptor> descriptor;
115 std::string typeId = "12345";
116 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
117 EXPECT_EQ(status, E_OK);
118 EXPECT_EQ(descriptor, nullptr);
119 LOG_INFO(UDMF_TEST, "GetTypeDescriptor003 end.");
120 }
121
122 /**
123 * @tc.name: GetTypeDescriptor004
124 * @tc.desc: Normal testcase of GetTypeDescriptor
125 * @tc.type: FUNC
126 */
127 HWTEST_F(UtdClientTest, GetTypeDescriptor004, TestSize.Level1)
128 {
129 LOG_INFO(UDMF_TEST, "GetTypeDescriptor004 begin.");
130
131 std::shared_ptr<TypeDescriptor> descriptor;
132 std::string typeId = "org.gnu.gnu-zip-archive";
133 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
134 EXPECT_EQ(status, E_OK);
135 EXPECT_EQ(descriptor->GetTypeId(), typeId);
136 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.archive");
137 EXPECT_EQ(descriptor->GetDescription(), "Gzip archive.");
138 EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_compress");
139 LOG_INFO(UDMF_TEST, "GetTypeDescriptor004 end.");
140 }
141
142 /**
143 * @tc.name: GetTypeDescriptor005
144 * @tc.desc: Negative test case, invalid typeId argument, returns nullptr
145 * @tc.type: FUNC
146 */
147 HWTEST_F(UtdClientTest, GetTypeDescriptor005, TestSize.Level1)
148 {
149 LOG_INFO(UDMF_TEST, "GetTypeDescriptor005 begin.");
150
151 std::shared_ptr<TypeDescriptor> descriptor;
152 std::string typeId = "...";
153 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
154 EXPECT_EQ(status, E_OK);
155 EXPECT_EQ(descriptor, nullptr);
156 LOG_INFO(UDMF_TEST, "GetTypeDescriptor005 end.");
157 }
158
159 /**
160 * @tc.name: GetTypeDescriptor006
161 * @tc.desc: Normal testcase of GetTypeDescriptor
162 * @tc.type: FUNC
163 */
164 HWTEST_F(UtdClientTest, GetTypeDescriptor006, TestSize.Level1)
165 {
166 LOG_INFO(UDMF_TEST, "GetTypeDescriptor006 begin.");
167
168 std::shared_ptr<TypeDescriptor> descriptor;
169 std::string typeId = "general.fax";
170 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
171 EXPECT_EQ(status, E_OK);
172 EXPECT_EQ(descriptor->GetTypeId(), typeId);
173 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.image");
174 EXPECT_EQ(descriptor->GetDescription(), "Base type for fax images.");
175 EXPECT_EQ(descriptor->GetIconFile(), "");
176 EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
177 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
178 LOG_INFO(UDMF_TEST, "GetTypeDescriptor006 end.");
179 }
180
181 /**
182 * @tc.name: GetUniformDataTypeByFilenameExtension001
183 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
184 * @tc.type: FUNC
185 */
186 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension001, TestSize.Level1)
187 {
188 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension001 begin.");
189 std::string filenameExtension = ".azw3";
190 std::string blongsToType = "general.ebook";
191 std::string currType;
192 auto status =
193 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
194 EXPECT_EQ(status, E_OK);
195 EXPECT_EQ(currType, "com.amazon.azw3");
196 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension001 end.");
197 }
198
199 /**
200 * @tc.name: GetUniformDataTypeByFilenameExtension002
201 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
202 * @tc.type: FUNC
203 */
204 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension002, TestSize.Level1)
205 {
206 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension002 begin.");
207 std::string filenameExtension = ".png";
208 std::string blongsToType = "general.image";
209 std::string currType;
210 auto status =
211 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
212 EXPECT_EQ(status, E_OK);
213 EXPECT_EQ(currType, "general.png");
214 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension002 end.");
215 }
216
217 /**
218 * @tc.name: GetUniformDataTypeByFilenameExtension003
219 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
220 * @tc.type: FUNC
221 */
222 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension003, TestSize.Level1)
223 {
224 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension003 begin.");
225 std::string filenameExtension = ".cpp";
226 std::string blongsToType = "general.source-code";
227 std::string currType;
228 auto status =
229 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
230 EXPECT_EQ(status, E_OK);
231 EXPECT_EQ(currType, "general.c-plus-plus-source");
232 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension003 end.");
233 }
234
235 /**
236 * @tc.name: GetUniformDataTypeByFilenameExtension004
237 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, para empty string, return E_INVALID_PARAMETERS
238 * @tc.type: FUNC
239 */
240 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension004, TestSize.Level1)
241 {
242 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension004 begin.");
243 std::string filenameExtension = "";
244 std::string blongsToType = "general.plain-text";
245 std::string currType;
246 auto status =
247 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
248 EXPECT_EQ(status, E_INVALID_PARAMETERS);
249 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension004 end.");
250 }
251
252 /**
253 * @tc.name: GetUniformDataTypeByFilenameExtension005
254 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, return invalid parameter
255 * @tc.type: FUNC
256 */
257 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension005, TestSize.Level1)
258 {
259 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension005 begin.");
260 std::string filenameExtension = ".test";
261 std::string blongsToType = "general.test";
262 std::string currType;
263 auto status =
264 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
265 EXPECT_EQ(status, E_INVALID_PARAMETERS);
266 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension005 end.");
267 }
268
269 /**
270 * @tc.name: GetUniformDataTypeByFilenameExtension006
271 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension
272 * @tc.type: FUNC
273 */
274 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension006, TestSize.Level1)
275 {
276 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension006 begin.");
277 std::string filenameExtension = ".mp3";
278 std::string blongsToType = "general.object";
279 std::string currType;
280 auto status =
281 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
282 EXPECT_EQ(status, E_OK);
283 EXPECT_EQ(currType, "general.mp3");
284 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension006 end.");
285 }
286
287 /**
288 * @tc.name: GetUniformDataTypeByFilenameExtension007
289 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, return invalid parameter
290 * @tc.type: FUNC
291 */
292 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension007, TestSize.Level1)
293 {
294 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension007 begin.");
295 std::string filenameExtension = ".mp3";
296 std::string blongsToType = "test";
297 std::string currType;
298 auto status =
299 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
300 EXPECT_EQ(status, E_INVALID_PARAMETERS);
301 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension007 end.");
302 }
303
304
305 /**
306 * @tc.name: GetUniformDataTypeByFilenameExtension008
307 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, return flexible type.
308 * @tc.type: FUNC
309 */
310 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtension008, TestSize.Level1)
311 {
312 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension008 begin.");
313 std::string filenameExtension = ".auto-image";
314 std::string blongsToType = "general.image";
315 std::string currType;
316 auto status =
317 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, currType, blongsToType);
318 EXPECT_EQ(status, E_OK);
319 std::shared_ptr<TypeDescriptor> descriptor;
320 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
321 EXPECT_EQ(status, E_OK);
322 EXPECT_EQ(descriptor->GetTypeId(), currType);
323 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.image");
324 EXPECT_EQ(descriptor->GetDescription().empty(), true);
325 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
326 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".auto-image");
327 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
328 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtension008 end.");
329 }
330
331 /**
332 * @tc.name: GetUniformDataTypeByMIMEType001
333 * @tc.desc: Normal testcase of GetUniformDataTypeByMIMEType
334 * @tc.type: FUNC
335 */
336 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType001, TestSize.Level1)
337 {
338 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType001 begin.");
339 std::string mimeType = "application/x-mobi8-ebook";
340 std::string blongsToType = "general.ebook";
341 std::string currType;
342 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
343 EXPECT_EQ(status, E_OK);
344 EXPECT_EQ(currType, "com.amazon.azw3");
345 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType001 end.");
346 }
347
348 /**
349 * @tc.name: GetUniformDataTypeByMIMEType002
350 * @tc.desc: Normal testcase of GetUniformDataTypeByMIMEType
351 * @tc.type: FUNC
352 */
353 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType002, TestSize.Level1)
354 {
355 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType002 begin.");
356 std::string mimeType = "application/vnd.ms-powerpoint";
357 std::string blongsToType = "general.composite-object";
358 std::string currType;
359 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
360 EXPECT_EQ(status, E_OK);
361 EXPECT_EQ(currType, "com.microsoft.powerpoint.ppt");
362 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType002 end.");
363 }
364
365 /**
366 * @tc.name: GetUniformDataTypeByMIMEType003
367 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType, return invalid parameter
368 * @tc.type: FUNC
369 */
370 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType003, TestSize.Level1)
371 {
372 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType003 begin.");
373 std::string mimeType = "test01";
374 std::string blongsToType = "";
375 std::string currType;
376 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
377 EXPECT_EQ(status, E_INVALID_PARAMETERS);
378 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType003 end.");
379 }
380
381 /**
382 * @tc.name: GetUniformDataTypeByMIMEType004
383 * @tc.desc: BelongsTo is invalid, return invalid parameter
384 * @tc.type: FUNC
385 */
386 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType004, TestSize.Level1)
387 {
388 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType004 begin.");
389 std::string mimeType = "";
390 std::string blongsToType = "test02";
391 std::string currType;
392 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
393 EXPECT_EQ(status, E_INVALID_PARAMETERS);
394 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType004 end.");
395 }
396
397 /**
398 * @tc.name: GetUniformDataTypeByMIMEType005
399 * @tc.desc: BelongsTo is invalid, return invalid parameter
400 * @tc.type: FUNC
401 */
402 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType005, TestSize.Level1)
403 {
404 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType005 begin.");
405 std::string mimeType = ".pm";
406 std::string blongsToType = "test03";
407 std::string currType;
408 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
409 EXPECT_EQ(status, E_INVALID_PARAMETERS);
410 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType005 end.");
411 }
412
413 /**
414 * @tc.name: GetUniformDataTypeByMIMEType006
415 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType, para empty string, return E_INVALID_PARAMETERS
416 * @tc.type: FUNC
417 */
418 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType006, TestSize.Level1)
419 {
420 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType006 begin.");
421 std::string mimeType = "";
422 std::string blongsToType = "general.entity";
423 std::string currType;
424 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
425 EXPECT_EQ(status, E_INVALID_PARAMETERS);
426 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType006 end.");
427 }
428
429 /**
430 * @tc.name: GetUniformDataTypeByMIMEType007
431 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType, return flexible type.
432 * @tc.type: FUNC
433 */
434 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMEType007, TestSize.Level1)
435 {
436 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType007 begin.");
437 std::string mimeType = "image/auto-image";
438 std::string blongsToType = "general.image";
439 std::string currType;
440 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
441 EXPECT_EQ(status, E_OK);
442 std::shared_ptr<TypeDescriptor> descriptor;
443 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
444 EXPECT_EQ(status, E_OK);
445 EXPECT_EQ(descriptor->GetTypeId(), currType);
446 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.image");
447 EXPECT_EQ(descriptor->GetDescription().empty(), true);
448 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
449 EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
450 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "image/auto-image");
451 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMEType007 end.");
452 }
453
454 /**
455 * @tc.name: BelongsTo001
456 * @tc.desc: Normal testcase of BelongsTo
457 * @tc.type: FUNC
458 */
459 HWTEST_F(UtdClientTest, BelongsTo001, TestSize.Level1)
460 {
461 LOG_INFO(UDMF_TEST, "BelongsTo001 begin.");
462 std::shared_ptr<TypeDescriptor> descriptor;
463 std::string typeId = "com.amazon.azw3";
464 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
465 EXPECT_EQ(status, E_OK);
466 bool checkRet = false;
467 ASSERT_NE(descriptor, nullptr);
468 status = descriptor->BelongsTo("general.composite-object", checkRet);
469 EXPECT_EQ(status, E_OK);
470 EXPECT_EQ(checkRet, true);
471 LOG_INFO(UDMF_TEST, "BelongsTo001 end.");
472 }
473
474 /**
475 * @tc.name: BelongsTo002
476 * @tc.desc: Normal testcase of BelongsTo
477 * @tc.type: FUNC
478 */
479 HWTEST_F(UtdClientTest, BelongsTo002, TestSize.Level1)
480 {
481 LOG_INFO(UDMF_TEST, "BelongsTo002 begin.");
482 std::shared_ptr<TypeDescriptor> descriptor;
483 std::string typeId = "com.amazon.azw3";
484 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
485 EXPECT_EQ(status, E_OK);
486 bool checkRet = false;
487 ASSERT_NE(descriptor, nullptr);
488 status = descriptor->BelongsTo(typeId, checkRet);
489 EXPECT_EQ(status, E_OK);
490 EXPECT_EQ(checkRet, true);
491 LOG_INFO(UDMF_TEST, "BelongsTo002 end.");
492 }
493
494 /**
495 * @tc.name: BelongsTo003
496 * @tc.desc: Normal testcase of BelongsTo
497 * @tc.type: FUNC
498 */
499 HWTEST_F(UtdClientTest, BelongsTo003, TestSize.Level1)
500 {
501 LOG_INFO(UDMF_TEST, "BelongsTo003 begin.");
502 std::shared_ptr<TypeDescriptor> descriptor;
503 std::string typeId = "general.tiff";
504 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
505 EXPECT_EQ(status, E_OK);
506 bool checkRet = false;
507 ASSERT_NE(descriptor, nullptr);
508 status = descriptor->BelongsTo("general.media", checkRet);
509 EXPECT_EQ(status, E_OK);
510 EXPECT_EQ(checkRet, true);
511 LOG_INFO(UDMF_TEST, "BelongsTo003 end.");
512 }
513
514 /**
515 * @tc.name: BelongsTo004
516 * @tc.desc: Normal testcase of BelongsTo
517 * @tc.type: FUNC
518 */
519 HWTEST_F(UtdClientTest, BelongsTo004, TestSize.Level1)
520 {
521 LOG_INFO(UDMF_TEST, "BelongsTo004 begin.");
522 std::shared_ptr<TypeDescriptor> descriptor;
523 std::string typeId = "general.tiff";
524 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
525 EXPECT_EQ(status, E_OK);
526 bool checkRet = false;
527 ASSERT_NE(descriptor, nullptr);
528 status = descriptor->BelongsTo("general.object", checkRet);
529 EXPECT_EQ(status, E_OK);
530 EXPECT_EQ(checkRet, true);
531 LOG_INFO(UDMF_TEST, "BelongsTo004 end.");
532 }
533
534 /**
535 * @tc.name: BelongsTo005
536 * @tc.desc: Abnormal testcase of BelongsTo
537 * @tc.type: FUNC
538 */
539 HWTEST_F(UtdClientTest, BelongsTo005, TestSize.Level1)
540 {
541 LOG_INFO(UDMF_TEST, "BelongsTo005 begin.");
542 std::shared_ptr<TypeDescriptor> descriptor;
543 std::string typeId = "general.c-header";
544 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
545 EXPECT_EQ(status, E_OK);
546 bool checkRet = false;
547 ASSERT_NE(descriptor, nullptr);
548 status = descriptor->BelongsTo("general.script", checkRet);
549 EXPECT_EQ(status, E_OK);
550 EXPECT_EQ(checkRet, false);
551 LOG_INFO(UDMF_TEST, "BelongsTo005 end.");
552 }
553
554 /**
555 * @tc.name: BelongsTo006
556 * @tc.desc: BelongsTo is invalid, return invalid parameter
557 * @tc.type: FUNC
558 */
559 HWTEST_F(UtdClientTest, BelongsTo006, TestSize.Level1)
560 {
561 LOG_INFO(UDMF_TEST, "BelongsTo006 begin.");
562 std::shared_ptr<TypeDescriptor> descriptor;
563 std::string typeId = "general.mpeg";
564 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
565 EXPECT_EQ(status, E_OK);
566 bool checkRet = false;
567 ASSERT_NE(descriptor, nullptr);
568 status = descriptor->BelongsTo("test04", checkRet);
569 EXPECT_EQ(status, E_INVALID_PARAMETERS);
570 EXPECT_EQ(checkRet, false);
571 LOG_INFO(UDMF_TEST, "BelongsTo006 end.");
572 }
573
574 /**
575 * @tc.name: IsLowerLevelType001
576 * @tc.desc: Normal testcase of IsLowerLevelType
577 * @tc.type: FUNC
578 */
579 HWTEST_F(UtdClientTest, IsLowerLevelType001, TestSize.Level1)
580 {
581 LOG_INFO(UDMF_TEST, "IsLowerLevelType001 begin.");
582 std::shared_ptr<TypeDescriptor> descriptor;
583 std::string typeId = "com.amazon.azw3";
584 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
585 EXPECT_EQ(status, E_OK);
586 bool checkRet = false;
587 ASSERT_NE(descriptor, nullptr);
588 status = descriptor->IsLowerLevelType("general.composite-object", checkRet);
589 EXPECT_EQ(status, E_OK);
590 EXPECT_EQ(checkRet, true);
591 LOG_INFO(UDMF_TEST, "IsLowerLevelType001 end.");
592 }
593
594 /**
595 * @tc.name: IsLowerLevelType002
596 * @tc.desc: TypeId is "', return invalid parameter
597 * @tc.type: FUNC
598 */
599 HWTEST_F(UtdClientTest, IsLowerLevelType002, TestSize.Level1)
600 {
601 LOG_INFO(UDMF_TEST, "IsLowerLevelType002 begin.");
602 std::shared_ptr<TypeDescriptor> descriptor;
603 std::string typeId = "general.object";
604 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
605 EXPECT_EQ(status, E_OK);
606 bool checkRet = false;
607 ASSERT_NE(descriptor, nullptr);
608 status = descriptor->IsLowerLevelType("", checkRet);
609 EXPECT_EQ(status, Status::E_INVALID_PARAMETERS);
610 EXPECT_EQ(checkRet, false);
611 LOG_INFO(UDMF_TEST, "IsLowerLevelType002 end.");
612 }
613
614 /**
615 * @tc.name: IsLowerLevelType003
616 * @tc.desc: Normal testcase of IsLowerLevelType
617 * @tc.type: FUNC
618 */
619 HWTEST_F(UtdClientTest, IsLowerLevelType003, TestSize.Level1)
620 {
621 LOG_INFO(UDMF_TEST, "IsLowerLevelType003 begin.");
622 std::shared_ptr<TypeDescriptor> descriptor;
623 std::string typeId = "com.microsoft.bmp";
624 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
625 EXPECT_EQ(status, E_OK);
626 bool checkRet = false;
627 ASSERT_NE(descriptor, nullptr);
628 status = descriptor->IsLowerLevelType("general.object", checkRet);
629 EXPECT_EQ(status, E_OK);
630 EXPECT_EQ(checkRet, true);
631 LOG_INFO(UDMF_TEST, "IsLowerLevelType003 end.");
632 }
633
634 /**
635 * @tc.name: IsLowerLevelType004
636 * @tc.desc: Abnormal testcase of IsLowerLevelType, the two values are equal
637 * @tc.type: FUNC
638 */
639 HWTEST_F(UtdClientTest, IsLowerLevelType004, TestSize.Level1)
640 {
641 LOG_INFO(UDMF_TEST, "IsLowerLevelType004 begin.");
642 std::shared_ptr<TypeDescriptor> descriptor;
643 std::string typeId = "com.amazon.azw3";
644 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
645 EXPECT_EQ(status, E_OK);
646 bool checkRet = false;
647 ASSERT_NE(descriptor, nullptr);
648 status = descriptor->IsLowerLevelType("com.amazon.azw3", checkRet);
649 EXPECT_EQ(status, E_OK);
650 EXPECT_EQ(checkRet, false);
651 LOG_INFO(UDMF_TEST, "IsLowerLevelType004 end.");
652 }
653
654 /**
655 * @tc.name: IsHigherLevelType001
656 * @tc.desc: Normal testcase of IsHigherLevelType
657 * @tc.type: FUNC
658 */
659 HWTEST_F(UtdClientTest, IsHigherLevelType001, TestSize.Level1)
660 {
661 LOG_INFO(UDMF_TEST, "IsHigherLevelType001 begin.");
662 std::shared_ptr<TypeDescriptor> descriptor;
663 std::string typeId = "general.composite-object";
664 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
665 EXPECT_EQ(status, E_OK);
666 bool checkRet = false;
667 ASSERT_NE(descriptor, nullptr);
668 status = descriptor->IsHigherLevelType("com.amazon.azw3", checkRet);
669 EXPECT_EQ(status, E_OK);
670 EXPECT_EQ(checkRet, true);
671 LOG_INFO(UDMF_TEST, "IsHigherLevelType001 end.");
672 }
673
674 /**
675 * @tc.name: IsHigherLevelType002
676 * @tc.desc: Abnormal testcase of IsHigherLevelType, the two values are equal
677 * @tc.type: FUNC
678 */
679 HWTEST_F(UtdClientTest, IsHigherLevelType002, TestSize.Level1)
680 {
681 LOG_INFO(UDMF_TEST, "IsHigherLevelType002 begin.");
682 std::shared_ptr<TypeDescriptor> descriptor;
683 std::string typeId = "com.amazon.azw3";
684 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
685 EXPECT_EQ(status, E_OK);
686 bool checkRet = false;
687 ASSERT_NE(descriptor, nullptr);
688 status = descriptor->IsHigherLevelType("com.amazon.azw3", checkRet);
689 EXPECT_EQ(status, E_OK);
690 EXPECT_EQ(checkRet, false);
691 LOG_INFO(UDMF_TEST, "IsHigherLevelType002 end.");
692 }
693
694 /**
695 * @tc.name: IsHigherLevelType003
696 * @tc.desc: Abnormal testcase of IsHigherLevelType
697 * @tc.type: FUNC
698 */
699 HWTEST_F(UtdClientTest, IsHigherLevelType003, TestSize.Level1)
700 {
701 LOG_INFO(UDMF_TEST, "IsHigherLevelType003 begin.");
702 std::shared_ptr<TypeDescriptor> descriptor;
703 std::string typeId = "general.image";
704 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
705 EXPECT_EQ(status, E_OK);
706 bool checkRet = false;
707 ASSERT_NE(descriptor, nullptr);
708 status = descriptor->IsHigherLevelType("general.object", checkRet);
709 EXPECT_EQ(status, E_OK);
710 EXPECT_EQ(checkRet, false);
711 LOG_INFO(UDMF_TEST, "IsHigherLevelType003 end.");
712 }
713
714 /**
715 * @tc.name: Equals001
716 * @tc.desc: Abnormal testcase of Equals, two values are different
717 * @tc.type: FUNC
718 */
719 HWTEST_F(UtdClientTest, Equals001, TestSize.Level1)
720 {
721 LOG_INFO(UDMF_TEST, "Equals001 begin.");
722 std::shared_ptr<TypeDescriptor> descriptor1;
723 std::string typeId1 = "com.amazon.azw3";
724 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId1, descriptor1);
725 EXPECT_EQ(status, E_OK);
726 std::string typeId2 = "general.composite-object";
727 std::shared_ptr<TypeDescriptor> descriptor2;
728 status = UtdClient::GetInstance().GetTypeDescriptor(typeId2, descriptor2);
729 EXPECT_EQ(status, E_OK);
730 bool ret = descriptor1->Equals(descriptor2);
731 EXPECT_EQ(ret, false);
732 LOG_INFO(UDMF_TEST, "Equals001 end.");
733 }
734
735 /**
736 * @tc.name: Equals002
737 * @tc.desc: Normal testcase of Equals
738 * @tc.type: FUNC
739 */
740 HWTEST_F(UtdClientTest, Equals002, TestSize.Level1)
741 {
742 LOG_INFO(UDMF_TEST, "Equals002 begin.");
743 std::shared_ptr<TypeDescriptor> descriptor1;
744 std::string typeId1 = "com.amazon.azw3";
745 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId1, descriptor1);
746 EXPECT_EQ(status, E_OK);
747 std::string typeId2 = "com.amazon.azw3";
748 std::shared_ptr<TypeDescriptor> descriptor2;
749 status = UtdClient::GetInstance().GetTypeDescriptor(typeId2, descriptor2);
750 EXPECT_EQ(status, E_OK);
751 bool ret = descriptor1->Equals(descriptor2);
752 EXPECT_EQ(ret, true);
753 LOG_INFO(UDMF_TEST, "Equals002 end.");
754 }
755
756 /**
757 * @tc.name: TypeDescriptorGetAttr001
758 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
759 * @tc.type: FUNC
760 */
761 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr001, TestSize.Level1)
762 {
763 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr001 begin.");
764 std::shared_ptr<TypeDescriptor> descriptor;
765 std::string typeId = "com.amazon.azw3";
766 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
767 EXPECT_EQ(status, E_OK);
768 EXPECT_EQ(descriptor->GetTypeId(), typeId);
769 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.ebook");
770 EXPECT_EQ(descriptor->GetDescription(), "AZW3 ebook.");
771 EXPECT_EQ(descriptor->GetIconFile(), "");
772 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".azw3");
773 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "application/vnd.amazon.mobi8-ebook");
774
775 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr001 end.");
776 }
777
778 /**
779 * @tc.name: TypeDescriptorGetAttr002
780 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
781 * @tc.type: FUNC
782 */
783 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr002, TestSize.Level1)
784 {
785 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr002 begin.");
786 std::shared_ptr<TypeDescriptor> descriptor;
787 std::string typeId = "general.text";
788 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
789 EXPECT_EQ(status, E_OK);
790 EXPECT_EQ(descriptor->GetTypeId(), typeId);
791 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.object");
792 EXPECT_EQ(descriptor->GetDescription(), "Base type for all text.");
793 EXPECT_EQ(descriptor->GetIconFile(), "");
794 EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
795 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "text/*");
796
797 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr002 end.");
798 }
799
800 /**
801 * @tc.name: TypeDescriptorGetAttr003
802 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
803 * @tc.type: FUNC
804 */
805 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr003, TestSize.Level1)
806 {
807 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr003 begin.");
808 std::shared_ptr<TypeDescriptor> descriptor;
809 std::string typeId = "general.image";
810 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
811 EXPECT_EQ(status, E_OK);
812 EXPECT_EQ(descriptor->GetTypeId(), typeId);
813 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.media");
814 EXPECT_EQ(descriptor->GetDescription(), "Base type for images.");
815 EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_image");
816 EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
817 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "image/*");
818
819 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr003 end.");
820 }
821
822 /**
823 * @tc.name: TypeDescriptorGetAttr004
824 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
825 * @tc.type: FUNC
826 */
827 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr004, TestSize.Level1)
828 {
829 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr004 begin.");
830 std::shared_ptr<TypeDescriptor> descriptor;
831 std::string typeId = "general.video";
832 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
833 EXPECT_EQ(status, E_OK);
834 EXPECT_EQ(descriptor->GetTypeId(), typeId);
835 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.media");
836 EXPECT_EQ(descriptor->GetDescription(), "Base type for video.");
837 EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_video");
838 EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
839 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "video/*");
840
841 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr004 end.");
842 }
843
844 /**
845 * @tc.name: TypeDescriptorGetAttr005
846 * @tc.desc: Normal testcase of TypeDescriptorGetAttr
847 * @tc.type: FUNC
848 */
849 HWTEST_F(UtdClientTest, TypeDescriptorGetAttr005, TestSize.Level1)
850 {
851 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr005 begin.");
852 std::shared_ptr<TypeDescriptor> descriptor;
853 std::string typeId = "general.audio";
854 auto status = UtdClient::GetInstance().GetTypeDescriptor(typeId, descriptor);
855 EXPECT_EQ(status, E_OK);
856 EXPECT_EQ(descriptor->GetTypeId(), typeId);
857 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.media");
858 EXPECT_EQ(descriptor->GetDescription(), "Base type for audio.");
859 EXPECT_EQ(descriptor->GetIconFile(), "sys.media.ohos_ic_normal_white_grid_audio");
860 EXPECT_EQ(descriptor->GetFilenameExtensions().empty(), true);
861 EXPECT_EQ(*(descriptor->GetMimeTypes().begin()), "audio/*");
862
863 LOG_INFO(UDMF_TEST, "TypeDescriptorGetAttr005 end.");
864 }
865
866 /**
867 * @tc.name: FlexibleType001
868 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
869 * @tc.type: FUNC
870 */
871 HWTEST_F(UtdClientTest, FlexibleType001, TestSize.Level1)
872 {
873 LOG_INFO(UDMF_TEST, "FlexibleType001 begin.");
874 std::string filenameExtension = ".mytext";
875 std::string blongsToType = "general.plain-text";
876 std::string flexTypeId;
877 auto status =
878 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
879 EXPECT_EQ(status, E_OK);
880 LOG_INFO(UDMF_TEST, "FlexibleType001, flexTypeId = %{public}s.", flexTypeId.c_str());
881 std::shared_ptr<TypeDescriptor> descriptor;
882 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
883 EXPECT_EQ(status, E_OK);
884 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
885 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
886 EXPECT_EQ(descriptor->GetDescription().empty(), true);
887 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
888 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
889 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
890 bool checkRet = false;
891 ASSERT_NE(descriptor, nullptr);
892 status = descriptor->IsHigherLevelType("general.object", checkRet); // cmp with gengral type.
893 EXPECT_EQ(status, E_OK);
894 EXPECT_EQ(checkRet, false);
895 LOG_INFO(UDMF_TEST, "FlexibleType001 end.");
896 }
897
898 /**
899 * @tc.name: FlexibleType002
900 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
901 * @tc.type: FUNC
902 */
903 HWTEST_F(UtdClientTest, FlexibleType002, TestSize.Level1)
904 {
905 LOG_INFO(UDMF_TEST, "FlexibleType002 begin.");
906 std::string filenameExtension = ".mytext";
907 std::string blongsToType = "general.plain-text";
908 std::string flexTypeId1;
909 auto status =
910 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId1, blongsToType);
911 EXPECT_EQ(status, E_OK);
912 LOG_INFO(UDMF_TEST, "FlexibleType002, flexTypeId1 = %{public}s.", flexTypeId1.c_str());
913 std::shared_ptr<TypeDescriptor> descriptor1;
914 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId1, descriptor1);
915 EXPECT_EQ(status, E_OK);
916
917 std::string filenameExtension2 = ".myvideo";
918 std::string blongsToType2 = "general.video";
919 std::string flexTypeId2;
920 status =
921 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension2, flexTypeId2, blongsToType2);
922 EXPECT_EQ(status, E_OK);
923 LOG_INFO(UDMF_TEST, "FlexibleType002, flexTypeId2 = %{public}s.", flexTypeId2.c_str());
924 std::shared_ptr<TypeDescriptor> descriptor2;
925 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId2, descriptor2);
926 EXPECT_EQ(status, E_OK);
927 EXPECT_EQ(descriptor2->GetTypeId(), flexTypeId2);
928 EXPECT_EQ(*(descriptor2->GetBelongingToTypes().begin()), "general.video");
929 EXPECT_EQ(descriptor2->GetDescription().empty(), true);
930 EXPECT_EQ(descriptor2->GetIconFile().empty(), true);
931 EXPECT_EQ(descriptor2->GetMimeTypes().empty(), true);
932 EXPECT_EQ(*(descriptor2->GetFilenameExtensions().begin()), ".myvideo");
933 bool checkRet = false;
934 ASSERT_NE(descriptor2, nullptr);
935 status = descriptor2->IsHigherLevelType(flexTypeId2, checkRet); // cmp with flexbile type.
936 EXPECT_EQ(status, E_OK);
937 EXPECT_EQ(checkRet, false);
938 LOG_INFO(UDMF_TEST, "FlexibleType002 end.");
939 }
940
941 /**
942 * @tc.name: FlexibleType001
943 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
944 * @tc.type: FUNC
945 */
946 HWTEST_F(UtdClientTest, FlexibleType003, TestSize.Level1)
947 {
948 LOG_INFO(UDMF_TEST, "FlexibleType003 begin.");
949 std::string filenameExtension = ".mytext";
950 std::string blongsToType = "general.plain-text";
951 std::string flexTypeId;
952 auto status =
953 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
954 EXPECT_EQ(status, E_OK);
955 LOG_INFO(UDMF_TEST, "FlexibleType003, flexTypeId = %{public}s.", flexTypeId.c_str());
956 std::shared_ptr<TypeDescriptor> descriptor;
957 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
958 EXPECT_EQ(status, E_OK);
959 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
960 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
961 EXPECT_EQ(descriptor->GetDescription().empty(), true);
962 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
963 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
964 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
965 bool checkRet = false;
966 ASSERT_NE(descriptor, nullptr);
967 status = descriptor->IsHigherLevelType("general.invildType", checkRet); // cmp with invildType type.
968 EXPECT_EQ(status, E_INVALID_PARAMETERS);
969 EXPECT_EQ(checkRet, false);
970 LOG_INFO(UDMF_TEST, "FlexibleType003 end.");
971 }
972
973
974 /**
975 * @tc.name: FlexibleType011
976 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
977 * @tc.type: FUNC
978 */
979 HWTEST_F(UtdClientTest, FlexibleType011, TestSize.Level1)
980 {
981 LOG_INFO(UDMF_TEST, "FlexibleType011 begin.");
982 std::string filenameExtension = ".mytext";
983 std::string blongsToType = "general.plain-text";
984 std::string flexTypeId;
985 auto status =
986 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
987 EXPECT_EQ(status, E_OK);
988 LOG_INFO(UDMF_TEST, "FlexibleType011, flexTypeId = %{public}s.", flexTypeId.c_str());
989 std::shared_ptr<TypeDescriptor> descriptor;
990 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
991 EXPECT_EQ(status, E_OK);
992 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
993 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
994 EXPECT_EQ(descriptor->GetDescription().empty(), true);
995 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
996 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
997 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
998 bool checkRet = false;
999 ASSERT_NE(descriptor, nullptr);
1000 status = descriptor->IsLowerLevelType("general.object", checkRet);
1001 EXPECT_EQ(status, E_OK);
1002 EXPECT_EQ(checkRet, true);
1003 LOG_INFO(UDMF_TEST, "FlexibleType011 end.");
1004 }
1005
1006 /**
1007 * @tc.name: FlexibleType012
1008 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1009 * @tc.type: FUNC
1010 */
1011 HWTEST_F(UtdClientTest, FlexibleType012, TestSize.Level1)
1012 {
1013 LOG_INFO(UDMF_TEST, "FlexibleType012 begin.");
1014 std::string filenameExtension = ".mytext";
1015 std::string blongsToType = "general.plain-text";
1016 std::string flexTypeId;
1017 auto status =
1018 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1019 EXPECT_EQ(status, E_OK);
1020 LOG_INFO(UDMF_TEST, "FlexibleType012, flexTypeId = %{public}s.", flexTypeId.c_str());
1021 std::shared_ptr<TypeDescriptor> descriptor;
1022 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1023 EXPECT_EQ(status, E_OK);
1024 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1025 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1026 EXPECT_EQ(descriptor->GetDescription().empty(), true);
1027 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1028 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1029 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1030 bool checkRet = false;
1031 ASSERT_NE(descriptor, nullptr);
1032 status = descriptor->IsLowerLevelType("general.video", checkRet);
1033 EXPECT_EQ(status, E_OK);
1034 EXPECT_EQ(checkRet, false);
1035 LOG_INFO(UDMF_TEST, "FlexibleType012 end.");
1036 }
1037
1038 /**
1039 * @tc.name: FlexibleType013
1040 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1041 * @tc.type: FUNC
1042 */
1043 HWTEST_F(UtdClientTest, FlexibleType013, TestSize.Level1)
1044 {
1045 LOG_INFO(UDMF_TEST, "FlexibleType013 begin.");
1046 std::string filenameExtension = ".mytext";
1047 std::string blongsToType = "general.plain-text";
1048 std::string flexTypeId1;
1049 auto status =
1050 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId1, blongsToType);
1051 EXPECT_EQ(status, E_OK);
1052 LOG_INFO(UDMF_TEST, "FlexibleType013, flexTypeId1 = %{public}s.", flexTypeId1.c_str());
1053 std::shared_ptr<TypeDescriptor> descriptor1;
1054 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId1, descriptor1);
1055 EXPECT_EQ(status, E_OK);
1056
1057 std::string filenameExtension2 = ".myvideo";
1058 std::string blongsToType2 = "general.video";
1059 std::string flexTypeId2;
1060 status =
1061 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension2, flexTypeId2, blongsToType2);
1062 EXPECT_EQ(status, E_OK);
1063 LOG_INFO(UDMF_TEST, "FlexibleType013, flexTypeId2 = %{public}s.", flexTypeId2.c_str());
1064 bool checkRet = false;
1065 ASSERT_NE(descriptor1, nullptr);
1066 status = descriptor1->IsLowerLevelType(flexTypeId2, checkRet); // cmp with flexbile type.
1067 EXPECT_EQ(status, E_OK);
1068 EXPECT_EQ(checkRet, false);
1069 LOG_INFO(UDMF_TEST, "FlexibleType013 end.");
1070 }
1071
1072 /**
1073 * @tc.name: FlexibleType014
1074 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1075 * @tc.type: FUNC
1076 */
1077 HWTEST_F(UtdClientTest, FlexibleType014, TestSize.Level1)
1078 {
1079 LOG_INFO(UDMF_TEST, "FlexibleType014 begin.");
1080 std::string filenameExtension = ".mytext";
1081 std::string blongsToType = "general.plain-text";
1082 std::string flexTypeId;
1083 auto status =
1084 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1085 EXPECT_EQ(status, E_OK);
1086 LOG_INFO(UDMF_TEST, "FlexibleType014, flexTypeId = %{public}s.", flexTypeId.c_str());
1087 std::shared_ptr<TypeDescriptor> descriptor;
1088 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1089 EXPECT_EQ(status, E_OK);
1090 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1091 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1092 EXPECT_EQ(descriptor->GetDescription().empty(), true);
1093 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1094 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1095 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1096 bool checkRet = false;
1097 ASSERT_NE(descriptor, nullptr);
1098 status = descriptor->IsLowerLevelType("general.invaildType", checkRet); // cmp with invaild type.
1099 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1100 EXPECT_EQ(checkRet, false);
1101 LOG_INFO(UDMF_TEST, "FlexibleType014 end.");
1102 }
1103
1104 /**
1105 * @tc.name: FlexibleType021
1106 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1107 * @tc.type: FUNC
1108 */
1109 HWTEST_F(UtdClientTest, FlexibleType021, TestSize.Level1)
1110 {
1111 LOG_INFO(UDMF_TEST, "FlexibleType021 begin.");
1112 std::string filenameExtension = ".mytext";
1113 std::string blongsToType = "general.plain-text";
1114 std::string flexTypeId;
1115 auto status =
1116 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1117 EXPECT_EQ(status, E_OK);
1118 LOG_INFO(UDMF_TEST, "FlexibleType021, flexTypeId = %{public}s.", flexTypeId.c_str());
1119 std::shared_ptr<TypeDescriptor> descriptor;
1120 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1121 EXPECT_EQ(status, E_OK);
1122 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1123 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1124 EXPECT_EQ(descriptor->GetDescription().empty(), true);
1125 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1126 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1127 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1128 bool checkRet = false;
1129 ASSERT_NE(descriptor, nullptr);
1130 status = descriptor->BelongsTo("general.object", checkRet);
1131 EXPECT_EQ(status, E_OK);
1132 EXPECT_EQ(checkRet, true);
1133 LOG_INFO(UDMF_TEST, "FlexibleType021 end.");
1134 }
1135
1136 /**
1137 * @tc.name: FlexibleType022
1138 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1139 * @tc.type: FUNC
1140 */
1141 HWTEST_F(UtdClientTest, FlexibleType022, TestSize.Level1)
1142 {
1143 LOG_INFO(UDMF_TEST, "FlexibleType022 begin.");
1144 std::string filenameExtension = ".mytext";
1145 std::string blongsToType = "general.plain-text";
1146 std::string flexTypeId;
1147 auto status =
1148 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1149 EXPECT_EQ(status, E_OK);
1150 LOG_INFO(UDMF_TEST, "FlexibleType022, flexTypeId = %{public}s.", flexTypeId.c_str());
1151 std::shared_ptr<TypeDescriptor> descriptor;
1152 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1153 EXPECT_EQ(status, E_OK);
1154 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1155 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1156 EXPECT_EQ(descriptor->GetDescription().empty(), true);
1157 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1158 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1159 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1160 bool checkRet = false;
1161 ASSERT_NE(descriptor, nullptr);
1162 status = descriptor->BelongsTo(flexTypeId, checkRet); // cmp with self.
1163 EXPECT_EQ(status, E_OK);
1164 EXPECT_EQ(checkRet, true);
1165 LOG_INFO(UDMF_TEST, "FlexibleType022 end.");
1166 }
1167
1168 /**
1169 * @tc.name: FlexibleType023
1170 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1171 * @tc.type: FUNC
1172 */
1173 HWTEST_F(UtdClientTest, FlexibleType023, TestSize.Level1)
1174 {
1175 LOG_INFO(UDMF_TEST, "FlexibleType023 begin.");
1176 std::string filenameExtension = ".mytext";
1177 std::string blongsToType = "general.plain-text";
1178 std::string flexTypeId1;
1179 auto status =
1180 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId1, blongsToType);
1181 EXPECT_EQ(status, E_OK);
1182 LOG_INFO(UDMF_TEST, "FlexibleType023, flexTypeId1 = %{public}s.", flexTypeId1.c_str());
1183 std::shared_ptr<TypeDescriptor> descriptor1;
1184 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId1, descriptor1);
1185 EXPECT_EQ(status, E_OK);
1186
1187 std::string filenameExtension2 = ".myvideo";
1188 std::string blongsToType2 = "general.video";
1189 std::string flexTypeId2;
1190 status =
1191 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension2, flexTypeId2, blongsToType2);
1192 EXPECT_EQ(status, E_OK);
1193 LOG_INFO(UDMF_TEST, "FlexibleType023, flexTypeId2 = %{public}s.", flexTypeId2.c_str());
1194 bool checkRet = false;
1195 ASSERT_NE(descriptor1, nullptr);
1196 status = descriptor1->BelongsTo(flexTypeId2, checkRet); // cmp with flexbile type.
1197 EXPECT_EQ(status, E_OK);
1198 EXPECT_EQ(checkRet, false);
1199 LOG_INFO(UDMF_TEST, "FlexibleType023 end.");
1200 }
1201
1202
1203 /**
1204 * @tc.name: FlexibleType024
1205 * @tc.desc: Normal testcase of flexibleType, flexibleType cmp with preset UTD.
1206 * @tc.type: FUNC
1207 */
1208 HWTEST_F(UtdClientTest, FlexibleType024, TestSize.Level1)
1209 {
1210 LOG_INFO(UDMF_TEST, "FlexibleType024 begin.");
1211 std::string filenameExtension = ".mytext";
1212 std::string blongsToType = "general.plain-text";
1213 std::string flexTypeId;
1214 auto status =
1215 UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, flexTypeId, blongsToType);
1216 EXPECT_EQ(status, E_OK);
1217 LOG_INFO(UDMF_TEST, "FlexibleType024, flexTypeId = %{public}s.", flexTypeId.c_str());
1218 std::shared_ptr<TypeDescriptor> descriptor;
1219 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1220 EXPECT_EQ(status, E_OK);
1221 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1222 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1223 EXPECT_EQ(descriptor->GetDescription().empty(), true);
1224 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1225 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1226 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1227 bool checkRet = false;
1228 ASSERT_NE(descriptor, nullptr);
1229 status = descriptor->BelongsTo("general.invaildType", checkRet); // cmp with invaild type.
1230 EXPECT_EQ(status, E_INVALID_PARAMETERS);
1231 LOG_INFO(UDMF_TEST, "FlexibleType024 end.");
1232 }
1233
1234 /**
1235 * @tc.name: IsUtd001
1236 * @tc.desc: IsUtd
1237 * @tc.type: FUNC
1238 */
1239 HWTEST_F(UtdClientTest, IsUtd001, TestSize.Level1)
1240 {
1241 LOG_INFO(UDMF_TEST, "IsUtd001 begin.");
1242 bool result = false;
1243 auto status = UtdClient::GetInstance().IsUtd("general.mp3", result);
1244 EXPECT_EQ(status, E_OK);
1245 EXPECT_EQ(result, true);
1246 status = UtdClient::GetInstance().IsUtd("com.amazon.azw3", result);
1247 EXPECT_EQ(status, E_OK);
1248 EXPECT_EQ(result, true);
1249 status = UtdClient::GetInstance().IsUtd("general.cer-certificate", result);
1250 EXPECT_EQ(status, E_OK);
1251 EXPECT_EQ(result, true);
1252 status = UtdClient::GetInstance().IsUtd("general.system", result);
1253 EXPECT_EQ(status, E_OK);
1254 EXPECT_EQ(result, true);
1255 status = UtdClient::GetInstance().IsUtd("com.example.demo.mytype-azw3", result);
1256 EXPECT_EQ(status, E_OK);
1257 EXPECT_EQ(result, true);
1258 status = UtdClient::GetInstance().IsUtd("com.example.demo.mytype", result);
1259 EXPECT_EQ(status, E_OK);
1260 EXPECT_EQ(result, true);
1261 status = UtdClient::GetInstance().IsUtd("com.example.demo.mytype3", result);
1262 EXPECT_EQ(status, E_OK);
1263 EXPECT_EQ(result, true);
1264 status = UtdClient::GetInstance().IsUtd("com.example.demo2.mytype3", result);
1265 EXPECT_EQ(status, E_OK);
1266 EXPECT_EQ(result, true);
1267 status = UtdClient::GetInstance().IsUtd("system.haha", result);
1268 EXPECT_EQ(status, E_OK);
1269 EXPECT_EQ(result, false);
1270 status = UtdClient::GetInstance().IsUtd("hello.text", result);
1271 EXPECT_EQ(status, E_OK);
1272 EXPECT_EQ(result, false);
1273 std::vector<TypeDescriptorCfg> allUTD = PresetTypeDescriptors::GetInstance().GetPresetTypes();
1274 for (auto item : allUTD) {
1275 status = UtdClient::GetInstance().IsUtd(item.typeId, result);
1276 EXPECT_EQ(status, E_OK);
1277 if (!result) {
1278 LOG_ERROR(UDMF_TEST, "IsUtd001 item is %{public}s is check fail. ", item.typeId.c_str());
1279 }
1280 EXPECT_EQ(result, true);
1281 }
1282 LOG_INFO(UDMF_TEST, "IsUtd001 end.");
1283 }
1284
1285 /**
1286 * @tc.name: IsUtd002
1287 * @tc.desc: IsUtd
1288 * @tc.type: FUNC
1289 */
1290 HWTEST_F(UtdClientTest, IsUtd002, TestSize.Level1)
1291 {
1292 LOG_INFO(UDMF_TEST, "IsUtd002 begin.");
1293 bool result = false;
1294 auto status = UtdClient::GetInstance().IsUtd("BROWSER", result);
1295 EXPECT_EQ(status, E_OK);
1296 EXPECT_EQ(result, false);
1297 status = UtdClient::GetInstance().IsUtd("IMAGE", result);
1298 EXPECT_EQ(status, E_OK);
1299 EXPECT_EQ(result, false);
1300 status = UtdClient::GetInstance().IsUtd("AUDIO", result);
1301 EXPECT_EQ(status, E_OK);
1302 EXPECT_EQ(result, false);
1303 status = UtdClient::GetInstance().IsUtd("VIDEO", result);
1304 EXPECT_EQ(status, E_OK);
1305 EXPECT_EQ(result, false);
1306 status = UtdClient::GetInstance().IsUtd("PDF", result);
1307 EXPECT_EQ(status, E_OK);
1308 EXPECT_EQ(result, false);
1309 status = UtdClient::GetInstance().IsUtd("WORD", result);
1310 EXPECT_EQ(status, E_OK);
1311 EXPECT_EQ(result, false);
1312 status = UtdClient::GetInstance().IsUtd("EXCEL", result);
1313 EXPECT_EQ(status, E_OK);
1314 EXPECT_EQ(result, false);
1315 status = UtdClient::GetInstance().IsUtd("PPT", result);
1316 EXPECT_EQ(status, E_OK);
1317 EXPECT_EQ(result, false);
1318 status = UtdClient::GetInstance().IsUtd("EMAIL", result);
1319 EXPECT_EQ(status, E_OK);
1320 EXPECT_EQ(result, false);
1321 status = UtdClient::GetInstance().IsUtd("txt", result);
1322 EXPECT_EQ(status, E_OK);
1323 EXPECT_EQ(result, false);
1324 status = UtdClient::GetInstance().IsUtd("abcdef", result);
1325 EXPECT_EQ(status, E_OK);
1326 EXPECT_EQ(result, false);
1327 LOG_INFO(UDMF_TEST, "IsUtd002 end.");
1328 }
1329
1330 /**
1331 * @tc.name: IsUtd003
1332 * @tc.desc: IsUtd
1333 * @tc.type: FUNC
1334 */
1335 HWTEST_F(UtdClientTest, IsUtd003, TestSize.Level1)
1336 {
1337 LOG_INFO(UDMF_TEST, "IsUtd003 begin.");
1338 bool result = false;
1339 auto status = UtdClient::GetInstance().IsUtd("*/*", result);
1340 EXPECT_EQ(status, E_OK);
1341 EXPECT_EQ(result, false);
1342 status = UtdClient::GetInstance().IsUtd("text/*", result);
1343 EXPECT_EQ(status, E_OK);
1344 EXPECT_EQ(result, false);
1345 status = UtdClient::GetInstance().IsUtd("image/*", result);
1346 EXPECT_EQ(status, E_OK);
1347 EXPECT_EQ(result, false);
1348 status = UtdClient::GetInstance().IsUtd("video/*", result);
1349 EXPECT_EQ(status, E_OK);
1350 EXPECT_EQ(result, false);
1351 status = UtdClient::GetInstance().IsUtd("audio/*", result);
1352 EXPECT_EQ(status, E_OK);
1353 EXPECT_EQ(result, false);
1354 status = UtdClient::GetInstance().IsUtd("audio/aiff", result);
1355 EXPECT_EQ(status, E_OK);
1356 EXPECT_EQ(result, false);
1357 LOG_INFO(UDMF_TEST, "IsUtd001 end.");
1358 }
1359
1360 /**
1361 * @tc.name: IsUtd004
1362 * @tc.desc: IsUtd
1363 * @tc.type: FUNC
1364 */
1365 HWTEST_F(UtdClientTest, IsUtd004, TestSize.Level1)
1366 {
1367 LOG_INFO(UDMF_TEST, "IsUtd004 begin.");
1368 bool result = false;
1369 auto status = UtdClient::GetInstance().IsUtd(".TXT", result);
1370 EXPECT_EQ(status, E_OK);
1371 EXPECT_EQ(result, false);
1372 status = UtdClient::GetInstance().IsUtd(".MP3", result);
1373 EXPECT_EQ(status, E_OK);
1374 EXPECT_EQ(result, false);
1375 status = UtdClient::GetInstance().IsUtd(".3gp", 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(".TXT", result);
1382 EXPECT_EQ(status, E_OK);
1383 EXPECT_EQ(result, false);
1384 status = UtdClient::GetInstance().IsUtd(".MP3", result);
1385 EXPECT_EQ(status, E_OK);
1386 EXPECT_EQ(result, false);
1387 status = UtdClient::GetInstance().IsUtd(".3gp", result);
1388 EXPECT_EQ(status, E_OK);
1389 EXPECT_EQ(result, false);
1390 status = UtdClient::GetInstance().IsUtd("abcdef", result);
1391 EXPECT_EQ(status, E_OK);
1392 EXPECT_EQ(result, false);
1393 LOG_INFO(UDMF_TEST, "IsUtd004 end.");
1394 }
1395
1396 /**
1397 * @tc.name: GetUniformDataTypeByMIMETypeByPrefix001
1398 * @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
1399 * @tc.type: FUNC
1400 */
1401 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix001, TestSize.Level1)
1402 {
1403 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix001 begin.");
1404 std::string mimeType = "application/vnd.openxmlformats-officedocument.*";
1405 std::string currType;
1406 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
1407 EXPECT_EQ(status, E_OK);
1408 std::shared_ptr<TypeDescriptor> descriptor;
1409 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
1410 EXPECT_EQ(status, E_OK);
1411 EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1412 EXPECT_EQ(descriptor->GetTypeId(), currType);
1413
1414 std::string mimeType2 = "application/vnd.openxmlformats-officedocument.wordprocessingml.*";
1415 std::string currType2;
1416 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType2, currType2);
1417 EXPECT_EQ(status, E_OK);
1418 status = UtdClient::GetInstance().GetTypeDescriptor(currType2, descriptor);
1419 EXPECT_EQ(status, E_OK);
1420 EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1421 EXPECT_EQ(descriptor->GetTypeId(), currType2);
1422 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix001 end.");
1423 }
1424
1425 /**
1426 * @tc.name: GetUniformDataTypeByMIMETypeByPrefix002
1427 * @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
1428 * @tc.type: FUNC
1429 */
1430 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix002, TestSize.Level1)
1431 {
1432 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix002 begin.");
1433 std::string mimeType = "application/vnd.openxmlformats-OFFICEdocument.*";
1434 std::string currType;
1435 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
1436 EXPECT_EQ(status, E_OK);
1437 std::shared_ptr<TypeDescriptor> descriptor;
1438 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
1439 EXPECT_EQ(status, E_OK);
1440 EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1441 EXPECT_EQ(descriptor->GetTypeId(), currType);
1442
1443 std::string mimeType2 = "application/vnd.openxmlformats-OFFICEdocument.wordprocessingml.*";
1444 std::string currType2;
1445 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType2, currType2);
1446 EXPECT_EQ(status, E_OK);
1447 status = UtdClient::GetInstance().GetTypeDescriptor(currType2, descriptor);
1448 EXPECT_EQ(status, E_OK);
1449 EXPECT_EQ(descriptor->GetTypeId(), "general.composite-object");
1450 EXPECT_EQ(descriptor->GetTypeId(), currType2);
1451 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix002 end.");
1452 }
1453
1454 /**
1455 * @tc.name: GetUniformDataTypesByFilenameExtension001
1456 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, if filtered by blongsToType
1457 * @tc.type: FUNC
1458 */
1459 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension001, TestSize.Level1)
1460 {
1461 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension001 begin.");
1462 std::string filenameExtension = ".azw3";
1463 std::string blongsToType = "general.ebook";
1464 std::vector<std::string> currTypes;
1465 auto status =
1466 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes);
1467 ASSERT_EQ(status, E_OK);
1468 ASSERT_EQ(currTypes.size(), 1);
1469 ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1470
1471 status =
1472 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1473 ASSERT_EQ(status, E_OK);
1474 ASSERT_EQ(currTypes.size(), 1);
1475 ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1476 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension001 end.");
1477 }
1478
1479 /**
1480 * @tc.name: GetUniformDataTypesByFilenameExtension002
1481 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension
1482 * @tc.type: FUNC
1483 */
1484 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension002, TestSize.Level1)
1485 {
1486 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension002 begin.");
1487 std::string filenameExtension = ".ts";
1488 std::vector<std::string> currTypes;
1489 auto status =
1490 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes);
1491 ASSERT_EQ(status, E_OK);
1492 ASSERT_EQ(currTypes.size(), 2);
1493 auto find1 = std::find(currTypes.begin(), currTypes.end(), "general.type-script") != currTypes.end();
1494 auto find2 = std::find(currTypes.begin(), currTypes.end(), "general.ts") != currTypes.end();
1495 ASSERT_EQ(find1, true);
1496 ASSERT_EQ(find2, true);
1497 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension002 end.");
1498 }
1499
1500 /**
1501 * @tc.name: GetUniformDataTypesByFilenameExtension003
1502 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, if filtered by blongsToType
1503 * @tc.type: FUNC
1504 */
1505 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension003, TestSize.Level1)
1506 {
1507 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension003 begin.");
1508 std::string filenameExtension = ".ts";
1509 std::vector<std::string> currTypes;
1510 std::string blongsToType = "general.text";
1511 auto status =
1512 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1513 ASSERT_EQ(status, E_OK);
1514 ASSERT_EQ(currTypes.size(), 1);
1515 ASSERT_EQ(currTypes[0], "general.type-script");
1516
1517 blongsToType = "general.video";
1518 status =
1519 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1520 ASSERT_EQ(status, E_OK);
1521 ASSERT_EQ(currTypes.size(), 1);
1522 ASSERT_EQ(currTypes[0], "general.ts");
1523
1524 blongsToType = "general.shell-script";
1525 status =
1526 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1527 ASSERT_EQ(status, E_OK);
1528 ASSERT_EQ(currTypes.size(), 1);
1529 ASSERT_EQ(currTypes[0].rfind("flex.z", 0), 0);
1530 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension003 end.");
1531 }
1532
1533 /**
1534 * @tc.name: GetUniformDataTypesByFilenameExtension004
1535 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension with flexibleType
1536 * @tc.type: FUNC
1537 */
1538 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension004, TestSize.Level1)
1539 {
1540 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004 begin.");
1541 std::string filenameExtension = ".mytext";
1542 std::string blongsToType = "general.plain-text";
1543 std::vector<std::string> flexTypeIds;
1544 auto status =
1545 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, flexTypeIds, blongsToType);
1546 EXPECT_EQ(status, E_OK);
1547 ASSERT_EQ(flexTypeIds.size(), 1);
1548 std::string flexTypeId = flexTypeIds[0];
1549 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004, flexTypeId = %{public}s.", flexTypeId.c_str());
1550 std::shared_ptr<TypeDescriptor> descriptor;
1551 status = UtdClient::GetInstance().GetTypeDescriptor(flexTypeId, descriptor);
1552 EXPECT_EQ(status, E_OK);
1553 EXPECT_EQ(descriptor->GetTypeId(), flexTypeId);
1554 EXPECT_EQ(*(descriptor->GetBelongingToTypes().begin()), "general.plain-text");
1555 EXPECT_EQ(descriptor->GetDescription().empty(), true);
1556 EXPECT_EQ(descriptor->GetIconFile().empty(), true);
1557 EXPECT_EQ(descriptor->GetMimeTypes().empty(), true);
1558 EXPECT_EQ(*(descriptor->GetFilenameExtensions().begin()), ".mytext");
1559 bool checkRet = false;
1560 ASSERT_NE(descriptor, nullptr);
1561 status = descriptor->IsHigherLevelType("general.object", checkRet); // cmp with gengral type.
1562 EXPECT_EQ(status, E_OK);
1563 EXPECT_EQ(checkRet, false);
1564 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension004 end.");
1565 }
1566
1567 /**
1568 * @tc.name: GetUniformDataTypesByMIMEType001
1569 * @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
1570 * @tc.type: FUNC
1571 */
1572 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType001, TestSize.Level1)
1573 {
1574 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType001 begin.");
1575 std::string mimeType = "application/x-mobi8-ebook";
1576 std::string blongsToType = "general.ebook";
1577 std::vector<std::string> currTypes;
1578 auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
1579 ASSERT_EQ(status, E_OK);
1580 ASSERT_EQ(currTypes.size(), 1);
1581 ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1582
1583 status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1584 ASSERT_EQ(status, E_OK);
1585 ASSERT_EQ(currTypes.size(), 1);
1586 ASSERT_EQ(currTypes[0], "com.amazon.azw3");
1587 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType001 end.");
1588 }
1589
1590 /**
1591 * @tc.name: GetUniformDataTypesByMIMEType002
1592 * @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
1593 * @tc.type: FUNC
1594 */
1595 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType002, TestSize.Level1)
1596 {
1597 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType002 begin.");
1598 std::string mimeType = "application/msword";
1599 std::vector<std::string> currTypes;
1600 std::string blongsToType = "general.composite-object";
1601 auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
1602 ASSERT_EQ(status, E_OK);
1603 ASSERT_EQ(currTypes.size(), 2);
1604 auto find1 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.doc") != currTypes.end();
1605 auto find2 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.dot") != currTypes.end();
1606 ASSERT_EQ(find1, true);
1607 ASSERT_EQ(find2, true);
1608
1609 status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1610 ASSERT_EQ(status, E_OK);
1611 ASSERT_EQ(currTypes.size(), 2);
1612 find1 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.doc") != currTypes.end();
1613 find2 = std::find(currTypes.begin(), currTypes.end(), "com.microsoft.word.dot") != currTypes.end();
1614 ASSERT_EQ(find1, true);
1615 ASSERT_EQ(find2, true);
1616 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType002 end.");
1617 }
1618
1619 /**
1620 * @tc.name: GetUniformDataTypesByMIMEType003
1621 * @tc.desc: Normal testcase of GetUniformDataTypesByMIMEType, if filtered by blongsToType
1622 * @tc.type: FUNC
1623 */
1624 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType003, TestSize.Level1)
1625 {
1626 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType003 begin.");
1627 std::string mimeType = "video/x-ms-asf";
1628 std::vector<std::string> currTypes;
1629 std::string blongsToType = "general.media";
1630 auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1631 ASSERT_EQ(status, E_OK);
1632 ASSERT_EQ(currTypes.size(), 2);
1633 auto find1 = std::find(currTypes.begin(), currTypes.end(),
1634 "com.microsoft.advanced-systems-format") != currTypes.end();
1635 auto find2 = std::find(currTypes.begin(), currTypes.end(),
1636 "com.microsoft.advanced-stream-redirector") != currTypes.end();
1637 ASSERT_EQ(find1, true);
1638 ASSERT_EQ(find2, true);
1639
1640 blongsToType = "general.video";
1641 status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1642 ASSERT_EQ(status, E_OK);
1643 ASSERT_EQ(currTypes.size(), 1);
1644 ASSERT_EQ(currTypes[0], "com.microsoft.advanced-stream-redirector");
1645
1646 blongsToType = "general.text";
1647 status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
1648 ASSERT_EQ(status, E_OK);
1649 ASSERT_EQ(currTypes.size(), 1);
1650 ASSERT_EQ(currTypes[0].rfind("flex.z", 0), 0);
1651 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType003 end.");
1652 }
1653
1654 /**
1655 * @tc.name: GetUniformDataTypesByMIMETypeByPrefix001
1656 * @tc.desc: normal testcase of GetUniformDatasTypeByMIMEType by prefix.
1657 * @tc.type: FUNC
1658 */
1659 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMETypeByPrefix001, TestSize.Level1)
1660 {
1661 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeByPrefix001 begin.");
1662 std::string mimeType = "model/*";
1663 std::vector<std::string> currTypes;
1664 auto status = UtdClient::GetInstance().GetUniformDataTypesByMIMEType(mimeType, currTypes);
1665 ASSERT_EQ(status, E_OK);
1666 ASSERT_EQ(currTypes.size(), 3);
1667 auto find1 = std::find(currTypes.begin(), currTypes.end(), "general.iges") != currTypes.end();
1668 auto find2 = std::find(currTypes.begin(), currTypes.end(), "general.mesh-model") != currTypes.end();
1669 auto find3 = std::find(currTypes.begin(), currTypes.end(), "com.autodesk.dwf") != currTypes.end();
1670 ASSERT_EQ(find1, true);
1671 ASSERT_EQ(find2, true);
1672 ASSERT_EQ(find3, true);
1673 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeByPrefix001 end.");
1674 }
1675
1676 /**
1677 * @tc.name: IsValidMimeType001,
1678 * @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains "?"
1679 * @tc.type: FUNC
1680 */
1681 HWTEST_F(UtdClientTest, IsValidMimeType001, TestSize.Level1)
1682 {
1683 LOG_INFO(UDMF_TEST, "IsValidMimeType001 begin.");
1684 const std::string mimeType = "mimeType?";
1685 UtdClient utdClient;
1686 bool ret = utdClient.IsValidMimeType(mimeType);
1687 EXPECT_EQ(ret, false);
1688 LOG_INFO(UDMF_TEST, "IsValidMimeType001 end.");
1689 }
1690
1691 /**
1692 * @tc.name: IsValidMimeType002
1693 * @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains ":"
1694 * @tc.type: FUNC
1695 */
1696 HWTEST_F(UtdClientTest, IsValidMimeType002, TestSize.Level1)
1697 {
1698 LOG_INFO(UDMF_TEST, "IsValidMimeType002 begin.");
1699 const std::string mimeType = "mimeType:";
1700 UtdClient utdClient;
1701 bool ret = utdClient.IsValidMimeType(mimeType);
1702 EXPECT_EQ(ret, false);
1703 LOG_INFO(UDMF_TEST, "IsValidMimeType002 end.");
1704 }
1705
1706 /**
1707 * @tc.name: IsValidMimeType003
1708 * @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains "="
1709 * @tc.type: FUNC
1710 */
1711 HWTEST_F(UtdClientTest, IsValidMimeType003, TestSize.Level1)
1712 {
1713 LOG_INFO(UDMF_TEST, "IsValidMimeType003 begin.");
1714 const std::string mimeType = "mimeType=";
1715 UtdClient utdClient;
1716 bool ret = utdClient.IsValidMimeType(mimeType);
1717 EXPECT_EQ(ret, false);
1718 LOG_INFO(UDMF_TEST, "IsValidMimeType003 end.");
1719 }
1720
1721 /**
1722 * @tc.name: IsValidMimeType004
1723 * @tc.desc: Abnormal testcase of IsValidMimeType, mimeType contains "\\"
1724 * @tc.type: FUNC
1725 */
1726 HWTEST_F(UtdClientTest, IsValidMimeType004, TestSize.Level1)
1727 {
1728 LOG_INFO(UDMF_TEST, "IsValidMimeType004 begin.");
1729 const std::string mimeType = "mimeType\\";
1730 UtdClient utdClient;
1731 bool ret = utdClient.IsValidMimeType(mimeType);
1732 EXPECT_EQ(ret, false);
1733 LOG_INFO(UDMF_TEST, "IsValidMimeType004 end.");
1734 }
1735
1736 /**
1737 * @tc.name: GetFlexibleTypeDescriptor001
1738 * @tc.desc: Abnormal testcase of GetFlexibleTypeDescriptor, typeId is ""
1739 * @tc.type: FUNC
1740 */
1741 HWTEST_F(UtdClientTest, GetFlexibleTypeDescriptor001, TestSize.Level1)
1742 {
1743 LOG_INFO(UDMF_TEST, "GetFlexibleTypeDescriptor001 begin.");
1744 const std::string typeId = "";
1745 std::shared_ptr<TypeDescriptor> descriptor = nullptr;
1746 UtdClient utdClient;
1747 Status ret = utdClient.GetFlexibleTypeDescriptor(typeId, descriptor);
1748 EXPECT_EQ(ret, Status::E_ERROR);
1749 LOG_INFO(UDMF_TEST, "GetFlexibleTypeDescriptor001 end.");
1750 }
1751
1752 /**
1753 * @tc.name: GetUniformDataTypesByFilenameExtension005
1754 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension, typeId is not empty,
1755 * belongsTo is not DEFAULT_TYPE_ID and typeId, belongsTo is not a lower level type
1756 * @tc.type: FUNC
1757 */
1758 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension005, TestSize.Level1)
1759 {
1760 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension005 begin.");
1761 const std::string fileExtension = "fileExtension";
1762 std::vector<std::string> typeIds = std::vector<std::string>();
1763 const std::string belongsTo = "";
1764 UtdClient utdClient;
1765 Status ret = utdClient.GetUniformDataTypesByFilenameExtension(fileExtension, typeIds, belongsTo);
1766 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
1767 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension005 end.");
1768 }
1769
1770 /**
1771 * @tc.name: GetUniformDataTypesByFilenameExtension006
1772 * @tc.desc: Normal testcase of GetUniformDataTypesByFilenameExtension, fileExtension is invaild
1773 * @tc.type: FUNC
1774 */
1775 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtension006, TestSize.Level1)
1776 {
1777 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension006 begin.");
1778 std::string filenameExtension = "?application/x-mobi8-ebook";
1779 std::vector<std::string> currTypes;
1780 std::string blongsToType = "general.plain-text";
1781 Status status =
1782 UtdClient::GetInstance().GetUniformDataTypesByFilenameExtension(filenameExtension, currTypes, blongsToType);
1783 ASSERT_EQ(status, Status::E_INVALID_PARAMETERS);
1784 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtension006 end.");
1785 }
1786
1787 /**
1788 * @tc.name: GetTypeIdFromCfg001
1789 * @tc.desc: Abnormal testcase of GetTypeIdFromCfg, mimeType is not empty, mimeType.back() is not '*'
1790 * @tc.type: FUNC
1791 */
1792 HWTEST_F(UtdClientTest, GetTypeIdFromCfg001, TestSize.Level1)
1793 {
1794 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg001 begin.");
1795 const std::string mimeType = "mimeType";
1796 UtdClient utdClient;
1797 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
1798 std::string ret = utdClient.GetTypeIdFromCfg(mimeType);
1799 EXPECT_EQ(ret, "");
1800 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg001 end.");
1801 }
1802
1803 /**
1804 * @tc.name: GetUniformDataTypesByMIMEType004
1805 * @tc.desc: Abnormal testcase of GetUniformDataTypesByMIMEType, mimeType is not empty, mimeType.back() is not '*'
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMEType004, TestSize.Level1)
1809 {
1810 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType004 begin.");
1811 const std::string mimeType = "mimeType";
1812 std::vector<std::string> typeIds = std::vector<std::string>();
1813 const std::string belongsTo = "";
1814 UtdClient utdClient;
1815 Status ret = utdClient.GetUniformDataTypesByMIMEType(mimeType, typeIds, belongsTo);
1816 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
1817 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMEType004 end.");
1818 }
1819
1820 /**
1821 * @tc.name: IsUtd005
1822 * @tc.desc: Abnormal testcase of IsUtd, typeId is empty
1823 * @tc.type: FUNC
1824 */
1825 HWTEST_F(UtdClientTest, IsUtd005, TestSize.Level1)
1826 {
1827 LOG_INFO(UDMF_TEST, "IsUtd005 begin.");
1828 std::string typeId = "";
1829 bool result = true;
1830 UtdClient utdClient;
1831 Status ret = utdClient.IsUtd(typeId, result);
1832 EXPECT_EQ(result, false);
1833 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
1834 LOG_INFO(UDMF_TEST, "IsUtd005 end.");
1835 }
1836
1837 /**
1838 * @tc.name: TryReloadCustomUtdTest001
1839 * @tc.desc: TryReloadCustomUtd
1840 * @tc.type: FUNC
1841 */
1842 HWTEST_F(UtdClientTest, TryReloadCustomUtdTest001, TestSize.Level1)
1843 {
1844 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest001 begin.");
1845 UtdClient utdClient;
1846 bool ret = utdClient.TryReloadCustomUtd();
1847 EXPECT_FALSE(ret);
1848 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest001 end.");
1849 }
1850
1851 /**
1852 * @tc.name: TryReloadCustomUtdTest002
1853 * @tc.desc: TryReloadCustomUtd
1854 * @tc.type: FUNC
1855 */
1856 HWTEST_F(UtdClientTest, TryReloadCustomUtdTest002, TestSize.Level1)
1857 {
1858 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest002 begin.");
1859 UtdClient utdClient;
1860 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1861 bool ret = utdClient.TryReloadCustomUtd();
1862 EXPECT_FALSE(ret);
1863 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest002 end.");
1864 }
1865
1866 /**
1867 * @tc.name: TryReloadCustomUtdTest003
1868 * @tc.desc: TryReloadCustomUtd
1869 * @tc.type: FUNC
1870 */
1871 HWTEST_F(UtdClientTest, TryReloadCustomUtdTest003, TestSize.Level1)
1872 {
1873 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest003 begin.");
1874 UtdClient utdClient;
1875 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
1876 auto now = std::chrono::system_clock::now();
1877 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
1878 std::filesystem::last_write_time(filePath, ftime);
1879 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1880 bool ret = utdClient.TryReloadCustomUtd();
1881 EXPECT_TRUE(ret);
1882 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest003 end.");
1883 }
1884
1885 /**
1886 * @tc.name: TryReloadCustomUtdTest004
1887 * @tc.desc: TryReloadCustomUtd
1888 * @tc.type: FUNC
1889 */
1890 HWTEST_F(UtdClientTest, TryReloadCustomUtdTest004, TestSize.Level1)
1891 {
1892 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest004 begin.");
1893 UtdClient utdClient;
1894 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
1895 std::filesystem::resize_file(filePath, USERID * USERID);
1896 bool ret = utdClient.TryReloadCustomUtd();
1897 EXPECT_FALSE(ret);
1898 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest004 end.");
1899 }
1900
TryReloadCustomUtdTest()1901 bool UtdClientTest::TryReloadCustomUtdTest()
1902 {
1903 UtdClient utdClient;
1904 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
1905 auto now = std::chrono::system_clock::now();
1906 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
1907 std::filesystem::last_write_time(filePath, ftime);
1908 std::filesystem::resize_file(filePath, USERID * USERID);
1909 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1910 return utdClient.TryReloadCustomUtd();
1911 }
1912
1913 /**
1914 * @tc.name: TryReloadCustomUtdTest005
1915 * @tc.desc: TryReloadCustomUtd
1916 * @tc.type: FUNC
1917 */
1918 HWTEST_F(UtdClientTest, TryReloadCustomUtdTest005, TestSize.Level0)
1919 {
1920 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest005 begin.");
__anon7b7872cc0102() 1921 std::thread t1([&]() {
1922 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1923 auto ret = TryReloadCustomUtdTest();
1924 EXPECT_TRUE(ret);
1925 });
1926 EXPECT_NO_FATAL_FAILURE(t1.join());
__anon7b7872cc0202() 1927 std::thread t2([&]() {
1928 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1929 auto ret = TryReloadCustomUtdTest();
1930 EXPECT_TRUE(ret);
1931 });
1932 EXPECT_NO_FATAL_FAILURE(t2.join());
__anon7b7872cc0302() 1933 std::thread t3([&]() {
1934 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1935 auto ret = TryReloadCustomUtdTest();
1936 EXPECT_TRUE(ret);
1937 });
1938 EXPECT_NO_FATAL_FAILURE(t3.join());
1939 LOG_INFO(UDMF_TEST, "TryReloadCustomUtdTest005 end.");
1940 }
1941
1942 /**
1943 * @tc.name: GetTypeDescriptorTest001
1944 * @tc.desc: GetTypeDescriptor
1945 * @tc.type: FUNC
1946 */
1947 HWTEST_F(UtdClientTest, GetTypeDescriptorTest001, TestSize.Level1)
1948 {
1949 LOG_INFO(UDMF_TEST, "GetTypeDescriptorTest001 begin.");
1950 UtdClient utdClient;
1951 std::string typeId("NotExist");
1952 std::shared_ptr<TypeDescriptor> descriptor = nullptr;
1953 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1954
1955 auto ret = utdClient.GetTypeDescriptor(typeId, descriptor);
1956 EXPECT_EQ(ret, 0);
1957 LOG_INFO(UDMF_TEST, "GetTypeDescriptorTest001 end.");
1958 }
1959
1960 /**
1961 * @tc.name: GetTypeDescriptorTest002
1962 * @tc.desc: GetTypeDescriptor
1963 * @tc.type: FUNC
1964 */
1965 HWTEST_F(UtdClientTest, GetTypeDescriptorTest002, TestSize.Level1)
1966 {
1967 LOG_INFO(UDMF_TEST, "GetTypeDescriptorTest002 begin.");
1968 UtdClient utdClient;
1969 std::string typeId("NotExist");
1970 std::shared_ptr<TypeDescriptor> descriptor = nullptr;
1971
1972 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1973 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
1974 auto now = std::chrono::system_clock::now();
1975 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
1976 std::filesystem::last_write_time(filePath, ftime);
1977
1978 auto ret = utdClient.GetTypeDescriptor(typeId, descriptor);
1979 EXPECT_EQ(ret, 0);
1980 LOG_INFO(UDMF_TEST, "GetTypeDescriptorTest002 end.");
1981 }
1982
1983 /**
1984 * @tc.name: GetUniformDataTypeByFilenameExtensionTest001
1985 * @tc.desc: GetUniformDataTypeByFilenameExtension
1986 * @tc.type: FUNC
1987 */
1988 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtensionTest001, TestSize.Level1)
1989 {
1990 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionTest001 begin.");
1991 UtdClient utdClient;
1992 std::string extension = "NotExist";
1993 std::string blongsToType = "general.object";
1994 std::string currType;
1995
1996 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
1997 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
1998 auto now = std::chrono::system_clock::now();
1999 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2000 std::filesystem::last_write_time(filePath, ftime);
2001
2002 auto ret = utdClient.GetUniformDataTypeByFilenameExtension(extension, currType, blongsToType);
2003 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
2004 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionTest001 end.");
2005 }
2006
2007 /**
2008 * @tc.name: GetUniformDataTypeByFilenameExtensionTest002
2009 * @tc.desc: GetUniformDataTypeByFilenameExtension
2010 * @tc.type: FUNC
2011 */
2012 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtensionTest002, TestSize.Level1)
2013 {
2014 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionTest002 begin.");
2015 UtdClient utdClient;
2016 std::string extension = ".mp3";
2017 std::string blongsToType = "NotExist";
2018 std::string currType;
2019
2020 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2021 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2022 auto now = std::chrono::system_clock::now();
2023 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2024 std::filesystem::last_write_time(filePath, ftime);
2025
2026 auto ret = utdClient.GetUniformDataTypeByFilenameExtension(extension, currType, blongsToType);
2027 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
2028 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionTest002 end.");
2029 }
2030
2031 /**
2032 * @tc.name: GetUniformDataTypesByFilenameExtensionTest007
2033 * @tc.desc: GetUniformDataTypesByFilenameExtension
2034 * @tc.type: FUNC
2035 */
2036 HWTEST_F(UtdClientTest, GetUniformDataTypesByFilenameExtensionTest007, TestSize.Level1)
2037 {
2038 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtensionTest007 begin.");
2039 UtdClient utdClient;
2040 std::string fileExtension = "fileExtension";
2041 std::vector<std::string> typeIds = std::vector<std::string>();
2042 std::string belongsTo = "";
2043
2044 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2045 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2046 auto now = std::chrono::system_clock::now();
2047 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2048 std::filesystem::last_write_time(filePath, ftime);
2049
2050 auto ret = utdClient.GetUniformDataTypesByFilenameExtension(fileExtension, typeIds, belongsTo);
2051 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
2052 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByFilenameExtensionTest007 end.");
2053 }
2054
2055 /**
2056 * @tc.name: GetUniformDataTypeByMIMETypeTest008
2057 * @tc.desc: GetUniformDataTypeByMIMEType
2058 * @tc.type: FUNC
2059 */
2060 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeTest008, TestSize.Level1)
2061 {
2062 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeTest008 begin.");
2063 UtdClient utdClient;
2064 std::string mimeType = "";
2065 std::string blongsToType = "test02";
2066 std::string currType;
2067
2068 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2069 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2070 auto now = std::chrono::system_clock::now();
2071 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2072 std::filesystem::last_write_time(filePath, ftime);
2073
2074 auto ret = utdClient.GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
2075 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
2076 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeTest008 end.");
2077 }
2078
2079 /**
2080 * @tc.name: GetTypeIdFromCfgTest002
2081 * @tc.desc: GetTypeIdFromCfg
2082 * @tc.type: FUNC
2083 */
2084 HWTEST_F(UtdClientTest, GetTypeIdFromCfgTest002, TestSize.Level1)
2085 {
2086 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfgTest002 begin.");
2087 std::string mimeType = "mimeType*";
2088 UtdClient utdClient;
2089 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2090
2091 std::string ret = utdClient.GetTypeIdFromCfg(mimeType);
2092 EXPECT_EQ(ret, "");
2093 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfgTest002 end.");
2094 }
2095
2096 /**
2097 * @tc.name: GetTypeIdFromCfgTest003
2098 * @tc.desc: GetTypeIdFromCfg
2099 * @tc.type: FUNC
2100 */
2101 HWTEST_F(UtdClientTest, GetTypeIdFromCfgTest003, TestSize.Level1)
2102 {
2103 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfgTest003 begin.");
2104
2105 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2106 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2107 auto now = std::chrono::system_clock::now();
2108 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2109 std::filesystem::last_write_time(filePath, ftime);
2110
2111 std::string mimeType = "mimeType*";
2112 UtdClient utdClient;
2113 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2114 std::string ret = utdClient.GetTypeIdFromCfg(mimeType);
2115 EXPECT_EQ(ret, "");
2116 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfgTest003 end.");
2117 }
2118
2119 /**
2120 * @tc.name: GetUniformDataTypesByMIMETypeTest005
2121 * @tc.desc: GetUniformDataTypesByMIMEType
2122 * @tc.type: FUNC
2123 */
2124 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMETypeTest005, TestSize.Level1)
2125 {
2126 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeTest005 begin.");
2127 UtdClient utdClient;
2128 std::string mimeType = "video/x-ms-asf";
2129 std::vector<std::string> currTypes;
2130 std::string blongsToType = "general.media";
2131
2132 auto ret = utdClient.GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
2133 EXPECT_EQ(ret, Status::E_OK);
2134 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2135 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2136 auto now = std::chrono::system_clock::now();
2137 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2138 std::filesystem::last_write_time(filePath, ftime);
2139
2140 ret = utdClient.GetUniformDataTypesByMIMEType(mimeType, currTypes, blongsToType);
2141 EXPECT_EQ(ret, Status::E_OK);
2142 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeTest005 end.");
2143 }
2144
2145 /**
2146 * @tc.name: GetUniformDataTypesByMIMETypeTest006
2147 * @tc.desc: GetUniformDataTypesByMIMEType
2148 * @tc.type: FUNC
2149 */
2150 HWTEST_F(UtdClientTest, GetUniformDataTypesByMIMETypeTest006, TestSize.Level1)
2151 {
2152 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeTest006 begin.");
2153 std::string mimeType = "mimeType";
2154 std::vector<std::string> typeIds = std::vector<std::string>();
2155 std::string belongsTo = "";
2156 UtdClient utdClient;
2157
2158 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2159 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2160 auto now = std::chrono::system_clock::now();
2161 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2162 std::filesystem::last_write_time(filePath, ftime);
2163
2164 auto ret = utdClient.GetUniformDataTypesByMIMEType(mimeType, typeIds, belongsTo);
2165 EXPECT_EQ(ret, Status::E_INVALID_PARAMETERS);
2166 LOG_INFO(UDMF_TEST, "GetUniformDataTypesByMIMETypeTest006 end.");
2167 }
2168
2169 /**
2170 * @tc.name: InitTest001
2171 * @tc.desc: Init
2172 * @tc.type: FUNC
2173 */
2174 HWTEST_F(UtdClientTest, InitTest001, TestSize.Level1)
2175 {
2176 LOG_INFO(UDMF_TEST, "InitTest001 begin.");
2177 UtdClient utdClient;
2178 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2179 TypeDescriptorCfg cfg;
2180 cfg.typeId = "com.example.utdTest.document";
2181 cfg.filenameExtensions = { ".my-doc", ".my-document" };
2182 utdClient.descriptorCfgs_.push_back(cfg);
2183
2184 auto ret = utdClient.Init();
2185 EXPECT_TRUE(ret);
2186 LOG_INFO(UDMF_TEST, "InitTest001 end.");
2187 }
2188
2189 /**
2190 * @tc.name: GetTypeIdsFromCfgtest001
2191 * @tc.desc: GetTypeIdsFromCfg
2192 * @tc.type: FUNC
2193 */
2194 HWTEST_F(UtdClientTest, GetTypeIdsFromCfgtest001, TestSize.Level1)
2195 {
2196 LOG_INFO(UDMF_TEST, "GetTypeIdsFromCfgtest001 begin.");
2197 UtdClient utdClient;
2198 std::string mimeType = "application/my-doc";
2199 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2200
2201 auto ret = utdClient.GetTypeIdsFromCfg(mimeType);
2202 EXPECT_TRUE(ret.empty());
2203 LOG_INFO(UDMF_TEST, "GetTypeIdsFromCfgtest001 end.");
2204 }
2205
2206 /**
2207 * @tc.name: GetTypeIdsFromCfgtest002
2208 * @tc.desc: GetTypeIdsFromCfg
2209 * @tc.type: FUNC
2210 */
2211 HWTEST_F(UtdClientTest, GetTypeIdsFromCfgtest002, TestSize.Level1)
2212 {
2213 LOG_INFO(UDMF_TEST, "GetTypeIdsFromCfgtest002 begin.");
2214 UtdClient utdClient;
2215 std::string mimeType = "application/my-doc";
2216 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2217 TypeDescriptorCfg cfg;
2218 cfg.typeId = "com.example.utdTest.document";
2219 cfg.mimeTypes = { "application/my-doc", "application/my-document" };
2220 utdClient.descriptorCfgs_.push_back(cfg);
2221
2222 auto ret = utdClient.GetTypeIdsFromCfg(mimeType);
2223 EXPECT_FALSE(ret.empty());
2224
2225 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2226 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2227 auto now = std::chrono::system_clock::now();
2228 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2229 std::filesystem::last_write_time(filePath, ftime);
2230
2231 ret = utdClient.GetTypeIdsFromCfg(mimeType);
2232 EXPECT_FALSE(ret.empty());
2233 LOG_INFO(UDMF_TEST, "GetTypeIdsFromCfgtest002 end.");
2234 }
2235
2236 /**
2237 * @tc.name: GetTypeIdFromCfg002
2238 * @tc.desc: GetTypeIdFromCfg
2239 * @tc.type: FUNC
2240 */
2241 HWTEST_F(UtdClientTest, GetTypeIdFromCfg002, TestSize.Level1)
2242 {
2243 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg002 begin.");
2244 std::string mimeType = "";
2245 UtdClient utdClient;
2246 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2247 auto ret = utdClient.GetTypeIdFromCfg(mimeType);
2248 EXPECT_EQ(ret, "");
2249 mimeType = "mimeType";
2250 ret = utdClient.GetTypeIdFromCfg(mimeType);
2251 EXPECT_EQ(ret, "");
2252 mimeType = "mimeType*";
2253 ret = utdClient.GetTypeIdFromCfg(mimeType);
2254 EXPECT_EQ(ret, "");
2255 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg002 end.");
2256 }
2257
2258 /**
2259 * @tc.name: GetTypeIdFromCfg003
2260 * @tc.desc: GetTypeIdFromCfg
2261 * @tc.type: FUNC
2262 */
2263 HWTEST_F(UtdClientTest, GetTypeIdFromCfg003, TestSize.Level1)
2264 {
2265 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg003 begin.");
2266 const std::string mimeType = "mimeType";
2267 UtdClient utdClient;
2268 utdClient.descriptorCfgs_ = std::vector<TypeDescriptorCfg>();
2269 std::string ret = utdClient.GetTypeIdFromCfg(mimeType);
2270 EXPECT_EQ(ret, "");
2271 std::this_thread::sleep_for(std::chrono::seconds(SLEEP_INTERVAL));
2272 std::string filePath = CustomUtdStore::GetInstance().GetCustomUtdPath(false, USERID);
2273 auto now = std::chrono::system_clock::now();
2274 auto ftime = std::filesystem::file_time_type::clock::now() + (now - std::chrono::system_clock::now());
2275 std::filesystem::last_write_time(filePath, ftime);
2276
2277 ret = utdClient.GetTypeIdFromCfg(mimeType);
2278 EXPECT_EQ(ret, "");
2279 LOG_INFO(UDMF_TEST, "GetTypeIdFromCfg003 end.");
2280 }
2281
2282 /**
2283 * @tc.name: IsHapTokenType001
2284 * @tc.desc: Normal testcase of IsHapTokenType
2285 * @tc.type: FUNC
2286 */
2287 HWTEST_F(UtdClientTest, IsHapTokenType001, TestSize.Level1)
2288 {
2289 LOG_INFO(UDMF_TEST, "IsHapTokenType001 begin.");
2290 HapInfoParams info = {
2291 .userID = 100,
2292 .bundleName = "ohos.test.demo",
2293 .instIndex = 0,
2294 .appIDDesc = "ohos.test.demo"
2295 };
2296
2297 HapPolicyParams policy = {
2298 .apl = APL_NORMAL,
2299 .domain = "test.domain",
2300 .permList = {
2301 {
2302 .permissionName = "ohos.permission.test",
2303 .bundleName = "ohos.test.demo",
2304 .grantMode = 1,
2305 .availableLevel = APL_NORMAL,
2306 .label = "label",
2307 .labelId = 1,
2308 .description = "test",
2309 .descriptionId = 1
2310 }
2311 },
2312 .permStateList = {
2313 {
2314 .permissionName = "ohos.permission.test",
2315 .isGeneral = true,
2316 .resDeviceID = {"local"},
2317 .grantStatus = {PermissionState::PERMISSION_GRANTED},
2318 .grantFlags = {1}
2319 }
2320 }
2321 };
2322 auto tokenID = AccessTokenKit::AllocHapToken(info, policy);
2323 SetSelfTokenID(tokenID.tokenIDEx);
2324 UtdClient utdClient;
2325 bool ret = utdClient.IsHapTokenType();
2326 EXPECT_TRUE(ret);
2327 LOG_INFO(UDMF_TEST, "IsHapTokenType001 end.");
2328 }
2329
2330 /**
2331 * @tc.name: GetUniformDataTypeByMIMETypeWithBelongsTo001
2332 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType with belongsTo
2333 * @tc.type: FUNC
2334 */
2335 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeWithBelongsTo001, TestSize.Level1)
2336 {
2337 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo001 begin.");
2338 std::string mimeType = "video/mp2ts";
2339 std::string utdType;
2340 std::string blongsToType = "invalid_type";
2341 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2342 EXPECT_EQ(status, E_INVALID_PARAMETERS);
2343 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo001 end.");
2344 }
2345
2346 /**
2347 * @tc.name: GetUniformDataTypeByMIMETypeWithBelongsTo002
2348 * @tc.desc: Normal testcase of GetUniformDataTypeByMIMEType with belongsTo
2349 * @tc.type: FUNC
2350 */
2351 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeWithBelongsTo002, TestSize.Level1)
2352 {
2353 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo002 begin.");
2354 std::string mimeType = "video/mp2ts";
2355 std::string utdType;
2356 std::string blongsToType = "general.video";
2357 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2358 EXPECT_EQ(status, E_OK);
2359 EXPECT_EQ(utdType, "general.ts");
2360
2361 mimeType = "video/mp2t";
2362 utdType = "";
2363 blongsToType = "general.video";
2364 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2365 EXPECT_EQ(status, E_OK);
2366 EXPECT_EQ(utdType, "general.ts");
2367 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo002 end.");
2368 }
2369
2370 /**
2371 * @tc.name: GetUniformDataTypeByMIMETypeWithBelongsTo003
2372 * @tc.desc: Normal testcase of GetUniformDataTypeByMIMEType with higher belongsTo
2373 * @tc.type: FUNC
2374 */
2375 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeWithBelongsTo003, TestSize.Level1)
2376 {
2377 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo003 begin.");
2378 std::string mimeType = "video/mp2ts";
2379 std::string utdType;
2380 std::string blongsToType = "general.media";
2381 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2382 EXPECT_EQ(status, E_OK);
2383 EXPECT_EQ(utdType, "general.ts");
2384
2385 mimeType = "video/mp2t";
2386 utdType = "";
2387 blongsToType = "general.object";
2388 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2389 EXPECT_EQ(status, E_OK);
2390 EXPECT_EQ(utdType, "general.ts");
2391 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo003 end.");
2392 }
2393
2394 /**
2395 * @tc.name: GetUniformDataTypeByMIMETypeWithBelongsTo004
2396 * @tc.desc: Abnormal testcase of GetUniformDataTypeByMIMEType with belongsTo
2397 * @tc.type: FUNC
2398 */
2399 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeWithBelongsTo004, TestSize.Level1)
2400 {
2401 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo004 begin.");
2402 std::string mimeType = "video/mp2ts";
2403 std::string utdType;
2404 std::string blongsToType = "general.source-code";
2405 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2406 EXPECT_EQ(status, E_OK);
2407 EXPECT_EQ(utdType.compare(0, std::string(FLEXIBLE_TYPE_FLAG).size(), FLEXIBLE_TYPE_FLAG), 0);
2408
2409 mimeType = "video/mp2t";
2410 utdType = "";
2411 blongsToType = "general.source-code";
2412 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, utdType, blongsToType);
2413 EXPECT_EQ(status, E_OK);
2414 EXPECT_EQ(utdType.compare(0, std::string(FLEXIBLE_TYPE_FLAG).size(), FLEXIBLE_TYPE_FLAG), 0);
2415 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeWithBelongsTo004 end.");
2416 }
2417
2418 /**
2419 * @tc.name: GetUniformDataTypeByFilenameExtensionWithBelongsTo001
2420 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension with belongsTo
2421 * @tc.type: FUNC
2422 */
2423 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtensionWithBelongsTo001, TestSize.Level1)
2424 {
2425 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo001 begin.");
2426 std::string filenameExtension = ".ts";
2427 std::string utdType;
2428 std::string blongsToType = "invalid_type";
2429 auto status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(
2430 filenameExtension, utdType, blongsToType);
2431 EXPECT_EQ(status, E_INVALID_PARAMETERS);
2432 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo001 end.");
2433 }
2434
2435 /**
2436 * @tc.name: GetUniformDataTypeByFilenameExtensionWithBelongsTo002
2437 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension with belongsTo
2438 * @tc.type: FUNC
2439 */
2440 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtensionWithBelongsTo002, TestSize.Level1)
2441 {
2442 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo002 begin.");
2443 std::string filenameExtension = ".ts";
2444 std::string utdType;
2445 std::string blongsToType = "general.video";
2446 auto status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(
2447 filenameExtension, utdType, blongsToType);
2448 EXPECT_EQ(status, E_OK);
2449 EXPECT_EQ(utdType, "general.ts");
2450
2451 utdType = "";
2452 blongsToType = "general.source-code";
2453 status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, utdType, blongsToType);
2454 EXPECT_EQ(status, E_OK);
2455 EXPECT_EQ(utdType, "general.type-script");
2456 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo002 end.");
2457 }
2458
2459 /**
2460 * @tc.name: GetUniformDataTypeByFilenameExtensionWithBelongsTo003
2461 * @tc.desc: Normal testcase of GetUniformDataTypeByFilenameExtension with higher belongsTo
2462 * @tc.type: FUNC
2463 */
2464 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtensionWithBelongsTo003, TestSize.Level1)
2465 {
2466 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo003 begin.");
2467 std::string filenameExtension = ".ts";
2468 std::string utdType;
2469 std::string blongsToType = "general.media";
2470 auto status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(
2471 filenameExtension, utdType, blongsToType);
2472 EXPECT_EQ(status, E_OK);
2473 EXPECT_EQ(utdType, "general.ts");
2474
2475 utdType = "";
2476 blongsToType = "general.text";
2477 status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, utdType, blongsToType);
2478 EXPECT_EQ(status, E_OK);
2479 EXPECT_EQ(utdType, "general.type-script");
2480 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo003 end.");
2481 }
2482
2483 /**
2484 * @tc.name: GetUniformDataTypeByFilenameExtensionWithBelongsTo004
2485 * @tc.desc: Abnormal testcase of GetUniformDataTypeByFilenameExtension with belongsTo
2486 * @tc.type: FUNC
2487 */
2488 HWTEST_F(UtdClientTest, GetUniformDataTypeByFilenameExtensionWithBelongsTo004, TestSize.Level1)
2489 {
2490 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo004 begin.");
2491 std::string filenameExtension = ".ts";
2492 std::string utdType;
2493 std::string blongsToType = "general.java-script";
2494 auto status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(
2495 filenameExtension, utdType, blongsToType);
2496 EXPECT_EQ(status, E_OK);
2497 EXPECT_EQ(utdType.compare(0, std::string(FLEXIBLE_TYPE_FLAG).size(), FLEXIBLE_TYPE_FLAG), 0);
2498
2499 utdType = "";
2500 blongsToType = "general.audio";
2501 status = UtdClient::GetInstance().GetUniformDataTypeByFilenameExtension(filenameExtension, utdType, blongsToType);
2502 EXPECT_EQ(status, E_OK);
2503 EXPECT_EQ(utdType.compare(0, std::string(FLEXIBLE_TYPE_FLAG).size(), FLEXIBLE_TYPE_FLAG), 0);
2504 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByFilenameExtensionWithBelongsTo004 end.");
2505 }
2506
2507 /**
2508 * @tc.name: GetUniformDataTypeByMIMETypeByPrefix003
2509 * @tc.desc: normal testcase of GetUniformDataTypeByMIMEType by prefix.
2510 * @tc.type: FUNC
2511 */
2512 HWTEST_F(UtdClientTest, GetUniformDataTypeByMIMETypeByPrefix003, TestSize.Level1)
2513 {
2514 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix003 begin.");
2515 std::string mimeType = "application/vnd.*";
2516 std::string currType;
2517 auto status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType);
2518 EXPECT_EQ(status, E_OK);
2519 std::shared_ptr<TypeDescriptor> descriptor;
2520 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
2521 EXPECT_EQ(status, E_OK);
2522 EXPECT_EQ(descriptor->GetTypeId(), "general.ebook");
2523
2524 currType = "";
2525 std::string blongsToType = "general.ebook";
2526 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
2527 EXPECT_EQ(status, E_OK);
2528 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
2529 EXPECT_EQ(status, E_OK);
2530 EXPECT_EQ(descriptor->GetTypeId(), "general.ebook");
2531
2532 currType = "";
2533 blongsToType = "general.media";
2534 status = UtdClient::GetInstance().GetUniformDataTypeByMIMEType(mimeType, currType, blongsToType);
2535 EXPECT_EQ(status, E_OK);
2536 status = UtdClient::GetInstance().GetTypeDescriptor(currType, descriptor);
2537 EXPECT_EQ(status, E_OK);
2538 EXPECT_EQ(descriptor->GetTypeId(), "general.image");
2539 LOG_INFO(UDMF_TEST, "GetUniformDataTypeByMIMETypeByPrefix003 end.");
2540 }
2541 } // OHOS::Test