From acfb29cbd80bfbca5d12a6b7d30d2cd92ab2cf2d Mon Sep 17 00:00:00 2001
From: Ruben Bridgewater <ruben@bridgewater.de>
Date: Sun, 19 Aug 2018 18:24:34 +0200
Subject: [PATCH] test: harden sequential/test-performance

1) This adds a better error logging so we are able to address further
   failures easier.
2) It adds a extra epsilon so the test runs into less issues in case
   the machine is under heavy load.
3) The epsilon in increased if the CPU is under heavy load.
4) The total startup epsilon was reduced due to recent startup time
   improvements.

PR-URL: /~https://github.com/nodejs/node/pull/22404
Fixes: /~https://github.com/nodejs/node/issues/19197
Refs: /~https://github.com/nodejs/reliability/issues/14
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Joyee Cheung <joyeec9h3@gmail.com>
---
 test/sequential/test-performance.js | 69 +++++++++++++++++++++--------
 1 file changed, 51 insertions(+), 18 deletions(-)

diff --git a/test/sequential/test-performance.js b/test/sequential/test-performance.js
index 95a401c5c89a16..72b78bea583bf0 100644
--- a/test/sequential/test-performance.js
+++ b/test/sequential/test-performance.js
@@ -11,11 +11,11 @@ assert(performance);
 assert(performance.nodeTiming);
 assert.strictEqual(typeof performance.timeOrigin, 'number');
 // Use a fairly large epsilon value, since we can only guarantee that the node
-// process started up in 20 seconds.
-assert(Math.abs(performance.timeOrigin - Date.now()) < 20000);
+// process started up in 15 seconds.
+assert(Math.abs(performance.timeOrigin - Date.now()) < 15000);
 
 const inited = performance.now();
-assert(inited < 20000);
+assert(inited < 15000);
 
 {
   // Should work without throwing any errors
@@ -56,12 +56,43 @@ assert(inited < 20000);
 assert.strictEqual(performance.nodeTiming.name, 'node');
 assert.strictEqual(performance.nodeTiming.entryType, 'node');
 
+let timeoutDelay = 111; // An extra of 111 ms for the first call.
+
+function checkDelay(cb) {
+  const defaultTimeout = 1;
+  const timer = setInterval(checkDelay, defaultTimeout);
+  const timeouts = 10;
+
+  const now = getTime();
+  let resolved = 0;
+
+  function checkDelay() {
+    resolved++;
+    if (resolved === timeouts) {
+      clearInterval(timer);
+      timeoutDelay = getTime() - now;
+      cb();
+    }
+  }
+}
+
+function getTime() {
+  const ts = process.hrtime();
+  return Math.ceil((ts[0] * 1e3) + (ts[1] / 1e6));
+}
+
 function checkNodeTiming(props) {
+  console.log(props);
+
   for (const prop of Object.keys(props)) {
     if (props[prop].around !== undefined) {
       assert.strictEqual(typeof performance.nodeTiming[prop], 'number');
       const delta = performance.nodeTiming[prop] - props[prop].around;
-      assert(Math.abs(delta) < 1000);
+      const delay = 1000 + timeoutDelay;
+      assert(
+        Math.abs(delta) < delay,
+        `${prop}: ${Math.abs(delta)} >= ${delay}`
+      );
     } else {
       assert.strictEqual(performance.nodeTiming[prop], props[prop],
                          `mismatch for performance property ${prop}: ` +
@@ -83,20 +114,22 @@ checkNodeTiming({
   loopExit: -1
 });
 
-setTimeout(() => {
-  checkNodeTiming({
-    name: 'node',
-    entryType: 'node',
-    startTime: 0,
-    duration: { around: performance.now() },
-    nodeStart: { around: 0 },
-    v8Start: { around: 0 },
-    bootstrapComplete: { around: inited },
-    environment: { around: 0 },
-    loopStart: { around: inited },
-    loopExit: -1
-  });
-}, 2000);
+checkDelay(() => {
+  setTimeout(() => {
+    checkNodeTiming({
+      name: 'node',
+      entryType: 'node',
+      startTime: 0,
+      duration: { around: performance.now() },
+      nodeStart: { around: 0 },
+      v8Start: { around: 0 },
+      bootstrapComplete: { around: inited },
+      environment: { around: 0 },
+      loopStart: { around: inited },
+      loopExit: -1
+    });
+  }, 1000);
+});
 
 process.on('exit', () => {
   checkNodeTiming({