1/* 2 * Copyright (C) 2024 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 { TraceRow } from '../../../../src/trace/component/trace/base/TraceRow'; 17import { Rect } from '../../../../src/trace/database/ui-worker/ProcedureWorkerCommon'; 18import { 19 XpowerGpuFreqRender, 20 XpowerGpuFreqStruct, 21} from '../../../../src/trace/database/ui-worker/ProcedureWorkerXpowerGpuFreq'; 22import { ColorUtils } from '../../../../src/trace/component/trace/base/ColorUtils'; 23import { SpApplication } from '../../../../src/trace/SpApplication'; 24import { SpSystemTrace } from '../../../../src/trace/component/SpSystemTrace'; 25jest.mock('../../../../src/trace/database/ui-worker/ProcedureWorker', () => { 26 return {}; 27}); 28jest.mock('../../../../src/trace/component/SpSystemTrace', () => { 29 return {}; 30}); 31jest 32 .spyOn(require('../../../../src/trace/database/ui-worker/ProcedureWorkerCommon'), 'isFrameContainPoint') 33 .mockReturnValue(true); 34describe('ProcedureWorkerXpowerGpuFreq Test', () => { 35 let row: TraceRow<XpowerGpuFreqStruct>; 36 let context: CanvasRenderingContext2D; 37 document.body.innerHTML = '<sp-application id="sss"></sp-application>'; 38 let spApplication = document.querySelector('#sss') as SpApplication; 39 spApplication.dark = false; 40 let frame = new Rect(0, 0, 100, 100); 41 beforeEach(() => { 42 row = TraceRow.skeleton<XpowerGpuFreqStruct>(); 43 TraceRow.range = { 44 startNS: 0, 45 endNS: 1000000, 46 totalNS: 1000000, 47 slicesTime: { 48 color: '#0ff', 49 startTime: 0, 50 endTime: 20000, 51 }, 52 scale: 1, 53 startX: 10, 54 endX: 30, 55 xs: [0, 1], 56 refresh: true, 57 xsTxt: ['0', '1'], 58 }; 59 60 row.dataListCache = [ 61 { 62 startNS: 100, 63 startTimeStr: '100', 64 dur: 10, 65 frequency: 10, 66 value: 10, 67 runTime: 10, 68 idleTime: 10, 69 runTimeStr: '10', 70 valueType: '', 71 idleTimeStr: '10', 72 count: 10, 73 translateY: 10, 74 frame: frame, 75 isHover: false, 76 }, 77 { 78 startNS: 100, 79 startTimeStr: '100', 80 dur: 10, 81 frequency: 10, 82 value: 10, 83 runTime: 10, 84 idleTime: 10, 85 runTimeStr: '10', 86 valueType: '', 87 idleTimeStr: '10', 88 count: 10, 89 translateY: 10, 90 frame: frame, 91 isHover: false, 92 }, 93 ]; 94 row.frame = frame; 95 context = { 96 save: jest.fn(), 97 translate: jest.fn(), 98 rect: jest.fn(), 99 clip: jest.fn(), 100 strokeStyle: '#000000', 101 strokeRect: jest.fn(), 102 fillRect: jest.fn(), 103 fillText: jest.fn(), 104 measureText: jest.fn().mockReturnValue({ width: 10 }), 105 beginPath: jest.fn(), 106 closePath: jest.fn(), 107 stroke: jest.fn(), 108 clearRect: jest.fn(), 109 fill: jest.fn(), 110 moveTo: jest.fn(), 111 lineTo: jest.fn(), 112 fillStyle: '#000000', 113 globalAlpha: 1, 114 font: '10px sans-serif', 115 canvas: { 116 clientWidth: 800, 117 }, 118 } as unknown as CanvasRenderingContext2D; 119 }); 120 const data = new XpowerGpuFreqStruct(); 121 data.startNS = 100; 122 data.isHover = true; 123 data.frame = frame; 124 const data1 = new XpowerGpuFreqStruct(); 125 data1.startNS = 200; 126 it('ProcedureWorkerXpowerGpuFreq01', () => { 127 const xpowerGpuFreqRender = new XpowerGpuFreqRender(); 128 xpowerGpuFreqRender.renderMainThread({ context, useCache: false }, row); 129 expect(context.beginPath).toHaveBeenCalled(); 130 expect(context.closePath).toHaveBeenCalled(); 131 expect(context.fillRect).toHaveBeenCalled(); 132 expect(context.globalAlpha).toBe(1); 133 expect(context.fillStyle).toBe('#333'); 134 expect(context.textBaseline).toBe('middle'); 135 expect(context.fillText).toHaveBeenCalled(); 136 }); 137 it('ProcedureWorkerXpowerGpuFreq02', () => { 138 const xpowerGpuFreqRender = new XpowerGpuFreqRender(); 139 xpowerGpuFreqRender.renderMainThread({ context, useCache: false }, row); 140 expect(row.dataListCache[0].value).toBe(10); 141 expect(row.dataListCache[0].startNS).toBe(100); 142 expect(row.dataListCache[0].startTimeStr).toBe('100'); 143 expect(row.dataListCache[0].dur).toBe(10); 144 expect(row.dataListCache[0].frequency).toBe(10); 145 expect(row.dataListCache[0].runTime).toBe(10); 146 expect(row.dataListCache[0].idleTime).toBe(10); 147 expect(row.dataListCache[0].runTimeStr).toBe('10'); 148 expect(row.dataListCache[0].idleTimeStr).toBe('10'); 149 expect(row.dataListCache[0].count).toBe(10); 150 expect(row.dataListCache[0].valueType).toBe(''); 151 expect(row.dataListCache[0].translateY).toBe(10); 152 expect(row.dataListCache[0].frame).toBe(frame); 153 expect(row.dataListCache[0].isHover).toBe(false); 154 }); 155 it('ProcedureWorkerXpowerGpuFreq03', () => { 156 row.isHover = true; 157 row.hoverX = 50; 158 row.hoverY = 50; 159 row.dataListCache[0].frame = new Rect(0, 0, 100, 100); 160 const xpowerGpuFreqRender = new XpowerGpuFreqRender(); 161 xpowerGpuFreqRender.renderMainThread({ context, useCache: false }, row); 162 expect(XpowerGpuFreqStruct.hoverXpowerStruct).toBeDefined(); 163 expect(XpowerGpuFreqStruct.hoverXpowerStruct!.startNS).toBe(100); 164 }); 165 it('ProcedureWorkerXpowerGpuFreq04', () => { 166 row.isHover = true; 167 row.hoverX = 50; 168 row.hoverY = 50; 169 row.dataListCache[0].frame = new Rect(0, 0, 100, 100); 170 const xpowerGpuFreqRender = new XpowerGpuFreqRender(); 171 xpowerGpuFreqRender.renderMainThread({ context, useCache: false }, row); 172 expect(XpowerGpuFreqStruct.hoverXpowerStruct).toBeDefined(); 173 expect(XpowerGpuFreqStruct.hoverXpowerStruct!.startNS).toBe(100); 174 }); 175 it('ProcedureWorkerXpowerGpuFreq05', () => { 176 XpowerGpuFreqStruct.drawStroke({ context, useCache: false }, data, row); 177 expect(context.strokeStyle).toBe('#000000'); 178 }); 179 it('ProcedureWorkerXpowerGpuFreq06', () => { 180 XpowerGpuFreqStruct.drawStroke({ context, useCache: false }, data, row); 181 expect(context.fillStyle).toBe('#000000'); 182 }); 183 it('ProcedureWorkerXpowerGpuFreq08', () => { 184 XpowerGpuFreqStruct.drawHistogram({ context, useCache: false }, data, row.frame); 185 expect(context.fillRect).toHaveBeenCalled(); 186 }); 187 it('ProcedureWorkerXpowerGpuFreq09', () => { 188 data.frame = new Rect(0, 0, 100, 100); 189 XpowerGpuFreqStruct.drawHistogram({ context, useCache: false }, data, row.frame); 190 expect(context.fillRect).toHaveBeenCalled(); 191 }); 192 it('ProcedureWorkerXpowerGpuFreq10', () => { 193 data.frame = new Rect(0, 0, 100, 100); 194 XpowerGpuFreqStruct.draw({ context, useCache: false }, data, row); 195 expect(data.frame).toBeDefined(); 196 }); 197 it('ProcedureWorkerXpowerGpuFreq11', () => { 198 let isHover = XpowerGpuFreqStruct.isHover(data); 199 expect(isHover).toBeFalsy(); 200 }); 201 it('ProcedureWorkerXpowerGpuFreq12', () => { 202 let equals = XpowerGpuFreqStruct.equals(data, data1); 203 expect(equals).toBeFalsy(); 204 }); 205 it('ProcedureWorkerXpowerGpuFreq13', () => { 206 XpowerGpuFreqStruct.setGpuFreqFrame(data, 5, 0, 1000000, 1000000, row.frame!); 207 expect(data.frame).toBeDefined(); 208 }); 209}); 210