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
16import {
17  ProcedureLogicWorkerFileSystem,
18  FileCallChain,
19  FileSample,
20  Stack,
21  FileSysEvent,
22  FileMerageBean,
23  IoCompletionTimes,
24  VirtualMemoryEvent,
25  FileAnalysisSample,
26  //@ts-ignore
27} from '../../../../src/trace/database/logic-worker/ProcedureLogicWorkerFileSystem';
28
29describe('ProcedureLogicWorkerFileSystem Test', () => {
30  let procedureLogicWorkerF = new ProcedureLogicWorkerFileSystem();
31
32  procedureLogicWorkerF.queryData = jest.fn();
33  procedureLogicWorkerF.initCallchains();
34  it('procedureLogicWorkerFileSystemTest', function () {
35    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
36    expect(procedureLogicWorkerFileSystem).not.toBeUndefined();
37  });
38
39  it('procedureLogicWorkerFileSystemTest01', function () {
40    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
41    window.postMessage = jest.fn(() => true);
42    let data = {
43      type: 'fileSystem-init',
44    };
45    expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined();
46  });
47  it('procedureLogicWorkerFileSystemTest35', function () {
48    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
49    window.postMessage = jest.fn(() => true);
50    let data = {
51      type: 'fileSystem-queryCallchains',
52      params: {
53        list: [],
54      },
55    };
56    expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined();
57  });
58  it('procedureLogicWorkerFileSystemTest36', function () {
59    window.postMessage = jest.fn(() => true);
60    let data = {
61      type: 'fileSystem-queryFileSamples',
62      params: {
63        list: [],
64      },
65    };
66    expect(procedureLogicWorkerF.handle(data)).toBeUndefined();
67  });
68  it('procedureLogicWorkerFileSystemTest37', function () {
69    window.postMessage = jest.fn(() => true);
70    let data = {
71      type: 'fileSystem-action',
72      length: 0,
73      params: {
74        callType: 'fileSystem',
75        args: [],
76        list: [],
77        filter: () => {
78          return [];
79        },
80      },
81    };
82    expect(procedureLogicWorkerF.handle(data)).toBeUndefined();
83  });
84  it('procedureLogicWorkerFileSystemTest38', function () {
85    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
86    window.postMessage = jest.fn(() => true);
87    let data = {
88      type: 'fileSystem-queryStack',
89      params: {
90        list: [],
91      },
92    };
93    expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined();
94  });
95  it('procedureLogicWorkerFileSystemTest39', function () {
96    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
97    window.postMessage = jest.fn(() => true);
98    let data = {
99      type: 'fileSystem-queryFileSysEvents',
100      params: {
101        list: [],
102      },
103    };
104    expect(procedureLogicWorkerFileSystem.handle(data)).toBeUndefined();
105  });
106
107  it('procedureLogicWorkerFileSystemTest07', function () {
108    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
109    expect(handlerMap.clearSplitMapData([true])).toBeUndefined();
110  });
111
112  it('procedureLogicWorkerFileSystemTest08', function () {
113    let fileCallChain = {
114      callChainId: 0,
115      depth: 0,
116      symbolsId: 0,
117      pathId: 0,
118      ip: '',
119    };
120    expect(fileCallChain).not.toBeUndefined();
121  });
122
123  it('procedureLogicWorkerFileSystemTest09', function () {
124    let stack = new Stack();
125    stack = {
126      type: 0,
127      symbol: '',
128      path: '',
129    };
130    expect(stack).not.toBeUndefined();
131  });
132
133  it('procedureLogicWorkerFileSystemTest10', function () {
134    let fileSysEvent = new FileSysEvent();
135    fileSysEvent = {
136      id: 0,
137      callchainId: 0,
138      startTs: 0,
139      startTsStr: '',
140      durStr: '',
141      dur: 0,
142      process: 0,
143      type: 0,
144      typeStr: '',
145      fd: '',
146      size: 0,
147      depth: 0,
148      firstArg: '',
149      secondArg: '',
150      thirdArg: '',
151      fourthArg: '',
152      returnValue: '',
153      error: '',
154      path: '',
155      symbol: '',
156      backtrace: [],
157    };
158    expect(fileSysEvent).not.toBeUndefined();
159  });
160
161  it('procedureLogicWorkerFileSystemTest11', function () {
162    let fileMerageBean = new FileMerageBean();
163    expect(fileMerageBean).not.toBeUndefined();
164  });
165
166  it('procedureLogicWorkerFileSystemTest13', function () {
167    let fileSample = {
168      callChainId: 0,
169      dur: 0,
170      pid: 0,
171      processName: '',
172    };
173    expect(fileSample).not.toBeUndefined();
174  });
175
176  it('procedureLogicWorkerFileSystemTest14', function () {
177    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
178    expect(handlerMap.clearAll()).toBeUndefined();
179  });
180
181  it('procedureLogicWorkerFileSystemTest15', function () {
182    window.postMessage = jest.fn(() => true);
183    let map = new Map();
184    map.set('symbol', '');
185    map.set('path', '');
186    map.set('libName', '');
187    map.set('symbolName', '');
188    let data = {
189      type: 'fileSystem-init',
190      params: map,
191    };
192    procedureLogicWorkerF.handle(data);
193    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
194    let currentNode = {
195      symbol: 'symbol',
196      path: 'path',
197      libName: 'libName',
198      symbolName: 'symbolName',
199    };
200    expect(handlerMap.setMerageName(currentNode)).toBeUndefined();
201  });
202
203  it('procedureLogicWorkerFileSystemTest33', function () {
204    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
205    let currentNode = {
206      pathId: -1,
207      symbol: '',
208      path: '',
209      libName: '',
210      symbolName: '',
211    };
212    expect(handlerMap.setMerageName(currentNode)).toBeUndefined();
213  });
214
215  it('procedureLogicWorkerFileSystemTest18', function () {
216    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
217    expect(procedureLogicWorkerFileSystem.initCallChainTopDown([])).toBeUndefined();
218  });
219
220  it('procedureLogicWorkerFileSystemTest19', function () {
221    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
222    expect(procedureLogicWorkerFileSystem.supplementFileSysEvents([], 'events'));
223  });
224
225  it('procedureLogicWorkerFileSystemTest21', function () {
226    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
227    expect(procedureLogicWorkerFileSystem.supplementFileSysEvents([], ''));
228  });
229  it('procedureLogicWorkerFileSystemTest22', function () {
230    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
231    expect(procedureLogicWorkerFileSystem.supplementFileSysEvents([]));
232  });
233
234  it('procedureLogicWorkerFileSystemTest20', function () {
235    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
236    expect(procedureLogicWorkerFileSystem.getStacksByCallchainId([]));
237  });
238
239  it('procedureLogicWorkerFileSystemTest23', function () {
240    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
241    let params = {
242      funcName: 'getCallChainsBySampleIds',
243    };
244    expect(handlerMap.resolvingAction(params));
245  });
246
247  it('procedureLogicWorkerFileSystemTest24', function () {
248    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
249    let params = {
250      funcName: 'getCurrentDataFromDb',
251    };
252    expect(handlerMap.resolvingAction(params));
253  });
254
255  it('procedureLogicWorkerFileSystemTest25', function () {
256    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
257    let params = {
258      funcName: 'hideSystemLibrary',
259    };
260    expect(handlerMap.resolvingAction(params));
261  });
262
263  it('procedureLogicWorkerFileSystemTest26', function () {
264    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
265    let params = {
266      funcName: 'hideNumMaxAndMin',
267    };
268    expect(handlerMap.resolvingAction(params));
269  });
270
271  it('procedureLogicWorkerFileSystemTest27', function () {
272    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
273    let params = {
274      funcName: 'splitAllProcess',
275    };
276    expect(handlerMap.resolvingAction(params));
277  });
278
279  it('procedureLogicWorkerFileSystemTest28', function () {
280    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
281    let params = {
282      funcName: 'resetAllNode',
283    };
284    expect(handlerMap.resolvingAction(params));
285  });
286
287  it('procedureLogicWorkerFileSystemTest29', function () {
288    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
289    let params = {
290      funcName: 'resotreAllNode',
291    };
292    expect(handlerMap.resolvingAction(params));
293  });
294
295  it('procedureLogicWorkerFileSystemTest30', function () {
296    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
297    let params = {
298      funcName: 'clearSplitMapData',
299    };
300    expect(handlerMap.resolvingAction(params));
301  });
302
303  it('procedureLogicWorkerFileSystemTest31', function () {
304    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
305    let params = {
306      funcName: 'splitTree',
307    };
308    expect(handlerMap.resolvingAction(params));
309  });
310
311  it('procedureLogicWorkerFileSystemTest32', function () {
312    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
313    let params = {
314      funcName: 'setSearchValue',
315    };
316    expect(handlerMap.resolvingAction(params));
317  });
318  it('procedureLogicWorkerFileSystemTest34', function () {
319    let currentNode = {
320      processName: '',
321      ip: '',
322      pid: 1,
323      pathId: '',
324      symbolsId: '',
325      selfDur: 1,
326      self: 1,
327      count: 1,
328      tsArray: [],
329      durArray: []
330    };
331    let callChain = {
332      ip: '',
333      pid: 1,
334      pathId: '',
335      symbolsId: '',
336    };
337    let sample = {
338      processName: '',
339      dur: 1,
340    };
341    let isEnd = true;
342    expect(FileMerageBean.merageCallChainSample(currentNode, callChain, sample, isEnd));
343  });
344  it('procedureLogicWorkerFileSystemTest40', function () {
345    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
346    let selectionParam = {
347      diskIOipids: {
348        length: 1,
349        join: jest.fn(() => true),
350      },
351      fileSystemType: {
352        length: 1,
353        join: jest.fn(() => true),
354      },
355    };
356    window.postMessage = jest.fn(() => true);
357    expect(handlerMap.queryFileSamples(selectionParam)).toBeUndefined();
358  });
359  it('procedureLogicWorkerFileSystemTest41', function () {
360    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
361    let sample = {
362      callChainId: 1,
363      type: {
364        toString,
365      },
366    };
367    window.postMessage = jest.fn(() => true);
368    expect(handlerMap.createThreadAndType(sample)).toBeTruthy();
369  });
370  it('procedureLogicWorkerFileSystemTest42', function () {
371    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
372    let currentNode = {
373      initChildren: {
374        filter: jest.fn(() => -1),
375      },
376    };
377    let callChainDataList = {
378      length: 1,
379    };
380    let index = 0;
381    let sample = {};
382    let isTopDown = {};
383    window.postMessage = jest.fn(() => true);
384    expect(handlerMap.merageChildrenByIndex(currentNode, callChainDataList, index, sample, isTopDown)).toBeUndefined();
385  });
386  it('procedureLogicWorkerFileSystemTest43', function () {
387    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
388    let params = {
389      length: 1,
390      forEach: jest.fn(() => true),
391    };
392    window.postMessage = jest.fn(() => true);
393    expect(handlerMap.resolvingAction(params)).toStrictEqual([]);
394  });
395
396  it('procedureLogicWorkerFileSystemTest45', function () {
397    let ioCompletionTimes = new IoCompletionTimes();
398    expect(ioCompletionTimes).toBeDefined();
399  });
400
401  it('procedureLogicWorkerFileSystemTest46', function () {
402    let virtualMemoryEvent = new VirtualMemoryEvent();
403    expect(virtualMemoryEvent).toBeDefined();
404  });
405  it('procedureLogicWorkerFileSystemTest47', function () {
406    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
407    expect(procedureLogicWorkerFileSystem.queryFileSysEvents(1, 0, [1], true)).toBeUndefined();
408  });
409  it('procedureLogicWorkerFileSystemTest48', function () {
410    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
411    expect(procedureLogicWorkerFileSystem.queryVMEvents(1, 0, [1])).toBeUndefined();
412  });
413  it('procedureLogicWorkerFileSystemTest49', function () {
414    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
415    expect(procedureLogicWorkerFileSystem.queryVMEvents(1, 0, [1])).toBeUndefined();
416  });
417  it('procedureLogicWorkerFileSystemTest50', function () {
418    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
419    expect(procedureLogicWorkerFileSystem.queryIOEvents(1, 0, [1])).toBeUndefined();
420  });
421  it('procedureLogicWorkerFileSystemTest51', function () {
422    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
423    window.postMessage = jest.fn(() => true);
424    let data = {
425      type: 'fileSystem-queryIoSamples',
426      params: {
427        list: [],
428      },
429    };
430    expect(procedureLogicWorkerF.handle(data)).toBeUndefined();
431  });
432  it('procedureLogicWorkerFileSystemTest52', function () {
433    window.postMessage = jest.fn(() => true);
434    let data = {
435      type: 'fileSystem-queryVirtualMemorySamples',
436      params: {
437        list: [],
438      },
439    };
440    expect(procedureLogicWorkerF.handle(data)).toBeUndefined();
441  });
442  it('procedureLogicWorkerFileSystemTest53', function () {
443    window.postMessage = jest.fn(() => true);
444    let data = {
445      type: 'fileSystem-queryVMEvents',
446      params: {
447        list: [],
448      },
449    };
450    expect(procedureLogicWorkerF.handle(data)).toBeUndefined();
451  });
452  it('procedureLogicWorkerFileSystemTest54', function () {
453    window.postMessage = jest.fn(() => true);
454    let data = {
455      type: 'fileSystem-queryIOEvents',
456      params: {
457        list: [],
458      },
459    };
460    expect(procedureLogicWorkerF.handle(data)).toBeUndefined();
461  });
462  it('procedureLogicWorkerFileSystemTest55', function () {
463    let procedureLogicWorkerFileSystem = new ProcedureLogicWorkerFileSystem();
464    expect(procedureLogicWorkerFileSystem.clearAll()).toBeUndefined();
465  });
466  it('procedureLogicWorkerFileSystemTest56', function () {
467    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
468    let selectionParam = {
469      diskIOipids: {
470        length: 1,
471        join: jest.fn(() => true),
472      },
473      fileSystemType: {
474        length: 2,
475        join: jest.fn(() => true),
476      },
477    };
478    window.postMessage = jest.fn(() => true);
479    expect(handlerMap.queryCallChainsSamples(selectionParam)).toBeUndefined();
480  });
481  it('procedureLogicWorkerFileSystemTest57', function () {
482    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
483    window.postMessage = jest.fn(() => true);
484    expect(handlerMap.clear()).toBeUndefined();
485  });
486  it('procedureLogicWorkerFileSystemTest59', function () {
487    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
488    let selectionParam = {
489      fileSystemType: {
490        length: 1,
491        join: jest.fn(() => true),
492      },
493      diskIOipids: {
494        length: 1,
495        join: jest.fn(() => true),
496      },  
497    };
498    window.postMessage = jest.fn(() => true);
499    expect(handlerMap.queryPageFaultSamples(selectionParam)).toBeUndefined();
500  });
501  it('procedureLogicWorkerFileSystemTest60', function () {
502    window.postMessage = jest.fn(() => true);
503    expect(procedureLogicWorkerF.fileSystemAnalysis([], [])).toEqual([]);
504  });
505  it('procedureLogicWorkerFileSystemTest61', function () {
506    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
507    window.postMessage = jest.fn(() => true);
508    expect(handlerMap.setEventId([])).toBeUndefined();
509  });
510  it('procedureLogicWorkerFileSystemTest62', function () {
511    let handlerMap = procedureLogicWorkerF.handlerMap.get('fileSystem');
512    window.postMessage = jest.fn(() => true);
513    expect(handlerMap.setEventId([])).toBeUndefined();
514  });
515  it('procedureLogicWorkerFileSystemTest63', function () {
516    let handlerMap = procedureLogicWorkerF.handlerMap.get('io');
517    let selectionParam = {
518      diskIOipids: {
519        length: 2,
520        join: jest.fn(() => true),
521      },
522      diskIOReadIds: {
523        length: 2,
524        join: jest.fn(() => true),
525      },
526      diskIOWriteIds: {
527        length: 2,
528        join: jest.fn(() => true),
529      },
530    };
531    window.postMessage = jest.fn(() => true);
532    expect(handlerMap.queryCallChainsSamples(selectionParam)).toBeUndefined();
533  });
534  it('procedureLogicWorkerFileSystemTest64', function () {
535    let handlerMap = procedureLogicWorkerF.handlerMap.get('virtualMemory');
536    let selectionParam = {
537      diskIOReadIds: {
538        length: 3,
539        join: jest.fn(() => true),
540      },
541      diskIOipids: {
542        length: 3,
543        join: jest.fn(() => true),
544      },
545      diskIOWriteIds: {
546        length: 3,
547        join: jest.fn(() => true),
548      },
549    };
550    window.postMessage = jest.fn(() => true);
551    expect(handlerMap.queryCallChainsSamples(selectionParam)).toBeUndefined();
552  });
553  it('procedureLogicWorkerFileSystemTest65', function () {
554    let handlerMap = procedureLogicWorkerF.handlerMap.get('io');
555    let selectionParam = {
556      diskIOipids: {
557        length: 3,
558        join: jest.fn(() => true),
559      },
560      diskIOReadIds: {
561        length: 3,
562        join: jest.fn(() => true),
563      },
564      diskIOWriteIds: {
565        length: 3,
566        join: jest.fn(() => true),
567      },
568    };
569    window.postMessage = jest.fn(() => true);
570    expect(handlerMap.queryIOSamples(selectionParam)).toBeUndefined();
571  });
572});
573