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 XpowerThreadInfoRender, 20 XpowerThreadInfoStruct, 21 drawMaxValue, 22 threadInfo, 23} from '../../../../src/trace/database/ui-worker/ProcedureWorkerXpowerThreadInfo'; 24import { SpApplication } from '../../../../src/trace/SpApplication'; 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('ProcedureWorkerXpowerThreadInfo Test', () => { 35 let row: TraceRow<XpowerThreadInfoStruct>; 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<XpowerThreadInfoStruct>(); 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 value: 10, 65 threadTime: 10, 66 threadTimeStr: '10', 67 threadName: 'aaa', 68 threadNameId: 0, 69 valueStr: '10', 70 dur: 10, 71 valueType: 'energy', 72 translateY: 10, 73 frame: frame, 74 isHover: false, 75 }, 76 { 77 startNS: 100, 78 startTimeStr: '100', 79 value: 20, 80 threadTime: 10, 81 threadTimeStr: '10', 82 threadName: 'aaa', 83 threadNameId: 0, 84 valueStr: '10', 85 dur: 10, 86 valueType: 'load', 87 translateY: 10, 88 frame: frame, 89 isHover: false, 90 }, 91 ]; 92 row.frame = frame; 93 context = { 94 save: jest.fn(), 95 translate: jest.fn(), 96 rect: jest.fn(), 97 clip: jest.fn(), 98 strokeStyle: '#000000', 99 strokeRect: jest.fn(), 100 fillRect: jest.fn(), 101 fillText: jest.fn(), 102 measureText: jest.fn().mockReturnValue({ width: 10 }), 103 beginPath: jest.fn(), 104 closePath: jest.fn(), 105 stroke: jest.fn(), 106 clearRect: jest.fn(), 107 fill: jest.fn(), 108 moveTo: jest.fn(), 109 lineTo: jest.fn(), 110 fillStyle: '#000000', 111 globalAlpha: 1, 112 font: '10px sans-serif', 113 canvas: { 114 clientWidth: 800, 115 }, 116 } as unknown as CanvasRenderingContext2D; 117 }); 118 const data = new XpowerThreadInfoStruct(); 119 data.startNS = 100; 120 data.isHover = true; 121 data.frame = frame; 122 const data1 = new XpowerThreadInfoStruct(); 123 data1.startNS = 200; 124 it('ProcedureWorkerXpowerThreadInfo01', () => { 125 const xpowerThreadInfoRender = new XpowerThreadInfoRender(); 126 xpowerThreadInfoRender.renderMainThread({ context, useCache: false, type: 'load' }, row); 127 expect(context.beginPath).toHaveBeenCalled(); 128 expect(context.closePath).toHaveBeenCalled(); 129 }); 130 it('ProcedureWorkerXpowerThreadInfo02', () => { 131 const xpowerThreadInfoRender = new XpowerThreadInfoRender(); 132 xpowerThreadInfoRender.renderMainThread({ context, useCache: false, type: 'load' }, row); 133 expect(row.dataListCache[0].value).toBe(10); 134 expect(row.dataListCache[0].startNS).toBe(100); 135 expect(row.dataListCache[0].startTimeStr).toBe('100'); 136 expect(row.dataListCache[0].threadTime).toBe(10); 137 expect(row.dataListCache[0].threadTimeStr).toBe('10'); 138 expect(row.dataListCache[0].threadName).toBe('aaa'); 139 expect(row.dataListCache[0].threadNameId).toBe(0); 140 expect(row.dataListCache[0].valueStr).toBe('10'); 141 expect(row.dataListCache[0].dur).toBe(10); 142 expect(row.dataListCache[0].valueType).toBe('energy'); 143 expect(row.dataListCache[0].translateY).toBe(10); 144 expect(row.dataListCache[0].frame).toBe(frame); 145 expect(row.dataListCache[0].isHover).toBe(false); 146 }); 147 it('ProcedureWorkerXpowerThreadInfo03', () => { 148 row.isHover = true; 149 row.hoverX = 50; 150 row.hoverY = 50; 151 row.dataListCache[0].frame = new Rect(0, 0, 100, 100); 152 const xpowerThreadInfoRender = new XpowerThreadInfoRender(); 153 xpowerThreadInfoRender.renderMainThread({ context, useCache: false, type: 'energy' }, row); 154 expect(XpowerThreadInfoStruct.hoverXpowerStruct).toBeDefined(); 155 expect(XpowerThreadInfoStruct.hoverXpowerStruct!.startNS).toBe(100); 156 }); 157 it('ProcedureWorkerXpowerThreadInfo04', () => { 158 row.isHover = true; 159 row.hoverX = 50; 160 row.hoverY = 50; 161 row.dataListCache[0].frame = new Rect(0, 0, 100, 100); 162 const xpowerThreadInfoRender = new XpowerThreadInfoRender(); 163 xpowerThreadInfoRender.renderMainThread({ context, useCache: false, type: 'load' }, row); 164 expect(XpowerThreadInfoStruct.hoverXpowerStruct).toBeDefined(); 165 expect(XpowerThreadInfoStruct.hoverXpowerStruct!.startNS).toBe(100); 166 }); 167 it('ProcedureWorkerXpowerThreadInfo05', () => { 168 XpowerThreadInfoStruct.drawStroke({ context, useCache: false }, data, row); 169 expect(context.strokeStyle).toBe('#000000'); 170 }); 171 it('ProcedureWorkerXpowerThreadInfo06', () => { 172 XpowerThreadInfoStruct.drawStroke({ context, useCache: false }, data, row); 173 expect(context.fillStyle).toBe('#000000'); 174 }); 175 it('ProcedureWorkerXpowerThreadInfo08', () => { 176 XpowerThreadInfoStruct.drawHistogram({ context, useCache: false }, data, 20, row); 177 expect(context.fillRect).toHaveBeenCalled(); 178 }); 179 it('ProcedureWorkerXpowerThreadInfo09', () => { 180 data.frame = new Rect(0, 0, 100, 100); 181 XpowerThreadInfoStruct.drawHistogram({ context, useCache: false }, data, 20, row); 182 expect(context.fillRect).toHaveBeenCalled(); 183 }); 184 it('ProcedureWorkerXpowerThreadInfo10', () => { 185 data.frame = new Rect(0, 0, 100, 100); 186 XpowerThreadInfoStruct.draw({ context, useCache: false }, data, 50, row); 187 expect(data.frame).toBeDefined(); 188 }); 189 it('ProcedureWorkerXpowerThreadInfo11', () => { 190 let isHover = XpowerThreadInfoStruct.isHover(data); 191 expect(isHover).toBeFalsy(); 192 }); 193 it('ProcedureWorkerXpowerThreadInfo12', () => { 194 let equals = XpowerThreadInfoStruct.equals(data, data1); 195 expect(equals).toBeFalsy(); 196 expect(XpowerThreadInfoStruct.equals(data, data1)).toBeDefined(); 197 }); 198 it('ProcedureWorkerXpowerThreadInfo13', () => { 199 XpowerThreadInfoStruct.setThreadInfoFrame(data, 5, 0, 1000000, 1000000, row.frame!); 200 expect(data.frame).toBeDefined(); 201 }); 202 it('ProcedureWorkerXpowerThreadInfo14', () => { 203 drawMaxValue({ context, useCache: false, type: 'load' }, '10'); 204 expect(data.frame).toBeDefined(); 205 expect(context.fillRect).toHaveBeenCalled(); 206 expect(context.globalAlpha).toBe(1); 207 expect(context.fillStyle).toBe('#333'); 208 expect(context.textBaseline).toBe('middle'); 209 expect(context.fillText).toHaveBeenCalled(); 210 }); 211 it('ProcedureWorkerXpowerThreadInfo15', () => { 212 threadInfo(row.dataList, row.dataListCache, 0, 100, 100, frame, true); 213 expect(data.frame).toBeDefined(); 214 }); 215}); 216