diff options
Diffstat (limited to 'util/patches/test-performance+1.1.3.patch')
| -rw-r--r-- | util/patches/test-performance+1.1.3.patch | 381 |
1 files changed, 381 insertions, 0 deletions
diff --git a/util/patches/test-performance+1.1.3.patch b/util/patches/test-performance+1.1.3.patch new file mode 100644 index 00000000..23b4900b --- /dev/null +++ b/util/patches/test-performance+1.1.3.patch @@ -0,0 +1,381 @@ +diff --git a/node_modules/test-performance/cjs/index.js b/node_modules/test-performance/cjs/index.js +index 65d5904..04638a1 100644 +--- a/node_modules/test-performance/cjs/index.js ++++ b/node_modules/test-performance/cjs/index.js +@@ -1,4 +1,4 @@ +-'use strict'; ++"use strict"; + + /*! ***************************************************************************** + Copyright (c) Microsoft Corporation. +@@ -15,50 +15,139 @@ OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + ++const { performance } = require("perf_hooks"); ++ + function __awaiter(thisArg, _arguments, P, generator) { +- function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } +- return new (P || (P = Promise))(function (resolve, reject) { +- function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } +- function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } +- function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } +- step((generator = generator.apply(thisArg, _arguments || [])).next()); +- }); ++ function adopt(value) { ++ return value instanceof P ++ ? value ++ : new P(function (resolve) { ++ resolve(value); ++ }); ++ } ++ return new (P || (P = Promise))(function (resolve, reject) { ++ function fulfilled(value) { ++ try { ++ step(generator.next(value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ function rejected(value) { ++ try { ++ step(generator["throw"](value)); ++ } catch (e) { ++ reject(e); ++ } ++ } ++ function step(result) { ++ result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); ++ } ++ step((generator = generator.apply(thisArg, _arguments || [])).next()); ++ }); + } + + function __generator(thisArg, body) { +- var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; +- return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; +- function verb(n) { return function (v) { return step([n, v]); }; } +- function step(op) { +- if (f) throw new TypeError("Generator is already executing."); +- while (_) try { +- if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; +- if (y = 0, t) op = [op[0] & 2, t.value]; +- switch (op[0]) { +- case 0: case 1: t = op; break; +- case 4: _.label++; return { value: op[1], done: false }; +- case 5: _.label++; y = op[1]; op = [0]; continue; +- case 7: op = _.ops.pop(); _.trys.pop(); continue; +- default: +- if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } +- if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } +- if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } +- if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } +- if (t[2]) _.ops.pop(); +- _.trys.pop(); continue; +- } +- op = body.call(thisArg, _); +- } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } +- if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; +- } ++ var _ = { ++ label: 0, ++ sent: function () { ++ if (t[0] & 1) throw t[1]; ++ return t[1]; ++ }, ++ trys: [], ++ ops: [], ++ }, ++ f, ++ y, ++ t, ++ g; ++ return ( ++ (g = { next: verb(0), throw: verb(1), return: verb(2) }), ++ typeof Symbol === "function" && ++ (g[Symbol.iterator] = function () { ++ return this; ++ }), ++ g ++ ); ++ function verb(n) { ++ return function (v) { ++ return step([n, v]); ++ }; ++ } ++ function step(op) { ++ if (f) throw new TypeError("Generator is already executing."); ++ while (_) ++ try { ++ if ( ++ ((f = 1), ++ y && ++ (t = ++ op[0] & 2 ++ ? y["return"] ++ : op[0] ++ ? y["throw"] || ((t = y["return"]) && t.call(y), 0) ++ : y.next) && ++ !(t = t.call(y, op[1])).done) ++ ) ++ return t; ++ if (((y = 0), t)) op = [op[0] & 2, t.value]; ++ switch (op[0]) { ++ case 0: ++ case 1: ++ t = op; ++ break; ++ case 4: ++ _.label++; ++ return { value: op[1], done: false }; ++ case 5: ++ _.label++; ++ y = op[1]; ++ op = [0]; ++ continue; ++ case 7: ++ op = _.ops.pop(); ++ _.trys.pop(); ++ continue; ++ default: ++ if (!((t = _.trys), (t = t.length > 0 && t[t.length - 1])) && (op[0] === 6 || op[0] === 2)) { ++ _ = 0; ++ continue; ++ } ++ if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { ++ _.label = op[1]; ++ break; ++ } ++ if (op[0] === 6 && _.label < t[1]) { ++ _.label = t[1]; ++ t = op; ++ break; ++ } ++ if (t && _.label < t[2]) { ++ _.label = t[2]; ++ _.ops.push(op); ++ break; ++ } ++ if (t[2]) _.ops.pop(); ++ _.trys.pop(); ++ continue; ++ } ++ op = body.call(thisArg, _); ++ } catch (e) { ++ op = [6, e]; ++ y = 0; ++ } finally { ++ f = t = 0; ++ } ++ if (op[0] & 5) throw op[1]; ++ return { value: op[0] ? op[1] : void 0, done: true }; ++ } + } + + var baselineFunctions = { +- standard: { +- expectedMsRunTime: 12, +- func: function (dummyParam) { +- }, +- }, ++ standard: { ++ expectedMsRunTime: 12, ++ func: function (dummyParam) {}, ++ }, + }; + + /** +@@ -66,28 +155,28 @@ var baselineFunctions = { + * to a baseline. + */ + function calculateExpectedPerformance(baselineExpected, baselineActual, target) { +- var performanceRatio = baselineActual / baselineExpected; +- return target / performanceRatio; ++ var performanceRatio = baselineActual / baselineExpected; ++ return target / performanceRatio; + } + + /** + * This runs a single performance test of a function + */ + function perfTest(func) { +- return __awaiter(this, void 0, void 0, function () { +- var start, end; +- return __generator(this, function (_a) { +- switch (_a.label) { +- case 0: +- start = performance.now(); +- return [4 /*yield*/, func()]; +- case 1: +- _a.sent(); +- end = performance.now(); +- return [2 /*return*/, end - start]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var start, end; ++ return __generator(this, function (_a) { ++ switch (_a.label) { ++ case 0: ++ start = performance.now(); ++ return [4 /*yield*/, func()]; ++ case 1: ++ _a.sent(); ++ end = performance.now(); ++ return [2 /*return*/, end - start]; ++ } ++ }); ++ }); + } + + var NUMBER_OF_TESTS = 10000; +@@ -96,22 +185,31 @@ var NUMBER_OF_TESTS = 10000; + * the average in milliseconds. + */ + function getScore(func) { +- return __awaiter(this, void 0, void 0, function () { +- var tests, results; +- var _this = this; +- return __generator(this, function (_a) { +- switch (_a.label) { +- case 0: +- tests = new Array(NUMBER_OF_TESTS).fill(undefined).map(function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_a) { +- return [2 /*return*/, perfTest(func)]; +- }); }); }); +- return [4 /*yield*/, Promise.all(tests)]; +- case 1: +- results = _a.sent(); +- return [2 /*return*/, results.reduce(function (acc, val) { return acc + val; }, 0) / NUMBER_OF_TESTS]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var tests, results; ++ var _this = this; ++ return __generator(this, function (_a) { ++ switch (_a.label) { ++ case 0: ++ tests = new Array(NUMBER_OF_TESTS).fill(undefined).map(function () { ++ return __awaiter(_this, void 0, void 0, function () { ++ return __generator(this, function (_a) { ++ return [2 /*return*/, perfTest(func)]; ++ }); ++ }); ++ }); ++ return [4 /*yield*/, Promise.all(tests)]; ++ case 1: ++ results = _a.sent(); ++ return [ ++ 2 /*return*/, ++ results.reduce(function (acc, val) { ++ return acc + val; ++ }, 0) / NUMBER_OF_TESTS, ++ ]; ++ } ++ }); ++ }); + } + + /** +@@ -119,31 +217,38 @@ function getScore(func) { + * known baseline function. + */ + function runTests(baselineFunc, targetFunc) { +- return __awaiter(this, void 0, void 0, function () { +- var initialBaselineScore, initialTargetScore, midwayBaselineScore, endTargetScore, endBaselineScore, totalBaselineScore, totalTargetScore; +- return __generator(this, function (_a) { +- switch (_a.label) { +- case 0: return [4 /*yield*/, getScore(baselineFunc)]; +- case 1: +- initialBaselineScore = _a.sent(); +- return [4 /*yield*/, getScore(targetFunc)]; +- case 2: +- initialTargetScore = _a.sent(); +- return [4 /*yield*/, getScore(baselineFunc)]; +- case 3: +- midwayBaselineScore = _a.sent(); +- return [4 /*yield*/, getScore(targetFunc)]; +- case 4: +- endTargetScore = _a.sent(); +- return [4 /*yield*/, getScore(baselineFunc)]; +- case 5: +- endBaselineScore = _a.sent(); +- totalBaselineScore = (initialBaselineScore + midwayBaselineScore + endBaselineScore) / 3; +- totalTargetScore = (initialTargetScore + endTargetScore) / 2; +- return [2 /*return*/, [totalBaselineScore, totalTargetScore]]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var initialBaselineScore, ++ initialTargetScore, ++ midwayBaselineScore, ++ endTargetScore, ++ endBaselineScore, ++ totalBaselineScore, ++ totalTargetScore; ++ return __generator(this, function (_a) { ++ switch (_a.label) { ++ case 0: ++ return [4 /*yield*/, getScore(baselineFunc)]; ++ case 1: ++ initialBaselineScore = _a.sent(); ++ return [4 /*yield*/, getScore(targetFunc)]; ++ case 2: ++ initialTargetScore = _a.sent(); ++ return [4 /*yield*/, getScore(baselineFunc)]; ++ case 3: ++ midwayBaselineScore = _a.sent(); ++ return [4 /*yield*/, getScore(targetFunc)]; ++ case 4: ++ endTargetScore = _a.sent(); ++ return [4 /*yield*/, getScore(baselineFunc)]; ++ case 5: ++ endBaselineScore = _a.sent(); ++ totalBaselineScore = (initialBaselineScore + midwayBaselineScore + endBaselineScore) / 3; ++ totalTargetScore = (initialTargetScore + endTargetScore) / 2; ++ return [2 /*return*/, [totalBaselineScore, totalTargetScore]]; ++ } ++ }); ++ }); + } + + /** +@@ -152,20 +257,22 @@ function runTests(baselineFunc, targetFunc) { + */ + var BASELINE_FUNCTION = baselineFunctions.standard; + function getPerformanceScore(func) { +- return __awaiter(this, void 0, void 0, function () { +- var _a, baseline, target; +- return __generator(this, function (_b) { +- switch (_b.label) { +- case 0: +- if (typeof func !== 'function') +- throw new Error(func + " is not a function"); +- return [4 /*yield*/, runTests(BASELINE_FUNCTION.func, func)]; +- case 1: +- _a = _b.sent(), baseline = _a[0], target = _a[1]; +- return [2 /*return*/, calculateExpectedPerformance(BASELINE_FUNCTION.expectedMsRunTime, baseline, target)]; +- } +- }); +- }); ++ return __awaiter(this, void 0, void 0, function () { ++ var _a, baseline, target; ++ return __generator(this, function (_b) { ++ switch (_b.label) { ++ case 0: ++ if (typeof func !== "function") throw new Error(func + " is not a function"); ++ return [4 /*yield*/, runTests(BASELINE_FUNCTION.func, func)]; ++ case 1: ++ (_a = _b.sent()), (baseline = _a[0]), (target = _a[1]); ++ return [ ++ 2 /*return*/, ++ calculateExpectedPerformance(BASELINE_FUNCTION.expectedMsRunTime, baseline, target), ++ ]; ++ } ++ }); ++ }); + } + + module.exports = getPerformanceScore; |