• 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
16import {
17  HeapStruct,
18  NativeHookCallInfo,
19  NativeHookStatistics,
20  NativeMemory,
21  ProcedureLogicWorkerNativeMemory,
22  StatisticsSelection,
23  //@ts-ignore
24} from '../../../../src/trace/database/logic-worker/ProcedureLogicWorkerNativeNemory';
25
26import {
27  HeapTreeDataBean,
28  //@ts-ignore
29} from '../../../../src/trace/database/logic-worker/ProcedureLogicWorkerCommon';
30
31describe('ProcedureLogicWorkerNativeNemory Test', () => {
32  let procedureLogicWorkerNativeMemory = new ProcedureLogicWorkerNativeMemory();
33  procedureLogicWorkerNativeMemory.resolvingActionCallInfo = jest.fn(() => true);
34  procedureLogicWorkerNativeMemory.resolvingActionCallInfo.dataSource = jest.fn(() => true);
35  procedureLogicWorkerNativeMemory.resolvingActionCallInfo.dataSource.map = jest.fn(() => true);
36  it('ProcedureLogicWorkerNativeNemoryTest01', function () {
37    expect(procedureLogicWorkerNativeMemory).not.toBeUndefined();
38  });
39
40  it('ProcedureLogicWorkerNativeNemoryTest02', function () {
41    let nativeHookStatistics = new NativeHookStatistics();
42    nativeHookStatistics = {
43      eventId: 0,
44      eventType: '',
45      subType: '',
46      subTypeId: 0,
47      heapSize: 0,
48      addr: '',
49      startTs: 0,
50      endTs: 0,
51      sumHeapSize: 0,
52      max: 0,
53      count: 0,
54      tid: 0,
55      threadName: '',
56      sSelected: false,
57    };
58    expect(nativeHookStatistics).not.toBeUndefined();
59  });
60
61  it('ProcedureLogicWorkerNativeNemoryTest03', function () {
62    let nativeHookCallInfo = new NativeHookCallInfo();
63    expect(nativeHookCallInfo).not.toBeUndefined();
64  });
65
66  it('ProcedureLogicWorkerNativeNemoryTest04', function () {
67    let heapTreeDataBean = new HeapTreeDataBean();
68    heapTreeDataBean = {
69      symbolId: 0,
70      fileId: 0,
71      startTs: 0,
72      endTs: 0,
73      depth: 0,
74      heapSize: 0,
75      eventId: '',
76    };
77    expect(heapTreeDataBean).not.toBeUndefined();
78  });
79
80  it('ProcedureLogicWorkerNativeNemoryTest05', function () {
81    let nativeMemory = new NativeMemory();
82    nativeMemory = {
83      index: 0,
84      eventId: 0,
85      eventType: '',
86      subType: '',
87      addr: '',
88      startTs: 0,
89      endTs: 0,
90      timestamp: '',
91      heapSize: 0,
92      heapSizeUnit: '',
93      symbol: '',
94      library: '',
95      isSelected: false,
96      state: '',
97      threadId: 0,
98      threadName: '',
99    };
100    expect(nativeMemory).not.toBeUndefined();
101  });
102
103  it('ProcedureLogicWorkerNativeNemoryTest06', function () {
104    let heapStruct = new HeapStruct();
105    expect(heapStruct).not.toBeUndefined();
106  });
107
108  it('ProcedureLogicWorkerNativeNemoryTest08', function () {
109    let statisticsSelection = new StatisticsSelection();
110    expect(statisticsSelection).not.toBeUndefined();
111  });
112
113  it('ProcedureLogicWorkerNativeNemoryTest09', function () {
114    expect(procedureLogicWorkerNativeMemory.clearAll()).toBeUndefined();
115  });
116
117  it('ProcedureLogicWorkerNativeNemoryTest11', function () {
118    expect(procedureLogicWorkerNativeMemory.getTypeFromIndex(-1, '', '')).toBeFalsy();
119  });
120
121  it('ProcedureLogicWorkerNativeNemoryTest12', function () {
122    expect(procedureLogicWorkerNativeMemory.getTypeFromIndex(0, '', '')).toBeTruthy();
123  });
124
125  it('ProcedureLogicWorkerNativeNemoryTest13', function () {
126    let item = {
127      eventType: 'AllocEvent',
128    };
129    expect(procedureLogicWorkerNativeMemory.getTypeFromIndex(1, item, '')).toBeTruthy();
130  });
131
132  it('ProcedureLogicWorkerNativeNemoryTest14', function () {
133    let item = {
134      eventType: 'MmapEvent',
135    };
136    expect(procedureLogicWorkerNativeMemory.getTypeFromIndex(2, item, '')).toBeTruthy();
137  });
138
139  it('ProcedureLogicWorkerNativeNemoryTest15', function () {
140    let stack = {
141      children: [],
142      count: 123,
143      countValue: '',
144      countPercent: '69%',
145      size: 32,
146      threadId: 3221,
147      threadName: 'AsyncTask',
148      heapSizeStr: '',
149      heapPercent: '56%',
150      tsArray: [],
151      countArray: []
152    };
153    expect(procedureLogicWorkerNativeMemory.
154      traverseTree(stack, {countArray: [],startTs: 23, tsArray: [],count: 0})).toBeUndefined();
155  });
156
157  it('ProcedureLogicWorkerNativeNemoryTest16', function () {
158    let stack = {
159      children: [],
160      count: 32,
161      countValue: '',
162      countPercent: '87%',
163      size: 23,
164      threadId: 332,
165      threadName: 'ssioncontroller',
166      heapSizeStr: '',
167      heapPercent: '12%',
168      tsArray: [],
169      countArray: []
170    };
171    expect(procedureLogicWorkerNativeMemory.traverseSampleTree(stack, {countArray: [],startTs: 23, tsArray: [],count: 0})).toBeUndefined();
172  });
173
174  it('procedureLogicWorkerFileSystemTest18', function () {
175    window.postMessage = jest.fn(() => true);
176    let data = {
177      params: [
178        {
179          list: '',
180        },
181      ],
182      action: '',
183      id: 2,
184      type: 'native-memory-init',
185    };
186    procedureLogicWorkerNativeMemory.clearAll = jest.fn(() => true);
187    procedureLogicWorkerNativeMemory.initDataDict = jest.fn(() => true);
188    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
189  });
190
191  it('procedureLogicWorkerFileSystemTest19', function () {
192    let data = {
193      params: [
194        {
195          list: '',
196        },
197      ],
198      action: '',
199      type: 'native-memory-queryDataDICT',
200      id: 1,
201    };
202    procedureLogicWorkerNativeMemory.initNMChartData = jest.fn(() => true);
203    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
204  });
205
206  it('procedureLogicWorkerFileSystemTest20', function () {
207    let data = {
208      id: 1,
209      params: [
210        {
211          list: '',
212        },
213      ],
214      action: '',
215      type: 'native-memory-queryNMChartData',
216    };
217    procedureLogicWorkerNativeMemory.initNMFrameData = jest.fn(() => true);
218    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
219  });
220
221  it('procedureLogicWorkerFileSystemTest21', function () {
222    let data = {
223      id: 3,
224      params: [
225        {
226          list: '',
227        },
228      ],
229      action: 'a',
230      type: 'native-memory-queryNMFrameData',
231    };
232    window.postMessage = jest.fn(() => true);
233    procedureLogicWorkerNativeMemory.initNMStack = jest.fn(() => true);
234    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
235  });
236
237  it('procedureLogicWorkerFileSystemTest22', function () {
238    let data = {
239      id: 4,
240      params: [
241        {
242          list: '',
243        },
244      ],
245      action: '',
246      type: 'native-memory-action',
247    };
248    window.postMessage = jest.fn(() => true);
249    procedureLogicWorkerNativeMemory.resolvingAction = jest.fn(() => true);
250    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
251  });
252  it('procedureLogicWorkerFileSystemTest23', function () {
253    window.postMessage = jest.fn(() => true);
254    expect(procedureLogicWorkerNativeMemory.queryData()).toBeUndefined();
255  });
256
257  it('procedureLogicWorkerFileSystemTest25', function () {
258    window.postMessage = jest.fn(() => true);
259    expect(procedureLogicWorkerNativeMemory.initNMChartData()).toBeTruthy();
260  });
261  it('procedureLogicWorkerFileSystemTest26', function () {
262    window.postMessage = jest.fn(() => true);
263    expect(procedureLogicWorkerNativeMemory.initNMFrameData()).toBeTruthy();
264  });
265  it('procedureLogicWorkerFileSystemTest27', function () {
266    window.postMessage = jest.fn(() => true);
267    let frameArr = {
268      map: jest.fn(() => true),
269    };
270    expect(procedureLogicWorkerNativeMemory.initNMStack(frameArr)).toBeTruthy();
271  });
272  it('procedureLogicWorkerFileSystemTest28', function () {
273    let paramMap = {
274      get: jest.fn(() => 'call-info'),
275    };
276    expect(procedureLogicWorkerNativeMemory.resolvingAction(paramMap)).toBeTruthy();
277  });
278  it('procedureLogicWorkerFileSystemTest29', function () {
279    let paramMap = new Map();
280    paramMap.set('actionType', 'info');
281    expect(procedureLogicWorkerNativeMemory.resolvingAction(paramMap)).toBeTruthy();
282  });
283  it('procedureLogicWorkerFileSystemTest30', function () {
284    let paramMap = {
285      get: jest.fn(() => 'memory-stack'),
286    };
287    expect(procedureLogicWorkerNativeMemory.resolvingAction(paramMap)).toBeTruthy();
288  });
289  it('procedureLogicWorkerFileSystemTest31', function () {
290    let paramMap = {
291      get: jest.fn(() => 'memory-chart'),
292    };
293    expect(procedureLogicWorkerNativeMemory.resolvingAction(paramMap)).toBeTruthy();
294  });
295  it('procedureLogicWorkerFileSystemTest32', function () {
296    let paramMap = {
297      get: jest.fn(() => true),
298    };
299    expect(procedureLogicWorkerNativeMemory.resolvingAction(paramMap)).toBeTruthy();
300  });
301  it('procedureLogicWorkerFileSystemTest35', function () {
302    window.postMessage = jest.fn(() => true);
303    expect(procedureLogicWorkerNativeMemory.queryCallchainsSamples('', 1, 1, [''])).toBeUndefined();
304  });
305
306  it('procedureLogicWorkerFileSystemTest37', function () {
307    window.postMessage = jest.fn(() => true);
308    expect(procedureLogicWorkerNativeMemory.queryStatisticCallchainsSamples('', 1, 1, [''])).toBeUndefined();
309  });
310  it('procedureLogicWorkerFileSystemTest42', function () {
311    window.postMessage = jest.fn(() => true);
312    let params = [
313      {
314        length: 1,
315      },
316    ];
317    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
318  });
319  it('procedureLogicWorkerFileSystemTest43', function () {
320    window.postMessage = jest.fn(() => true);
321    let params = {
322      symbol: '',
323      path: '',
324      symbolId: 1,
325      fileId: 1,
326      lib: '',
327      symbolName: '',
328      type: 0,
329    };
330    procedureLogicWorkerNativeMemory.dataCache.dataDict = new Map();
331    procedureLogicWorkerNativeMemory.dataCache.dataDict.set(0, '');
332    procedureLogicWorkerNativeMemory.dataCache.dataDict.set(1, 'H:RSMainThread::DoComposition');
333    procedureLogicWorkerNativeMemory.dataCache.dataDict.set(2, 'H:RSUniRender::Process:[EntryView]');
334    procedureLogicWorkerNativeMemory.dataCache.dataDict.set(3, 'iowait');
335    expect(procedureLogicWorkerNativeMemory.setMerageName(params)).toBeUndefined();
336  });
337  it('procedureLogicWorkerFileSystemTest44', function () {
338    window.postMessage = jest.fn(() => true);
339    expect(procedureLogicWorkerNativeMemory.clearSplitMapData('')).toBeUndefined();
340  });
341  it('procedureLogicWorkerFileSystemTest49', function () {
342    let data = {
343      id: 1,
344      params: [
345        {
346          list: [{
347            value: 'name/value'
348          }],
349        },
350      ],
351      action: '',
352      type: 'native-memory-calltree-action',
353    };
354    window.postMessage = jest.fn(() => true);
355    procedureLogicWorkerNativeMemory.initNMStack = jest.fn(() => true);
356    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
357  });
358  it('procedureLogicWorkerFileSystemTest50', function () {
359    let data = {
360      id: 2,
361      params: [
362        {
363          list: '',
364          value:''
365        },
366      ],
367      action: '',
368      type: 'native-memory-init-responseType',
369    };
370    procedureLogicWorkerNativeMemory.initNMStack = jest.fn(() => true);
371    window.postMessage = jest.fn(() => true);
372    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
373  });
374  it('procedureLogicWorkerFileSystemTest51', function () {
375    let data = {
376      id: 1,
377      params: [
378        {
379          list: [
380            {
381              value: 'name/value'
382            }
383          ],
384        },
385      ],
386      action: 'a',
387      type: 'native-memory-get-responseType',
388    };
389    window.postMessage = jest.fn(() => true);
390    procedureLogicWorkerNativeMemory.initNMStack = jest.fn(() => true);
391    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
392  });
393  it('procedureLogicWorkerFileSystemTest52', function () {
394    let data = {
395      id: 1,
396      params: [
397        {
398          list: '',
399        },
400      ],
401      action: 'b',
402      type: 'native-memory-queryNativeHookStatistic',
403    };
404    window.postMessage = jest.fn(() => true);
405    procedureLogicWorkerNativeMemory.initNMStack = jest.fn(() => true);
406    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
407  });
408
409  it('procedureLogicWorkerFileSystemTest56', function () {
410    window.postMessage = jest.fn(() => true);
411    let data = {
412      params: {
413        list: '',
414        get: jest.fn(() => true),
415      },
416      action: '',
417      id: 2,
418      type: 'native-memory-queryNativeHookEvent',
419    };
420    procedureLogicWorkerNativeMemory.clearAll = jest.fn(() => true);
421    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
422  });
423  it('procedureLogicWorkerFileSystemTest57', function () {
424    window.postMessage = jest.fn(() => true);
425    let data = {
426      params: {
427        list: '',
428        types: {
429          join: jest.fn(() => true),
430        },
431      },
432      action: '',
433      id: 4,
434      type: 'native-memory-queryAnalysis',
435    };
436    procedureLogicWorkerNativeMemory.clearAll = jest.fn(() => true);
437    procedureLogicWorkerNativeMemory.initDataDict = jest.fn(() => true);
438    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
439  });
440  it('procedureLogicWorkerFileSystemTest58', function () {
441    window.postMessage = jest.fn(() => true);
442    let data = {
443      params: {
444        list: '',
445        types: {
446          join: jest.fn(() => true),
447        },
448      },
449      action: 'c',
450      id: 4,
451      type: 'native-memory-queryStatisticCallchainsSamples',
452    };
453    procedureLogicWorkerNativeMemory.clearAll = jest.fn(() => true);
454    procedureLogicWorkerNativeMemory.initDataDict = jest.fn(() => true);
455    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
456  });
457  it('procedureLogicWorkerFileSystemTest59', function () {
458    window.postMessage = jest.fn(() => true);
459    let data = {
460      params: {
461        types: {
462          join: jest.fn(() => true),
463        },
464        list: '',
465      },
466      action: '',
467      id: 4,
468      type: 'native-memory-queryCallchainsSamples',
469    };
470    procedureLogicWorkerNativeMemory.clearAll = jest.fn(() => true);
471    procedureLogicWorkerNativeMemory.initDataDict = jest.fn(() => true);
472    expect(procedureLogicWorkerNativeMemory.handle(data)).toBeUndefined();
473  });
474  it('procedureLogicWorkerFileSystemTest60', function () {
475    window.postMessage = jest.fn(() => true);
476    expect(procedureLogicWorkerNativeMemory.supplementNativeHoodData()).toBeUndefined();
477  });
478  it('procedureLogicWorkerFileSystemTest61', function () {
479    window.postMessage = jest.fn(() => true);
480    let memory = {
481      subTypeId: '',
482    };
483    expect(procedureLogicWorkerNativeMemory.fillNativeHook(memory)).toBeUndefined();
484  });
485  it('procedureLogicWorkerFileSystemTest62', function () {
486    window.postMessage = jest.fn(() => true);
487    expect(procedureLogicWorkerNativeMemory.initNMFrameData()).toBeTruthy();
488  });
489  it('procedureLogicWorkerFileSystemTest63', function () {
490    window.postMessage = jest.fn(() => true);
491    let paramMap = {
492      get: jest.fn(() => true),
493    };
494    expect(procedureLogicWorkerNativeMemory.resolvingAction(paramMap)).toBeTruthy();
495  });
496  it('procedureLogicWorkerFileSystemTest64', function () {
497    window.postMessage = jest.fn(() => true);
498    let paramMap = {
499      get: jest.fn(() => true),
500    };
501    expect(procedureLogicWorkerNativeMemory.resolvingActionNativeMemoryStack(paramMap)).toBeTruthy();
502  });
503  it('procedureLogicWorkerFileSystemTest65', function () {
504    window.postMessage = jest.fn(() => true);
505    let paramMap = {
506      get: jest.fn(() => true),
507    };
508    expect(procedureLogicWorkerNativeMemory.resolvingActionNativeMemory(paramMap)).toBeTruthy();
509  });
510  it('procedureLogicWorkerFileSystemTest66', function () {
511    window.postMessage = jest.fn(() => true);
512    expect(procedureLogicWorkerNativeMemory.sortByNativeMemoryColumn('', 0, [])).toBeTruthy();
513  });
514  it('procedureLogicWorkerFileSystemTest67', function () {
515    window.postMessage = jest.fn(() => true);
516    let arr = {
517      isRelease: true,
518      startTs: 31,
519      endTs: 61,
520      addr: '',
521    };
522    expect(procedureLogicWorkerNativeMemory.setApplyIsRelease([], arr)).toBeUndefined();
523  });
524  it('procedureLogicWorkerFileSystemTest68', function () {
525    window.postMessage = jest.fn(() => true);
526    expect(procedureLogicWorkerNativeMemory.freshCurrentCallchains([], true)).toBeUndefined();
527  });
528  it('procedureLogicWorkerFileSystemTest69', function () {
529    window.postMessage = jest.fn(() => true);
530    let currentNode = new NativeHookCallInfo();
531    currentNode.symbol = '';
532    let callChain = new HeapTreeDataBean();
533    callChain.AllocationFunction = '';
534    let sample = new NativeHookStatistics();
535    sample.countArray = [0,1];
536    sample.tsArray = [0,1];
537    expect(procedureLogicWorkerNativeMemory.mergeCallChainSample(currentNode, callChain, sample)).toBeUndefined();
538  });
539  it('procedureLogicWorkerFileSystemTest70', function () {
540    window.postMessage = jest.fn(() => true);
541    expect(procedureLogicWorkerNativeMemory.createThreadSample([])).toStrictEqual([]);
542  });
543  it('procedureLogicWorkerFileSystemTest71', function () {
544    window.postMessage = jest.fn(() => true);
545    let currentNode = {
546      initChildren: {
547        filter: jest.fn(() => true),
548      },
549    };
550    expect(procedureLogicWorkerNativeMemory.merageChildrenByIndex(currentNode, [], 21, [], true)).toBeUndefined();
551  });
552  it('procedureLogicWorkerFileSystemTest72', function () {
553    window.postMessage = jest.fn(() => true);
554    let params = [
555      {
556        length: 1,
557        funcName: 'groupCallchainSample',
558        funcArgs: [
559          {
560            get: jest.fn(() => true),
561          },
562        ],
563      },
564    ];
565    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
566  });
567  it('procedureLogicWorkerFileSystemTest73', function () {
568    window.postMessage = jest.fn(() => true);
569    let params = [
570      {
571        length: 1,
572        funcName: 'getCallChainsBySampleIds',
573        funcArgs: [
574          {
575            get: jest.fn(() => true),
576          },
577        ],
578      },
579    ];
580    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
581  });
582  it('procedureLogicWorkerFileSystemTest74', function () {
583    window.postMessage = jest.fn(() => true);
584    let params = [
585      {
586        length: 1,
587        funcName: 'hideSystemLibrary',
588        funcArgs: [
589          {
590            get: jest.fn(() => true),
591          },
592        ],
593      },
594    ];
595    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
596  });
597  it('procedureLogicWorkerFileSystemTest75', function () {
598    window.postMessage = jest.fn(() => true);
599    let params = [
600      {
601        length: 1,
602        funcName: 'hideNumMaxAndMin',
603        funcArgs: [
604          {
605            get: jest.fn(() => true),
606          },
607        ],
608      },
609    ];
610    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
611  });
612  it('procedureLogicWorkerFileSystemTest76', function () {
613    window.postMessage = jest.fn(() => true);
614    let params = [
615      {
616        length: 1,
617        funcArgs: [
618          {
619            get: jest.fn(() => true),
620            forEach: jest.fn(() => true),
621          },
622        ],
623        funcName: 'splitAllProcess',
624      },
625    ];
626    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
627  });
628  it('procedureLogicWorkerFileSystemTest77', function () {
629    window.postMessage = jest.fn(() => true);
630    let params = [
631      {
632        length: 2,
633        funcName: 'resetAllNode',
634        funcArgs: [
635          {
636            get: jest.fn(() => true),
637          },
638        ],
639      },
640    ];
641    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
642  });
643  it('procedureLogicWorkerFileSystemTest78', function () {
644    window.postMessage = jest.fn(() => true);
645    let params = [
646      {
647        length: 2,
648        funcName: 'resotreAllNode',
649        funcArgs: [
650          {
651            get: jest.fn(() => true),
652            forEach: jest.fn(() => true),
653          },
654        ],
655      },
656    ];
657    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
658  });
659  it('procedureLogicWorkerFileSystemTest79', function () {
660    window.postMessage = jest.fn(() => true);
661    let params = [
662      {
663        length: 2,
664        funcName: 'splitTree',
665        funcArgs: [
666          {
667            get: jest.fn(() => true),
668          },
669        ],
670      },
671    ];
672    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
673  });
674  it('procedureLogicWorkerFileSystemTest80', function () {
675    window.postMessage = jest.fn(() => true);
676    let params = [
677      {
678        length: 2,
679        funcName: 'setSearchValue',
680        funcArgs: [
681          {
682            get: jest.fn(() => true),
683          },
684        ],
685      },
686    ];
687    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
688  });
689  it('procedureLogicWorkerFileSystemTest81', function () {
690    window.postMessage = jest.fn(() => true);
691    let params = [
692      {
693        length: 2,
694        funcName: 'clearSplitMapData',
695        funcArgs: [
696          {
697            get: jest.fn(() => true),
698          },
699        ],
700      },
701    ];
702    expect(procedureLogicWorkerNativeMemory.resolvingNMCallAction(params)).toStrictEqual([]);
703  });
704  it('procedureLogicWorkerFileSystemTest83', function () {
705    window.postMessage = jest.fn(() => true);
706    let nativeHookCallInfo = new NativeHookCallInfo();
707    expect(nativeHookCallInfo.totalCount).toEqual(0);
708  });
709  it('procedureLogicWorkerFileSystemTest84', function () {
710    window.postMessage = jest.fn(() => true);
711    let nativeHookCallInfo = new NativeHookCallInfo();
712    expect(nativeHookCallInfo.totalSize).toEqual(0);
713  });
714  it('procedureLogicWorkerFileSystemTest85', function () {
715    window.postMessage = jest.fn(() => true);
716    let nativeHookCallInfo = new NativeHookCallInfo();
717    nativeHookCallInfo.totalCount = true;
718    expect(nativeHookCallInfo).toBeTruthy();
719  });
720  it('procedureLogicWorkerFileSystemTest86', function () {
721    window.postMessage = jest.fn(() => true);
722    let nativeHookCallInfo = new NativeHookCallInfo();
723    nativeHookCallInfo.totalSize = true;
724    expect(nativeHookCallInfo).toBeTruthy();
725  });
726  it('procedureLogicWorkerFileSystemTest87', function () {
727    window.postMessage = jest.fn(() => true);
728    let currentNode = new NativeHookCallInfo();
729    let callChain = new HeapTreeDataBean();
730    callChain.AllocationFunction = 'AllocationFunction';
731    let sample = new NativeHookStatistics();
732    sample.countArray = [];
733    sample.tsArray = [];
734    expect(procedureLogicWorkerNativeMemory.mergeCallChainSample(currentNode, callChain, sample)).toBeUndefined();
735  });
736});
737