KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta 
How to use benchmarkSignature method in Best
Best JavaScript code snippet using best
runner-stream.ts
Source:runner-stream.ts 
1/*2 * Copyright (c) 2019, salesforce.com, inc.3 * All rights reserved.4 * SPDX-License-Identifier: MIT5 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT6*/7import path from "path";8import { isInteractive as globaIsInteractive } from "@best/utils";9import chalk from "chalk";10import trimPath from "./utils/trim-path";11import countEOL from "./utils/count-eod";12import { ProxiedStream, proxyStream } from "./utils/proxy-stream";13import {14 BenchmarkRuntimeConfig,15 RunnerStream,16 BenchmarksBundle,17 BenchmarkUpdateState,18} from "@best/types";19enum State {20 QUEUED = 'QUEUED',21 RUNNING = 'RUNNING',22 DONE = 'DONE',23 ERROR = 'ERROR',24}25interface BenchmarkStatus { state: State; displayPath: string; projectName: string, progress?: BenchmarkProgress }26type AllBencharkRunnerState = Map<string, BenchmarkStatus>27interface BenchmarkProgress {28 executedIterations: number,29 estimated: number,30 runtime: number,31 avgIteration: number,32}33const STATE_ANSI = {34 RUNNING: chalk.reset.inverse.yellow.bold(` ${State.RUNNING} `),35 QUEUED: chalk.reset.inverse.gray.bold(` ${State.QUEUED} `),36 ERROR: chalk.reset.inverse.redBright.bold(` ${State.ERROR} `),37 DONE: chalk.reset.inverse.green.bold(` ${State.DONE} `),38};39const INIT_MSG = '\n Running benchmarks... \n\n';40const PROGRESS_TEXT = chalk.dim('Progress running: ');41const PROGRESS_BAR_WIDTH = 40;42const DEFAULT_TIMEOUT = 60;43function printState(state: State) {44 return STATE_ANSI[state];45}46function printDisplayName(displayPath: string, overflow: number) {47 const dirname = overflow ? trimPath(path.dirname(displayPath), overflow) : path.dirname(displayPath);48 const basename = path.basename(displayPath);49 return chalk.dim(dirname + path.sep) + chalk.bold(basename);50}51function printProjectName(projectName: string) {52 return ' ' + chalk.reset.cyan.dim(`(${projectName})`);53}54function calculateBenchmarkProgress(progress: BenchmarkUpdateState, { iterations, maxDuration, minSampleCount }: BenchmarkRuntimeConfig): BenchmarkProgress {55 const { executedIterations, executedTime } = progress;56 const avgIteration = executedTime / executedIterations;57 const runtime = parseInt((executedTime / 1000) + '', 10);58 let estimated: number;59 if (iterations) {60 estimated = Math.round(iterations * avgIteration / 1000) + 1;61 } else if (avgIteration * minSampleCount > maxDuration) {62 estimated = Math.round(minSampleCount * avgIteration / 1000) + 1;63 } else {64 estimated = maxDuration / 1000;65 }66 return {67 executedIterations,68 estimated,69 runtime,70 avgIteration,71 };72}73function printProgressBar(runTime: number, estimatedTime: number, width: number) {74 // If we are more than one second over the estimated time, highlight it.75 const renderedTime = estimatedTime && runTime >= estimatedTime + 1 ? chalk.bold.yellow(runTime + 's') : runTime + 's';76 let time = chalk.bold(`Time:`) + ` ${renderedTime}`;77 if (runTime < estimatedTime) {78 time += `, estimated ${estimatedTime}s`;79 }80 // Only show a progress bar if the test run is actually going to take some time81 if (estimatedTime > 2 && runTime < estimatedTime && width) {82 const availableWidth = Math.min(PROGRESS_BAR_WIDTH, width);83 const length = Math.min(Math.floor(runTime / estimatedTime * availableWidth), availableWidth);84 if (availableWidth >= 2) {85 time += '\n' + chalk.green('â').repeat(length) + chalk.white('â').repeat(availableWidth - length);86 }87 }88 return time;89}90export default class RunnerOutputStream implements RunnerStream {91 stdoutColumns: number;92 stdoutWrite: Function;93 isInteractive: boolean;94 _streamBuffer: string = '';95 _state: AllBencharkRunnerState;96 _innerLog: string = '';97 _scheduled: NodeJS.Timeout | null = null;98 _proxyStream: ProxiedStream;99 constructor(buildConfig: BenchmarksBundle[], stream: NodeJS.WriteStream, isInteractive?: boolean) {100 this.stdoutColumns = stream.columns || 80;101 this.stdoutWrite = stream.write.bind(stream);102 this.isInteractive = isInteractive !== undefined ? isInteractive : globaIsInteractive;103 this._state = this.initState(buildConfig);104 this._proxyStream = proxyStream(stream, this.isInteractive);105 }106 initState(buildConfigs: BenchmarksBundle[]): AllBencharkRunnerState {107 return buildConfigs.reduce((state: AllBencharkRunnerState, benchmarkBundle: BenchmarksBundle): AllBencharkRunnerState => {108 benchmarkBundle.benchmarkBuilds.forEach(({ benchmarkEntry, benchmarkSignature, projectConfig: { projectName }}) => {109 state.set(benchmarkSignature, {110 projectName,111 state: State.QUEUED,112 displayPath: benchmarkEntry,113 });114 });115 return state;116 }, new Map());117 }118 clearBufferStream() {119 let buffer = this._streamBuffer;120 const lines = countEOL(buffer);121 if (lines) {122 buffer = '\r\x1B[K\r\x1B[1A'.repeat(lines);123 }124 if (this.isInteractive) {125 // clear last line126 this.stdoutWrite('\x1b[999D\x1b[K');127 }128 this.stdoutWrite(buffer);129 this._streamBuffer = '';130 }131 writeBufferStream(str: string) {132 this._streamBuffer += str;133 this.stdoutWrite(str);134 }135 updateRunnerState(benchmarkSignature: string, state: State) {136 const stateConfig = this._state.get(benchmarkSignature);137 if (!stateConfig) {138 throw new Error(`Unknown benchmark build started (${benchmarkSignature})`);139 }140 if (stateConfig.state !== State.ERROR) {141 stateConfig.state = state;142 }143 }144 scheduleUpdate(time?: number, fn?: Function) {145 if (!this._scheduled) {146 this._scheduled = setTimeout(() => {147 fn ? fn() : this.updateStream();148 this._scheduled = null;149 }, time || DEFAULT_TIMEOUT);150 }151 }152 printBenchmarkState({ state, projectName, displayPath }: { state: State, projectName: string, displayPath: string }) {153 const columns = this.stdoutColumns;154 const overflow = columns - (state.length + projectName.length + displayPath.length + /* for padding */ 14);155 const hasOverflow = overflow < 0;156 const ansiState = printState(state);157 const ansiProjectName = printProjectName(projectName);158 const ansiDisplayname = printDisplayName(displayPath, hasOverflow ? Math.abs(overflow): 0);159 return `${ansiState} ${ansiProjectName} ${ansiDisplayname}\n`;160 }161 printProgress(progress: BenchmarkProgress, { displayPath }: BenchmarkStatus): string {162 const benchmarkName = chalk.bold.black(path.basename(displayPath));163 return [164 `\n${PROGRESS_TEXT} ${benchmarkName}`,165 chalk.bold.black('Avg iteration: ') + progress.avgIteration.toFixed(2) + 'ms',166 chalk.bold.black('Completed iterations: ') + progress.executedIterations,167 printProgressBar(progress.runtime, progress.estimated, 40)168 ].join('\n') + '\n\n';169 }170 updateStream() {171 let buffer = INIT_MSG;172 let progressStr: string = '';173 for (const benchmarkState of this._state.values()) {174 const { state, displayPath, projectName, progress } = benchmarkState;175 buffer += this.printBenchmarkState({ state, displayPath, projectName });176 if (state === State.RUNNING && progress) {177 progressStr += this.printProgress(progress, benchmarkState);178 }179 }180 const streamProxyBuffer = this._proxyStream.readBuffer();181 streamProxyBuffer ? `Buffered console logs:\n ${streamProxyBuffer}` : '';182 this.clearBufferStream();183 this.writeBufferStream(buffer + progressStr + streamProxyBuffer);184 }185 log(message: string) {186 this._innerLog = message;187 if (this.isInteractive) {188 this.scheduleUpdate();189 } else {190 this.stdoutWrite(` :: ${message}\n`);191 }192 }193 _clearTimeout() {194 if (this._scheduled) {195 clearTimeout(this._scheduled);196 this._scheduled = null;197 }198 }199 // -- Lifecycle200 onBenchmarkStart(benchmarkSignature: string) {201 this.updateRunnerState(benchmarkSignature, State.RUNNING);202 if (this.isInteractive) {203 this.scheduleUpdate();204 } else {205 const benchmarkState = this._state.get(benchmarkSignature);206 if (benchmarkState) {207 this.stdoutWrite(this.printBenchmarkState(benchmarkState));208 }209 }210 }211 onBenchmarkEnd(benchmarkSignature: string) {212 this.updateRunnerState(benchmarkSignature, State.DONE);213 this._innerLog = '';214 const benchmarkState = this._state.get(benchmarkSignature);215 if (benchmarkState) {216 if (this.isInteractive) {217 if (benchmarkState.state === State.ERROR) {218 this.updateStream();219 this.stdoutWrite('\n');220 } else {221 this.scheduleUpdate();222 }223 } else {224 this._clearTimeout();225 this.stdoutWrite(this.printBenchmarkState(benchmarkState) + '\n');226 }227 }228 }229 onBenchmarkError(benchmarkSignature: string) {230 this.updateRunnerState(benchmarkSignature, State.ERROR);231 }232 updateBenchmarkProgress(benchmarkSignature: string, updatedBenchmarkState: BenchmarkUpdateState, runtimeOpts: BenchmarkRuntimeConfig) {233 const progress = calculateBenchmarkProgress(updatedBenchmarkState, runtimeOpts);234 const benchmarkState = this._state.get(benchmarkSignature);235 benchmarkState!.progress = progress;236 const { executedIterations, avgIteration, estimated, runtime } = progress;237 const runIter = executedIterations.toString().padEnd(5, " ");238 const avgIter = `${avgIteration.toFixed(2)}ms`.padEnd(10, " ");239 const remaining = estimated - runtime;240 if (this.isInteractive) {241 this.scheduleUpdate();242 } else {243 this.scheduleUpdate(2500, () => {244 this.stdoutWrite(245 ` :: ${benchmarkState!.displayPath} > ran: ${runIter} | avg: ${avgIter} | remainingTime: ${remaining}s \n`246 );247 });248 }249 }250 init() {251 if (this.isInteractive) {252 this.updateStream();253 } else {254 this.stdoutWrite(INIT_MSG);255 }256 }257 finish() {258 this._clearTimeout();259 this._proxyStream.unproxyStream();260 if (this.isInteractive) {261 this.updateStream();262 } else {263 this.stdoutWrite('\n');264 }265 }...
remote-client.ts
Source:remote-client.ts
1/*2 * Copyright (c) 2019, salesforce.com, inc.3 * All rights reserved.4 * SPDX-License-Identifier: MIT5 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT6 */7import { EventEmitter } from 'events';8import path from 'path';9import { Socket as ServerSocket } from 'socket.io';10import SocketIOFile from 'socket.io-file';11import { BEST_RPC } from '@best/shared';12import {13 BrowserSpec,14 BuildConfig,15 RunnerStream,16 BenchmarkRuntimeConfig,17 BenchmarkUpdateState,18 AgentState,19} from '@best/types';20import { RemoteClientConfig } from '@best/types';21import { getUploaderInstance, extractBenchmarkTarFile } from './utils/benchmark-loader';22enum RemoteClientState {23 IDLE = 'IDLE',24 REQUESTING_JOB_INFO = 'REQUESTING_JOB_INFO',25 REQUESTING_JOB_PAYLOAD = 'REQUESTING_JOB_PAYLOAD',26}27const { DISCONNECT, CONNECT_ERROR, ERROR, RECONNECT_FAILED, BENCHMARK_UPLOAD_RESPONSE } = BEST_RPC;28const RPC_METHODS = [DISCONNECT, CONNECT_ERROR, ERROR, RECONNECT_FAILED, BENCHMARK_UPLOAD_RESPONSE];29export default class RemoteClient extends EventEmitter implements RunnerStream {30 private socket: ServerSocket;31 private uploader?: SocketIOFile;32 private specs?: BrowserSpec;33 public connected: boolean;34 private pendingBenchmarksToUpload: number;35 private pendingResultsToSend: number = 0;36 private state: RemoteClientState = RemoteClientState.IDLE;37 private _requestJobSuccess: Function = function () {};38 private _requestJobError: Function = function (err: any) {39 throw new Error(err);40 };41 private debounce?: any;42 constructor(socket: ServerSocket, { specs, jobs }: RemoteClientConfig) {43 super();44 this.socket = socket;45 this.connected = this.socket.connected;46 this.specs = specs;47 this.pendingBenchmarksToUpload = jobs;48 RPC_METHODS.forEach((methodName) => this.socket.on(methodName, (this as any)[methodName].bind(this)));49 }50 // -- Socket lifecycle ------------------------------------------------------------51 [CONNECT_ERROR](reason: string) {52 console.log(`${this.getId()} - socket:connect_error`, reason);53 this.disconnectClient(reason);54 }55 [DISCONNECT](reason: string) {56 if (this.connected) {57 console.log(`${this.getId()} - socket:disconnect`, reason);58 this.disconnectClient(reason);59 }60 }61 [ERROR](reason: string) {62 console.log(`${this.getId()} - socket:error`, reason);63 this.disconnectClient(reason);64 }65 [RECONNECT_FAILED](reason: string) {66 console.log(`${this.getId()} - socket:reconnect_failed`, reason);67 this.disconnectClient(reason);68 }69 // -- Specific Best RPC Commands ------------------------------------------------------------70 async [BENCHMARK_UPLOAD_RESPONSE](benchmarkConfig: BuildConfig, emitContinuationForUpload: Function) {71 if (this.state !== RemoteClientState.REQUESTING_JOB_INFO) {72 this.disconnectClient('Client should not send jobs at this point.');73 this._requestJobError('Unexpected upload response');74 }75 console.log(76 `[AGENT_REMOTE_CLIENT] Receiving benchmark ${benchmarkConfig.benchmarkSignature} from socket ${this.socket.id}`,77 );78 const { benchmarkEntry, benchmarkName, benchmarkSignature } = benchmarkConfig;79 const uploader = this.getUploader();80 this.state = RemoteClientState.REQUESTING_JOB_PAYLOAD;81 emitContinuationForUpload(benchmarkSignature); // This is an ACK, telling the client that is ok to send the file now82 try {83 // Retrieve an uncompress the benchmark bundle84 const tarFile = await uploader.load(benchmarkEntry);85 await extractBenchmarkTarFile(tarFile);86 // Modify the benchmark bundle to point to the new files87 const uploadDir = path.dirname(tarFile);88 benchmarkConfig.benchmarkRemoteEntry = path.join(uploadDir, `${benchmarkName}.html`);89 benchmarkConfig.benchmarkRemoteFolder = uploadDir;90 console.log(91 `[AGENT_REMOTE_CLIENT] Completed upload for benchmark ${benchmarkConfig.benchmarkSignature} from socket ${this.socket.id}`,92 );93 this.state = RemoteClientState.IDLE;94 this.pendingBenchmarksToUpload -= 1;95 this.pendingResultsToSend += 1;96 this._requestJobSuccess(benchmarkConfig);97 // Notify upload updates98 this.emit(BEST_RPC.REMOTE_CLIENT_UPLOAD_COMPLETED);99 } catch (err) {100 this.disconnectClient(err as any);101 this._requestJobError(err);102 } finally {103 this.state = RemoteClientState.IDLE;104 }105 }106 // -- Private107 getUploader(): any {108 if (!this.uploader) {109 const uploader = getUploaderInstance(this.socket);110 uploader.on('stream', ({ wrote, size }: any) => {111 console.log(` :: [ARC-${this.socket.id}] loading benchmark (${wrote} / ${size})`);112 });113 this.uploader = uploader;114 }115 return this.uploader;116 }117 // -- RunnerStream methods ----------------------------------------------------------118 finish() {119 console.log(`[AGENT_REMOTE_CLIENT] finishingRunner`);120 }121 init() {122 console.log(`[AGENT_REMOTE_CLIENT] startingRunner`);123 }124 log(message: string) {125 if (this.socket.connected) {126 this.socket.emit(BEST_RPC.BENCHMARK_LOG, message);127 }128 }129 onBenchmarkEnd(benchmarkSignature: string) {130 console.log(`[AGENT_REMOTE_CLIENT] benchmarkEnd(${benchmarkSignature})`);131 if (this.socket.connected) {132 this.socket.emit(BEST_RPC.BENCHMARK_END, benchmarkSignature);133 this.emit(BEST_RPC.BENCHMARK_END, benchmarkSignature);134 clearTimeout(this.debounce);135 this.debounce = undefined;136 }137 }138 onBenchmarkError(benchmarkSignature: string) {139 if (this.socket.connected) {140 this.socket.emit(BEST_RPC.BENCHMARK_ERROR, benchmarkSignature);141 this.emit(BEST_RPC.BENCHMARK_ERROR, benchmarkSignature);142 }143 }144 onBenchmarkStart(benchmarkSignature: string) {145 if (this.socket.connected) {146 console.log(`[AGENT_REMOTE_CLIENT] benchmarkStart(${benchmarkSignature})`);147 this.socket.emit(BEST_RPC.BENCHMARK_START, benchmarkSignature);148 this.emit(BEST_RPC.BENCHMARK_START, benchmarkSignature);149 }150 }151 updateBenchmarkProgress(benchmarkSignature: string, state: BenchmarkUpdateState, opts: BenchmarkRuntimeConfig) {152 if (!this.debounce && this.socket.connected) {153 this.debounce = setTimeout(() => {154 this.debounce = undefined;155 if (this.socket.connected) {156 console.log(157 `[AGENT_REMOTE_CLIENT] benchmarkProgress(${benchmarkSignature}) | iterations: ${state.executedIterations}`,158 );159 this.socket.emit(BEST_RPC.BENCHMARK_UPDATE, benchmarkSignature, state, opts);160 this.emit(BEST_RPC.BENCHMARK_UPDATE, benchmarkSignature, state, opts);161 }162 }, 1000);163 }164 }165 // -- Imperative methods ------------------------------------------------------------166 disconnectClient(reason?: string) {167 if (this.connected) {168 this.connected = false;169 this.pendingBenchmarksToUpload = -1;170 this.socket.emit(BEST_RPC.AGENT_REJECTION, reason);171 this.socket.disconnect(true);172 this.emit(BEST_RPC.DISCONNECT, reason);173 }174 }175 getId() {176 return `REMOTE_CLIENT_${this.socket.id}`;177 }178 getPendingBenchmarks() {179 return this.pendingBenchmarksToUpload;180 }181 getSpecs() {182 return this.specs;183 }184 getState() {185 return {186 clientId: this.toString(),187 specs: this.specs,188 jobs: this.getPendingBenchmarks(),189 state: this.isIdle() ? AgentState.IDLE : AgentState.BUSY,190 };191 }192 getStatusInfo() {193 return `remining jobs: ${this.pendingBenchmarksToUpload} | specs: ${this.specs} | state: ${this.state}`;194 }195 isBusy() {196 return !this.isIdle();197 }198 isIdle() {199 return this.state === RemoteClientState.IDLE;200 }201 requestJob(): Promise<BuildConfig> {202 if (this.isIdle()) {203 return new Promise((resolve, reject) => {204 this.state = RemoteClientState.REQUESTING_JOB_INFO;205 this.socket.emit(BEST_RPC.BENCHMARK_UPLOAD_REQUEST);206 this._requestJobSuccess = resolve;207 this._requestJobError = reject;208 });209 } else {210 return Promise.reject(`RemoteClient is busy`);211 }212 }213 sendResults(results: any) {214 this.pendingResultsToSend -= 1;215 console.log(`[AGENT_REMOTE_CLIENT] Sending Results | pending: ${this.pendingResultsToSend}`);216 this.socket.emit(BEST_RPC.BENCHMARK_RESULTS, results);217 if (this.pendingBenchmarksToUpload === 0 && this.pendingResultsToSend === 0) {218 this.emit(BEST_RPC.REMOTE_CLIENT_EMPTY_QUEUE);219 }220 }221 toString() {222 return this.getId();223 }...
index.ts
Source:index.ts
1/*2 * Copyright (c) 2019, salesforce.com, inc.3 * All rights reserved.4 * SPDX-License-Identifier: MIT5 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT6*/7import { FrozenGlobalConfig, FrozenProjectConfig, BuildConfig, BenchmarkRuntimeConfig, BenchmarkResults, BenchmarkResultsState, BenchmarkResultsSnapshot, Interruption } from '@best/types';8import AbstractRunner from '@best/runner-abstract';9import HeadlessBrowser from "./headless";10import { RunnerStream } from "@best/types";11declare var BEST: any;12const UPDATE_INTERVAL = 300;13export default class Runner extends AbstractRunner {14 async run(benchmarkBuilds: BuildConfig[], projectConfig: FrozenProjectConfig, globalConfig: FrozenGlobalConfig, runnerLogStream: RunnerStream, interruption?: Interruption): Promise<BenchmarkResultsSnapshot[]> {15 const snapshotResults: BenchmarkResultsSnapshot[] = [];16 for (const benchmarkInfo of benchmarkBuilds) {17 const { benchmarkEntry, benchmarkRemoteEntry, benchmarkSignature } = benchmarkInfo;18 const runtimeOptions = this.getRuntimeOptions(projectConfig);19 const state = this.initializeBenchmarkState();20 const { url, terminate } = await this.initializeServer(benchmarkRemoteEntry || benchmarkEntry, projectConfig);21 const browser = new HeadlessBrowser(url, projectConfig);22 try {23 await browser.initialize();24 runnerLogStream.onBenchmarkStart(benchmarkSignature);25 const { results } = await this.runIterations(benchmarkSignature, browser, state, runtimeOptions, runnerLogStream, interruption);26 const version = await browser.version();27 const environment = await this.getEnvironment({ version }, projectConfig, globalConfig);28 snapshotResults.push({ results, environment, benchmarkInfo, projectConfig });29 } catch (e) {30 runnerLogStream.onBenchmarkError(benchmarkSignature);31 throw e;32 } finally {33 runnerLogStream.onBenchmarkEnd(benchmarkSignature);34 await browser.close();35 terminate();36 }37 }38 return snapshotResults;39 }40 initializeBenchmarkState(): BenchmarkResultsState {41 return { executedTime: 0, executedIterations: 0, results: [] };42 }43 async runIterations(benchmarkSignature: string, browser: HeadlessBrowser, state: BenchmarkResultsState, runtimeOptions: BenchmarkRuntimeConfig, runnnerLogStream: RunnerStream, interruption?: Interruption): Promise<BenchmarkResultsState> {44 return runtimeOptions.iterateOnClient45 ? this.runClientIterations(benchmarkSignature, browser, state, runtimeOptions, runnnerLogStream)46 : this.runServerIterations(benchmarkSignature, browser, state, runtimeOptions, runnnerLogStream, interruption);47 }48 async runClientIterations(benchmarkSignature: string, browser: HeadlessBrowser, state: BenchmarkResultsState, runtimeOptions: BenchmarkRuntimeConfig, runnerLogStream: RunnerStream): Promise<BenchmarkResultsState> {49 // Run an iteration to estimate the time it will take50 const testResult = await this.runIteration(browser, { iterations: 1 });51 const estimatedIterationTime = testResult.aggregate;52 const start = Date.now();53 // eslint-disable-next-line lwc/no-set-interval54 const intervalId = setInterval(() => {55 const executing = Date.now() - start;56 state.executedTime = executing;57 state.executedIterations = Math.round(executing / estimatedIterationTime);58 const updatedState = { executedIterations: state.executedIterations, executedTime: state.executedTime };59 runnerLogStream.updateBenchmarkProgress(benchmarkSignature, updatedState, runtimeOptions);60 }, UPDATE_INTERVAL);61 await browser.reloadPage();62 const { results: [root,] } = await this.runIteration(browser, runtimeOptions);63 state.results.push(root);64 clearInterval(intervalId);65 return state;66 }67 async runServerIterations(benchmarkSignature: string, browser: HeadlessBrowser, state: BenchmarkResultsState, runtimeOptions: BenchmarkRuntimeConfig, runnnerLogStream: RunnerStream, interruption?: Interruption): Promise<BenchmarkResultsState> {68 if (interruption && interruption.requestedInterruption) {69 throw new Error(`Halted execution: interruption`);70 }71 if (state.executedTime < runtimeOptions.maxDuration || state.executedIterations < runtimeOptions.minSampleCount) {72 const start = Date.now();73 const benchmarkResults = await this.runIteration(browser, runtimeOptions);74 const { results: [root,] } = benchmarkResults;75 await browser.reloadPage();76 state.executedTime += Date.now() - start;77 state.executedIterations += 1;78 if (root) {79 state.results.push(root);80 }81 const updatedState = { executedIterations: state.executedIterations, executedTime: state.executedTime };82 runnnerLogStream.updateBenchmarkProgress(benchmarkSignature, updatedState, runtimeOptions);83 return this.runIterations(benchmarkSignature, browser, state, runtimeOptions, runnnerLogStream, interruption);84 }85 return state;86 }87 runIteration(browser: HeadlessBrowser, payload: any): Promise<BenchmarkResults> {88 return browser.evaluate((o: any) => BEST.runBenchmark(o), payload);89 }90 static async getBrowserSpecs() {91 return HeadlessBrowser.getSpecs();92 }...
Using AI Code Generation
1var BestSigner = require('bestsigner');2var bestSigner = new BestSigner();3bestSigner.benchmarkSignature(function(err, result) {4 if (err) {5 console.log(err);6 } else {7 console.log(result);8 }9});10var BestSigner = require('bestsigner');11var bestSigner = new BestSigner();12bestSigner.benchmarkSignature(function(err, result) {13 if (err) {14 console.log(err);15 } else {16 console.log(result);17 }18});19var BestSigner = require('bestsigner');20var bestSigner = new BestSigner();21bestSigner.benchmarkSignature(function(err, result) {22 if (err) {23 console.log(err);24 } else {25 console.log(result);26 }27});28var BestSigner = require('bestsigner');29var bestSigner = new BestSigner();30bestSigner.benchmarkSignature(function(err, result) {31 if (err) {32 console.log(err);33 } else {34 console.log(result);35 }36});37var BestSigner = require('bestsigner');38var bestSigner = new BestSigner();39bestSigner.benchmarkSignature(function(err, result) {40 if (err) {41 console.log(err);42 } else {43 console.log(result);44 }45});46var BestSigner = require('bestsigner');47var bestSigner = new BestSigner();48bestSigner.benchmarkSignature(function(err, result) {49 if (err) {50 console.log(err);51 } else {52 console.log(result);53 }54});55var BestSigner = require('bestsigner');56var bestSigner = new BestSigner();57bestSigner.benchmarkSignature(function(err, result) {58 if (err) {59 console.log(err);60 }
Using AI Code Generation
1var BestSigner = require('bestsigner');2var fs = require('fs');3var bestsigner = new BestSigner();4var message = 'Hello World!';5var algorithm = 'sha1';6var privateKey = fs.readFileSync('private.pem');7var publicKey = fs.readFileSync('public.pem');8var signature = bestsigner.sign(message, algorithm, privateKey);9var verified = bestsigner.verify(message, algorithm, signature, publicKey);10console.log('Signature: ' + signature);11console.log('Verified: ' + verified);12var benchmark = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);13console.log('Benchmark: ' + benchmark);14var benchmark2 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);15console.log('Benchmark: ' + benchmark2);16var benchmark3 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);17console.log('Benchmark: ' + benchmark3);18var benchmark4 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);19console.log('Benchmark: ' + benchmark4);20var benchmark5 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);21console.log('Benchmark: ' + benchmark5);22var benchmark6 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);23console.log('Benchmark: ' + benchmark6);24var benchmark7 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);25console.log('Benchmark: ' + benchmark7);26var benchmark8 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);27console.log('Benchmark: ' + benchmark8);28var benchmark9 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);29console.log('Benchmark: ' + benchmark9);30var benchmark10 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);31console.log('Benchmark: ' + benchmark10);32var benchmark11 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey);33console.log('Benchmark: ' + benchmark11);34var benchmark12 = bestsigner.benchmarkSignature('sha1', 1000, privateKey, publicKey
Using AI Code Generation
1var BestSigner = require('bestsigner');2var signer = new BestSigner();3signer.benchmarkSignature('test.txt', function (err, result) {4 if (err) {5 console.log(err);6 } else {7 console.log(result);8 }9});10var BestSigner = require('bestsigner');11var signer = new BestSigner();12signer.benchmarkSignature('test.txt', function (err, result) {13 if (err) {14 console.log(err);15 } else {16 console.log(result);17 }18});19var BestSigner = require('bestsigner');20var signer = new BestSigner();21signer.benchmarkVerification('test.txt', function (err, result) {22 if (err) {23 console.log(err);24 } else {25 console.log(result);26 }27});28var BestSigner = require('bestsigner');29var signer = new BestSigner();30signer.benchmarkVerification('test.txt', function (err, result) {31 if (err) {32 console.log(err);33 } else {34 console.log(result);35 }36});
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run Best automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
