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