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.markSearchNode(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, [{name:'sf'}], 0, [], 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('PerfCallChainTest79', function () { 680 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 681 expect(procedureLogicWorkerPerf.perfReset()).toBeUndefined(); 682 }); 683 it('PerfCallChainTest80', function () { 684 let currentNode = { 685 symbolName: '', 686 tsArray: [], 687 }; 688 let callChain = { 689 vaddrInFile: { 690 toString: jest.fn(() => true), 691 }, 692 }; 693 expect( 694 PerfCallChainMerageData.merageCallChainSample( 695 currentNode, 696 callChain, 697 { 698 ts: '', 699 }, 700 true 701 ) 702 ); 703 }); 704 it('PerfCallChainTest81', function () { 705 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 706 let data = { 707 id: 18, 708 type: 'perf-async', 709 }; 710 procedureLogicWorkerPerf.perfAsync = jest.fn(() => true); 711 procedureLogicWorkerPerf.handle(data); 712 expect(procedureLogicWorkerPerf.perfAsync).toHaveBeenCalled(); 713 }); 714 it('PerfCallChainTest82', function () { 715 let perfCallChain = new PerfCallChain(); 716 perfCallChain.startNS = 10; 717 perfCallChain.dur = 10; 718 perfCallChain.sampleId = 10; 719 perfCallChain.vaddrInFile = 10; 720 perfCallChain.callChainId = 10; 721 perfCallChain.tid = 10; 722 expect(perfCallChain.startNS).toEqual(10); 723 expect(perfCallChain.dur).toEqual(10); 724 expect(perfCallChain.sampleId).toEqual(10); 725 expect(perfCallChain.vaddrInFile).toEqual(10); 726 expect(perfCallChain.callChainId).toEqual(10); 727 expect(perfCallChain.tid).toEqual(10); 728 }); 729 it('PerfCallChainTest83', function () { 730 let perfCallChainMerageData = new PerfCallChainMerageData(); 731 perfCallChainMerageData.totalEvent = 80; 732 expect(perfCallChainMerageData.totalEvent).toEqual(80); 733 }); 734 it('PerfCallChainTest84', function () { 735 let perfThread = new PerfThread(); 736 perfThread.tid = 80; 737 expect(perfThread.tid).toEqual(80); 738 }); 739 it('PerfCallChainTest85', function () { 740 let perfFile = new PerfFile(); 741 perfFile.symbol = '80'; 742 perfFile.path = 'C:/myfile'; 743 let data = { 744 path: 'C:/myfile', 745 }; 746 expect(perfFile.setFileName()).toBeUndefined(); 747 }); 748 it('PerfCallChainTest86', function () { 749 let data = { 750 path: 'C:/myfile', 751 fileId: 5, 752 symbol: 'f', 753 fileName: 'myfile', 754 setFileName: 'sfd', 755 }; 756 expect(PerfFile.setFileName(data)).toBeUndefined(); 757 }); 758 it('PerfCallChainTest87', function () { 759 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 760 let data = new PerfCountSample(); 761 data.sampleId = 10; 762 expect(procedureLogicWorkerPerf.getBottomUp()).not.toBeUndefined(); 763 }); 764 it('PerfCallChainTest88', function () { 765 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 766 expect(procedureLogicWorkerPerf.combineCallChainForAnalysis()).not.toBeUndefined(); 767 }); 768 it('PerfCallChainTest90', function () { 769 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 770 let data = { 771 id: 18, 772 type: 'perf-reset', 773 }; 774 procedureLogicWorkerPerf.perfReset = jest.fn(() => true); 775 procedureLogicWorkerPerf.handle(data); 776 expect(procedureLogicWorkerPerf.perfReset).toHaveBeenCalled(); 777 }); 778 it('PerfCallChainTest91', function () { 779 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 780 let data = { 781 id: 18, 782 type: 'perf-reset', 783 }; 784 procedureLogicWorkerPerf.perfReset = jest.fn(() => true); 785 procedureLogicWorkerPerf.handle(data); 786 expect(procedureLogicWorkerPerf.perfReset).toHaveBeenCalled(); 787 }); 788 it('PerfCallChainTest92', function () { 789 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 790 let data = [{ funcArgs: [1, 2, 3] }]; 791 expect(procedureLogicWorkerPerf.setLib(data)).toBeUndefined(); 792 }); 793 it('PerfCallChainTest93', function () { 794 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 795 let data = [{ funcArgs: [1, 2, 3] }]; 796 expect(procedureLogicWorkerPerf.setSymbol(data)).toBeUndefined(); 797 }); 798 it('PerfCallChainTest94', function () { 799 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 800 let data = [ 801 { funcName: 'getCallChainsBySampleIds', funcArgs: [1, 8, 5] }, 802 { funcName: 'hideSystemLibrary', funcArgs: [1, 8, 5] }, 803 { funcName: 'hideThreadState', funcArgs: [1, 8, 5] }, 804 { funcName: 'hideThread', funcArgs: [1, 8, 5] }, 805 ]; 806 procedureLogicWorkerPerf.lib = { name: 'getCallChainsBySampleIds' }; 807 expect(procedureLogicWorkerPerf.calReturnData(data)).not.toBeUndefined(); 808 }); 809 it('PerfCallChainTest95', function () { 810 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 811 let data = [ 812 { funcName: 'getCallChainsBySampleIds', funcArgs: [1, 8, 5] }, 813 { funcName: 'hideSystemLibrary', funcArgs: [1, 8, 5] }, 814 { funcName: 'hideThreadState', funcArgs: [1, 8, 5] }, 815 { funcName: 'hideThread', funcArgs: [1, 8, 5] }, 816 ]; 817 procedureLogicWorkerPerf.symbol = { name: 'hideThread' }; 818 expect(procedureLogicWorkerPerf.calReturnData(data)).not.toBeUndefined(); 819 }); 820 it('PerfCallChainTest96', function () { 821 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 822 let data = [ 823 { startNS: 50, dur: 8, sampleId: 1, callChainId: 4 }, 824 { startNS: 50, dur: 8, sampleId: 80, callChainId: 4 }, 825 ]; 826 expect(procedureLogicWorkerPerf.initPerfCallChainTopDown(data)).toBeUndefined(); 827 }); 828 it('PerfCallChainTest97', function () { 829 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 830 let perfCountSample = new PerfCountSample(); 831 let perfThread = new PerfThread(); 832 perfThread.processName = 'a'; 833 procedureLogicWorkerPerf.threadData[0] = perfThread; 834 let perfCallChainMerageData = new PerfCallChainMerageData(); 835 perfCallChainMerageData.tid = 0; 836 procedureLogicWorkerPerf.currentTreeMapData['sf'] = perfCallChainMerageData; 837 let list: PerfCallChain[] = [ 838 { startNS: 50, dur: 8, sampleId: 1, callChainId: 4 }, 839 { startNS: 50, dur: 8, sampleId: 80, callChainId: 4 }, 840 ]; 841 expect(procedureLogicWorkerPerf.addOtherCallchainsData(perfCountSample, list)).toBeUndefined(); 842 }); 843 it('PerfCallChainTest98', function () { 844 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 845 let perfThread = new PerfThread(); 846 perfThread.processName = 'a'; 847 procedureLogicWorkerPerf.threadData[0] = perfThread; 848 let perfCallChainMerageData = new PerfCallChainMerageData(); 849 perfCallChainMerageData.tid = 0; 850 procedureLogicWorkerPerf.currentTreeMapData['sf'] = perfCallChainMerageData; 851 expect(procedureLogicWorkerPerf.mergeNodeData(5, 8)).not.toBeUndefined(); 852 }); 853 it('PerfCallChainTest99', function () { 854 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 855 let perfCountSample = new PerfCountSample(); 856 perfCountSample.sampleId = 0; 857 perfCountSample.tid = 0; 858 let perfThread = new PerfThread(); 859 perfThread.processName = 'a'; 860 procedureLogicWorkerPerf.threadData[0] = perfThread; 861 let perfCallChain = new PerfCallChain(); 862 perfCallChain.name = '0'; 863 procedureLogicWorkerPerf.callChainData[0] = [perfCallChain]; 864 expect(procedureLogicWorkerPerf.freshPerfCallchains([perfCountSample], true)).toBeUndefined(); 865 }); 866 it('PerfCallChainTest100', function () { 867 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 868 let perf = new PerfCallChainMerageData(); 869 procedureLogicWorkerPerf.currentTreeList = [perf]; 870 expect(procedureLogicWorkerPerf.handleCurrentTreeList(100, 8)).toBeUndefined(); 871 }); 872 it('PerfCallChainTest101', function () { 873 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 874 let perfThread = new PerfThread(); 875 perfThread.processName = 'a'; 876 procedureLogicWorkerPerf.threadData[0] = perfThread; 877 let perfCallChainMerageData = new PerfCallChainMerageData(); 878 perfCallChainMerageData.tid = 0; 879 procedureLogicWorkerPerf.currentTreeMapData['sf'] = perfCallChainMerageData; 880 let perf = new PerfCallChainMerageData(); 881 let perfCallChain = new PerfCallChain(); 882 perfCallChain.name = '0'; 883 let callChainDataList = [perfCallChain]; 884 procedureLogicWorkerPerf.callChainData[0] = [perfCallChain]; 885 let perfCountSample = new PerfCountSample(); 886 procedureLogicWorkerPerf.currentTreeList = [perf]; 887 expect( 888 procedureLogicWorkerPerf.mergeChildrenByIndex( 889 perfCallChainMerageData, 890 callChainDataList, 891 100, 892 perfCountSample, 893 true 894 ) 895 ).toBeUndefined(); 896 }); 897 it('PerfCallChainTest102', function () { 898 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 899 let perf = new PerfCallChainMerageData(); 900 expect(procedureLogicWorkerPerf.hasSearchNode(perf)).not.toBeUndefined(); 901 }); 902 it('PerfCallChainTest103', function () { 903 let data = new PerfCallChainMerageData(); 904 let sampleArray = [data]; 905 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 906 expect(procedureLogicWorkerPerf.kernelCombination()).toBeUndefined(); 907 expect(procedureLogicWorkerPerf.markSearchNode(sampleArray, 's', true)).toBeUndefined(); 908 }); 909 it('PerfCallChainTest104', function () { 910 let data = [{funcName: 'a', funcArgs: [0,1,2]}]; 911 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 912 expect(procedureLogicWorkerPerf.resolvingAction(data)).not.toBeUndefined(); 913 }); 914 it('PerfCallChainTest105', function () { 915 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 916 let perf = new PerfCallChainMerageData(); 917 procedureLogicWorkerPerf.currentTreeList = [perf]; 918 perf.parentNode = new PerfCallChainMerageData(); 919 perf.parentNode.parentId = '10'; 920 expect(procedureLogicWorkerPerf.handleCurrentTreeList(100, 8)).toBeUndefined(); 921 }); 922 it('PerfCallChainTest106', function () { 923 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 924 let perf = new PerfCallChainMerageData(); 925 let samples = [perf]; 926 expect(procedureLogicWorkerPerf.splitPerfTree(samples, '8', true, false)).toBeUndefined(); 927 }); 928 it('PerfCallChainTest107', function () { 929 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 930 let perf = new PerfCallChainMerageData(); 931 let samples = [perf]; 932 procedureLogicWorkerPerf.recursionPerfChargeInitTree = jest.fn(); 933 expect(procedureLogicWorkerPerf.splitPerfTree(samples, '8', false, false)).toBeUndefined(); 934 }); 935 it('PerfCallChainTest108', function () { 936 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 937 let perf = new PerfCallChainMerageData(); 938 procedureLogicWorkerPerf.recursionPerfChargeInitTree = jest.fn(); 939 expect(procedureLogicWorkerPerf.recursionPerfChargeInitTree(perf, '8', false)).toBeUndefined(); 940 }); 941 it('PerfCallChainTest109', function () { 942 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 943 procedureLogicWorkerPerf.recursionPerfChargeInitTree = jest.fn(); 944 let sample = { 945 symbolName: '8', 946 initChildren: { 947 length: 2, 948 forEach: jest.fn(() => true), 949 }, 950 }; 951 expect(procedureLogicWorkerPerf.recursionPerfPruneInitTree(sample, '8', true)).toBeUndefined(); 952 }); 953 it('PerfCallChainTest110', function () { 954 let procedureLogicWorkerPerf = new ProcedureLogicWorkerPerf(); 955 let perf = new PerfCallChainMerageData(); 956 procedureLogicWorkerPerf.recursionPerfChargeInitTree = jest.fn(); 957 expect(procedureLogicWorkerPerf.recursionPerfPruneInitTree(perf, '8', true)).toBeUndefined(); 958 }); 959}); 960