• 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 { RangeRuler } from '../../../../../src/trace/component/trace/timer-shaft/RangeRuler';
17import { Mark } from '../../../../../src/trace/component/trace/timer-shaft/RangeRuler';
18import { TimerShaftElement } from '../../../../../src/trace/component/trace/TimerShaftElement';
19import { SpSystemTrace } from '../../../../../src/trace/component/SpSystemTrace';
20
21jest.mock('../../../../../src/trace/database/ui-worker/ProcedureWorker', () => {
22  return {};
23});
24jest.mock('../../../../../src/js-heap/model/DatabaseStruct', () => {});
25jest.mock('../../../../../src/trace/database/ui-worker/ProcedureWorkerSnapshot', () => {
26  return {};
27});
28const intersectionObserverMock = () => ({
29  observe: () => null,
30});
31window.IntersectionObserver = jest.fn().mockImplementation(intersectionObserverMock);
32window.ResizeObserver =
33  window.ResizeObserver ||
34  jest.fn().mockImplementation(() => ({
35    disconnect: jest.fn(),
36    observe: jest.fn(),
37    unobserve: jest.fn(),
38  }));
39
40describe('RangeRuler Test', () => {
41  const canvas = document.createElement('canvas');
42  canvas.width = 1;
43  canvas.height = 1;
44  const ctx = canvas.getContext('2d');
45
46  document.body.innerHTML = '<sp-system-trace style="visibility:visible;" id="sp-system-trace">' +
47    '<timer-shaft-element id="timerShaftEL"><timer-shaft-element>';
48
49  let timerShaftElement = document.querySelector('#timerShaftEL') as TimerShaftElement;
50
51  let rangeRuler = new RangeRuler(
52    timerShaftElement,
53    {
54      x: 20,
55      y: 20,
56      width: 100,
57      height: 100,
58    },
59    {
60      startX: 10,
61      endX: 30,
62    },
63    () => {}
64  );
65  let mark = new Mark(canvas, 'name',ctx, {
66    x: 20,
67    y: 20,
68    width: 100,
69    height: 100,
70  });
71
72  rangeRuler.cpuUsage = [
73    {
74      cpu: 1,
75      ro: 2,
76      rate: 2,
77    },
78  ];
79
80  mark.isHover = true;
81  let currentSlicesTime = {
82    startTime: 1,
83    endTime: 200
84  }
85  it('RangeRulerTest01', function () {
86    expect(rangeRuler.drawCpuUsage()).toBeUndefined();
87  });
88
89  it('RangeRulerTest02', function () {
90    expect(rangeRuler.fillX()).toBeUndefined();
91  });
92
93  it('RangeRulerTest21', function () {
94    rangeRuler.range.startNS = -1;
95    expect(rangeRuler.fillX()).toBe(undefined);
96  });
97
98  it('RangeRulerTest22', function () {
99    rangeRuler.range.endNS = -1;
100    expect(rangeRuler.fillX()).toBe(undefined);
101  });
102
103  it('RangeRulerTest23', function () {
104    rangeRuler.range.endNS = -1;
105    rangeRuler.range.totalNS = -2;
106    expect(rangeRuler.fillX()).toBe(undefined);
107  });
108
109  it('RangeRulerTest24', function () {
110    rangeRuler.range.startNS = -1;
111    rangeRuler.range.totalNS = -2;
112    expect(rangeRuler.fillX()).toBe(undefined);
113  });
114
115  it('RangeRulerTest03', function () {
116    expect(
117      rangeRuler.keyPress({
118        key: 'w',
119      }, currentSlicesTime)
120    ).toBeUndefined();
121  });
122
123  it('RangeRulerTest04', function () {
124    expect(
125      rangeRuler.keyPress({
126        key: 's',
127      }, currentSlicesTime)
128    ).toBeUndefined();
129  });
130
131  it('RangeRulerTest05', function () {
132    expect(
133      rangeRuler.keyPress({
134        key: 'a',
135      })
136    ).toBeUndefined();
137  });
138
139  it('RangeRulerTest06', function () {
140    expect(
141      rangeRuler.keyPress({
142        key: 'd',
143      })
144    ).toBeUndefined();
145  });
146
147  it('RangeRulerTest07', function () {
148    expect(
149      rangeRuler.keyUp({
150        key: 'w',
151      })
152    ).toBeUndefined();
153  });
154
155  it('RangeRulerTest08', function () {
156    expect(
157      rangeRuler.keyUp({
158        key: 's',
159      })
160    ).toBeUndefined();
161  });
162
163  it('RangeRulerTest09', function () {
164    expect(
165      rangeRuler.keyUp({
166        key: 'a',
167      })
168    ).toBeUndefined();
169  });
170
171  it('RangeRulerTest10', function () {
172    expect(
173      rangeRuler.keyUp({
174        key: 'd',
175      })
176    ).toBeUndefined();
177  });
178
179  it('RangeRulerTest11', function () {
180    expect(
181      rangeRuler.mouseUp({
182        key: '',
183      })
184    ).toBeUndefined();
185  });
186
187  it('RangeRulerTest12', function () {
188    expect(
189      rangeRuler.mouseOut({
190        key: '',
191      })
192    ).toBeUndefined();
193  });
194
195  it('RangeRulerTest13', function () {
196    rangeRuler.rangeRect = jest.fn(() => true);
197    rangeRuler.rangeRect.containsWithPadding = jest.fn(() => true);
198    expect(
199      rangeRuler.mouseDown({
200        key: '',
201      })
202    ).toBeUndefined();
203  });
204
205  it('RangeRulerTest14', function () {
206    rangeRuler.rangeRect = jest.fn(() => true);
207    rangeRuler.rangeRect.containsWithPadding = jest.fn(() => false);
208    rangeRuler.frame = jest.fn(() => false);
209    rangeRuler.frame.containsWithMargin = jest.fn(() => true);
210    rangeRuler.rangeRect.containsWithMargin = jest.fn(() => false);
211    expect(
212      rangeRuler.mouseDown({
213        key: '',
214      })
215    ).toBeUndefined();
216  });
217
218  it('RangeRulerTest15', function () {
219    let htmlElement: any = document.createElement('sp-system-trace');
220    rangeRuler.centerXPercentage = jest.fn(() => -1);
221    expect(
222      rangeRuler.mouseMove({
223        key: '',
224      }, htmlElement)
225    ).toBeUndefined();
226  });
227
228  it('RangeRulerTest16', () => {
229    rangeRuler.movingMark = jest.fn(() => false);
230    rangeRuler.movingMark.frame = jest.fn(() => false);
231    rangeRuler.movingMark.frame.x = jest.fn(() => false);
232    rangeRuler.rangeRect = jest.fn(() => true);
233    rangeRuler.rangeRect.containsWithPadding = jest.fn(() => true);
234    rangeRuler.movingMark.inspectionFrame = jest.fn(() => false);
235    rangeRuler.movingMark.inspectionFrame.x = jest.fn(() => false);
236    expect(
237      rangeRuler.mouseMove({
238        key: '',
239      })
240    ).toBeUndefined();
241  });
242
243  it('RangeRulerTest17', () => {
244    rangeRuler.notifyHandler = jest.fn(() => true);
245    rangeRuler.movingMark.inspectionFrame.x = jest.fn(() => false);
246    rangeRuler.frame = jest.fn(() => true);
247    rangeRuler.frame.x = jest.fn(() => true);
248    rangeRuler.frame.y = jest.fn(() => true);
249    expect(rangeRuler.draw()).toBeUndefined();
250  });
251
252  it('RangeRulerTest18', function () {
253    expect(mark.isHover).toBeTruthy();
254  });
255  it('RangeRulerTest19', function () {
256    expect(rangeRuler.draw()).toBeUndefined();
257  });
258
259  it('RangeRulerTest20', function () {
260    rangeRuler.setRangeNS(0, 2000);
261    expect(rangeRuler.getRange().scale).toBe(50);
262  });
263
264  it('RangeRulerTest25', function () {
265    expect(rangeRuler.delayDraw()).toBeUndefined();
266  });
267  it('RangeRulerTest26', function () {
268    let frameCallback: any;
269    global.requestAnimationFrame = (callback) => {
270      frameCallback = callback;
271      return 0;
272    };
273    rangeRuler.keyPressF();
274    if (frameCallback) {
275      frameCallback();
276    }
277    global.requestAnimationFrame = (callback) => {
278      frameCallback = callback;
279      return 0;
280    };
281    rangeRuler.keyPressW();
282    if (frameCallback) {
283      frameCallback();
284    }
285    global.requestAnimationFrame = (callback) => {
286      frameCallback = callback;
287      return 0;
288    };
289    rangeRuler.keyPressS();
290    if (frameCallback) {
291      frameCallback();
292    }
293    global.requestAnimationFrame = (callback) => {
294      frameCallback = callback;
295      return 0;
296    };
297    rangeRuler.keyPressA();
298    if (frameCallback) {
299      frameCallback();
300    }
301    global.requestAnimationFrame = (callback) => {
302      frameCallback = callback;
303      return 0;
304    };
305    rangeRuler.keyPressD();
306    if (frameCallback) {
307      frameCallback();
308    }
309    global.requestAnimationFrame = (callback) => {
310      frameCallback = callback;
311      return 0;
312    };
313    rangeRuler.keyUpW();
314    if (frameCallback) {
315      frameCallback();
316    }
317    global.requestAnimationFrame = (callback) => {
318      frameCallback = callback;
319      return 0;
320    };
321    rangeRuler.keyUpS();
322    if (frameCallback) {
323      frameCallback();
324    }
325    global.requestAnimationFrame = (callback) => {
326      frameCallback = callback;
327      return 0;
328    };
329    rangeRuler.keyUpA();
330    if (frameCallback) {
331      frameCallback();
332    }
333    global.requestAnimationFrame = (callback) => {
334      frameCallback = callback;
335      return 0;
336    };
337    rangeRuler.keyUpEnd();
338    if (frameCallback) {
339      frameCallback();
340    }
341    global.requestAnimationFrame = (callback) => {
342      frameCallback = callback;
343      return 0;
344    };
345    rangeRuler.keyUpD();
346    if (frameCallback) {
347      frameCallback();
348    }
349    expect(rangeRuler.getScale()).toBe(50)
350  });
351  it('RangeRulerTest27', function () {
352    expect(mark.draw()).toBeUndefined();
353  });
354  it('RangeRulerTest28', function () {
355    expect(rangeRuler.drawSelectionRange()).toBeUndefined();
356  });
357  it('RangeRulerTest29', function () {
358    expect(rangeRuler.translate(100)).toBeUndefined();
359  });
360
361  it('RangeRulerTest30', function () {
362    rangeRuler.isMovingRange = false;
363    rangeRuler.handleMovingFresh(10, 20);
364
365    let frameCallback: any;
366    global.requestAnimationFrame = (callback) => {
367      frameCallback = callback;
368      return 0;
369    };
370    rangeRuler.scale = 100;
371    rangeRuler.keyPressW();
372    if (frameCallback) {
373      frameCallback();
374    }
375    expect(rangeRuler.getScale()).toBe(100);
376  });
377});
378