• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1/*
2 * Copyright (C) 2022 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
16//@ts-ignore
17import {
18    ProcedureLogicWorkerFileSystem,
19    FileCallChain,
20    FileSample,
21    Stack,
22    FileSysEvent,
23    FileMerageBean,
24    IoCompletionTimes, VirtualMemoryEvent
25    //@ts-ignore
26} from "../../../../dist/trace/database/logic-worker/ProcedureLogicWorkerFileSystem.js"
27
28describe('ProcedureLogicWorkerFileSystem Test', ()=> {
29
30    it('procedureLogicWorkerFileSystemTest', function () {
31        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
32        expect(procedureLogicWorkerFileSystem).not.toBeUndefined();
33    });
34
35    it('procedureLogicWorkerFileSystemTest01', function () {
36        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
37        window.postMessage = jest.fn(()=>true)
38        let data ={
39            type: "fileSystem-init"
40        }
41        expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined()
42    });
43    it('procedureLogicWorkerFileSystemTest35', function () {
44        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
45        window.postMessage = jest.fn(()=>true)
46        let data ={
47            type: "fileSystem-queryCallchains",
48            params: {
49                list:[]
50            }
51        }
52        expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined()
53    });
54    it('procedureLogicWorkerFileSystemTest36', function () {
55        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
56        window.postMessage = jest.fn(()=>true)
57        let data ={
58            type: "fileSystem-queryFileSamples",
59            params: {
60                list:[]
61            }
62        }
63        expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined()
64    });
65    it('procedureLogicWorkerFileSystemTest37', function () {
66        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
67        window.postMessage = jest.fn(()=>true)
68        let data ={
69            type: "fileSystem-action",
70            length:0,
71            params: {
72                list:[],
73                filter:() => {return []}
74            }
75        }
76        expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined()
77    });
78    it('procedureLogicWorkerFileSystemTest38', function () {
79        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
80        window.postMessage = jest.fn(()=>true)
81        let data ={
82            type: "fileSystem-queryStack",
83            params: {
84                list:[]
85            }
86        }
87        expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined()
88    });
89    it('procedureLogicWorkerFileSystemTest39', function () {
90        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
91        window.postMessage = jest.fn(()=>true)
92        let data ={
93            type: "fileSystem-queryFileSysEvents",
94            params: {
95                list:[]
96            }
97        }
98        expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined()
99    });
100
101    it('procedureLogicWorkerFileSystemTest07', function () {
102        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
103        expect(procedureLogicWorkerFileSystem.clearSplitMapData()).toBeUndefined()
104    });
105
106    it('procedureLogicWorkerFileSystemTest08', function () {
107        let fileCallChain = {
108            callChainId: 0,
109            depth: 0,
110            symbolsId: 0,
111            pathId: 0,
112            ip: "",
113        }
114        expect(fileCallChain).not.toBeUndefined()
115    });
116
117    it('procedureLogicWorkerFileSystemTest09', function () {
118        let stack = new Stack ();
119        stack = {
120            type: 0,
121            symbol: "",
122            path: "",
123        }
124        expect(stack).not.toBeUndefined()
125    });
126
127    it('procedureLogicWorkerFileSystemTest10', function () {
128        let fileSysEvent  = new FileSysEvent  ();
129        fileSysEvent = {
130            id: 0,
131            callchainId: 0,
132            startTs: 0,
133            startTsStr: "",
134            durStr: "",
135            dur: 0,
136            process: 0,
137            type: 0,
138            typeStr: "",
139            fd: "",
140            size: 0,
141            depth: 0,
142            firstArg: "",
143            secondArg: "",
144            thirdArg: "",
145            fourthArg: "",
146            returnValue: "",
147            error: "",
148            path: "",
149            symbol: "",
150            backtrace: [],
151        }
152        expect(fileSysEvent).not.toBeUndefined()
153    });
154
155    it('procedureLogicWorkerFileSystemTest11', function () {
156        let fileMerageBean = new FileMerageBean();
157        expect(fileMerageBean).not.toBeUndefined();
158
159    });
160
161    it('procedureLogicWorkerFileSystemTest13', function () {
162        let fileSample = {
163            callChainId: 0,
164            dur: 0,
165            pid: 0,
166            processName: "",
167        }
168        expect(fileSample).not.toBeUndefined()
169    });
170
171    it('procedureLogicWorkerFileSystemTest14', function () {
172        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
173        expect(procedureLogicWorkerFileSystem.clearAll()).toBeUndefined();
174
175    });
176
177    it('procedureLogicWorkerFileSystemTest15', function () {
178        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
179        let currentNode = {
180            symbol: '',
181            path: '',
182            libName: '',
183            symbolName: '',
184        }
185        expect(procedureLogicWorkerFileSystem.setMerageName(currentNode)).toBeUndefined();
186
187    });
188
189    it('procedureLogicWorkerFileSystemTest33', function () {
190        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
191        let currentNode = {
192            pathId: -1,
193            symbol: '',
194            path: '',
195            libName: '',
196            symbolName: '',
197        }
198        expect(procedureLogicWorkerFileSystem.setMerageName(currentNode)).toBeUndefined();
199
200    });
201
202    it('procedureLogicWorkerFileSystemTest17', function () {
203        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
204        expect(procedureLogicWorkerFileSystem.freshCurrentCallchains([],1)).toBeUndefined();
205
206    });
207
208    it('procedureLogicWorkerFileSystemTest18', function () {
209        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
210        expect(procedureLogicWorkerFileSystem.initCallChainTopDown([])).toBeUndefined();
211
212    });
213
214    it('procedureLogicWorkerFileSystemTest19', function () {
215        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
216        expect(procedureLogicWorkerFileSystem.supplementFileSysEvents([],'events'));
217
218    });
219
220    it('procedureLogicWorkerFileSystemTest21', function () {
221        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
222        expect(procedureLogicWorkerFileSystem.supplementFileSysEvents([],''));
223
224    });
225    it('procedureLogicWorkerFileSystemTest22', function () {
226        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
227        expect(procedureLogicWorkerFileSystem.supplementFileSysEvents([]));
228
229    });
230
231    it('procedureLogicWorkerFileSystemTest20', function () {
232        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
233        expect(procedureLogicWorkerFileSystem.getStacksByCallchainId([]));
234
235    });
236
237    it('procedureLogicWorkerFileSystemTest23', function () {
238        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
239        let params = {
240            funcName: 'getCallChainsBySampleIds',
241        }
242        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
243
244    });
245
246    it('procedureLogicWorkerFileSystemTest24', function () {
247        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
248        let params = {
249            funcName: 'getCurrentDataFromDb',
250        }
251        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
252
253    });
254
255    it('procedureLogicWorkerFileSystemTest25', function () {
256        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
257        let params = {
258            funcName: 'hideSystemLibrary',
259        }
260        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
261
262    });
263
264    it('procedureLogicWorkerFileSystemTest26', function () {
265        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
266        let params = {
267            funcName: 'hideNumMaxAndMin',
268        }
269        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
270
271    });
272
273    it('procedureLogicWorkerFileSystemTest27', function () {
274        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
275        let params = {
276            funcName: 'splitAllProcess',
277        }
278        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
279
280    });
281
282    it('procedureLogicWorkerFileSystemTest28', function () {
283        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
284        let params = {
285            funcName: 'resetAllNode',
286        }
287        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
288
289    });
290
291    it('procedureLogicWorkerFileSystemTest29', function () {
292        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
293        let params = {
294            funcName: 'resotreAllNode',
295        }
296        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
297
298    });
299
300    it('procedureLogicWorkerFileSystemTest30', function () {
301        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
302        let params = {
303            funcName: 'clearSplitMapData',
304        }
305        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
306
307    });
308
309    it('procedureLogicWorkerFileSystemTest31', function () {
310        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
311        let params = {
312            funcName: 'splitTree',
313        }
314        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
315
316    });
317
318    it('procedureLogicWorkerFileSystemTest32', function () {
319        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
320        let params = {
321            funcName: 'setSearchValue',
322        }
323        expect(procedureLogicWorkerFileSystem.resolvingAction(params));
324
325    });
326    it('procedureLogicWorkerFileSystemTest34', function () {
327        let currentNode = {
328            processName: "",
329            ip:"",
330            pid:1,
331            pathId:"",
332            symbolsId:"",
333            selfDur:1,
334            self:1,
335            count:1,
336        }
337        let callChain = {
338            ip:"",
339            pid:1,
340            pathId:"",
341            symbolsId:"",
342
343        }
344        let sample = {
345            processName:"",
346            dur:1,
347        }
348        let isEnd = true;
349        expect(FileMerageBean .merageCallChainSample(currentNode, callChain, sample, isEnd));
350
351    });
352    it('procedureLogicWorkerFileSystemTest40', function () {
353        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
354        let selectionParam = {
355            fileSystemType:{
356                length:1,
357                join:jest.fn(()=>true)
358            }
359        }
360        window.postMessage = jest.fn(()=>true)
361        expect(procedureLogicWorkerFileSystem.queryFileSamples(selectionParam)).toBeUndefined();
362
363    });
364    it('procedureLogicWorkerFileSystemTest41', function () {
365        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
366        let sample = {
367            callChainId:1,
368            type:{
369                toString
370            }
371        }
372        window.postMessage = jest.fn(()=>true)
373        expect(procedureLogicWorkerFileSystem.createThreadAndType(sample)).toBeTruthy()
374
375    });
376    it('procedureLogicWorkerFileSystemTest42', function () {
377        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
378        let currentNode = {
379            initChildren:{
380                filter:jest.fn(()=>-1)
381            }
382        }
383        let callChainDataList = {
384            length:1,
385        }
386        let index = 0;
387        let sample = {
388
389        }
390        let isTopDown = {
391
392        }
393        window.postMessage = jest.fn(()=>true)
394        expect(procedureLogicWorkerFileSystem.merageChildrenByIndex(currentNode, callChainDataList, index, sample, isTopDown)).toBeUndefined()
395
396    });
397    it('procedureLogicWorkerFileSystemTest43', function () {
398        let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
399        let params = {
400            length:1,
401            forEach:jest.fn(()=>true)
402
403
404        }
405        window.postMessage = jest.fn(()=>true)
406        expect(procedureLogicWorkerFileSystem.resolvingAction(params)).toStrictEqual([])
407
408    });
409
410    it('procedureLogicWorkerFileSystemTest45', function () {
411        let ioCompletionTimes = new IoCompletionTimes();
412        expect(ioCompletionTimes).toBeDefined();
413
414    });
415
416    it('procedureLogicWorkerFileSystemTest46', function () {
417        let virtualMemoryEvent = new VirtualMemoryEvent();
418        expect(virtualMemoryEvent).toBeDefined();
419
420    });
421})