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
16import { describe, beforeAll, beforeEach, afterEach, afterAll, it, expect } from 'deccjsunit/index';
17import UTD from '@ohos.data.uniformTypeDescriptor';
18
19const ERROR_PARAMETER = '401';
20const INVALID_TYPE1 = 'invalidUtdType';
21const INVALID_TYPE2 = 123456;
22
23
24describe('UdmfUtdJSTest', function () {
25
26  /*
27   * @tc.name UdmfTestTypeDescriptor001
28   * @tc.desc Test Js Api input invalid string
29   * @tc.type: FUNC
30   * @tc.require: issueNumber
31   */
32  it('UdmfTestTypeDescriptor001', 0, function () {
33    const TAG = 'UdmfTestTypeDescriptor001:';
34    console.info(TAG, 'start');
35    let typeObj = UTD.getTypeDescriptor('general.invalidType');
36    console.info(TAG, 'typeDescriptor, ret= ' + typeObj);
37    if (typeObj == null) {
38      console.info(TAG, 'typeDescriptor, typeObj == null is true');
39    }
40    expect((typeObj == null)).assertEqual(true);
41    console.info(TAG, 'end');
42  });
43
44  /*
45   * @tc.name UdmfTestTypeDescriptor002
46   * @tc.desc Test Js Api
47   * @tc.type: FUNC
48   * @tc.require: issueNumber
49   */
50  it('UdmfTestTypeDescriptor002', 0, function () {
51    const TAG = 'UdmfTestTypeDescriptor002:';
52    console.info(TAG, 'start');
53    let typeObj = UTD.getTypeDescriptor('com.adobe.photoshop-image');
54    let typeId = typeObj.typeId;
55    let belonging = typeObj.belongingToTypes;
56    let description = typeObj.description;
57    let referenceURL = typeObj.referenceURL;
58    let iconFile = typeObj.iconFile;
59    let filenameExtensions = typeObj.filenameExtensions;
60    let mimeTypes = typeObj.mimeTypes;
61    console.info(TAG, ', typeId: ' + typeId + ', ' + Object.prototype.toString.call(typeId) +
62      ', belongingToTypes: ' + belonging + ', ' + Object.prototype.toString.call(belonging));
63    console.info(TAG, 'description: ' + typeObj.description + ', ' + Object.prototype.toString.call(description));
64    console.info(TAG, 'referenceURL: ' + referenceURL + ', ' + Object.prototype.toString.call(referenceURL) +
65      ', iconFile: ' + iconFile + ', ' + Object.prototype.toString.call(iconFile));
66    expect(typeObj.typeId).assertEqual(UTD.UniformDataType.PHOTOSHOP_IMAGE);
67    expect(typeObj.belongingToTypes[0]).assertEqual('general.image');
68    expect(typeObj.description).assertEqual('Adobe Photoshop document.');
69    let equalStr = 'https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/' +
70      'apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype';
71    expect(typeObj.referenceURL).assertEqual(equalStr);
72    expect(typeObj.iconFile).assertEqual('sys.media.ohos_ic_normal_white_grid_image');
73    expect(typeObj.filenameExtensions[0]).assertEqual('.psd');
74    expect(typeObj.mimeTypes[0]).assertEqual('image/x-photoshop');
75    console.info(TAG, 'end');
76  });
77
78  /*
79   * @tc.name UdmfTestTypeDescriptor003
80   * @tc.desc Test Js Api
81   * @tc.type: FUNC
82   * @tc.require: issueNumber
83   */
84  it('UdmfTestTypeDescriptor003', 0, function () {
85    const TAG = 'UdmfTestTypeDescriptor003:';
86    console.info(TAG, 'start');
87    let typeObj = UTD.getTypeDescriptor('general.type-script');
88    let typeObj2 = UTD.getTypeDescriptor('general.python-script');
89    let typeObj3 = UTD.getTypeDescriptor('general.python-script');
90    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
91    console.info(TAG, 'typeDescriptor, ret ' + typeObj2);
92    let ret = typeObj.equals(typeObj2);
93    console.info(TAG, 'typeObj equals with typeObj2 is ' + ret);
94    expect(ret).assertEqual(false);
95    ret = typeObj2.equals(typeObj3);
96    console.info(TAG, 'typeObj2 equals with typeObj3 is ' + ret);
97    expect(ret).assertEqual(true);
98    console.info(TAG, 'end');
99  });
100
101  /*
102   * @tc.name UdmfTestTypeDescriptor004
103   * @tc.desc Test Js Api invalid para type
104   * @tc.type: FUNC
105   * @tc.require: issueNumber
106   */
107  it('UdmfTestTypeDescriptor004', 0, function () {
108    const TAG = 'UdmfTestTypeDescriptor004:';
109    console.info(TAG, 'start');
110    try {
111      let typeObj = UTD.getTypeDescriptor(null);
112      console.info(TAG, 'typeDescriptor, ret ' + typeObj);
113    } catch (e) {
114      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
115      expect(e.code === ERROR_PARAMETER).assertTrue();
116    }
117    console.info(TAG, 'end');
118  });
119
120  /*
121 * @tc.name UdmfTestTypeDescriptor005
122 * @tc.desc Test Js Api
123 * @tc.type: FUNC
124 * @tc.require: issueNumber
125 */
126  it('UdmfTestTypeDescriptor005', 0, function () {
127    const TAG = 'UdmfTestTypeDescriptor005:';
128    console.info(TAG, 'start');
129    let typeObj = UTD.getTypeDescriptor('com.adobe.photoshop-image', INVALID_TYPE1, INVALID_TYPE2);
130    let typeId = typeObj.typeId;
131    let belonging = typeObj.belongingToTypes;
132    let description = typeObj.description;
133    let referenceURL = typeObj.referenceURL;
134    let iconFile = typeObj.iconFile;
135    console.info(TAG, ', typeId: ' + typeId + ', ' + Object.prototype.toString.call(typeId) +
136      ', belongingToTypes: ' + belonging + ', ' + Object.prototype.toString.call(belonging));
137    console.info(TAG, 'description: ' + typeObj.description + ', ' + Object.prototype.toString.call(description));
138    console.info(TAG, 'referenceURL: ' + referenceURL + ', ' + Object.prototype.toString.call(referenceURL) +
139      ', iconFile: ' + iconFile + ', ' + Object.prototype.toString.call(iconFile));
140    expect(typeObj.typeId).assertEqual(UTD.UniformDataType.PHOTOSHOP_IMAGE);
141    expect(typeObj.belongingToTypes[0]).assertEqual('general.image');
142    expect(typeObj.description).assertEqual('Adobe Photoshop document.');
143    let equalStr = 'https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/' +
144      'apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype';
145    expect(typeObj.referenceURL).assertEqual(equalStr);
146    expect(typeObj.iconFile).assertEqual('sys.media.ohos_ic_normal_white_grid_image');
147    console.info(TAG, 'end');
148  });
149
150  /*
151   * @tc.name UdmfTestTypeDescriptor007
152   * @tc.desc Test Js Api foreach all UniformDataType
153   * @tc.type: FUNC
154   * @tc.require: issueNumber
155   */
156  it('UdmfTestTypeDescriptor006', 0, function () {
157    const TAG = 'UdmfTestTypeDescriptor006:';
158    console.info(TAG, 'start');
159    for (let utdType in UTD.UniformDataType) {
160      let typeObj = UTD.getTypeDescriptor(UTD.UniformDataType[utdType]);
161      if (typeObj != null) {
162        expect(typeObj.typeId).assertEqual(UTD.UniformDataType[utdType]);
163      }
164    }
165    console.info(TAG, 'end');
166  });
167
168  /*
169   * @tc.name UdmfTestTypeDescriptor007
170   * @tc.desc Test Js Api getTypeDescriptor no para
171   * @tc.type: FUNC
172   * @tc.require: issueNumber
173   */
174  it('UdmfTestTypeDescriptor007', 0, function () {
175    const TAG = 'UdmfTestTypeDescriptor007:';
176    console.info(TAG, 'start');
177    try {
178      let typeObj = UTD.getTypeDescriptor();
179      console.info(TAG, 'typeDescriptor, ret ' + typeObj);
180    } catch (e) {
181      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
182      expect(e.code === ERROR_PARAMETER).assertTrue();
183    }
184    console.info(TAG, 'end');
185  });
186
187  /*
188   * @tc.name UdmfTestTypeDescriptor008
189   * @tc.desc Test Js Api equals invalid para type
190   * @tc.type: FUNC
191   * @tc.require: issueNumber
192   */
193  it('UdmfTestTypeDescriptor008', 0, function () {
194    const TAG = 'UdmfTestTypeDescriptor008:';
195    console.info(TAG, 'start');
196    let typeObj = UTD.getTypeDescriptor('general.type-script');
197    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
198    try {
199      typeObj.equals('1111');
200      expect().assertFail();
201    } catch (e) {
202      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
203      expect(e.code === ERROR_PARAMETER).assertTrue();
204    }
205    console.info(TAG, 'end');
206  });
207
208  /*
209   * @tc.name UdmfTestTypeDescriptor009
210   * @tc.desc Test Js Api enum value judge part1
211   * @tc.type: FUNC
212   * @tc.require: issueNumber
213   */
214  it('UdmfTestTypeDescriptor009', 0, function () {
215    const TAG = 'UdmfTestTypeDescriptor009:';
216    console.info(TAG, 'start');
217    expect(UTD.UniformDataType.TEXT).assertEqual('general.text');
218    expect(UTD.UniformDataType.PLAIN_TEXT).assertEqual('general.plain-text');
219    expect(UTD.UniformDataType.HTML).assertEqual('general.html');
220    expect(UTD.UniformDataType.HYPERLINK).assertEqual('general.hyperlink');
221    expect(UTD.UniformDataType.XML).assertEqual('general.xml');
222    expect(UTD.UniformDataType.SOURCE_CODE).assertEqual('general.source-code');
223    expect(UTD.UniformDataType.SCRIPT).assertEqual('general.script');
224    expect(UTD.UniformDataType.SHELL_SCRIPT).assertEqual('general.shell-script');
225    expect(UTD.UniformDataType.CSH_SCRIPT).assertEqual('general.csh-script');
226    expect(UTD.UniformDataType.PERL_SCRIPT).assertEqual('general.perl-script');
227    expect(UTD.UniformDataType.PHP_SCRIPT).assertEqual('general.php-script');
228    expect(UTD.UniformDataType.PYTHON_SCRIPT).assertEqual('general.python-script');
229    expect(UTD.UniformDataType.RUBY_SCRIPT).assertEqual('general.ruby-script');
230    expect(UTD.UniformDataType.TYPE_SCRIPT).assertEqual('general.type-script');
231    expect(UTD.UniformDataType.JAVA_SCRIPT).assertEqual('general.java-script');
232    expect(UTD.UniformDataType.C_HEADER).assertEqual('general.c-header');
233    expect(UTD.UniformDataType.C_SOURCE).assertEqual('general.c-source');
234    expect(UTD.UniformDataType.C_PLUS_PLUS_HEADER).assertEqual('general.c-plus-plus-header');
235    expect(UTD.UniformDataType.C_PLUS_PLUS_SOURCE).assertEqual('general.c-plus-plus-source');
236    expect(UTD.UniformDataType.JAVA_SOURCE).assertEqual('general.java-source');
237    expect(UTD.UniformDataType.EBOOK).assertEqual('general.ebook');
238    expect(UTD.UniformDataType.EPUB).assertEqual('general.epub');
239    expect(UTD.UniformDataType.AZW).assertEqual('com.amazon.azw');
240    expect(UTD.UniformDataType.AZW3).assertEqual('com.amazon.azw3');
241    expect(UTD.UniformDataType.KFX).assertEqual('com.amazon.kfx');
242    expect(UTD.UniformDataType.MOBI).assertEqual('com.amazon.mobi');
243    expect(UTD.UniformDataType.MEDIA).assertEqual('general.media');
244    expect(UTD.UniformDataType.IMAGE).assertEqual('general.image');
245    expect(UTD.UniformDataType.JPEG).assertEqual('general.jpeg');
246    console.info(TAG, 'end');
247  });
248
249  /*
250   * @tc.name UdmfTestTypeDescriptor010
251   * @tc.desc Test Js Api enum value judge part2
252   * @tc.type: FUNC
253   * @tc.require: issueNumber
254   */
255  it('UdmfTestTypeDescriptor010', 0, function () {
256    const TAG = 'UdmfTestTypeDescriptor010:';
257    console.info(TAG, 'start');
258    expect(UTD.UniformDataType.PNG).assertEqual('general.png');
259    expect(UTD.UniformDataType.RAW_IMAGE).assertEqual('general.raw-image');
260    expect(UTD.UniformDataType.TIFF).assertEqual('general.tiff');
261    expect(UTD.UniformDataType.BMP).assertEqual('com.microsoft.bmp');
262    expect(UTD.UniformDataType.ICO).assertEqual('com.microsoft.ico');
263    expect(UTD.UniformDataType.PHOTOSHOP_IMAGE).assertEqual('com.adobe.photoshop-image');
264    expect(UTD.UniformDataType.AI_IMAGE).assertEqual('com.adobe.illustrator.ai-image');
265    expect(UTD.UniformDataType.WORD_DOC).assertEqual('com.microsoft.word.doc');
266    expect(UTD.UniformDataType.EXCEL).assertEqual('com.microsoft.excel.xls');
267    expect(UTD.UniformDataType.PPT).assertEqual('com.microsoft.powerpoint.ppt');
268    expect(UTD.UniformDataType.PDF).assertEqual('com.adobe.pdf');
269    expect(UTD.UniformDataType.POSTSCRIPT).assertEqual('com.adobe.postscript');
270    expect(UTD.UniformDataType.ENCAPSULATED_POSTSCRIPT).assertEqual('com.adobe.encapsulated-postscript');
271    expect(UTD.UniformDataType.VIDEO).assertEqual('general.video');
272    expect(UTD.UniformDataType.AVI).assertEqual('general.avi');
273    expect(UTD.UniformDataType.MPEG).assertEqual('general.mpeg');
274    expect(UTD.UniformDataType.MPEG4).assertEqual('general.mpeg-4');
275    expect(UTD.UniformDataType.VIDEO_3GPP).assertEqual('general.3gpp');
276    expect(UTD.UniformDataType.VIDEO_3GPP2).assertEqual('general.3gpp2');
277    expect(UTD.UniformDataType.WINDOWS_MEDIA_WM).assertEqual('com.microsoft.windows-media-wm');
278    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMV).assertEqual('com.microsoft.windows-media-wmv');
279    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMP).assertEqual('com.microsoft.windows-media-wmp');
280    expect(UTD.UniformDataType.AUDIO).assertEqual('general.audio');
281    expect(UTD.UniformDataType.AAC).assertEqual('general.aac');
282    expect(UTD.UniformDataType.AIFF).assertEqual('general.aiff');
283    expect(UTD.UniformDataType.ALAC).assertEqual('general.alac');
284    expect(UTD.UniformDataType.FLAC).assertEqual('general.flac');
285    expect(UTD.UniformDataType.MP3).assertEqual('general.mp3');
286    expect(UTD.UniformDataType.OGG).assertEqual('general.ogg');
287    expect(UTD.UniformDataType.PCM).assertEqual('general.pcm');
288    expect(UTD.UniformDataType.ADOBE_F4V).assertEqual('com.adobe.f4v');
289    expect(UTD.UniformDataType.MP2T).assertEqual('general.mp2t');
290    expect(UTD.UniformDataType.YOUTUBE_VIDEO).assertEqual('com.youtube.video');
291    expect(UTD.UniformDataType.WEBEX_VIDEO).assertEqual('com.cisco.webex-video');
292    expect(UTD.UniformDataType.MPEG2).assertEqual('general.mpeg-2');
293    expect(UTD.UniformDataType.MPEG1).assertEqual('general.mpeg-1');
294    expect(UTD.UniformDataType.REALMEDIA_VBR).assertEqual('com.real.realmedia-vbr');
295    expect(UTD.UniformDataType.REAL_REALVIDEO).assertEqual('com.real.realvideo');
296    expect(UTD.UniformDataType.DIVX_VIDEO).assertEqual('general.divx-video');
297    expect(UTD.UniformDataType.CSIRO_ANNODEX).assertEqual('org.csiro.annodex');
298    expect(UTD.UniformDataType.OGV).assertEqual('general.ogv');
299    expect(UTD.UniformDataType.LSF_VIDEO).assertEqual('com.microsoft.lsf-video');
300    expect(UTD.UniformDataType.H264_VIDEO).assertEqual('general.h264-video');
301    console.info(TAG, 'end');
302  });
303
304  /*
305   * @tc.name UdmfTestTypeDescriptor011
306   * @tc.desc Test Js Api enum value judge part3
307   * @tc.type: FUNC
308   * @tc.require: issueNumber
309   */
310  it('UdmfTestTypeDescriptor011', 0, function () {
311    const TAG = 'UdmfTestTypeDescriptor011:';
312    console.info(TAG, 'start');
313    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMA).assertEqual('com.microsoft.windows-media-wma');
314    expect(UTD.UniformDataType.WAVEFORM_AUDIO).assertEqual('com.microsoft.waveform-audio');
315    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMX).assertEqual('com.microsoft.windows-media-wmx');
316    expect(UTD.UniformDataType.WINDOWS_MEDIA_WVX).assertEqual('com.microsoft.windows-media-wvx');
317    expect(UTD.UniformDataType.WINDOWS_MEDIA_WAX).assertEqual('com.microsoft.windows-media-wax');
318    expect(UTD.UniformDataType.FILE).assertEqual('general.file');
319    expect(UTD.UniformDataType.DIRECTORY).assertEqual('general.directory');
320    expect(UTD.UniformDataType.FOLDER).assertEqual('general.folder');
321    expect(UTD.UniformDataType.SYMLINK).assertEqual('general.symlink');
322    expect(UTD.UniformDataType.ARCHIVE).assertEqual('general.archive');
323    expect(UTD.UniformDataType.BZ2_ARCHIVE).assertEqual('general.bz2-archive');
324    expect(UTD.UniformDataType.DISK_IMAGE).assertEqual('general.disk-image');
325    expect(UTD.UniformDataType.TAR_ARCHIVE).assertEqual('general.tar-archive');
326    expect(UTD.UniformDataType.ZIP_ARCHIVE).assertEqual('general.zip-archive');
327    expect(UTD.UniformDataType.JAVA_ARCHIVE).assertEqual('com.sun.java-archive');
328    expect(UTD.UniformDataType.GNU_TAR_ARCHIVE).assertEqual('org.gnu.gnu-tar-archive');
329    expect(UTD.UniformDataType.GNU_ZIP_ARCHIVE).assertEqual('org.gnu.gnu-zip-archive');
330    expect(UTD.UniformDataType.GNU_ZIP_TAR_ARCHIVE).assertEqual('org.gnu.gnu-zip-tar-archive');
331    expect(UTD.UniformDataType.CALENDAR).assertEqual('general.calendar');
332    expect(UTD.UniformDataType.CONTACT).assertEqual('general.contact');
333    expect(UTD.UniformDataType.DATABASE).assertEqual('general.database');
334    expect(UTD.UniformDataType.MESSAGE).assertEqual('general.message');
335    expect(UTD.UniformDataType.VCARD).assertEqual('general.vcard');
336    expect(UTD.UniformDataType.NAVIGATION).assertEqual('general.navigation');
337    expect(UTD.UniformDataType.LOCATION).assertEqual('general.location');
338    expect(UTD.UniformDataType.OPENHARMONY_FORM).assertEqual('openharmony.form');
339    expect(UTD.UniformDataType.OPENHARMONY_APP_ITEM).assertEqual('openharmony.app-item');
340    expect(UTD.UniformDataType.OPENHARMONY_PIXEL_MAP).assertEqual('openharmony.pixel-map');
341    expect(UTD.UniformDataType.OPENHARMONY_ATOMIC_SERVICE).assertEqual('openharmony.atomic-service');
342    expect(UTD.UniformDataType.JPEG2000).assertEqual('general.jpeg-2000');
343    expect(UTD.UniformDataType.RAF_RAW_IMAGE).assertEqual('com.fujifilm.raf-raw-image');
344    expect(UTD.UniformDataType.NRW_RAW_IMAGE).assertEqual('com.nikon.nrw-raw-image');
345    expect(UTD.UniformDataType.RW2_RAW_IMAGE).assertEqual('com.panasonic.rw2-raw-image');
346    expect(UTD.UniformDataType.PEF_RAW_IMAGE).assertEqual('com.pentax.pef-raw-image');
347    expect(UTD.UniformDataType.SRW_RAW_IMAGE).assertEqual('com.sumsung.srw-raw-image');
348    expect(UTD.UniformDataType.ERF_RAW_IMAGE).assertEqual('com.epson.erf-raw-image');
349    expect(UTD.UniformDataType.ORF_RAW_IMAGE).assertEqual('com.olympus.orf-raw-image');
350    expect(UTD.UniformDataType.IEF_IMAGE).assertEqual('general.ief-image');
351    expect(UTD.UniformDataType.ART_IMAGE).assertEqual('com.aol.art-image');
352    expect(UTD.UniformDataType.CONTENT_FORM).assertEqual('general.content-form');
353    expect(UTD.UniformDataType.M4P_AUDIO).assertEqual('com.apple.m4p-audio');
354    expect(UTD.UniformDataType.AC3_AUDIO).assertEqual('general.ac3-audio');
355    console.info(TAG, 'end');
356  });
357
358  /*
359  * @tc.name UdmfTestTypeDescriptor012
360  * @tc.desc Test Js Api belongsTo
361  * @tc.type: FUNC
362  * @tc.require: issueNumber
363  */
364  it('UdmfTestTypeDescriptor012', 0, function () {
365    const TAG = 'UdmfTestTypeDescriptor012:';
366    console.info(TAG, 'start');
367    let typeObj = UTD.getTypeDescriptor('general.type-script');
368    let ret = typeObj.belongsTo('general.text');
369    expect(ret === true).assertTrue();
370    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
371    console.info(TAG, 'end');
372  });
373
374  /*
375  * @tc.name UdmfTestTypeDescriptor013
376  * @tc.desc Test Js Api isLowerLevelType
377  * @tc.type: FUNC
378  * @tc.require: issueNumber
379  */
380  it('UdmfTestTypeDescriptor013', 0, function () {
381    const TAG = 'UdmfTestTypeDescriptor013:';
382    console.info(TAG, 'start');
383    let typeObj = UTD.getTypeDescriptor('general.type-script');
384    let ret = typeObj.isLowerLevelType('general.text');
385    expect(ret === true).assertTrue();
386    console.info(TAG, 'typeDescriptor, ret ' + ret);
387    console.info(TAG, 'end');
388  });
389
390  /*
391  * @tc.name UdmfTestTypeDescriptor014
392  * @tc.desc Test Js Api isLowerLevelType
393  * @tc.type: FUNC
394  * @tc.require: issueNumber
395  */
396  it('UdmfTestTypeDescriptor014', 0, function () {
397    const TAG = 'UdmfTestTypeDescriptor014:';
398    console.info(TAG, 'start');
399    let typeObj = UTD.getTypeDescriptor('general.text');
400    let ret = typeObj.isHigherLevelType('general.type-script');
401    expect(ret === true).assertTrue();
402    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
403    console.info(TAG, 'end');
404  });
405
406  /*
407  * @tc.name UdmfTestTypeDescriptor015
408  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
409  * @tc.type: FUNC
410  * @tc.require: issueNumber
411  */
412  it('UdmfTestTypeDescriptor015', 0, function () {
413    const TAG = 'UdmfTestTypeDescriptor015:';
414    console.info(TAG, 'start');
415    let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts', 'general.text');
416    expect(typeId === 'general.type-script').assertTrue();
417    console.info(TAG, 'typeDescriptor, ret ' + typeId);
418    console.info(TAG, 'end');
419  });
420
421  /*
422  * @tc.name UdmfTestTypeDescriptor016
423  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
424  * @tc.type: FUNC
425  * @tc.require: issueNumber
426  */
427  it('UdmfTestTypeDescriptor016', 0, function () {
428    const TAG = 'UdmfTestTypeDescriptor016:';
429    console.info(TAG, 'start');
430    let typeId = UTD.getUniformDataTypeByMIMEType('application/vnd.ms-excel', 'general.object');
431    expect(typeId === 'com.microsoft.excel.xls').assertTrue();
432    console.info(TAG, 'typeDescriptor, ret ' + typeId);
433    console.info(TAG, 'end');
434  });
435
436  /*
437  * @tc.name UdmfTestTypeDescriptor017
438  * @tc.desc Test Js Api getUniformDataTypeByMIMEType invalid para
439  * @tc.type: FUNC
440  * @tc.require: issueNumber
441  */
442  it('UdmfTestTypeDescriptor017', 0, function () {
443    const TAG = 'UdmfTestTypeDescriptor017:';
444    console.info(TAG, 'start');
445    try {
446      let typeId = UTD.getUniformDataTypeByMIMEType('');
447      console.error(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
448      expect().assertFail();
449    } catch (e) {
450      console.info(TAG, `get e. code is ${e.code},message is ${e.message} `);
451      expect(e.code === ERROR_PARAMETER).assertEqual(true);
452
453    }
454    console.info(TAG, 'end');
455  });
456
457  /*
458  * @tc.name UdmfTestTypeDescriptor018
459  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
460  * @tc.type: FUNC
461  * @tc.require: issueNumber
462  */
463  it('UdmfTestTypeDescriptor018', 0, function () {
464    const TAG = 'UdmfTestTypeDescriptor018:';
465    console.info(TAG, 'start');
466    try {
467      let typeId = UTD.getUniformDataTypeByFilenameExtension('');
468      console.error(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
469      expect().assertFail();
470    } catch (e) {
471      console.info(TAG, `get e. code is ${e.code},message is ${e.message} `);
472      expect(e.code === ERROR_PARAMETER).assertEqual(true);
473    }
474    console.info(TAG, 'end');
475  });
476
477  /*
478  * @tc.name UdmfTestTypeDescriptor019
479  * @tc.desc Test Js Api belongsTo invalid para
480  * @tc.type: FUNC
481  * @tc.require: issueNumber
482  */
483  it('UdmfTestTypeDescriptor019', 0, function () {
484    const TAG = 'UdmfTestTypeDescriptor019:';
485    console.info(TAG, 'start');
486    let typeObj = UTD.getTypeDescriptor('general.type-script');
487    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
488    try {
489      typeObj.belongsTo('1111');
490      expect().assertFail();
491    } catch (e) {
492      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
493      expect(e.code === ERROR_PARAMETER).assertTrue();
494    }
495    console.info(TAG, 'end');
496  });
497
498  /*
499   * @tc.name UdmfTestTypeDescriptor020
500   * @tc.desc Test Js Api equals invalid para type
501   * @tc.type: FUNC
502   * @tc.require: issueNumber
503   */
504  it('UdmfTestTypeDescriptor020', 0, function () {
505    const TAG = 'UdmfTestTypeDescriptor020:';
506    console.info(TAG, 'start');
507    let typeObj = UTD.getTypeDescriptor('general.type-script');
508    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
509    try {
510      typeObj.isLowerLevelType('1111');
511      expect().assertFail();
512    } catch (e) {
513      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
514      expect(e.code === ERROR_PARAMETER).assertTrue();
515    }
516    console.info(TAG, 'end');
517  });
518
519  /*
520   * @tc.name UdmfTestTypeDescriptor021
521   * @tc.desc Test Js Api isHigherLevelType invalid para type
522   * @tc.type: FUNC
523   * @tc.require: issueNumber
524   */
525  it('UdmfTestTypeDescriptor021', 0, function () {
526    const TAG = 'UdmfTestTypeDescriptor021:';
527    console.info(TAG, 'start');
528    let typeObj = UTD.getTypeDescriptor('general.type-script');
529    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
530    try {
531      typeObj.isHigherLevelType('1111');
532      expect().assertFail();
533    } catch (e) {
534      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
535      expect(e.code === ERROR_PARAMETER).assertTrue();
536    }
537    console.info(TAG, 'end');
538  });
539
540  /*
541  * @tc.name UdmfTestTypeDescriptor022
542  * @tc.desc Test Js Api belongsTo invalid para
543  * @tc.type: FUNC
544  * @tc.require: issueNumber
545  */
546  it('UdmfTestTypeDescriptor022', 0, function () {
547    const TAG = 'UdmfTestTypeDescriptor022:';
548    console.info(TAG, 'start');
549    try {
550      let typeId = UTD.getTypeDescriptor('general.type-script');
551      console.info(TAG, 'typeDescriptor, ret ' + typeId);
552      typeId.belongsTo();
553      expect().assertFail();
554    } catch (e) {
555      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
556      expect(e.code === ERROR_PARAMETER).assertTrue();
557    }
558    console.info(TAG, 'end');
559  });
560
561  /*
562  * @tc.name UdmfTestTypeDescriptor023
563  * @tc.desc Test Js Api isLowerLevelType invalid para
564  * @tc.type: FUNC
565  * @tc.require: issueNumber
566  */
567  it('UdmfTestTypeDescriptor023', 0, function () {
568    const TAG = 'UdmfTestTypeDescriptor023:';
569    console.info(TAG, 'start');
570    try {
571      let typeId = UTD.getTypeDescriptor('general.type-script');
572      console.info(TAG, 'typeDescriptor, ret ' + typeId);
573      typeId.isLowerLevelType();
574      expect().assertFail();
575    } catch (e) {
576      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
577      expect(e.code === ERROR_PARAMETER).assertTrue();
578    }
579    console.info(TAG, 'end');
580  });
581
582  /*
583  * @tc.name UdmfTestTypeDescriptor024
584  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
585  * @tc.type: FUNC
586  * @tc.require: issueNumber
587  */
588  it('UdmfTestTypeDescriptor024', 0, function () {
589    const TAG = 'UdmfTestTypeDescriptor024:';
590    console.info(TAG, 'start');
591    try {
592      let typeId = UTD.getTypeDescriptor('general.type-script');
593      console.info(TAG, 'typeDescriptor, ret ' + typeId);
594      typeId.isHigherLevelType();
595      expect().assertFail();
596    } catch (e) {
597      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
598      expect(e.code === ERROR_PARAMETER).assertTrue();
599    }
600    console.info(TAG, 'end');
601  });
602
603  /*
604  * @tc.name UdmfTestTypeDescriptor025
605  * @tc.desc Test Js Api getUniformDataTypeByMIMEType invalid para
606  * @tc.type: FUNC
607  * @tc.require: issueNumber
608  */
609  it('UdmfTestTypeDescriptor025', 0, function () {
610    const TAG = 'UdmfTestTypeDescriptor025:';
611    console.info(TAG, 'start');
612    try {
613      let typeId = UTD.getUniformDataTypeByMIMEType();
614      console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
615      expect().assertFail();
616    } catch (e) {
617      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
618      expect(e.code === ERROR_PARAMETER).assertTrue();
619    }
620    console.info(TAG, 'end');
621  });
622
623  /*
624  * @tc.name UdmfTestTypeDescriptor026
625  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
626  * @tc.type: FUNC
627  * @tc.require: issueNumber
628  */
629  it('UdmfTestTypeDescriptor026', 0, function () {
630    const TAG = 'UdmfTestTypeDescriptor026:';
631    console.info(TAG, 'start');
632    try {
633      let typeId = UTD.getUniformDataTypeByFilenameExtension();
634      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
635      expect().assertFail();
636    } catch (e) {
637      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
638      expect(e.code === ERROR_PARAMETER).assertTrue();
639    }
640    console.info(TAG, 'end');
641  });
642
643  /*
644  * @tc.name UdmfTestTypeDescriptor027
645  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
646  * @tc.type: FUNC
647  * @tc.require: issueNumber
648  */
649  it('UdmfTestTypeDescriptor027', 0, function () {
650    const TAG = 'UdmfTestTypeDescriptor027:';
651    console.info(TAG, 'start');
652    let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts');
653    expect(typeId === 'general.type-script').assertTrue();
654    console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
655    console.info(TAG, 'end');
656  });
657
658  /*
659  * @tc.name UdmfTestTypeDescriptor028
660  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
661  * @tc.type: FUNC
662  * @tc.require: issueNumber
663  */
664  it('UdmfTestTypeDescriptor028', 0, function () {
665    const TAG = 'UdmfTestTypeDescriptor028:';
666    console.info(TAG, 'start');
667    let typeId = UTD.getUniformDataTypeByMIMEType('application/vnd.ms-excel');
668    expect(typeId === 'com.microsoft.excel.xls').assertTrue();
669    console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
670    console.info(TAG, 'end');
671  });
672
673  /*
674  * @tc.name UdmfTestTypeDescriptor029
675  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
676  * @tc.type: FUNC
677  * @tc.require: issueNumber
678  */
679  it('UdmfTestTypeDescriptor029', 0, function () {
680    const TAG = 'UdmfTestTypeDescriptor029:';
681    console.info(TAG, 'start');
682    try {
683      let flexibleType = UTD.getUniformDataTypeByFilenameExtension('.invalidFilenameExtension');
684      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + flexibleType);
685      let flexibleTypeObj = UTD.getTypeDescriptor(flexibleType);
686      console.info(TAG, 'UDMF,typeId:' + flexibleTypeObj.typeId);
687      console.info(TAG, 'belongingToTypes:' + flexibleTypeObj.belongingToTypes);
688      console.info(TAG, 'filenameExtension:' + flexibleTypeObj.filenameExtensions);
689      console.info(TAG, 'mimeTypes:' + flexibleTypeObj.mimeTypes);
690      expect(flexibleTypeObj.typeId).assertEqual(flexibleType);
691      expect(flexibleTypeObj.belongingToTypes.length).assertEqual(0);
692      expect(flexibleTypeObj.filenameExtensions[0]).assertEqual('.invalidfilenameextension');
693      expect(flexibleTypeObj.mimeTypes.length).assertEqual(0);
694    } catch (e) {
695      console.error(TAG, `get e. code is ${e.code}, message is ${e.message} `);
696      expect().assertFail();
697    }
698    console.info(TAG, 'end');
699  });
700
701  /*
702  * @tc.name UdmfTestTypeDescriptor030
703  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
704  * @tc.type: FUNC
705  * @tc.require: issueNumber
706  */
707  it('UdmfTestTypeDescriptor030', 0, function () {
708    const TAG = 'UdmfTestTypeDescriptor030:';
709    console.info(TAG, 'start');
710    try {
711      let flexibleType = UTD.getUniformDataTypeByMIMEType('invalidMIMEType');
712      console.info(TAG, 'flexibleType=====>' + flexibleType);
713      let flexibleTypeObj = UTD.getTypeDescriptor(flexibleType);
714      console.info(TAG, 'typeId:' + flexibleTypeObj.typeId);
715      console.info(TAG, 'belongingToTypes:' + flexibleTypeObj.belongingToTypes);
716      console.info(TAG, 'filenameExtension:' + flexibleTypeObj.filenameExtensions);
717      console.info(TAG, 'mimeTypes:' + flexibleTypeObj.mimeTypes);
718      expect(flexibleTypeObj.typeId).assertEqual(flexibleType);
719      expect(flexibleTypeObj.belongingToTypes.length).assertEqual(0);
720      expect(flexibleTypeObj.mimeTypes[0]).assertEqual('invalidmimetype');
721      expect(flexibleTypeObj.filenameExtensions.length).assertEqual(0);
722    } catch (e) {
723      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
724      expect().assertFail();
725    }
726    console.info(TAG, 'end');
727  });
728
729  /*
730  * @tc.name UdmfTestTypeDescriptor031
731  * @tc.desc Test Js Api belongsTo invalid para
732  * @tc.type: FUNC
733  * @tc.require: issueNumber
734  */
735  it('UdmfTestTypeDescriptor031', 0, function () {
736    const TAG = 'UdmfTestTypeDescriptor031:';
737    console.info(TAG, 'start');
738    let typeId = UTD.getTypeDescriptor('general.type-script');
739    console.info(TAG, 'typeDescriptor, ret ' + typeId);
740    let ret = typeId.belongsTo('general.type-script');
741    expect(ret === true).assertTrue();
742    console.info(TAG, 'end');
743  });
744
745  /*
746  * @tc.name UdmfTestTypeDescriptor032
747  * @tc.desc Test Js Api isLowerLevelType invalid para
748  * @tc.type: FUNC
749  * @tc.require: issueNumber
750  */
751  it('UdmfTestTypeDescriptor032', 0, function () {
752    const TAG = 'UdmfTestTypeDescriptor032:';
753    console.info(TAG, 'start');
754    let typeId = UTD.getTypeDescriptor('general.type-script');
755    console.info(TAG, 'typeDescriptor, ret ' + typeId);
756    let ret = typeId.isLowerLevelType('general.type-script');
757    expect(ret === false).assertTrue();
758    console.info(TAG, 'end');
759  });
760
761  /*
762  * @tc.name UdmfTestTypeDescriptor033
763  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
764  * @tc.type: FUNC
765  * @tc.require: issueNumber
766  */
767  it('UdmfTestTypeDescriptor033', 0, function () {
768    const TAG = 'UdmfTestTypeDescriptor033:';
769    console.info(TAG, 'start');
770    let typeId = UTD.getTypeDescriptor('general.type-script');
771    console.info(TAG, 'typeDescriptor, ret ' + typeId);
772    let ret = typeId.isHigherLevelType('general.type-script');
773    expect(ret === false).assertTrue();
774    console.info(TAG, 'end');
775  });
776
777  /*
778  * @tc.name UdmfTestTypeDescriptor032
779  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
780  * @tc.type: FUNC
781  * @tc.require: issueNumber
782  */
783  it('UdmfTestTypeDescriptor034', 0, function () {
784    const TAG = 'UdmfTestTypeDescriptor034:';
785    console.info(TAG, 'start');
786    try {
787      let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts', '');
788      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
789      expect().assertFail();
790    } catch (e) {
791      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
792      expect(e.code === ERROR_PARAMETER).assertTrue();
793    }
794    console.info(TAG, 'end');
795  });
796
797  /*
798  * @tc.name UdmfTestTypeDescriptor035
799  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
800  * @tc.type: FUNC
801  * @tc.require: issueNumber
802  */
803  it('UdmfTestTypeDescriptor035', 0, function () {
804    const TAG = 'UdmfTestTypeDescriptor035:';
805    console.info(TAG, 'start');
806    try {
807      let typeId = UTD.getUniformDataTypeByMIMEType('video/3gpp2', '');
808      console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
809      expect().assertFail();
810    } catch (e) {
811      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
812      expect(e.code === ERROR_PARAMETER).assertTrue();
813    }
814    console.info(TAG, 'end');
815  });
816
817  /*
818  * @tc.name UdmfTestTypeDescriptor036
819  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension
820  * @tc.type: FUNC
821  * @tc.require: issueNumber
822  */
823  it('UdmfTestTypeDescriptor036', 0, function () {
824    const TAG = 'UdmfTestTypeDescriptor036:';
825    console.info(TAG, 'start');
826    let typeIds = UTD.getUniformDataTypesByFilenameExtension('.txt');
827    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
828    expect(typeIds.includes('general.plain-text')).assertTrue();
829    console.info(TAG, 'end');
830  });
831
832  /*
833  * @tc.name UdmfTestTypeDescriptor037
834  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension
835  * @tc.type: FUNC
836  * @tc.require: issueNumber
837  */
838  it('UdmfTestTypeDescriptor037', 0, function () {
839    const TAG = 'UdmfTestTypeDescriptor037:';
840    console.info(TAG, 'start');
841    let typeIds = UTD.getUniformDataTypesByFilenameExtension('.txt', 'general.text');
842    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
843    expect(typeIds.includes('general.plain-text')).assertTrue();
844    console.info(TAG, 'end');
845  });
846
847  /*
848  * @tc.name UdmfTestTypeDescriptor038
849  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension invalid param
850  * @tc.type: FUNC
851  * @tc.require: issueNumber
852  */
853  it('UdmfTestTypeDescriptor038', 0, function () {
854    const TAG = 'UdmfTestTypeDescriptor038:';
855    console.info(TAG, 'start');
856    try {
857      let flexTypeIds = UTD.getUniformDataTypesByFilenameExtension('.txt', 'general.video');
858      console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + flexTypeIds);
859      let flexTypeObj = UTD.getTypeDescriptor(flexTypeIds[0]);
860      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + flexTypeObj);
861      console.info(TAG, 'UDMF,typeId:' + flexTypeObj.typeId);
862      console.info(TAG, 'belongingToTypes:' + flexTypeObj.belongingToTypes);
863      console.info(TAG, 'filenameExtension:' + flexTypeObj.filenameExtensions);
864      console.info(TAG, 'mimeTypes:' + flexTypeObj.mimeTypes);
865      expect(flexTypeObj.typeId).assertEqual(flexTypeIds[0]);
866      expect(flexTypeObj.belongingToTypes.length).assertEqual(1);
867      expect(flexTypeObj.filenameExtensions[0]).assertEqual('.txt');
868      expect(flexTypeObj.mimeTypes.length).assertEqual(0);
869    } catch (e) {
870      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
871      expect(e.code === ERROR_PARAMETER).assertTrue();
872    }
873    console.info(TAG, 'end');
874  });
875
876  /*
877  * @tc.name UdmfTestTypeDescriptor039
878  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension invalid param
879  * @tc.type: FUNC
880  * @tc.require: issueNumber
881  */
882  it('UdmfTestTypeDescriptor039', 0, function () {
883    const TAG = 'UdmfTestTypeDescriptor039:';
884    console.info(TAG, 'start');
885    try {
886      let typeIds = UTD.getUniformDataTypesByFilenameExtension('.txt', 'invalid.invalid');
887      console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
888      expect().assertFail();
889    } catch (e) {
890      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
891      expect(e.code === ERROR_PARAMETER).assertTrue();
892    }
893    console.info(TAG, 'end');
894  });
895
896  /*
897  * @tc.name UdmfTestTypeDescriptor040
898  * @tc.desc Test Js Api GetUniformDataTypesByFilenameExtension invalid para
899  * @tc.type: FUNC
900  * @tc.require: issueNumber
901  */
902  it('UdmfTestTypeDescriptor040', 0, function () {
903    const TAG = 'UdmfTestTypeDescriptor040:';
904    console.info(TAG, 'start');
905    try {
906      let typeIds = UTD.getUniformDataTypesByFilenameExtension('.invalid', '');
907      console.error(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
908      expect().assertFail();
909    } catch (e) {
910      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
911      expect(e.code === ERROR_PARAMETER).assertTrue();
912    }
913    console.info(TAG, 'end');
914  });
915
916  /*
917  * @tc.name UdmfTestTypeDescriptor041
918  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType
919  * @tc.type: FUNC
920  * @tc.require: issueNumber
921  */
922  it('UdmfTestTypeDescriptor041', 0, function () {
923    const TAG = 'UdmfTestTypeDescriptor041:';
924    console.info(TAG, 'start');
925    let typeIds = UTD.getUniformDataTypesByMIMEType('text/plain');
926    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
927    expect(typeIds.includes('general.plain-text')).assertTrue();
928    console.info(TAG, 'end');
929  });
930
931  /*
932  * @tc.name UdmfTestTypeDescriptor042
933  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType
934  * @tc.type: FUNC
935  * @tc.require: issueNumber
936  */
937  it('UdmfTestTypeDescriptor042', 0, function () {
938    const TAG = 'UdmfTestTypeDescriptor042:';
939    console.info(TAG, 'start');
940    let typeIds = UTD.getUniformDataTypesByMIMEType('text/plain', 'general.text');
941    console.info(TAG, 'GetUniformDataTypesByFilenameExtension, ret ' + typeIds);
942    expect(typeIds.includes('general.plain-text')).assertTrue();
943    console.info(TAG, 'end');
944  });
945
946  /*
947  * @tc.name UdmfTestTypeDescriptor043
948  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType invalid param
949  * @tc.type: FUNC
950  * @tc.require: issueNumber
951  */
952  it('UdmfTestTypeDescriptor043', 0, function () {
953    const TAG = 'UdmfTestTypeDescriptor043:';
954    console.info(TAG, 'start');
955    try {
956      let flexTypeIds = UTD.getUniformDataTypesByMIMEType('text/plain', 'general.video');
957      console.info(TAG, 'GetUniformDataTypesByMIMEType, ret ' + flexTypeIds);
958      let flexTypeObj = UTD.getTypeDescriptor(flexTypeIds[0]);
959      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + flexTypeObj);
960      console.info(TAG, 'UDMF,typeId:' + flexTypeObj.typeId);
961      console.info(TAG, 'belongingToTypes:' + flexTypeObj.belongingToTypes);
962      console.info(TAG, 'filenameExtension:' + flexTypeObj.filenameExtensions);
963      console.info(TAG, 'mimeTypes:' + flexTypeObj.mimeTypes);
964      expect(flexTypeObj.typeId).assertEqual(flexTypeIds[0]);
965      expect(flexTypeObj.belongingToTypes.length).assertEqual(1);
966      expect(flexTypeObj.filenameExtensions.length).assertEqual(0);
967      expect(flexTypeObj.mimeTypes.length).assertEqual(1);
968    } catch (e) {
969      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
970      expect(e.code === ERROR_PARAMETER).assertTrue();
971    }
972    console.info(TAG, 'end');
973  });
974
975  /*
976  * @tc.name UdmfTestTypeDescriptor044
977  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType invalid param
978  * @tc.type: FUNC
979  * @tc.require: issueNumber
980  */
981  it('UdmfTestTypeDescriptor044', 0, function () {
982    const TAG = 'UdmfTestTypeDescriptor044:';
983    console.info(TAG, 'start');
984    try {
985      let typeIds = UTD.getUniformDataTypesByMIMEType('text/plain', 'invalid.invalid');
986      console.info(TAG, 'GetUniformDataTypesByMIMEType, ret ' + typeIds);
987      expect().assertFail();
988    } catch (e) {
989      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
990      expect(e.code === ERROR_PARAMETER).assertTrue();
991    }
992    console.info(TAG, 'end');
993  });
994
995  /*
996  * @tc.name UdmfTestTypeDescriptor045
997  * @tc.desc Test Js Api GetUniformDataTypesByMIMEType invalid para
998  * @tc.type: FUNC
999  * @tc.require: issueNumber
1000  */
1001  it('UdmfTestTypeDescriptor045', 0, function () {
1002    const TAG = 'UdmfTestTypeDescriptor045:';
1003    console.info(TAG, 'start');
1004    try {
1005      let typeIds = UTD.getUniformDataTypesByMIMEType('invalid/invalid', '');
1006      console.error(TAG, 'GetUniformDataTypesByMIMEType, ret ' + typeIds);
1007      expect().assertFail();
1008    } catch (e) {
1009      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
1010      expect(e.code === ERROR_PARAMETER).assertTrue();
1011    }
1012    console.info(TAG, 'end');
1013  });
1014
1015  /*
1016   * @tc.name UdmfTestTypeDescriptor046
1017   * @tc.desc Test Js Api
1018   * @tc.type: FUNC
1019   * @tc.require: issueIAY1VI
1020   */
1021  it('UdmfTestTypeDescriptor046', 0, function () {
1022    const TAG = 'UdmfTestTypeDescriptor046:';
1023    console.info(TAG, 'start');
1024    let typeObj = UTD.getTypeDescriptor('com.adobe.f4v');
1025    let typeId = typeObj.typeId;
1026    let belonging = typeObj.belongingToTypes;
1027    let description = typeObj.description;
1028    let referenceURL = typeObj.referenceURL;
1029    let iconFile = typeObj.iconFile;
1030    let filenameExtensions = typeObj.filenameExtensions;
1031    let mimeTypes = typeObj.mimeTypes;
1032    console.info(TAG, ', typeId: ' + typeId + ', ' + Object.prototype.toString.call(typeId) +
1033      ', belongingToTypes: ' + belonging + ', ' + Object.prototype.toString.call(belonging));
1034    console.info(TAG, 'description: ' + typeObj.description + ', ' + Object.prototype.toString.call(description));
1035    console.info(TAG, 'referenceURL: ' + referenceURL + ', ' + Object.prototype.toString.call(referenceURL) +
1036      ', iconFile: ' + iconFile + ', ' + Object.prototype.toString.call(iconFile));
1037    expect(typeObj.typeId).assertEqual(UTD.UniformDataType.ADOBE_F4V);
1038    expect(typeObj.belongingToTypes[0]).assertEqual('general.video');
1039    expect(typeObj.description).assertEqual('Flash MP4 Video File');
1040    let equalStr = 'https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/' +
1041      'apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype';
1042    expect(typeObj.referenceURL).assertEqual(equalStr);
1043    expect(typeObj.iconFile).assertEqual('');
1044    expect(typeObj.filenameExtensions[0]).assertEqual('.f4v');
1045    expect(typeObj.mimeTypes[0]).assertEqual('video/mp4');
1046    console.info(TAG, 'end');
1047  });
1048
1049  /*
1050   * @tc.name UdmfTestTypeDescriptor047
1051   * @tc.desc Test Js Api
1052   * @tc.type: FUNC
1053   * @tc.require: issueIAY1VI
1054   */
1055  it('UdmfTestTypeDescriptor047', 0, function () {
1056    const TAG = 'UdmfTestTypeDescriptor047:';
1057    console.info(TAG, 'start');
1058    let typeObj = UTD.getTypeDescriptor('general.ac3-audio');
1059    let typeId = typeObj.typeId;
1060    let belonging = typeObj.belongingToTypes;
1061    let description = typeObj.description;
1062    let referenceURL = typeObj.referenceURL;
1063    let iconFile = typeObj.iconFile;
1064    let filenameExtensions = typeObj.filenameExtensions;
1065    let mimeTypes = typeObj.mimeTypes;
1066    console.info(TAG, ', typeId: ' + typeId + ', ' + Object.prototype.toString.call(typeId) +
1067      ', belongingToTypes: ' + belonging + ', ' + Object.prototype.toString.call(belonging));
1068    console.info(TAG, 'description: ' + typeObj.description + ', ' + Object.prototype.toString.call(description));
1069    console.info(TAG, 'referenceURL: ' + referenceURL + ', ' + Object.prototype.toString.call(referenceURL) +
1070      ', iconFile: ' + iconFile + ', ' + Object.prototype.toString.call(iconFile));
1071    expect(typeObj.typeId).assertEqual(UTD.UniformDataType.AC3_AUDIO);
1072    expect(typeObj.belongingToTypes[0]).assertEqual('general.audio');
1073    expect(typeObj.description).assertEqual('Audio Codec 3 File Format');
1074    let equalStr = 'https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/' +
1075      'apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype';
1076    expect(typeObj.referenceURL).assertEqual(equalStr);
1077    expect(typeObj.iconFile).assertEqual('');
1078    expect(typeObj.filenameExtensions[0]).assertEqual('.ac3');
1079    expect(typeObj.mimeTypes[0]).assertEqual('audio/ac3');
1080    console.info(TAG, 'end');
1081  });
1082
1083  /*
1084   * @tc.name UdmfTestTypeDescriptor048
1085   * @tc.desc Test Js Api isLowerLevelType
1086   * @tc.type: FUNC
1087   * @tc.require: issueIAY1VI
1088   */
1089  it('UdmfTestTypeDescriptor048', 0, function () {
1090    const TAG = 'UdmfTestTypeDescriptor048:';
1091    console.info(TAG, 'start');
1092    let typeObj = UTD.getTypeDescriptor('com.aol.art-image');
1093    let belongsToRet = typeObj.belongsTo('general.image');
1094    expect(belongsToRet === true).assertTrue();
1095    let LowerLevelRet = typeObj.isLowerLevelType('general.object');
1096    expect(LowerLevelRet === true).assertTrue();
1097    console.info(TAG, 'end');
1098  });
1099
1100  /*
1101   * @tc.name UdmfTestTypeDescriptor049
1102   * @tc.desc Test Js Api isLowerLevelType
1103   * @tc.type: FUNC
1104   * @tc.require: issueIAY1VI
1105   */
1106   it('UdmfTestTypeDescriptor049', 0, function () {
1107     const TAG = 'UdmfTestTypeDescriptor049:';
1108     console.info(TAG, 'start');
1109     let typeObj = UTD.getTypeDescriptor('com.aol.art-image');
1110     let belongsToRet = typeObj.belongsTo('general.image');
1111     expect(belongsToRet === true).assertTrue();
1112     let LowerLevelRet = typeObj.isLowerLevelType('general.object');
1113     expect(LowerLevelRet === true).assertTrue();
1114     console.info(TAG, 'end');
1115   });
1116
1117  /*
1118   * @tc.name UdmfTestTypeDescriptor050
1119   * @tc.desc Test Js Api isHigherLevelType
1120   * @tc.type: FUNC
1121   * @tc.require: issueIAY1VI
1122   */
1123   it('UdmfTestTypeDescriptor050', 0, function () {
1124    const TAG = 'UdmfTestTypeDescriptor050:';
1125    console.info(TAG, 'start');
1126    let typeObj = UTD.getTypeDescriptor('com.apple.m4p-audio');
1127    let belongsToRet = typeObj.belongsTo('general.audio');
1128    expect(belongsToRet === true).assertTrue();
1129    let higherLevelRet = UTD.getTypeDescriptor('general.media').isHigherLevelType(UTD.UniformDataType.M4P_AUDIO);
1130    expect(higherLevelRet === true).assertTrue();
1131    console.info(TAG, 'end');
1132  });
1133
1134  /*
1135   * @tc.name UdmfTestTypeDescriptor051
1136   * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
1137   * @tc.type: FUNC
1138   * @tc.require: issueIAY1VI
1139   */
1140  it('UdmfTestTypeDescriptor051', 0, function () {
1141    const TAG = 'UdmfTestTypeDescriptor051:';
1142    console.info(TAG, 'start');
1143    let typeId = UTD.getUniformDataTypeByFilenameExtension('.nrw');
1144    expect(typeId === 'com.nikon.nrw-raw-image').assertTrue();
1145    console.info(TAG, 'typeDescriptor, ret ' + typeId);
1146    console.info(TAG, 'end');
1147  });
1148
1149  /*
1150   * @tc.name UdmfTestTypeDescriptor052
1151   * @tc.desc Test utd(general.mpeg-4) filename extension
1152   * @tc.type: FUNC
1153   * @tc.require: issueIAY1VI
1154   */
1155  it('UdmfTestTypeDescriptor052', 0, function () {
1156    const TAG = 'UdmfTestTypeDescriptor052:';
1157    console.info(TAG, 'start');
1158    let typeObj = UTD.getTypeDescriptor('general.mpeg-4');
1159    let filenameExtensions = typeObj.filenameExtensions;
1160    expect(typeObj.filenameExtensions[0]).assertEqual('.mp4');
1161    expect(typeObj.filenameExtensions[1]).assertEqual('.mp4v');
1162    expect(typeObj.filenameExtensions[2]).assertEqual('.mpeg4');
1163    console.info(TAG, 'end');
1164  });
1165
1166  /*
1167   * @tc.name UdmfTestTypeDescriptor053
1168   * @tc.desc Test utd(general.heif) filename extension
1169   * @tc.type: FUNC
1170   * @tc.require: issueIAY1VI
1171   */
1172  it('UdmfTestTypeDescriptor053', 0, function () {
1173    const TAG = 'UdmfTestTypeDescriptor053:';
1174    console.info(TAG, 'start');
1175    let typeObj = UTD.getTypeDescriptor('general.heif');
1176    let filenameExtensions = typeObj.filenameExtensions;
1177    expect(typeObj.filenameExtensions[0]).assertEqual('.heif');
1178    expect(typeObj.filenameExtensions[1]).assertEqual('.heifs');
1179    expect(typeObj.filenameExtensions[2]).assertEqual('.hif');
1180    console.info(TAG, 'end');
1181  });
1182
1183  /*
1184   * @tc.name UdmfTestTypeDescriptor054
1185   * @tc.desc Test utd(general.mpeg-4-audio) filename extension
1186   * @tc.type: FUNC
1187   * @tc.require: issueIAY1VI
1188   */
1189  it('UdmfTestTypeDescriptor054', 0, function () {
1190    const TAG = 'UdmfTestTypeDescriptor054:';
1191    console.info(TAG, 'start');
1192    let typeObj = UTD.getTypeDescriptor('general.mpeg-4-audio');
1193    let filenameExtensions = typeObj.filenameExtensions;
1194    expect(typeObj.filenameExtensions[0]).assertEqual('.m4a');
1195    expect(typeObj.filenameExtensions[1]).assertEqual('.m4b');
1196    console.info(TAG, 'end');
1197  });
1198
1199  /*
1200   * @tc.name UdmfTestTypeDescriptor055
1201   * @tc.desc Test utd(general.heic) filename extension
1202   * @tc.type: FUNC
1203   * @tc.require: issueIAY1VI
1204   */
1205  it('UdmfTestTypeDescriptor055', 0, function () {
1206    const TAG = 'UdmfTestTypeDescriptor055:';
1207    console.info(TAG, 'start');
1208    let typeObj = UTD.getTypeDescriptor('general.heic');
1209    let filenameExtensions = typeObj.filenameExtensions;
1210    expect(typeObj.filenameExtensions[0]).assertEqual('.heic');
1211    expect(typeObj.filenameExtensions[1]).assertEqual('.heics');
1212    console.info(TAG, 'end');
1213  });
1214});