nodejs
diff --git a/‎test/sequential/test-performance.js‎
Lines changed: 51 additions & 18 deletions b/‎test/sequential/test-performance.js‎
Lines changed: 51 additions & 18 deletions
@@ -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({