• 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  ProcedureLogicWorkerPerf,
19  PerfCountSample,
20  PerfCallChainMerageData,
21  PerfStack,
22  PerfCmdLine,
23  timeMsFormat2p,
24  PerfFile,
25  PerfThread,
26  PerfCallChain,
27} from '../../../../dist/trace/database/logic-worker/ProcedureLogicWorkerPerf.js';
28//@ts-ignore
29import { PerfCall } from '../../../../dist/trace/database/logic-worker/ProcedureLogicWorkerCommon.js';
30
31describe('ProcedureLogicWorkerPerf Test', () => {
32  it('ProcedureLogicWorkerPerfTest', function () {
33    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
34    expect(procedureLogicWorkerPerf).not.toBeUndefined();
35  });
36
37  it('ProcedureLogicWorkerPerfTest01', function () {
38    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
39    let data = {
40      id: 1,
41      params: [
42        {
43          list: '',
44        },
45      ],
46      action: '',
47      type: 'perf-init',
48    };
49    procedureLogicWorkerPerf.initPerfFiles = jest.fn(() => true);
50    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
51  });
52
53  it('ProcedureLogicWorkerPerfTest02', function () {
54    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
55    let data = {
56      id: 1,
57      params: [
58        {
59          list: '',
60        },
61      ],
62      action: '',
63      type: 'perf-queryPerfFiles',
64    };
65    procedureLogicWorkerPerf.initPerfThreads = jest.fn(() => true);
66    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
67  });
68
69  it('ProcedureLogicWorkerPerfTest03', function () {
70    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
71    let data = {
72      id: 1,
73      params: [
74        {
75          list: '',
76        },
77      ],
78      action: '',
79      type: 'perf-queryPerfThread',
80    };
81    procedureLogicWorkerPerf.initPerfCalls = jest.fn(() => true);
82    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
83  });
84
85  it('ProcedureLogicWorkerPerfTest04', function () {
86    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
87    let data = {
88      id: 1,
89      params: [
90        {
91          list: '',
92        },
93      ],
94      action: '',
95      type: 'perf-queryPerfCalls',
96    };
97    procedureLogicWorkerPerf.initPerfCallchains = jest.fn(() => true);
98    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
99  });
100
101  it('ProcedureLogicWorkerPerfTest05', function () {
102    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
103    let data = {
104      id: 1,
105      params: [
106        {
107          list: '',
108        },
109      ],
110      action: '',
111      type: 'perf-queryPerfCallchains',
112    };
113    window.postMessage = jest.fn(() => true);
114    procedureLogicWorkerPerf.initCallChainTopDown = jest.fn(() => true);
115    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
116  });
117
118  it('ProcedureLogicWorkerPerfTest06', function () {
119    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
120    let data = {
121      id: 1,
122      params: [
123        {
124          list: '',
125        },
126      ],
127      action: '',
128      type: 'perf-queryCallchainsGroupSample',
129    };
130    window.postMessage = jest.fn(() => true);
131    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
132  });
133
134  it('ProcedureLogicWorkerPerfTest07', function () {
135    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
136    let data = {
137      id: 1,
138      params: [
139        {
140          list: '',
141        },
142      ],
143      action: '',
144      type: 'perf-action',
145    };
146    procedureLogicWorkerPerf.resolvingAction = jest.fn(() => true);
147    window.postMessage = jest.fn(() => true);
148    expect(procedureLogicWorkerPerf.handle(data)).toBeUndefined();
149  });
150
151  it('ProcedureLogicWorkerPerfTest08', function () {
152    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
153    expect(procedureLogicWorkerPerf.clearAll()).toBeUndefined();
154  });
155
156  it('ProcedureLogicWorkerPerfTest14', function () {
157    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
158    let callChain = {
159      sampleId: '',
160      depth: 0,
161      canCharge: false,
162      name: '',
163      tid: '',
164      fileName: '',
165      threadName: '',
166    };
167    expect(procedureLogicWorkerPerf.addPerfCallData(callChain)).toBeUndefined();
168  });
169
170  it('ProcedureLogicWorkerPerfTest19', function () {
171    let perfCountSample = new PerfCountSample();
172    perfCountSample = {
173      sampleId: 0,
174      count: 0,
175      pid: 0,
176      tid: 0,
177      threadState: '',
178    };
179    expect(perfCountSample).not.toBeUndefined();
180  });
181
182  it('ProcedureLogicWorkerPerfTest20', function () {
183    let perfStack = new PerfStack();
184    perfStack = {
185      sample: '',
186      path: '',
187      fileId: 0,
188      type: 0,
189      vaddrInFile: 0,
190    };
191    expect(perfStack).not.toBeUndefined();
192  });
193
194  it('ProcedureLogicWorkerPerfTest21', function () {
195    let perfCmdLine = new PerfCmdLine();
196    perfCmdLine = {
197      report_value: '',
198    };
199    expect(perfCmdLine).not.toBeUndefined();
200  });
201
202  it('ProcedureLogicWorkerPerfTest21', function () {
203    let perfCmdLine = new PerfCmdLine();
204    perfCmdLine = {
205      report_value: '',
206    };
207    expect(perfCmdLine).not.toBeUndefined();
208  });
209
210  it('ProcedureLogicWorkerPerfTest21', function () {
211    let perfCall = new PerfCall();
212    perfCall = {
213      sampleId: 0,
214      name: '',
215      depth: 0,
216    };
217    expect(perfCall).not.toBeUndefined();
218  });
219
220  it('ProcedureLogicWorkerPerfTest22', function () {
221    expect(timeMsFormat2p('')).toBe('0s');
222  });
223
224  it('ProcedureLogicWorkerPerfTest23', function () {
225    expect(timeMsFormat2p(3600_000)).toBe('1.00h');
226  });
227
228  it('ProcedureLogicWorkerPerfTest24', function () {
229    expect(timeMsFormat2p(60_000)).toBe('1.00min');
230  });
231
232  it('ProcedureLogicWorkerPerfTest25', function () {
233    expect(timeMsFormat2p(1_000)).toBe('1.00s');
234  });
235
236  it('ProcedureLogicWorkerPerfTest26', function () {
237    expect(timeMsFormat2p(100)).toBe('100.00ms');
238  });
239
240  it('ProcedureLogicWorkerPerfTest31', function () {
241    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
242    procedureLogicWorkerPerf.recursionChargeInitTree = jest.fn(() => undefined);
243    let node = [
244      {
245        symbolName: '',
246        libName: '',
247        length: 1,
248        initChildren: {
249          length: 1,
250        },
251      },
252    ];
253    expect(procedureLogicWorkerPerf.recursionChargeInitTree(node, '', true)).toBeUndefined();
254  });
255
256  it('ProcedureLogicWorkerPerfTest33', function () {
257    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
258    procedureLogicWorkerPerf.recursionPruneInitTree = jest.fn(() => undefined);
259    let node = {
260      symbolName: '',
261      libName: '',
262      length: 1,
263      initChildren: {
264        length: 1,
265      },
266    };
267    expect(procedureLogicWorkerPerf.recursionPruneInitTree(node, '', true)).toBeUndefined();
268  });
269
270  it('ProcedureLogicWorkerPerfTest34', function () {
271    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
272    procedureLogicWorkerPerf.recursionChargeByRule = jest.fn(() => undefined);
273    let node = {
274      initChildren: [
275        {
276          length: 1,
277        },
278      ],
279    };
280    let rule = {
281      child: {
282        isStore: 1,
283      },
284    };
285    expect(procedureLogicWorkerPerf.recursionChargeByRule(node, '', rule)).toBeUndefined();
286  });
287
288  it('ProcedureLogicWorkerPerfTest35', function () {
289    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
290    window.postMessage = jest.fn(() => true);
291    expect(procedureLogicWorkerPerf.queryData('', '', '')).toBeUndefined();
292  });
293
294  it('ProcedureLogicWorkerPerfTest36', function () {
295    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
296    procedureLogicWorkerPerf.queryData = jest.fn(() => true);
297    expect(procedureLogicWorkerPerf.initPerfFiles()).toBeUndefined();
298  });
299
300  it('ProcedureLogicWorkerPerfTest37', function () {
301    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
302    procedureLogicWorkerPerf.queryData = jest.fn(() => true);
303    expect(procedureLogicWorkerPerf.initPerfThreads()).toBeUndefined();
304  });
305
306  it('ProcedureLogicWorkerPerfTest38', function () {
307    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
308    procedureLogicWorkerPerf.queryData = jest.fn(() => true);
309    expect(procedureLogicWorkerPerf.initPerfCalls()).toBeUndefined();
310  });
311
312  it('ProcedureLogicWorkerPerfTest39', function () {
313    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
314    procedureLogicWorkerPerf.queryData = jest.fn(() => true);
315    expect(procedureLogicWorkerPerf.initPerfCallchains()).toBeUndefined();
316  });
317
318  it('ProcedureLogicWorkerPerfTest40', function () {
319    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
320    procedureLogicWorkerPerf.queryData = jest.fn(() => true);
321    let selectionParam = {
322      perfAll: '',
323      perfCpus: [1],
324      perfProcess: [2],
325      perfThread: [1],
326      leftNs: 0,
327      rightNs: 0,
328    };
329    expect(procedureLogicWorkerPerf.getCurrentDataFromDb(selectionParam)).toBeUndefined();
330  });
331
332  it('ProcedureLogicWorkerPerfTest41', function () {
333    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
334    let currentNode = {
335      children: [],
336      initChildren: [],
337    };
338    let list = [
339      {
340        length: 1,
341        name: '',
342      },
343    ];
344    expect(procedureLogicWorkerPerf.merageChildren(currentNode, list, true)).toBeUndefined();
345  });
346  it('ProcedureLogicWorkerPerfTest42', function () {
347    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
348    let sampleIds = {
349      length: 1,
350    };
351    let isTopDown = {};
352    expect(procedureLogicWorkerPerf.groupNewTreeNoId(sampleIds, isTopDown)).toStrictEqual([]);
353  });
354  it('ProcedureLogicWorkerPerfTest46', function () {
355    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
356    let node = {
357      children: {
358        length: 1,
359        forEach: jest.fn(() => true),
360      },
361      libName: 1,
362    };
363    let symbolName = 1;
364
365    let isSymbol = true;
366    expect(procedureLogicWorkerPerf.recursionPruneTree(node, symbolName, isSymbol)).toBeUndefined();
367  });
368  it('ProcedureLogicWorkerPerfTest47', function () {
369    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
370    let node = {
371      initChildren: {
372        length: 1,
373        forEach: jest.fn(() => true),
374      },
375    };
376    let ruleName = 1;
377
378    let rule = true;
379    expect(procedureLogicWorkerPerf.recursionChargeByRule(node, ruleName, rule)).toBeUndefined();
380  });
381  it('ProcedureLogicWorkerPerfTest48', function () {
382    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
383    let node = {
384      initChildren: {
385        length: 1,
386        forEach: jest.fn(() => true),
387      },
388    };
389    let symbolName = 1;
390    expect(procedureLogicWorkerPerf.pruneChildren(node, symbolName)).toBeUndefined();
391  });
392  it('ProcedureLogicWorkerPerfTest49', function () {
393    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
394    expect(procedureLogicWorkerPerf.clearSplitMapData()).toBeUndefined();
395  });
396  it('PerfFileTest01', function () {
397    let perfFile = new PerfFile();
398    expect(perfFile.constructor()).toBeUndefined();
399  });
400  it('PerfFileTest02', function () {
401    let perfFile = new PerfFile();
402    let path = true;
403    expect(perfFile.setFileName(path)).toBeUndefined();
404  });
405  it('PerfThreadTest01', function () {
406    let perfThread = new PerfThread();
407    expect(perfThread.constructor()).toBeUndefined();
408  });
409  it('PerfCallChainTest01', function () {
410    let perfCallChain = new PerfCallChain();
411    expect(perfCallChain.constructor()).toBeUndefined();
412  });
413  it('PerfCallChainMerageDataTest01', function () {
414    let perfCallChainMerageData = new PerfCallChainMerageData();
415    expect(perfCallChainMerageData.constructor()).toEqual({
416      addr: '',
417      canCharge: true,
418      children: [],
419      count: 0,
420      currentTreeParentNode: undefined,
421      depth: 0,
422      dur: 0,
423      id: '',
424      initChildren: [],
425      isSearch: false,
426      isSelected: false,
427      isStore: 0,
428      lib: '',
429      libName: '',
430      parentId: '',
431      path: '',
432      pid: 0,
433      searchShow: true,
434      self: '0s',
435      selfDur: 0,
436      size: 0,
437      symbol: '',
438      symbolName: '',
439      tid: 0,
440      type: 0,
441      vaddrInFile: 0,
442      weight: '',
443      weightPercent: '',
444    });
445  });
446  it('PerfCallChainMerageDataTest03', function () {
447    let perfCallChainMerageData = new PerfCallChainMerageData();
448    perfCallChainMerageData.parentNode = true;
449    expect(perfCallChainMerageData.parentNode).toBeTruthy();
450  });
451  it('PerfCallChainMerageDataTest04', function () {
452    let perfCallChainMerageData = new PerfCallChainMerageData();
453    perfCallChainMerageData.total = true;
454    expect(perfCallChainMerageData.total).toBeTruthy();
455  });
456  it('ProcedureLogicWorkerPerfTest53', function () {
457    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
458    expect(procedureLogicWorkerPerf.hideSystemLibrary()).toBeUndefined();
459  });
460  it('ProcedureLogicWorkerPerfTest54', function () {
461    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
462    expect(procedureLogicWorkerPerf.hideNumMaxAndMin(1, '∞')).toBeUndefined();
463  });
464  it('ProcedureLogicWorkerPerfTest55', function () {
465    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
466    let sampleArray = [
467      {
468        addr: '',
469        canCharge: true,
470        children: [],
471        count: 4,
472        currentTreeParentNode: {
473          addr: '',
474          canCharge: true,
475          children: [],
476          count: 4,
477          currentTreeParentNode: {},
478          depth: 0,
479          dur: 1,
480          id: '11758',
481          initChildren: [],
482          isSearch: false,
483          isSelected: false,
484          isStore: 0,
485          lib: '',
486          libName: 'ld-musl-aarch64.so.1',
487          parentId: '977',
488          path: '/system/lib/ld-musl-aarch64.so.1',
489          pid: 28917,
490          searchShow: false,
491          self: '0ms',
492          selfDur: 4,
493          size: 0,
494          symbol: 'fopen64  (ld-musl-aarch64.so.1)',
495          symbolName: 'fopen64',
496          tid: 28922,
497          type: 0,
498          vaddrInFile: 730108,
499          weight: '1.00ms',
500          weightPercent: '0.0%',
501        },
502        depth: 0,
503        dur: 4,
504        id: '2791',
505        initChildren: [],
506        isSearch: false,
507        isSelected: false,
508        isStore: 0,
509        lib: '',
510        libName: '[kernel.kallsyms]',
511        parentId: '2790',
512        path: '[kernel.kallsyms]',
513        pid: 28917,
514        searchShow: false,
515        self: '4.00ms',
516        selfDur: 4,
517        size: 0,
518        symbol: 'perf_trace_sched_switch  ([kernel.kallsyms])',
519        symbolName: 'perf_trace_sched_switch',
520        tid: 28922,
521        type: 0,
522        vaddrInFile: -274609073904,
523        weight: '4.00ms',
524        weightPercent: '0.0%',
525      },
526    ];
527    expect(procedureLogicWorkerPerf.findSearchNode(sampleArray, 'da', false)).toBeUndefined();
528  });
529  it('ProcedureLogicWorkerPerfTest56', function () {
530    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
531    expect(procedureLogicWorkerPerf.splitAllProcess([])).toBeUndefined();
532  });
533  it('ProcedureLogicWorkerPerfTest57', function () {
534    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
535    let callChains = [
536      {
537        tid: 1,
538        sampleId: 20,
539      },
540      {
541        tid: 2,
542        sampleId: 30,
543      },
544    ];
545    expect(procedureLogicWorkerPerf.initPerfCallChainBottomUp(callChains)).toBeUndefined();
546  });
547  it('ProcedureLogicWorkerPerfTest58', function () {
548    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
549    let callChains = [
550      {
551        tid: 1,
552        sampleId: 20,
553        symbolId: -1,
554        fileName: 'a',
555      },
556      {
557        tid: 2,
558        sampleId: 30,
559        symbolId: 0,
560        fileName: 'a',
561      },
562    ];
563    expect(procedureLogicWorkerPerf.setPerfCallChainFrameName(callChains)).toBeUndefined();
564  });
565  it('ProcedureLogicWorkerPerfTest59', function () {
566    let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf();
567    let callChains = [
568      {
569        sampleId: '',
570        depth: 0,
571        canCharge: false,
572        name: '',
573        tid: '',
574        fileName: '',
575        threadName: '',
576      },
577      {
578        sampleId: '',
579        depth: 0,
580        canCharge: false,
581        name: '',
582        tid: '',
583        fileName: '',
584        threadName: '',
585      },
586    ];
587    expect(procedureLogicWorkerPerf.addPerfGroupData(callChains)).toBeUndefined();
588  });
589});
590