• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (c) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
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    console.info(TAG, ', typeId: ' + typeId + ', ' + Object.prototype.toString.call(typeId) +
60      ', belongingToTypes: ' + belonging + ', ' + Object.prototype.toString.call(belonging));
61    console.info(TAG, 'description: ' + typeObj.description + ', ' + Object.prototype.toString.call(description));
62    console.info(TAG, 'referenceURL: ' + referenceURL + ', ' + Object.prototype.toString.call(referenceURL) +
63      ', iconFile: ' + iconFile + ', ' + Object.prototype.toString.call(iconFile));
64    expect(typeObj.typeId).assertEqual(UTD.UniformDataType.PHOTOSHOP_IMAGE);
65    expect(typeObj.belongingToTypes[0]).assertEqual('general.image');
66    expect(typeObj.description).assertEqual('Adobe Photoshop document.');
67    let equalStr = 'https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/' +
68      'apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype';
69    expect(typeObj.referenceURL).assertEqual(equalStr);
70    expect(typeObj.iconFile).assertEqual('sys.media.ohos_ic_normal_white_grid_image');
71    console.info(TAG, 'end');
72  });
73
74  /*
75   * @tc.name UdmfTestTypeDescriptor003
76   * @tc.desc Test Js Api
77   * @tc.type: FUNC
78   * @tc.require: issueNumber
79   */
80  it ('UdmfTestTypeDescriptor003', 0, function () {
81    const TAG = 'UdmfTestTypeDescriptor003:';
82    console.info(TAG, 'start');
83    let typeObj = UTD.getTypeDescriptor('general.type-script');
84    let typeObj2 = UTD.getTypeDescriptor('general.python-script');
85    let typeObj3 = UTD.getTypeDescriptor('general.python-script');
86    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
87    console.info(TAG, 'typeDescriptor, ret ' + typeObj2);
88    let ret = typeObj.equals(typeObj2);
89    console.info(TAG, 'typeObj equals with typeObj2 is ' + ret);
90    expect(ret).assertEqual(false);
91    ret = typeObj2.equals(typeObj3);
92    console.info(TAG, 'typeObj2 equals with typeObj3 is ' + ret);
93    expect(ret).assertEqual(true);
94    console.info(TAG, 'end');
95  });
96
97  /*
98   * @tc.name UdmfTestTypeDescriptor004
99   * @tc.desc Test Js Api invalid para type
100   * @tc.type: FUNC
101   * @tc.require: issueNumber
102   */
103  it ('UdmfTestTypeDescriptor004', 0, function () {
104    const TAG = 'UdmfTestTypeDescriptor004:';
105    console.info(TAG, 'start');
106    try {
107      let typeObj = UTD.getTypeDescriptor(null);
108      console.info(TAG, 'typeDescriptor, ret ' + typeObj);
109    } catch (e) {
110      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
111      expect(e.code === ERROR_PARAMETER).assertTrue();
112    }
113    console.info(TAG, 'end');
114  });
115
116  /*
117 * @tc.name UdmfTestTypeDescriptor005
118 * @tc.desc Test Js Api
119 * @tc.type: FUNC
120 * @tc.require: issueNumber
121 */
122  it ('UdmfTestTypeDescriptor005', 0, function () {
123    const TAG = 'UdmfTestTypeDescriptor005:';
124    console.info(TAG, 'start');
125    let typeObj = UTD.getTypeDescriptor('com.adobe.photoshop-image', INVALID_TYPE1, INVALID_TYPE2);
126    let typeId = typeObj.typeId;
127    let belonging = typeObj.belongingToTypes;
128    let description = typeObj.description;
129    let referenceURL = typeObj.referenceURL;
130    let iconFile = typeObj.iconFile;
131    console.info(TAG, ', typeId: ' + typeId + ', ' + Object.prototype.toString.call(typeId) +
132      ', belongingToTypes: ' + belonging + ', ' + Object.prototype.toString.call(belonging));
133    console.info(TAG, 'description: ' + typeObj.description + ', ' + Object.prototype.toString.call(description));
134    console.info(TAG, 'referenceURL: ' + referenceURL + ', ' + Object.prototype.toString.call(referenceURL) +
135      ', iconFile: ' + iconFile + ', ' + Object.prototype.toString.call(iconFile));
136    expect(typeObj.typeId).assertEqual(UTD.UniformDataType.PHOTOSHOP_IMAGE);
137    expect(typeObj.belongingToTypes[0]).assertEqual('general.image');
138    expect(typeObj.description).assertEqual('Adobe Photoshop document.');
139    let equalStr = 'https://gitee.com/openharmony/docs/blob/master/en/application-dev/reference/' +
140      'apis/js-apis-data-uniformTypeDescriptor.md#uniformdatatype';
141    expect(typeObj.referenceURL).assertEqual(equalStr);
142    expect(typeObj.iconFile).assertEqual('sys.media.ohos_ic_normal_white_grid_image');
143    console.info(TAG, 'end');
144  });
145
146  /*
147   * @tc.name UdmfTestTypeDescriptor007
148   * @tc.desc Test Js Api foreach all UniformDataType
149   * @tc.type: FUNC
150   * @tc.require: issueNumber
151   */
152  it ('UdmfTestTypeDescriptor006', 0, function () {
153    const TAG = 'UdmfTestTypeDescriptor006:';
154    console.info(TAG, 'start');
155    for (let utdType in UTD.UniformDataType) {
156      let typeObj = UTD.getTypeDescriptor(UTD.UniformDataType[utdType]);
157      if (typeObj != null) {
158        expect(typeObj.typeId).assertEqual(UTD.UniformDataType[utdType]);
159      }
160    }
161    console.info(TAG, 'end');
162  });
163
164  /*
165   * @tc.name UdmfTestTypeDescriptor007
166   * @tc.desc Test Js Api getTypeDescriptor no para
167   * @tc.type: FUNC
168   * @tc.require: issueNumber
169   */
170  it ('UdmfTestTypeDescriptor007', 0, function () {
171    const TAG = 'UdmfTestTypeDescriptor007:';
172    console.info(TAG, 'start');
173    try {
174      let typeObj = UTD.getTypeDescriptor();
175      console.info(TAG, 'typeDescriptor, ret ' + typeObj);
176    } catch (e) {
177      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
178      expect(e.code === ERROR_PARAMETER).assertTrue();
179    }
180    console.info(TAG, 'end');
181  });
182
183  /*
184   * @tc.name UdmfTestTypeDescriptor008
185   * @tc.desc Test Js Api equals invalid para type
186   * @tc.type: FUNC
187   * @tc.require: issueNumber
188   */
189  it ('UdmfTestTypeDescriptor008', 0, function () {
190    const TAG = 'UdmfTestTypeDescriptor008:';
191    console.info(TAG, 'start');
192    let typeObj = UTD.getTypeDescriptor('general.type-script');
193    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
194    try {
195      typeObj.equals('1111');
196      expect().assertFail();
197    } catch (e) {
198      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
199      expect(e.code === ERROR_PARAMETER).assertTrue();
200    }
201    console.info(TAG, 'end');
202  });
203
204  /*
205   * @tc.name UdmfTestTypeDescriptor009
206   * @tc.desc Test Js Api enum value judge part1
207   * @tc.type: FUNC
208   * @tc.require: issueNumber
209   */
210  it ('UdmfTestTypeDescriptor009', 0, function () {
211    const TAG = 'UdmfTestTypeDescriptor009:';
212    console.info(TAG, 'start');
213    expect(UTD.UniformDataType.TEXT).assertEqual('general.text');
214    expect(UTD.UniformDataType.PLAIN_TEXT).assertEqual('general.plain-text');
215    expect(UTD.UniformDataType.HTML).assertEqual('general.html');
216    expect(UTD.UniformDataType.HYPERLINK).assertEqual('general.hyperlink');
217    expect(UTD.UniformDataType.XML).assertEqual('general.xml');
218    expect(UTD.UniformDataType.SOURCE_CODE).assertEqual('general.source-code');
219    expect(UTD.UniformDataType.SCRIPT).assertEqual('general.script');
220    expect(UTD.UniformDataType.SHELL_SCRIPT).assertEqual('general.shell-script');
221    expect(UTD.UniformDataType.CSH_SCRIPT).assertEqual('general.csh-script');
222    expect(UTD.UniformDataType.PERL_SCRIPT).assertEqual('general.perl-script');
223    expect(UTD.UniformDataType.PHP_SCRIPT).assertEqual('general.php-script');
224    expect(UTD.UniformDataType.PYTHON_SCRIPT).assertEqual('general.python-script');
225    expect(UTD.UniformDataType.RUBY_SCRIPT).assertEqual('general.ruby-script');
226    expect(UTD.UniformDataType.TYPE_SCRIPT).assertEqual('general.type-script');
227    expect(UTD.UniformDataType.JAVA_SCRIPT).assertEqual('general.java-script');
228    expect(UTD.UniformDataType.C_HEADER).assertEqual('general.c-header');
229    expect(UTD.UniformDataType.C_SOURCE).assertEqual('general.c-source');
230    expect(UTD.UniformDataType.C_PLUS_PLUS_HEADER).assertEqual('general.c-plus-plus-header');
231    expect(UTD.UniformDataType.C_PLUS_PLUS_SOURCE).assertEqual('general.c-plus-plus-source');
232    expect(UTD.UniformDataType.JAVA_SOURCE).assertEqual('general.java-source');
233    expect(UTD.UniformDataType.EBOOK).assertEqual('general.ebook');
234    expect(UTD.UniformDataType.EPUB).assertEqual('general.epub');
235    expect(UTD.UniformDataType.AZW).assertEqual('com.amazon.azw');
236    expect(UTD.UniformDataType.AZW3).assertEqual('com.amazon.azw3');
237    expect(UTD.UniformDataType.KFX).assertEqual('com.amazon.kfx');
238    expect(UTD.UniformDataType.MOBI).assertEqual('com.amazon.mobi');
239    expect(UTD.UniformDataType.MEDIA).assertEqual('general.media');
240    expect(UTD.UniformDataType.IMAGE).assertEqual('general.image');
241    expect(UTD.UniformDataType.JPEG).assertEqual('general.jpeg');
242    console.info(TAG, 'end');
243  });
244
245  /*
246   * @tc.name UdmfTestTypeDescriptor010
247   * @tc.desc Test Js Api enum value judge part2
248   * @tc.type: FUNC
249   * @tc.require: issueNumber
250   */
251  it ('UdmfTestTypeDescriptor010', 0, function () {
252    const TAG = 'UdmfTestTypeDescriptor010:';
253    console.info(TAG, 'start');
254    expect(UTD.UniformDataType.PNG).assertEqual('general.png');
255    expect(UTD.UniformDataType.RAW_IMAGE).assertEqual('general.raw-image');
256    expect(UTD.UniformDataType.TIFF).assertEqual('general.tiff');
257    expect(UTD.UniformDataType.BMP).assertEqual('com.microsoft.bmp');
258    expect(UTD.UniformDataType.ICO).assertEqual('com.microsoft.ico');
259    expect(UTD.UniformDataType.PHOTOSHOP_IMAGE).assertEqual('com.adobe.photoshop-image');
260    expect(UTD.UniformDataType.AI_IMAGE).assertEqual('com.adobe.illustrator.ai-image');
261    expect(UTD.UniformDataType.WORD_DOC).assertEqual('com.microsoft.word.doc');
262    expect(UTD.UniformDataType.EXCEL).assertEqual('com.microsoft.excel.xls');
263    expect(UTD.UniformDataType.PPT).assertEqual('com.microsoft.powerpoint.ppt');
264    expect(UTD.UniformDataType.PDF).assertEqual('com.adobe.pdf');
265    expect(UTD.UniformDataType.POSTSCRIPT).assertEqual('com.adobe.postscript');
266    expect(UTD.UniformDataType.ENCAPSULATED_POSTSCRIPT).assertEqual('com.adobe.encapsulated-postscript');
267    expect(UTD.UniformDataType.VIDEO).assertEqual('general.video');
268    expect(UTD.UniformDataType.AVI).assertEqual('general.avi');
269    expect(UTD.UniformDataType.MPEG).assertEqual('general.mpeg');
270    expect(UTD.UniformDataType.MPEG4).assertEqual('general.mpeg-4');
271    expect(UTD.UniformDataType.VIDEO_3GPP).assertEqual('general.3gpp');
272    expect(UTD.UniformDataType.VIDEO_3GPP2).assertEqual('general.3gpp2');
273    expect(UTD.UniformDataType.WINDOWS_MEDIA_WM).assertEqual('com.microsoft.windows-media-wm');
274    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMV).assertEqual('com.microsoft.windows-media-wmv');
275    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMP).assertEqual('com.microsoft.windows-media-wmp');
276    expect(UTD.UniformDataType.AUDIO).assertEqual('general.audio');
277    expect(UTD.UniformDataType.AAC).assertEqual('general.aac');
278    expect(UTD.UniformDataType.AIFF).assertEqual('general.aiff');
279    expect(UTD.UniformDataType.ALAC).assertEqual('general.alac');
280    expect(UTD.UniformDataType.FLAC).assertEqual('general.flac');
281    expect(UTD.UniformDataType.MP3).assertEqual('general.mp3');
282    expect(UTD.UniformDataType.OGG).assertEqual('general.ogg');
283    expect(UTD.UniformDataType.PCM).assertEqual('general.pcm');
284    console.info(TAG, 'end');
285  });
286
287  /*
288   * @tc.name UdmfTestTypeDescriptor011
289   * @tc.desc Test Js Api enum value judge part3
290   * @tc.type: FUNC
291   * @tc.require: issueNumber
292   */
293  it ('UdmfTestTypeDescriptor011', 0, function () {
294    const TAG = 'UdmfTestTypeDescriptor011:';
295    console.info(TAG, 'start');
296    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMA).assertEqual('com.microsoft.windows-media-wma');
297    expect(UTD.UniformDataType.WAVEFORM_AUDIO).assertEqual('com.microsoft.waveform-audio');
298    expect(UTD.UniformDataType.WINDOWS_MEDIA_WMX).assertEqual('com.microsoft.windows-media-wmx');
299    expect(UTD.UniformDataType.WINDOWS_MEDIA_WVX).assertEqual('com.microsoft.windows-media-wvx');
300    expect(UTD.UniformDataType.WINDOWS_MEDIA_WAX).assertEqual('com.microsoft.windows-media-wax');
301    expect(UTD.UniformDataType.FILE).assertEqual('general.file');
302    expect(UTD.UniformDataType.DIRECTORY).assertEqual('general.directory');
303    expect(UTD.UniformDataType.FOLDER).assertEqual('general.folder');
304    expect(UTD.UniformDataType.SYMLINK).assertEqual('general.symlink');
305    expect(UTD.UniformDataType.ARCHIVE).assertEqual('general.archive');
306    expect(UTD.UniformDataType.BZ2_ARCHIVE).assertEqual('general.bz2-archive');
307    expect(UTD.UniformDataType.DISK_IMAGE).assertEqual('general.disk-image');
308    expect(UTD.UniformDataType.TAR_ARCHIVE).assertEqual('general.tar-archive');
309    expect(UTD.UniformDataType.ZIP_ARCHIVE).assertEqual('general.zip-archive');
310    expect(UTD.UniformDataType.JAVA_ARCHIVE).assertEqual('com.sun.java-archive');
311    expect(UTD.UniformDataType.GNU_TAR_ARCHIVE).assertEqual('org.gnu.gnu-tar-archive');
312    expect(UTD.UniformDataType.GNU_ZIP_ARCHIVE).assertEqual('org.gnu.gnu-zip-archive');
313    expect(UTD.UniformDataType.GNU_ZIP_TAR_ARCHIVE).assertEqual('org.gnu.gnu-zip-tar-archive');
314    expect(UTD.UniformDataType.CALENDAR).assertEqual('general.calendar');
315    expect(UTD.UniformDataType.CONTACT).assertEqual('general.contact');
316    expect(UTD.UniformDataType.DATABASE).assertEqual('general.database');
317    expect(UTD.UniformDataType.MESSAGE).assertEqual('general.message');
318    expect(UTD.UniformDataType.VCARD).assertEqual('general.vcard');
319    expect(UTD.UniformDataType.NAVIGATION).assertEqual('general.navigation');
320    expect(UTD.UniformDataType.LOCATION).assertEqual('general.location');
321    expect(UTD.UniformDataType.OPENHARMONY_FORM).assertEqual('openharmony.form');
322    expect(UTD.UniformDataType.OPENHARMONY_APP_ITEM).assertEqual('openharmony.app-item');
323    expect(UTD.UniformDataType.OPENHARMONY_PIXEL_MAP).assertEqual('openharmony.pixel-map');
324    expect(UTD.UniformDataType.OPENHARMONY_ATOMIC_SERVICE).assertEqual('openharmony.atomic-service');
325    console.info(TAG, 'end');
326  });
327
328  /*
329  * @tc.name UdmfTestTypeDescriptor012
330  * @tc.desc Test Js Api belongsTo
331  * @tc.type: FUNC
332  * @tc.require: issueNumber
333  */
334  it ('UdmfTestTypeDescriptor012', 0, function () {
335    const TAG = 'UdmfTestTypeDescriptor012:';
336    console.info(TAG, 'start');
337    let typeObj = UTD.getTypeDescriptor('general.type-script');
338    let ret = typeObj.belongsTo('general.plain-text');
339    expect(ret === true).assertTrue();
340    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
341    console.info(TAG, 'end');
342  });
343
344  /*
345  * @tc.name UdmfTestTypeDescriptor013
346  * @tc.desc Test Js Api isLowerLevelType
347  * @tc.type: FUNC
348  * @tc.require: issueNumber
349  */
350  it ('UdmfTestTypeDescriptor013', 0, function () {
351    const TAG = 'UdmfTestTypeDescriptor013:';
352    console.info(TAG, 'start');
353    let typeObj = UTD.getTypeDescriptor('general.type-script');
354    let ret = typeObj.isLowerLevelType('general.plain-text');
355    expect(ret === true).assertTrue();
356    console.info(TAG, 'typeDescriptor, ret ' + ret);
357    console.info(TAG, 'end');
358  });
359
360  /*
361  * @tc.name UdmfTestTypeDescriptor014
362  * @tc.desc Test Js Api isLowerLevelType
363  * @tc.type: FUNC
364  * @tc.require: issueNumber
365  */
366  it ('UdmfTestTypeDescriptor014', 0, function () {
367    const TAG = 'UdmfTestTypeDescriptor014:';
368    console.info(TAG, 'start');
369    let typeObj = UTD.getTypeDescriptor('general.plain-text');
370    let ret = typeObj.isHigherLevelType('general.type-script');
371    expect(ret === true).assertTrue();
372    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
373    console.info(TAG, 'end');
374  });
375
376  /*
377  * @tc.name UdmfTestTypeDescriptor015
378  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
379  * @tc.type: FUNC
380  * @tc.require: issueNumber
381  */
382  it ('UdmfTestTypeDescriptor015', 0, function () {
383    const TAG = 'UdmfTestTypeDescriptor015:';
384    console.info(TAG, 'start');
385    let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts', 'general.plain-text');
386    expect(typeId === 'general.type-script').assertTrue();
387    console.info(TAG, 'typeDescriptor, ret ' + typeId);
388    console.info(TAG, 'end');
389  });
390
391  /*
392  * @tc.name UdmfTestTypeDescriptor016
393  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
394  * @tc.type: FUNC
395  * @tc.require: issueNumber
396  */
397  it ('UdmfTestTypeDescriptor016', 0, function () {
398    const TAG = 'UdmfTestTypeDescriptor016:';
399    console.info(TAG, 'start');
400    let typeId = UTD.getUniformDataTypeByMIMEType('application/vnd.ms-excel', 'general.object');
401    expect(typeId === 'com.microsoft.excel.xls').assertTrue();
402    console.info(TAG, 'typeDescriptor, ret ' + typeId);
403    console.info(TAG, 'end');
404  });
405
406  /*
407  * @tc.name UdmfTestTypeDescriptor017
408  * @tc.desc Test Js Api getUniformDataTypeByMIMEType invalid para
409  * @tc.type: FUNC
410  * @tc.require: issueNumber
411  */
412  it('UdmfTestTypeDescriptor017', 0, function () {
413    const TAG = 'UdmfTestTypeDescriptor017:';
414    console.info(TAG, 'start');
415    try {
416      let typeId = UTD.getUniformDataTypeByMIMEType('');
417      console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
418      expect(typeId === null).assertTrue();
419    } catch (e) {
420      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
421      expect().assertFail();
422    }
423    console.info(TAG, 'end');
424  });
425
426  /*
427  * @tc.name UdmfTestTypeDescriptor018
428  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
429  * @tc.type: FUNC
430  * @tc.require: issueNumber
431  */
432  it('UdmfTestTypeDescriptor018', 0, function () {
433    const TAG = 'UdmfTestTypeDescriptor018:';
434    console.info(TAG, 'start');
435    try {
436      let typeId = UTD.getUniformDataTypeByFilenameExtension('');
437      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
438      expect(typeId === null).assertTrue();
439    } catch (e) {
440      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
441      expect().assertFail();
442    }
443    console.info(TAG, 'end');
444  });
445
446  /*
447  * @tc.name UdmfTestTypeDescriptor019
448  * @tc.desc Test Js Api belongsTo invalid para
449  * @tc.type: FUNC
450  * @tc.require: issueNumber
451  */
452  it('UdmfTestTypeDescriptor019', 0, function () {
453    const TAG = 'UdmfTestTypeDescriptor019:';
454    console.info(TAG, 'start');
455    let typeObj = UTD.getTypeDescriptor('general.type-script');
456    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
457    try {
458      typeObj.belongsTo('1111');
459      expect().assertFail();
460    } catch (e) {
461      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
462      expect(e.code === ERROR_PARAMETER).assertTrue();
463    }
464    console.info(TAG, 'end');
465  });
466
467  /*
468   * @tc.name UdmfTestTypeDescriptor020
469   * @tc.desc Test Js Api equals invalid para type
470   * @tc.type: FUNC
471   * @tc.require: issueNumber
472   */
473  it('UdmfTestTypeDescriptor020', 0, function () {
474    const TAG = 'UdmfTestTypeDescriptor020:';
475    console.info(TAG, 'start');
476    let typeObj = UTD.getTypeDescriptor('general.type-script');
477    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
478    try {
479      typeObj.isLowerLevelType('1111');
480      expect().assertFail();
481    } catch (e) {
482      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
483      expect(e.code === ERROR_PARAMETER).assertTrue();
484    }
485    console.info(TAG, 'end');
486  });
487
488  /*
489   * @tc.name UdmfTestTypeDescriptor021
490   * @tc.desc Test Js Api isHigherLevelType invalid para type
491   * @tc.type: FUNC
492   * @tc.require: issueNumber
493   */
494  it('UdmfTestTypeDescriptor021', 0, function () {
495    const TAG = 'UdmfTestTypeDescriptor021:';
496    console.info(TAG, 'start');
497    let typeObj = UTD.getTypeDescriptor('general.type-script');
498    console.info(TAG, 'typeDescriptor, ret ' + typeObj);
499    try {
500      typeObj.isHigherLevelType('1111');
501      expect().assertFail();
502    } catch (e) {
503      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
504      expect(e.code === ERROR_PARAMETER).assertTrue();
505    }
506    console.info(TAG, 'end');
507  });
508
509  /*
510  * @tc.name UdmfTestTypeDescriptor022
511  * @tc.desc Test Js Api belongsTo invalid para
512  * @tc.type: FUNC
513  * @tc.require: issueNumber
514  */
515  it('UdmfTestTypeDescriptor022', 0, function () {
516    const TAG = 'UdmfTestTypeDescriptor022:';
517    console.info(TAG, 'start');
518    try {
519      let typeId = UTD.getTypeDescriptor('general.type-script');
520      console.info(TAG, 'typeDescriptor, ret ' + typeId);
521      typeId.belongsTo();
522      expect().assertFail();
523    } catch (e) {
524      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
525      expect(e.code === ERROR_PARAMETER).assertTrue();
526    }
527    console.info(TAG, 'end');
528  });
529
530  /*
531  * @tc.name UdmfTestTypeDescriptor023
532  * @tc.desc Test Js Api isLowerLevelType invalid para
533  * @tc.type: FUNC
534  * @tc.require: issueNumber
535  */
536  it('UdmfTestTypeDescriptor023', 0, function () {
537    const TAG = 'UdmfTestTypeDescriptor023:';
538    console.info(TAG, 'start');
539    try {
540      let typeId = UTD.getTypeDescriptor('general.type-script');
541      console.info(TAG, 'typeDescriptor, ret ' + typeId);
542      typeId.isLowerLevelType();
543      expect().assertFail();
544    } catch (e) {
545      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
546      expect(e.code === ERROR_PARAMETER).assertTrue();
547    }
548    console.info(TAG, 'end');
549  });
550
551  /*
552  * @tc.name UdmfTestTypeDescriptor024
553  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
554  * @tc.type: FUNC
555  * @tc.require: issueNumber
556  */
557  it('UdmfTestTypeDescriptor024', 0, function () {
558    const TAG = 'UdmfTestTypeDescriptor024:';
559    console.info(TAG, 'start');
560    try {
561      let typeId = UTD.getTypeDescriptor('general.type-script');
562      console.info(TAG, 'typeDescriptor, ret ' + typeId);
563      typeId.isHigherLevelType();
564      expect().assertFail();
565    } catch (e) {
566      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
567      expect(e.code === ERROR_PARAMETER).assertTrue();
568    }
569    console.info(TAG, 'end');
570  });
571
572  /*
573  * @tc.name UdmfTestTypeDescriptor025
574  * @tc.desc Test Js Api getUniformDataTypeByMIMEType invalid para
575  * @tc.type: FUNC
576  * @tc.require: issueNumber
577  */
578  it('UdmfTestTypeDescriptor025', 0, function () {
579    const TAG = 'UdmfTestTypeDescriptor025:';
580    console.info(TAG, 'start');
581    try {
582      let typeId = UTD.getUniformDataTypeByMIMEType();
583      console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
584      expect().assertFail();
585    } catch (e) {
586      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
587      expect(e.code === ERROR_PARAMETER).assertTrue();
588    }
589    console.info(TAG, 'end');
590  });
591
592  /*
593  * @tc.name UdmfTestTypeDescriptor026
594  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
595  * @tc.type: FUNC
596  * @tc.require: issueNumber
597  */
598  it('UdmfTestTypeDescriptor026', 0, function () {
599    const TAG = 'UdmfTestTypeDescriptor026:';
600    console.info(TAG, 'start');
601    try {
602      let typeId = UTD.getUniformDataTypeByFilenameExtension();
603      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
604      expect().assertFail();
605    } catch (e) {
606      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
607      expect(e.code === ERROR_PARAMETER).assertTrue();
608    }
609    console.info(TAG, 'end');
610  });
611
612  /*
613  * @tc.name UdmfTestTypeDescriptor027
614  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
615  * @tc.type: FUNC
616  * @tc.require: issueNumber
617  */
618  it('UdmfTestTypeDescriptor027', 0, function () {
619    const TAG = 'UdmfTestTypeDescriptor027:';
620    console.info(TAG, 'start');
621    let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts');
622    expect(typeId === 'general.type-script').assertTrue();
623    console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
624    console.info(TAG, 'end');
625  });
626
627  /*
628  * @tc.name UdmfTestTypeDescriptor028
629  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
630  * @tc.type: FUNC
631  * @tc.require: issueNumber
632  */
633  it('UdmfTestTypeDescriptor028', 0, function () {
634    const TAG = 'UdmfTestTypeDescriptor028:';
635    console.info(TAG, 'start');
636    let typeId = UTD.getUniformDataTypeByMIMEType('application/vnd.ms-excel');
637    expect(typeId === 'com.microsoft.excel.xls').assertTrue();
638    console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
639    console.info(TAG, 'end');
640  });
641
642  /*
643  * @tc.name UdmfTestTypeDescriptor029
644  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
645  * @tc.type: FUNC
646  * @tc.require: issueNumber
647  */
648  it('UdmfTestTypeDescriptor029', 0, function () {
649    const TAG = 'UdmfTestTypeDescriptor029:';
650    console.info(TAG, 'start');
651    try {
652      let typeId = UTD.getUniformDataTypeByFilenameExtension('invalidFilenameExtension');
653      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
654      expect(typeId === null).assertTrue();
655    } catch (e) {
656      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
657      expect().assertFail();
658    }
659    console.info(TAG, 'end');
660  });
661
662  /*
663  * @tc.name UdmfTestTypeDescriptor030
664  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
665  * @tc.type: FUNC
666  * @tc.require: issueNumber
667  */
668  it('UdmfTestTypeDescriptor030', 0, function () {
669    const TAG = 'UdmfTestTypeDescriptor030:';
670    console.info(TAG, 'start');
671    try {
672      let typeId = UTD.getUniformDataTypeByMIMEType('invalidMIMEType');
673      console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
674      expect(typeId === null).assertTrue();
675    } catch (e) {
676      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
677      expect().assertFail();
678    }
679    console.info(TAG, 'end');
680  });
681
682  /*
683  * @tc.name UdmfTestTypeDescriptor031
684  * @tc.desc Test Js Api belongsTo invalid para
685  * @tc.type: FUNC
686  * @tc.require: issueNumber
687  */
688  it('UdmfTestTypeDescriptor031', 0, function () {
689    const TAG = 'UdmfTestTypeDescriptor031:';
690    console.info(TAG, 'start');
691    let typeId = UTD.getTypeDescriptor('general.type-script');
692    console.info(TAG, 'typeDescriptor, ret ' + typeId);
693    let ret = typeId.belongsTo('general.type-script');
694    expect(ret === true).assertTrue();
695    console.info(TAG, 'end');
696  });
697
698  /*
699  * @tc.name UdmfTestTypeDescriptor032
700  * @tc.desc Test Js Api isLowerLevelType invalid para
701  * @tc.type: FUNC
702  * @tc.require: issueNumber
703  */
704  it('UdmfTestTypeDescriptor032', 0, function () {
705    const TAG = 'UdmfTestTypeDescriptor032:';
706    console.info(TAG, 'start');
707    let typeId = UTD.getTypeDescriptor('general.type-script');
708    console.info(TAG, 'typeDescriptor, ret ' + typeId);
709    let ret = typeId.isLowerLevelType('general.type-script');
710    expect(ret === false).assertTrue();
711    console.info(TAG, 'end');
712  });
713
714  /*
715  * @tc.name UdmfTestTypeDescriptor033
716  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension invalid para
717  * @tc.type: FUNC
718  * @tc.require: issueNumber
719  */
720  it('UdmfTestTypeDescriptor033', 0, function () {
721    const TAG = 'UdmfTestTypeDescriptor033:';
722    console.info(TAG, 'start');
723    let typeId = UTD.getTypeDescriptor('general.type-script');
724    console.info(TAG, 'typeDescriptor, ret ' + typeId);
725    let ret = typeId.isHigherLevelType('general.type-script');
726    expect(ret === false).assertTrue();
727    console.info(TAG, 'end');
728  });
729
730  /*
731  * @tc.name UdmfTestTypeDescriptor032
732  * @tc.desc Test Js Api getUniformDataTypeByFilenameExtension
733  * @tc.type: FUNC
734  * @tc.require: issueNumber
735  */
736  it('UdmfTestTypeDescriptor034', 0, function () {
737    const TAG = 'UdmfTestTypeDescriptor034:';
738    console.info(TAG, 'start');
739    try {
740      let typeId = UTD.getUniformDataTypeByFilenameExtension('.ts', '');
741      console.info(TAG, 'getUniformDataTypeByFilenameExtension, ret ' + typeId);
742      expect().assertFail();
743    } catch (e) {
744      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
745      expect(e.code === ERROR_PARAMETER).assertTrue();
746    }
747    console.info(TAG, 'end');
748  });
749
750  /*
751  * @tc.name UdmfTestTypeDescriptor035
752  * @tc.desc Test Js Api getUniformDataTypeByMIMEType
753  * @tc.type: FUNC
754  * @tc.require: issueNumber
755  */
756  it('UdmfTestTypeDescriptor035', 0, function () {
757    const TAG = 'UdmfTestTypeDescriptor035:';
758    console.info(TAG, 'start');
759    try {
760      let typeId = UTD.getUniformDataTypeByMIMEType('video/3gpp2', '');
761      console.info(TAG, 'getUniformDataTypeByMIMEType, ret ' + typeId);
762      expect().assertFail();
763    } catch (e) {
764      console.error(TAG, `get e. code is ${e.code},message is ${e.message} `);
765      expect(e.code === ERROR_PARAMETER).assertTrue();
766    }
767    console.info(TAG, 'end');
768  });
769});