diff --git a/test/integration/fixtures/pending/skip-async-before-hooks.fixture.js b/test/integration/fixtures/pending/skip-async-before-hooks.fixture.js
index 7afd6bc670..0aa1409e6a 100644
--- a/test/integration/fixtures/pending/skip-async-before-hooks.fixture.js
+++ b/test/integration/fixtures/pending/skip-async-before-hooks.fixture.js
@@ -1,59 +1,72 @@
 'use strict';
+var assert = require('assert');
 
-describe('outer suite', function () {
-
-  before(function () {
-    console.log('outer before');
+describe('outer suite', function() {
+  var runOrder = [];
+  before(function() {
+    runOrder.push('outer before');
   });
 
-  it('should run this test', function () { });
-
-  describe('inner suite', function () {
+  it('should run test-1', function() {
+    runOrder.push('should run test-1');
+  });
 
-    before(function (done) {
-      console.log('inner before');
+  describe('inner suite', function() {
+    before(function(done) {
+      runOrder.push('inner before');
       var self = this;
-      setTimeout(function () {
+      setTimeout(function() {
         self.skip();   // done() is not required
       }, 0);
     });
 
-    beforeEach(function () {
-      throw new Error('beforeEach should not run');
+    before(function() {
+      runOrder.push('inner before-2 should not run');
     });
 
-    afterEach(function () {
-      throw new Error('afterEach should not run');
+    beforeEach(function() {
+      runOrder.push('beforeEach should not run');
     });
 
-    it('should not run this test', function () {
-      throw new Error('inner suite test should not run');
+    afterEach(function() {
+      runOrder.push('afterEach should not run');
+    });
+
+    after(function() {
+      runOrder.push('inner after');
     });
 
-    after(function () {
-      console.log('inner after');
+    it('should not run this test', function() {
+      throw new Error('inner suite test should not run');
     });
 
-    describe('skipped suite', function () {
-      before(function () {
-        console.log('skipped before');
+    describe('skipped suite', function() {
+      before(function() {
+        runOrder.push('skipped suite before should not run');
       });
 
-      it('should not run this test', function () {
+      it('should not run this test', function() {
         throw new Error('skipped suite test should not run');
       });
 
-      after(function () {
-        console.log('skipped after');
+      after(function() {
+        runOrder.push('skipped suite after should not run');
       });
     });
-
   });
 
-  it('should run this test', function () { });
-
-  after(function () {
-    console.log('outer after');
+  it('should run test-2', function() {
+    runOrder.push('should run test-2');
   });
 
+  after(function() {
+    runOrder.push('outer after');
+    assert.deepStrictEqual(runOrder, [
+      'outer before', 
+      'should run test-1', 'should run test-2',
+      'inner before', 'inner after',
+      'outer after'
+    ]);
+    throw new Error('should throw this error');
+  });
 });
diff --git a/test/integration/fixtures/pending/skip-sync-before-hooks.fixture.js b/test/integration/fixtures/pending/skip-sync-before-hooks.fixture.js
index 1649656202..629ba29552 100644
--- a/test/integration/fixtures/pending/skip-sync-before-hooks.fixture.js
+++ b/test/integration/fixtures/pending/skip-sync-before-hooks.fixture.js
@@ -1,57 +1,69 @@
 'use strict';
+var assert = require('assert');
 
-describe('outer suite', function () {
-
-  before(function () {
-    console.log('outer before');
+describe('outer suite', function() {
+  var runOrder = [];
+  before(function() {
+    runOrder.push('outer before');
   });
 
-  it('should run this test', function () { });
+  it('should run test-1', function() {
+    runOrder.push('should run test-1');
+  });
 
-  describe('inner suite', function () {
-    before(function () {
+  describe('inner suite', function() {
+    before(function() {
+      runOrder.push('inner before');
       this.skip();
     });
 
-    before(function () {
-      console.log('inner before');
+    before(function() {
+      runOrder.push('inner before-2 should not run');
     });
 
-    beforeEach(function () {
-      throw new Error('beforeEach should not run');
+    beforeEach(function() {
+      runOrder.push('beforeEach should not run');
     });
 
-    afterEach(function () {
-      throw new Error('afterEach should not run');
+    afterEach(function() {
+      runOrder.push('afterEach should not run');
     });
 
-    after(function () {
-      console.log('inner after');
+    after(function() {
+      runOrder.push('inner after');
     });
 
-    it('should never run this test', function () {
+    it('should never run this test', function() {
       throw new Error('inner suite test should not run');
     });
 
-    describe('skipped suite', function () {
-      before(function () {
-        console.log('skipped before');
+    describe('skipped suite', function() {
+      before(function() {
+        runOrder.push('skipped suite before should not run');
       });
 
-      it('should never run this test', function () {
+      it('should never run this test', function() {
         throw new Error('skipped suite test should not run');
       });
 
-      after(function () {
-        console.log('skipped after');
+      after(function() {
+        runOrder.push('skipped suite after should not run');
       });
     });
   });
 
-  it('should run this test', function () { });
-
-  after(function () {
-    console.log('outer after');
-  })
+  it('should run test-2', function() {
+    runOrder.push('should run test-2');
+  });
 
+  after(function() {
+    runOrder.push('outer after');
+    assert.deepStrictEqual(runOrder, [
+      'outer before', 
+      'should run test-1', 'should run test-2',
+      'inner before', 'inner after',
+      'outer after'
+    ]);
+    throw new Error('should throw this error');
+  });
 });
diff --git a/test/integration/fixtures/pending/skip-sync-before-inner.fixture.js b/test/integration/fixtures/pending/skip-sync-before-inner.fixture.js
new file mode 100644
index 0000000000..947c676be8
--- /dev/null
+++ b/test/integration/fixtures/pending/skip-sync-before-inner.fixture.js
@@ -0,0 +1,38 @@
+'use strict';
+var assert = require('assert');
+
+describe('outer suite', function() {
+  var runOrder = [];
+  before(function() {
+    runOrder.push('outer before');
+    this.skip();
+  });
+
+  it('should never run this outer test', function() {
+    throw new Error('outer suite test should not run');
+  });
+
+  describe('inner suite', function() {
+    before(function() { runOrder.push('no inner before'); });
+    before(function(done) { runOrder.push('no inner before'); done(); });
+    before(async function() { runOrder.push('no inner before'); });
+    before(function() { return new Promise(runOrder.push('no inner before')); });
+
+    after(function() { runOrder.push('no inner after'); });
+    after(function(done) { runOrder.push('no inner after'); done(); });
+    after(async function() { runOrder.push('no inner after'); });
+    after(function() { return new Promise(runOrder.push('no inner after')); });
+
+    it('should never run this inner test', function() {
+      throw new Error('inner suite test should not run');
+    });
+  });
+
+  after(function() {
+    runOrder.push('outer after');
+    assert.deepStrictEqual(runOrder, [
+      'outer before', 'outer after'
+    ]);
+    throw new Error('should throw this error');
+  });
+});
diff --git a/test/integration/pending.spec.js b/test/integration/pending.spec.js
index ae6a57f0ca..51a7bc9b16 100644
--- a/test/integration/pending.spec.js
+++ b/test/integration/pending.spec.js
@@ -3,8 +3,6 @@
 var assert = require('assert');
 var helpers = require('./helpers');
 var run = helpers.runMochaJSON;
-var runMocha = helpers.runMocha;
-var splitRegExp = helpers.splitRegExp;
 var invokeNode = helpers.invokeNode;
 var toJSONRunResult = helpers.toJSONRunResult;
 var args = [];
@@ -111,43 +109,38 @@ describe('pending', function() {
         });
       });
       it('should run before and after hooks', function(done) {
-        runMocha(
-          'pending/skip-sync-before-hooks.fixture.js',
-          args.concat(['--reporter', 'dot']),
-          function(err, res) {
-            if (err) {
-              done(err);
-              return;
-            }
-
-            var lines = res.output
-              .split(splitRegExp)
-              .map(function(line) {
-                return line.trim();
-              })
-              .filter(function(line) {
-                return line.length;
-              })
-              .slice(0, -1);
-
-            var expected = [
-              'outer before',
-              'inner before',
-              'inner after',
-              'outer after'
-            ];
-
-            assert.strictEqual(res.pending, 2);
-            assert.strictEqual(res.passing, 2);
-            assert.strictEqual(res.failing, 0);
-            assert.strictEqual(res.code, 0);
-            expected.forEach(function(line, i) {
-              assert.strictEqual(true, lines[i].includes(line));
-            });
-
-            done();
+        run('pending/skip-sync-before-hooks.fixture.js', function(err, res) {
+          if (err) {
+            return done(err);
           }
-        );
+          expect(res, 'to have failed with error', 'should throw this error')
+            .and('to have failed test count', 1)
+            .and('to have pending test count', 2)
+            .and('to have passed test count', 2)
+            .and(
+              'to have passed test order',
+              'should run test-1',
+              'should run test-2'
+            );
+          done();
+        });
+      });
+      it('should skip all sync/async inner before/after hooks', function(done) {
+        run('pending/skip-sync-before-inner.fixture.js', function(err, res) {
+          if (err) {
+            return done(err);
+          }
+          expect(res, 'to have failed with error', 'should throw this error')
+            .and('to have failed test count', 1)
+            .and('to have pending test count', 2)
+            .and('to have passed test count', 0)
+            .and(
+              'to have pending test order',
+              'should never run this outer test',
+              'should never run this inner test'
+            );
+          done();
+        });
       });
     });
 
@@ -245,43 +238,21 @@ describe('pending', function() {
         });
       });
       it('should run before and after hooks', function(done) {
-        runMocha(
-          'pending/skip-async-before-hooks.fixture.js',
-          args.concat(['--reporter', 'dot']),
-          function(err, res) {
-            if (err) {
-              done(err);
-              return;
-            }
-
-            var lines = res.output
-              .split(splitRegExp)
-              .map(function(line) {
-                return line.trim();
-              })
-              .filter(function(line) {
-                return line.length;
-              })
-              .slice(0, -1);
-
-            var expected = [
-              'outer before',
-              'inner before',
-              'inner after',
-              'outer after'
-            ];
-
-            assert.strictEqual(res.pending, 2);
-            assert.strictEqual(res.passing, 2);
-            assert.strictEqual(res.failing, 0);
-            assert.strictEqual(res.code, 0);
-            expected.forEach(function(line, i) {
-              assert.strictEqual(true, lines[i].includes(line));
-            });
-
-            done();
+        run('pending/skip-async-before-hooks.fixture.js', function(err, res) {
+          if (err) {
+            return done(err);
           }
-        );
+          expect(res, 'to have failed with error', 'should throw this error')
+            .and('to have failed test count', 1)
+            .and('to have pending test count', 2)
+            .and('to have passed test count', 2)
+            .and(
+              'to have passed test order',
+              'should run test-1',
+              'should run test-2'
+            );
+          done();
+        });
       });
     });