• 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
16jest.mock('../../../../src/trace/database/ui-worker/ProcedureWorkerCPU', () => {});
17jest.mock('../../../../src/trace/component/trace/base/TraceSheet', () => {});
18jest.mock('../../../../src/trace/component/SpSystemTrace', () => {
19  return {
20    CurrentSlicesTime: () => {},
21  };
22});
23import {
24  drawFlagLine,
25  drawLines,
26  Point,
27  Rect,
28  ns2s,
29  ns2x,
30  drawSelection,
31  drawWakeUp,
32  fillCacheData,
33  findRange,
34  dataFilterHandler,
35  drawFlagLineSegment,
36  drawSelectionRange,
37  drawLinkLines,
38  drawString2Line,
39  drawWakeUpList,
40  // @ts-ignore
41} from '../../../../src/trace/database/ui-worker/ProcedureWorkerCommon';
42import { Flag } from '../../../../src/trace/database/ui-worker/ProcedureWorkerTimeline';
43import { ColorUtils } from '../../../../src/trace/component/trace/base/ColorUtils';
44import { TraceRow } from '../../../../src/trace/component/trace/base/TraceRow';
45import { EventCenter } from '../../../../src/trace/component/trace/base/EventCenter';
46
47declare global {
48  interface Window {
49    SmartEvent: {
50      UI: {
51        RefreshCanvas: string; //selected menu trace
52        SliceMark: string; //Set the tag scope
53        TraceRowComplete: string; //Triggered after the row component has finished loading data
54        MenuTrace: string; //selected menu trace
55        TimeRange: string; //Set the timeline range
56      };
57    };
58    subscribeOnce(evt: string, fn: (b: any) => void): void;
59    clearTraceRowComplete(): void;
60    unsubscribe(evt: string, fn: (b: any) => void): void;
61    publish(evt: string, data: any): void;
62    subscribe(evt: string, fn: (b: any) => void): void;
63  }
64}
65
66window.SmartEvent = {
67  UI: {
68    MenuTrace: 'SmartEvent-UI-MenuTrace',
69    RefreshCanvas: 'SmartEvent-UI-RefreshCanvas',
70    SliceMark: 'SmartEvent-UI-SliceMark',
71    TimeRange: 'SmartEvent-UI-TimeRange',
72    TraceRowComplete: 'SmartEvent-UI-TraceRowComplete',
73  },
74};
75Window.prototype.unsubscribe = (ev, fn) => EventCenter.unsubscribe(ev, fn);
76Window.prototype.subscribe = (ev, fn) => EventCenter.subscribe(ev, fn);
77Window.prototype.publish = (ev, data) => EventCenter.publish(ev, data);
78Window.prototype.subscribeOnce = (ev, data) => EventCenter.subscribeOnce(ev, data);
79Window.prototype.clearTraceRowComplete = () => EventCenter.clearTraceRowComplete();
80
81describe('ProcedureWorkerCommon Test', () => {
82  let rect = new Rect();
83  let fullData = [
84    {
85      cpu: 2,
86      dur: 140000,
87      end_state: 'S',
88      frame: {
89        y: 5,
90        height: 30,
91      },
92      id: 62,
93      name: '2555',
94      priority: 100,
95      processCmdLine: 'com.test',
96      processId: 2983,
97      processName: 'com.test',
98      schedId: 44,
99      startTime: 3845000,
100      tid: 2996,
101      type: 'thread',
102    },
103  ];
104  let filterData = [
105    {
106      cpu: 0,
107      dur: 69444,
108      end_state: 'sR',
109      frame: { y: 15, height: 10, x: 13, width: 34 },
110      id: 4,
111      name: 'test',
112      priority: 23,
113      processCmdLine: 'test',
114      processId: 3255,
115      processName: 'test',
116      schedId: 3,
117      startTime: 53333,
118      tid: 6,
119      translateY: 0,
120      type: 'thread',
121      v: false,
122    },
123  ];
124  let condition = {
125    startKey: 'startNS',
126    durKey: 'dur',
127    startNS: 20,
128    endNS: 1000,
129    totalNS: 2000,
130    frame: { x: 10, y: 10 },
131    paddingTop: 5,
132    useCache: true,
133  };
134
135  let timerShaftElement = document.createElement('timer-shaft-element');
136  timerShaftElement.totalNS = 1000;
137  timerShaftElement.startNS = 1000;
138  timerShaftElement.endNS = 2000;
139  timerShaftElement.setRangeNS(1522, 5222);
140  timerShaftElement.getBoundingClientRect = jest.fn(() => {
141    return {
142      width: 648,
143    };
144  });
145
146  it('ProcedureWorkerCommon01', function () {
147    expect(rect.contains(1, 2)).not.toBeUndefined();
148  });
149
150  it('ProcedureWorkerCommon02', function () {
151    expect(rect.containsWithPadding()).not.toBeUndefined();
152  });
153
154  it('ProcedureWorkerCommon03', function () {
155    let point = new Point();
156    expect(point).not.toBeUndefined();
157  });
158
159  it('ProcedureWorkerCommon04', function () {
160    let rect = new Rect();
161    expect(Rect.contains(rect, 1, 2)).toBe(false);
162  });
163
164  it('ProcedureWorkerCommon05', function () {
165    let rect = new Rect();
166    expect(Rect.containsWithPadding(rect, 1, 2, 1, 2)).toBe(false);
167  });
168
169  it('ProcedureWorkerCommon06', function () {
170    let rect = new Rect();
171    expect(Rect.containsWithMargin(rect, 1, 2, 1, 2, 1, 1)).toBe(false);
172  });
173
174  it('ProcedureWorkerCommon07', function () {
175    let rect = new Rect();
176    let rect2 = new Rect();
177    expect(Rect.intersect(rect, rect2)).toBe(false);
178  });
179
180  it('ProcedureWorkerCommon08', function () {
181    let rect = new Rect();
182    expect(rect.containsWithMargin(1, 2, 3, 5, 4, 5)).toBe(false);
183  });
184
185  it('ProcedureWorkerCommon09', function () {
186    let rect = new Rect();
187    expect(rect.containsWithPadding(1, 2, 3, 5)).toBe(false);
188  });
189
190  it('ProcedureWorkerCommon10', function () {
191    let rect = new Rect();
192    let rect2 = new Rect();
193    expect(rect.intersect(rect2)).toBe(false);
194  });
195
196  it('ProcedureWorkerCommon011', function () {
197    expect(ColorUtils.formatNumberComma('11232')).toBe('11,232');
198  });
199
200  it('ProcedureWorkerCommon012', function () {
201    const canvas = document.createElement('canvas');
202    canvas.width = 1;
203    canvas.height = 1;
204    const ctx = canvas.getContext('2d');
205    let aaa = [1, 2, 3];
206    drawLines(ctx, aaa, 1, '#ffff');
207    expect(ColorUtils.formatNumberComma('11232')).toBe('11,232');
208  });
209
210  it('ProcedureWorkerCommon013', function () {
211    const canvas = document.createElement('canvas');
212    canvas.width = 1;
213    canvas.height = 1;
214    const ctx = canvas.getContext('2d');
215    let aaa = [1, 2, 3];
216    let flag = new Flag(1, 2, 3, 4, 5, '#FFF', false);
217    let rect2 = new Rect();
218    drawFlagLine(ctx, aaa, flag, 1, 2, 2, rect2);
219    expect(ColorUtils.formatNumberComma('11232')).toBe('11,232');
220  });
221
222  it('ProcedureWorkerCommon20', function () {
223    expect(ns2s(2_000_000_000)).toBe('2.0 s');
224  });
225
226  it('ProcedureWorkerCommon21', function () {
227    expect(ns2s(2_000_000)).toBe('2.0 ms');
228  });
229
230  it('ProcedureWorkerCommon22', function () {
231    expect(ns2s(2_000)).toBe('2.0 μs');
232  });
233
234  it('ProcedureWorkerCommon23', function () {
235    expect(ns2s(1)).toBe('1.0 ns');
236  });
237
238  it('ProcedureWorkerCommon25', function () {
239    expect(ColorUtils.hashFunc('', 10, 10)).toBe(3);
240  });
241
242  it('ProcedureWorkerCommon26', function () {
243    expect(ns2x(10, 1, 0, 1, { width: 2 })).toBe(2);
244  });
245
246  it('ProcedureWorkerCommon27', function () {
247    expect(ns2x(-10, 1, 0, 1, { width: 2 })).toBe(0);
248  });
249
250  it('ProcedureWorkerCommon28', function () {
251    const canvas = document.createElement('canvas');
252    canvas.width = 1;
253    canvas.height = 1;
254    const ctx = canvas.getContext('2d');
255    let flag = {
256      color: '',
257      x: 1,
258    };
259    let select = {
260      color: '',
261      x: 1,
262      time: '',
263    };
264    let frame = {
265      height: 1,
266    };
267    let slicesTime = {
268      startTime: 1,
269      endTime: 1,
270      color: '#dadada',
271    };
272    expect(drawFlagLine(ctx, flag, select, 1, 2, 1, frame, slicesTime)).toBeUndefined();
273  });
274
275  it('ProcedureWorkerCommon29', function () {
276    const canvas = document.createElement('canvas');
277    canvas.width = 1;
278    canvas.height = 1;
279    const context = canvas.getContext('2d');
280
281    let params = {
282      isRangeSelect: true,
283      rangeSelectObject: {
284        startX: 31,
285        endX: 13,
286        startNS: 132,
287        endNS: 120,
288      },
289      startNS: 21,
290      endNS: 120,
291      totalNS: 49,
292      frame: {
293        y: 1,
294      },
295    };
296    expect(drawSelection(context, params)).toBeUndefined();
297  });
298
299  it('ProcedureWorkerCommon30', function () {
300    const canvas = document.createElement('canvas');
301    canvas.width = 1;
302    canvas.height = 1;
303    const context = canvas.getContext('2d');
304    let wake = {
305      wakeupTime: 12,
306      cpu: 2,
307    };
308    let frame = new Rect(20, 30, 10, 30);
309    let selectCpuStruct = [
310      {
311        cpu: 3,
312        dur: 9031110,
313        end_state: 'R',
314        frame: { y: 0, height: 60, x: 31, width: 3 },
315        id: 9,
316        name: 'test',
317        priority: 120,
318        processCmdLine: 'lin',
319        processId: 3303,
320        processName: 'test',
321        schedId: 55,
322        startTime: 4064044,
323        tid: 3303,
324        translateY: 40,
325        type: 'thread',
326        v: true,
327      },
328    ];
329    expect(drawWakeUp(context, wake, 1, 2, 1, frame, selectCpuStruct, undefined)).toBeUndefined();
330  });
331
332  it('ProcedureWorkerCommon31', function () {
333    let fillCache = fillCacheData(filterData, condition);
334    expect(fillCache).toBe(true);
335  });
336
337  it('ProcedureWorkerCommon32', function () {
338    let slice = findRange(fullData, condition);
339    expect(slice.length).toBe(1);
340  });
341
342  it('ProcedureWorkerCommon33', function () {
343    let condition = {
344      startKey: 'startNS',
345      durKey: 'dur',
346      startNS: 20,
347      endNS: 1000,
348      totalNS: 2000,
349      frame: { x: 10, y: 10 },
350      paddingTop: 5,
351      useCache: false,
352    };
353    let dataFilter = dataFilterHandler(fullData, filterData, condition);
354    expect(dataFilter).toBeUndefined();
355  });
356
357  it('ProcedureWorkerCommon34', function () {
358    const canvas = document.createElement('canvas');
359    canvas.width = 1;
360    canvas.height = 1;
361    const ctx = canvas.getContext('2d');
362    const hoverFlag = {
363      x: 300,
364      y: 300,
365      width: 1300,
366      height: 1030,
367      time: 2550,
368      color: 'red',
369      selected: false,
370      text: 'test',
371      hidden: false,
372      type: 'type',
373    };
374    const selectFlag = {
375      x: 180,
376      y: 180,
377      width: 800,
378      height: 80,
379      time: 258,
380      color: 'green',
381      selected: false,
382      text: 'test',
383      hidden: false,
384      type: 'type',
385    };
386    TraceRow.range = {
387      startNS: 64,
388      endNS: 25453,
389      totalNS: 333,
390    };
391    let data = {
392      sportRuler: {
393        slicesTimeList: [
394          {
395            startTime: 11,
396            endTime: 22,
397            color: '#dadada',
398          },
399          {
400            startTime: 33,
401            endTime: 66,
402            color: '#dadada',
403          },
404        ],
405      },
406    };
407    expect(
408      drawFlagLineSegment(
409        ctx,
410        hoverFlag,
411        selectFlag,
412        {
413          y: 15,
414          height: 10,
415          x: 11,
416          width: 53,
417        },
418        data
419      )
420    ).toBeUndefined();
421  });
422
423  it('ProcedureWorkerCommon35', function () {
424    const canvas = document.createElement('canvas');
425    canvas.width = 1;
426    canvas.height = 1;
427    const context = canvas.getContext('2d');
428    let params = {
429      rangeSelect: true,
430      rangeSelectObject: {
431        startX: 71,
432        endX: 100,
433        startNS: 61,
434        endNS: 100,
435      },
436      startNS: 401,
437      endNS: 190,
438      totalNS: 999,
439      frame: {
440        y: 3,
441      },
442    };
443    TraceRow.rangeSelectObject = {
444      startX: 125,
445      endX: 25226,
446    };
447    expect(drawSelectionRange(context, params)).toBeUndefined();
448  });
449  it('ProcedureWorkerCommon37', function () {
450    const canvas = document.createElement('canvas');
451    canvas.width = 1;
452    canvas.height = 1;
453    const context = canvas.getContext('2d');
454    let tm = {
455      getRange:jest.fn(()=>true),
456      getBoundingClientRect:jest.fn(()=>true),
457    };
458    expect(drawLinkLines(context,[],tm,true)).toBeUndefined();
459  });
460  it('ProcedureWorkerCommon38', function () {
461    const canvas = document.createElement('canvas');
462    canvas.width = 1;
463    canvas.height = 1;
464    const context = canvas.getContext('2d');
465    expect(drawString2Line(context,[],[],2,[],[])).toBeUndefined();
466  });
467  it('ProcedureWorkerCommon39', function () {
468    const canvas = document.createElement('canvas');
469    canvas.width = 1;
470    canvas.height = 1;
471    const context = canvas.getContext('2d');
472    let wake = {
473      wakeupTime:23,
474    };
475    let frame = new Rect(20, 30, 10, 30);
476    expect(drawWakeUpList(context,wake,0,1000,1000,frame,true,undefined,false)).toBeUndefined();
477  });
478});
479