• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2* Copyright (c) 2022 Shenzhen Kaihong Digital Industry Development 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*/
15let genDir = "../../src/gen/"
16const re = require(genDir + "tools/re");
17const { analyzeFile } = require(genDir + "analyze");
18const { analyzeEnum, analyzeEnumResult } = require(genDir + "analyze/enum");
19const { analyzeFunction, analyzeSubInterface, getFuncParaType } = require(genDir + "analyze/function");
20const { analyzeInterface } = require(genDir + "analyze/interface");
21const { analyzeNamespace, parseNamespace } = require(genDir + "analyze/namespace");
22const { parseEnum, parseFunction, parseInterface } = require(genDir + "analyze/namespace");
23const { analyzeParams } = require(genDir + "analyze/params");
24const { analyzeReturn } = require(genDir + "analyze/return");
25const { readFile } = require("../../src/gen/tools/FileRW");
26
27var assert = require("assert");
28var correctResult;
29function before() {
30    let data = readFile("test/unittest/result.json")
31    if (data) {
32        correctResult = JSON.parse(data);
33    }
34}
35
36describe('Analyze', function () {
37    before(function () {
38        before();
39    });
40
41    it('test gen/analyze analyzeFile', function () {
42        let structOfTs = analyzeFile("test/unittest/@ohos.input_sample.d.ts");
43        let retJson = JSON.stringify(structOfTs)
44        let retNameSpace = retJson.search("\"name\":\"napitest\"");
45        assert.strictEqual(retNameSpace > 0, true);
46        let retLicense = retJson.search("Copyright");
47        assert.strictEqual(retLicense > 0, true);
48    });
49
50    partOfEnum();
51
52    partOfFunction(correctResult);
53
54    it('test gen/analyze/interface analyzeInterface', function () {
55        let ret = analyzeInterface(correctResult['ParamIn']['analyzeInterface']);
56        let retJson = JSON.stringify(ret)
57        let valueArray = retJson.substring(retJson.indexOf("\[") + 1, retJson.indexOf("\]")).split("}");
58        let numContain = valueArray[0].indexOf("\"name\":\"num1\",\"type\":\"NUMBER_TYPE_");
59        assert.strictEqual(numContain > 0, true);
60        assert.strictEqual(valueArray[1], ",{\"name\":\"str1\",\"type\":\"string\"");
61        let numArrayCon = valueArray[2].indexOf("\"name\":\"nums\",\"type\":\"Array<NUMBER_TYPE_");
62        assert.strictEqual(numArrayCon > 0, true);
63        assert.strictEqual(valueArray[3], ",{\"name\":\"strs\",\"type\":\"Array<string>\"");
64        let asyncExit = retJson.search("\"name\":\"if_async\",\"type\":4")
65        assert.strictEqual(asyncExit > 0, true);
66        let asyncArray = retJson.substring(retJson.lastIndexOf("\[") + 1, retJson.lastIndexOf("\]")).split("}");
67        assert.strictEqual(asyncArray[0], "{\"name\":\"v1\",\"type\":\"string\",\"optional\":false");
68        assert.strictEqual(asyncArray[1], ",{\"name\":\"cb\",\"type\":\"AsyncCallback<string>\",\"optional\":false");
69        assert.strictEqual(asyncArray[2], "],\"ret\":\"string\"");
70    });
71
72    partOfNamespace(correctResult);
73
74    partOfParam();
75
76    it('test gen/analyze/return analyzeReturn', function () {
77        let ret = analyzeReturn("string");
78        assert.strictEqual(ret[0], 'string');
79        assert.strictEqual(ret[1], false);
80    });
81
82    it('test gen/analyze/return analyzeReturn', function () {
83        let ret = analyzeReturn("Promise<string>");
84        assert.strictEqual(ret[0], 'Promise<string>');
85        assert.strictEqual(ret[1], true);
86    });
87
88});
89
90function partOfEnum() {
91    it('test gen/analyze/enum analyzeNumberEnum', function () {
92        let data = '\nDENIED = "-1"';
93        let retJson = JSON.stringify(analyzeEnum(data));
94        let enumValueType = retJson.search("\"enumValueType\":1");
95        assert.strictEqual(enumValueType > 0, true);
96        let element = retJson.search("\"name\":\"DENIED\",\"value\":\"-1\",\"type\":\"string\"");
97        assert.strictEqual(element > 0, true);
98    });
99
100    it('test gen/analyze/enum analyzeStringEnum', function () {
101        let data = '\nFAULT = 1,\nSTATISTIC = 2,\nSECURITY = 3,\nBEHAVIOR = 4,\n';
102        let retJson = JSON.stringify(analyzeEnum(data));
103        let enumValueType = retJson.search("\"enumValueType\":0");
104        assert.strictEqual(enumValueType > 0, true);
105        let element = retJson.search("\"name\":\"FAULT\",\"value\":\"1\",\"type\":\"NUMBER_TYPE_");
106        assert.strictEqual(element > 0, true);
107        let retFunc = retJson.substring(retJson.search("function") - 1, retJson.search("function") + 12);
108        assert.strictEqual(retFunc, "\"function\":[]");
109    });
110
111    it('test gen/analyze/enum analyzeEnumStringResult', function () {
112        let result = {
113            element: [{ name: "STATUS0", value: "0", type: "string" }],
114            function: [],
115            enumValueType: 0
116        }
117        let retJson = JSON.stringify(analyzeEnumResult(result, 'STATUS0 = "1"', '0'))
118        let enumValueType = retJson.search("\"enumValueType\":1");
119        assert.strictEqual(enumValueType > 0, true);
120    });
121
122}
123
124function partOfFunction(correctResult) {
125    it('test gen/analyze/function analyzeSubInterface', function () {
126        let data = correctResult['ParamIn']['analyzeSubInterface'];
127        let retJson = JSON.stringify(analyzeSubInterface(data))
128        let retNum = retJson.search("{\"name\":\"num1\",\"type\":\"NUMBER_TYPE_");
129        assert.strictEqual(retNum > 0, true);
130        let retString = retJson.search("{\"name\":\"str1\",\"type\":\"string\"}");
131        assert.strictEqual(retString > 0, true);
132        let retArrayNum = retJson.search("{\"name\":\"nums\",\"type\":\"Array<NUMBER_TYPE_");
133        assert.strictEqual(retArrayNum > 0, true);
134        let retArrayString = retJson.search("{\"name\":\"strs\",\"type\":\"Array<string>\"}");
135        assert.strictEqual(retArrayString > 0, true);
136    });
137
138    it('test gen/analyze/function getFuncParaType', function () {
139        let data = 'if_direct(v1: string, v2: boolean): string;';
140        let v = { name: 'v1', type: 'string' };
141        let retJson = JSON.stringify(getFuncParaType(v, '', data))
142        assert.strictEqual(retJson, "{\"name\":\"v1\",\"type\":\"string\"}");
143    });
144
145    it('test gen/analyze/function analyzeDirectFunction', function () {
146        let data = "if_direct(v1: string, v2: boolean): string;";
147        let ret = analyzeFunction(data, false, `if_direct`, "v1: string, v2: boolean", "asdfgh");
148        let retJson = JSON.stringify(ret)
149        let str1 = "{\"name\":\"v1\",\"type\":\"string\",\"optional\":false},";
150        let str2 = "{\"name\":\"v2\",\"type\":\"boolean\",\"optional\":false}";
151        let retValue = retJson.search(str1 + str2)
152        assert.strictEqual(retValue > 0, true);
153        let retName = retJson.search("\"name\":\"if_direct\"")
154        assert.strictEqual(retName > 0, true);
155        let retType = retJson.search("\"type\":1")
156        assert.strictEqual(retType > 0, true);
157    });
158
159    partOfFunctionTwo();
160}
161
162function partOfFunctionTwo() {
163
164    it('test gen/analyze/function analyzeAsyncFunction', function () {
165        let data = "if_async(v1: string, cb: AsyncCallback<string>): string;";
166        let ret = analyzeFunction(data, false, `if_async`, "v1: string, cb: AsyncCallback<string>", "qwerty");
167        let retJson = JSON.stringify(ret)
168        let str1 = "{\"name\":\"v1\",\"type\":\"string\",\"optional\":false},";
169        let str2 = "{\"name\":\"cb\",\"type\":\"AsyncCallback<string>\",\"optional\":false}";
170        let retValue = retJson.search(str1 + str2)
171        assert.strictEqual(retValue > 0, true);
172        let retName = retJson.search("\"name\":\"if_async\"")
173        assert.strictEqual(retName > 0, true);
174        let retType = retJson.search("\"type\":4")
175        assert.strictEqual(retType > 0, true);
176    });
177
178    it('test gen/analyze/function analyzeSyncFunction', function () {
179        let data = "if_callback(v1: string, cb: Callback<Array<string>>): string;";
180        let ret = analyzeFunction(data, false, `if_callback`, "v1: string, cb: Callback<Array<string>>", "zxcvbn");
181        let retJson = JSON.stringify(ret)
182        let retType = retJson.search("\"type\":2")
183        assert.strictEqual(retType > 0, true);
184    });
185
186    it('test gen/analyze/function analyzePromiseFunction', function () {
187        let data = "if_promise(v1: Array<number>): Promise<boolean>;";
188        let ret = analyzeFunction(data, false, `if_promise`, "v1: Array<number>", "Promise<boolean>");
189        assert.strictEqual(ret, null);
190    });
191}
192
193function partOfNamespace(correctResult) {
194    it('test gen/analyze/namespace analyzeNamespace', function () {
195        let ret = analyzeNamespace(correctResult['ParamIn']['analyzeNamespace']);
196        let retJson = JSON.stringify(ret);
197        let nameResult = retJson.substring(retJson.search("namespace") - 1, retJson.length - 1);
198        let searchExport = nameResult.search("\"exports\"")
199        let exportResult = nameResult.substring(searchExport, nameResult.search("\"exports\"") + 20);
200        assert.strictEqual(exportResult, "\"exports\":[\"Entity\"]")
201        let enumResult = nameResult.substring(nameResult.search("\"enum\""), nameResult.indexOf("\"const\"") - 1);
202        assert.strictEqual(enumResult.search("\"name\":\"Entity\"") > 0, true);
203        assert.strictEqual(enumResult.search("\"enumValueType\":0") > 0, true);
204        let searchInte = nameResult.indexOf("\"interface\"")
205        let interResult = nameResult.substring(searchInte, nameResult.indexOf("\"class\"") - 1);
206        assert.strictEqual(interResult.search("{\"name\":\"animal\",\"type\":\"string\"}") > 0, true);
207        let interFun = interResult.substring(interResult.search("function") - 1, interResult.length - 3);
208        let interValue = "\"value\":[{\"name\":\"v1\",\"type\":\"string\",\"optional\":false}],";
209        let interRet = "\"ret\":\"string\"}]"
210        assert.strictEqual(interFun, "\"function\":[{\"name\":\"fix\",\"type\":1," + interValue + interRet);
211
212    });
213
214    it('test gen/analyze/namespace analyzeNamespaceClass', function () {
215        let ret = analyzeNamespace('\nnamespace Space3 {\nclass TestClass {\nstatic $fun1(v:string):boolean;\n}\n}\n');
216        let retJson = JSON.stringify(ret);
217        let nameResult = retJson.substring(retJson.search("namespace"), retJson.length - 2)
218        let qiePianStart = nameResult.lastIndexOf("\"class\"") - 1
219        let classResult = nameResult.substring(qiePianStart, nameResult.lastIndexOf("\"namespace\"") - 2)
220        assert.strictEqual(classResult.search("\"functiontType\":\"static\"") > 0, true)
221    });
222
223    it('test gen/analyze/namespace analyzeNamespaceFunction', function () {
224        let ret = analyzeNamespace('\nnamespace Space3 {\nfunction fun1(v: string): boolean;\n}\n');
225        let retJson = JSON.stringify(ret);
226        let nameResult = retJson.substring(retJson.search("namespace"), retJson.length - 2)
227        let qiePianStart = nameResult.lastIndexOf("\"function\"");
228        let funcResult = nameResult.substring(qiePianStart, nameResult.lastIndexOf("\"interface\"") - 2);
229        assert.strictEqual(funcResult.search("\"name\":\"fun1\",\"type\":1") > 0, true)
230        assert.strictEqual(funcResult.search("{\"name\":\"v\",\"type\":\"string\",\"optional\":false}") > 0, true)
231    });
232
233    partOfNamespaceTwo(correctResult);
234
235    partOfNamespaceThere(correctResult);
236}
237
238function partOfNamespaceTwo(correctResult) {
239    it('test gen/analyze/namespace parseNamespace', function () {
240        let data = correctResult['ParamIn']['parseNamespace'];
241        let matchs = re.match(" *\n*", data)
242        let result = {
243            exports: [],
244            enum: [],
245            const: [],
246            type: [],
247            function: [],
248            interface: [],
249            class: [],
250            namespace: [],
251        }
252        let ret = parseNamespace(matchs, data, result);
253        let retJson = JSON.stringify(ret)
254        assert.strictEqual(retJson, "\"\\n\"");
255    });
256
257    it('test gen/analyze/namespace parseEnum', function () {
258        let data = correctResult['ParamIn']['parseEnum']
259        let matchs = re.match(" *\n*", data)
260        let result = {
261            exports: [],
262            enum: [],
263            const: [],
264            type: [],
265            function: [],
266            interface: [],
267            class: [],
268            namespace: [],
269        }
270        let ret = parseEnum(matchs, data, result);
271        let retJson = JSON.stringify(ret)
272        assert.strictEqual(retJson, "\"\\n\"");
273    })
274}
275
276function partOfNamespaceThere(correctResult) {
277    it('test gen/analyze/namespace parseFunction', function () {
278        let data = 'function fun1(name: string, flags: number): boolean;\n';
279        let matchs = re.match(" *\n*", data)
280        let result = {
281            exports: [],
282            enum: [],
283            const: [],
284            type: [],
285            function: [],
286            interface: [],
287            class: [],
288            namespace: [],
289        }
290        let ret = parseFunction(matchs, data, result);
291        let retJson = JSON.stringify(ret)
292        assert.strictEqual(retJson, "\"\"");
293    });
294
295    it('test gen/analyze/namespace parseInterface', function () {
296        let data = correctResult['ParamIn']['parseInterface']
297        let matchs = re.match(" *\n*", data)
298        let result = {
299            exports: [],
300            enum: [],
301            const: [],
302            type: [],
303            function: [],
304            interface: [],
305            class: [],
306            namespace: [],
307        }
308        let ret = parseInterface(matchs, data, result);
309        let retJson = JSON.stringify(ret)
310        assert.strictEqual(retJson, "\"\\nfunction fun1(v: ConfigOption): void\\n\"");
311    });
312}
313
314function partOfParam() {
315    it('test gen/analyze/params analyzeDirectParams', function () {
316        let ret = analyzeParams('', 'v1:string,v2:boolean');
317        let retJson = JSON.stringify(ret)
318        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
319        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v1\",\"type\":\"string\",\"optional\":false") > 0, true);
320        assert.strictEqual(retJsonpian[1].indexOf("\"name\":\"v2\",\"type\":\"boolean\",\"optional\":false") > 0, true);
321        assert.strictEqual(ret[1], 1);
322    });
323
324    it('test gen/analyze/params analyzeAsynctParams', function () {
325        let ret = analyzeParams('', 'v2:string,cb:AsyncCallback<string>');
326        let retJson = JSON.stringify(ret)
327        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
328        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v2\",\"type\":\"string\",\"optional\":false") > 0, true);
329        let flag = retJsonpian[1].indexOf("\"name\":\"cb\",\"type\":\"AsyncCallback<string>\",\"optional\":false") > 0
330        assert.strictEqual(flag, true);
331        assert.strictEqual(ret[1], 4);
332    });
333
334    it('test gen/analyze/params analyzeSynctParams', function () {
335        let ret = analyzeParams('', 'v2:boolean,cb:Callback<boolean>');
336        let retJson = JSON.stringify(ret)
337        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
338        assert.strictEqual(retJsonpian[0].indexOf("\"name\":\"v2\",\"type\":\"boolean\",\"optional\":false") > 0, true);
339        let flag = retJsonpian[1].indexOf("\"name\":\"cb\",\"type\":\"Callback<boolean>\",\"optional\":false") > 0
340        assert.strictEqual(flag, true);
341        assert.strictEqual(ret[1], 2);
342    });
343
344    it('test gen/analyze/params analyzeArrayParams', function () {
345        let ret = analyzeParams('', "v1: Array<number>,v2:Map<string,boolean>");
346        let retJson = JSON.stringify(ret)
347        let retJsonpian = retJson.substring(2, retJson.length - 4).split("}");
348        let flagArray = retJsonpian[0].indexOf("\"name\":\"v1\",\"type\":\"Array<number>\",\"optional\":false") > 0
349        assert.strictEqual(flagArray, true);
350        let flag = retJsonpian[1].indexOf("\"name\":\"v2\",\"type\":\"Map<string,boolean>\",\"optional\":false") > 0
351        assert.strictEqual(flag, true);
352    });
353
354    it('test gen/analyze/params analyzeMapParams', function () {
355        let ret = analyzeParams('', "v1: string[],v2:{[key:string]:boolean}");
356        let retJson = JSON.stringify(ret)
357        let retJsonpian = retJson.substring(2, retJson.length - 4);
358        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v2\",\"type\":\"{\[key:string\]:boolean}\"") > 0, true);
359        assert.strictEqual(retJsonpian.indexOf("\"name\":\"v1\",\"type\":\"string[]\",\"optional\":false") > 0, true);
360    });
361
362}
363
364