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