diff --git a/index.js b/index.js
index 51649bd..84b9803 100644
--- a/index.js
+++ b/index.js
@@ -343,7 +343,7 @@ if (instrumentPromise) {
  * The async boundary in promises that must be patched is between the
  * fulfillment of the promise and the execution of any callback that is waiting
  * for that fulfillment to happen. This means that we need to trigger a create
- * when accept or reject is called and trigger before, after and error handlers
+ * when resolve or reject is called and trigger before, after and error handlers
  * around the callback execution. There may be multiple callbacks for each
  * fulfilled promise, so handlers will behave similar to setInterval where
  * there may be multiple before after and error calls for each create call.
@@ -351,8 +351,8 @@ if (instrumentPromise) {
  * async-listener monkeypatching has one basic entry point: `wrapCallback`.
  * `wrapCallback` should be called when create should be triggered and be
  * passed a function to wrap, which will execute the body of the async work.
- * The accept and reject calls can be modified fairly easily to call
- * `wrapCallback`, but at the time of accept and reject all the work to be done
+ * The resolve and reject calls can be modified fairly easily to call
+ * `wrapCallback`, but at the time of resolve and reject all the work to be done
  * on fulfillment may not be defined, since a call to then, chain or fetch can
  * be made even after the promise has been fulfilled. To get around this, we
  * create a placeholder function which will call a function passed into it,
@@ -364,14 +364,14 @@ if (instrumentPromise) {
  * different ways depending on the return value of the callback. When the
  * callback return a Promise, the new Promise is resolved asynchronously after
  * the returned Promise has been also been resolved. When something other than
- * a promise is resolved the accept call for the new Promise is put in the
+ * a promise is resolved the resolve call for the new Promise is put in the
  * microtask queue and asynchronously resolved.
  *
  * Then must be wrapped so that its returned promise has a wrapper that can be
  * used to invoke further continuations. This wrapper cannot be created until
  * after the callback has run, since the callback may return either a promise
  * or another value. Fortunately we already have a wrapper function around the
- * callback we can use (the wrapper created by accept or reject).
+ * callback we can use (the wrapper created by resolve or reject).
  *
  * By adding an additional argument to this wrapper, we can pass in the
  * returned promise so it can have its own wrapper appended. the wrapper
@@ -379,7 +379,7 @@ if (instrumentPromise) {
  * value. If a promise is returned, the new Promise can proxy the returned
  * Promise's wrapper (this wrapper may not exist yet, but will by the time the
  * wrapper needs to be invoked). Otherwise, a new wrapper can be create the
- * same way as in accept and reject. Since this wrapper is created
+ * same way as in resolve and reject. Since this wrapper is created
  * synchronously within another wrapper, it will properly appear as a
  * continuation from within the callback.
  */
@@ -412,15 +412,15 @@ function wrapPromise() {
 
     return promise;
 
-    function wrappedExecutor(accept, reject) {
+    function wrappedExecutor(resolve, reject) {
       context = this;
       args = [wrappedAccept, wrappedReject];
 
       // These wrappers create a function that can be passed a function and an argument to
-      // call as a continuation from the accept or reject.
+      // call as a continuation from the resolve or reject.
       function wrappedAccept(val) {
         ensureAslWrapper(promise, false);
-        return accept(val);
+        return resolve(val);
       }
 
       function wrappedReject(val) {
@@ -433,14 +433,25 @@ function wrapPromise() {
   util.inherits(wrappedPromise, Promise);
 
   wrap(Promise.prototype, 'then', wrapThen);
+  // Node.js <v7 only, alias for .then
   if (Promise.prototype.chain) {
     wrap(Promise.prototype, 'chain', wrapThen);
   }
 
-  var PromiseMethods = ['accept', 'all', 'defer', 'race', 'reject', 'resolve'];
-
-  PromiseMethods.forEach(function(key) {
-    wrappedPromise[key] = Promise[key];
+  var PromiseFunctions = [
+    'all',
+    'race',
+    'reject',
+    'resolve',
+    'accept',  // Node.js <v7 only
+    'defer'    // Node.js <v7 only
+  ];
+
+  PromiseFunctions.forEach(function(key) {
+    // don't break `in` by creating a key for undefined entries
+    if (typeof Promise[key] === 'function') {
+      wrappedPromise[key] = Promise[key];
+    }
   });
 
   global.Promise = wrappedPromise;
@@ -487,7 +498,7 @@ function wrapPromise() {
       return next;
 
       // wrap callbacks (success, error) so that the callbacks will be called as a
-      // continuations of the accept or reject call using the __asl_wrapper created above.
+      // continuations of the resolve or reject call using the __asl_wrapper created above.
       function bind(fn) {
         if (typeof fn !== 'function') return fn;
         return wrapCallback(function (val) {
diff --git a/test/native-promises.tap.js b/test/native-promises.tap.js
index b694cb1..b9f071b 100644
--- a/test/native-promises.tap.js
+++ b/test/native-promises.tap.js
@@ -112,106 +112,6 @@ test('then', function(t) {
   }
 });
 
-test('chain', function chainTest(t) {
-  var listener = addListner();
-
-  var promise = new Promise(function(accept, reject) {
-    listener.currentName = 'accept';
-    accept(10);
-  });
-
-  promise.chain(function(val) {
-    listener.currentName = 'nextTick in first chain';
-    process.nextTick(function() {
-      t.strictEqual(val, 10);
-    });
-    listener.currentName = 'first chain continuation';
-  });
-
-  listener.currentName = 'setImmediate in root';
-  setImmediate(function() {
-    promise.chain(function(val) {
-      t.strictEqual(val, 10);
-      t.strictEqual(this, global);
-      listener.currentName = 'setTimeout in 2nd chain';
-      setTimeout(function() {
-        t.deepEqual(listener.root, expected);
-        t.end();
-      });
-      listener.currentName = '2nd chain continuation';
-    });
-  });
-
-  process.removeAsyncListener(listener.listener);
-
-  var expected = {
-    name: 'root',
-    children: [
-      {
-        name: 'accept',
-        children: [
-          {
-            name: 'nextTick in first chain',
-            children: [],
-            before: 1,
-            after: 1,
-            error: 0
-          },
-          {
-            name: 'first chain continuation',
-            children: [],
-            before: 0,
-            after: 0,
-            error: 0
-          },
-          {
-            name: 'setTimeout in 2nd chain',
-            children: [],
-            before: 1,
-            after: 0,
-            error: 0
-          },
-          {
-            name: '2nd chain continuation',
-            children: [],
-            before: 0,
-            after: 0,
-            error: 0
-          }
-        ],
-        before: 2,
-        after: 2,
-        error: 0
-      },
-      {
-        name: 'accept',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'setImmediate in root',
-        children: [
-          {
-            name: 'first chain continuation',
-            children: [],
-            before: 1,
-            after: 1,
-            error: 0
-          }
-        ],
-        before: 1,
-        after: 1,
-        error: 0
-      }
-    ],
-    before: 0,
-    after: 0,
-    error: 0
-  }
-});
-
 test('catch', function(t) {
   var listener = addListner();
 
@@ -328,143 +228,6 @@ test('catch', function(t) {
   };
 });
 
-test('future chains', function futureChainTest(t) {
-  var listener = addListner();
-
-  listener.currentName = 'resolve';
-  var promise = Promise.resolve();
-
-  promise
-    .then(function() { listener.currentName = '1st then'; })
-    .then(function() { listener.currentName = '2nd then'; })
-    .then(function() { listener.currentName = '3rd then'; });
-
-  promise
-    .chain(function() { listener.currentName = '1st chain'; })
-    .chain(function() { listener.currentName = '2nd chain'; })
-    .chain(function() { listener.currentName = '3rd chain'; });
-
-  listener.currentName = 'setTimeout';
-  setTimeout(function() {
-    t.deepEqual(listener.root, expected);
-    t.end();
-  });
-
-  process.removeAsyncListener(listener.listener);
-
-  var expected = {
-    name: 'root',
-    children: [
-      {
-        name: 'resolve',
-        children: [
-          {
-            name: '1st then',
-            children: [
-              {
-                name: '2nd then',
-                children: [
-                  {
-                    name: '3rd then',
-                    children: [],
-                    before: 0,
-                    after: 0,
-                    error: 0
-                  }
-                ],
-                before: 1,
-                after: 1,
-                error: 0
-              }
-            ],
-            before: 1,
-            after: 1,
-            error: 0
-          },
-          {
-            name: '1st chain',
-            children: [
-              {
-                name: '2nd chain',
-                children: [
-                  {
-                    name: '3rd chain',
-                    children: [],
-                    before: 0,
-                    after: 0,
-                    error: 0
-                  }
-                ],
-                before: 1,
-                after: 1,
-                error: 0
-              }
-            ],
-            before: 1,
-            after: 1,
-            error: 0
-          }
-        ],
-        before: 2,
-        after: 2,
-        error: 0
-      },
-      {
-        name: 'resolve',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'resolve',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'resolve',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'resolve',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'resolve',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'resolve',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'setTimeout',
-        children: [],
-        before: 1,
-        after: 0,
-        error: 0
-      }
-    ],
-    before: 0,
-    after: 0,
-    error: 0
-  }
-});
-
 test('Promise.resolve', function resolveTest(t) {
   var listener = addListner();
 
@@ -507,60 +270,6 @@ test('Promise.resolve', function resolveTest(t) {
   });
 });
 
-test('Promise.accept', function acceptTest(t) {
-  var listener = addListner();
-
-  listener.currentName = 'accept';
-  var p = Promise.accept(123);
-
-  p.then(function then(value) {
-    listener.currentName = 'nextTick';
-    process.nextTick(function next() {
-      t.equal(value, 123);
-      t.deepEqual(listener.root, {
-        name: 'root',
-        children: [{
-          name: 'accept',
-          children: [
-            {
-              name: 'nextTick',
-              children: [],
-              before: 1,
-              after: 0,
-              error: 0
-            },
-            {
-              name: 'then continuation',
-              children: [],
-              before: 0,
-              after: 0,
-              error: 0
-            }
-          ],
-          before: 1,
-          after: 1,
-          error: 0
-        },
-        {
-          name: 'accept',
-          children: [],
-          before: 1,
-          after: 1,
-          error: 0
-        }],
-        before: 0,
-        after: 0,
-        error: 0
-      });
-      t.end();
-    });
-
-    listener.currentName = 'then continuation';
-  });
-
-  process.removeAsyncListener(listener.listener);
-});
-
 test('Promise.reject', function rejectTest(t) {
   var listener = addListner();
 
@@ -1106,76 +815,19 @@ test('Promise.race - reject', function raceTest(t) {
   }
 });
 
-test('Promise.defer', function diferTest(t) {
+test('instanceof', function diferTest(t) {
+  var p = Promise.resolve(10);
+
+  t.ok(p instanceof Promise, 'instanceof should work on wrapped Promise');
+  t.ok(p instanceof unwrappedPromise, 'instanceof should work on unwrapped Promise');
+  t.end()
+});
+
+test('then chain with promise', function(t) {
   var listener = addListner();
 
-  listener.currentName = 'defer';
-  var p = Promise.defer();
-  listener.currentName = 'resolve';
-  p.resolve(123);
-  listener.currentName = 'reject';
-  p.reject(456);
-
-  p.promise.then(function then(value) {
-    listener.currentName = 'nextTick';
-    process.nextTick(function next() {
-      process.removeAsyncListener(listener.listener);
-      t.equal(value, 123);
-      t.deepEqual(listener.root, {
-        name: 'root',
-        children: [{
-          name: 'resolve',
-          children: [
-            {
-              name: 'nextTick',
-              children: [],
-              before: 1,
-              after: 0,
-              error: 0
-            },
-            {
-              name: 'then continuation',
-              children: [],
-              before: 0,
-              after: 0,
-              error: 0
-            }
-          ],
-          before: 1,
-          after: 1,
-          error: 0
-        },
-        {
-          name: 'reject',
-          children: [],
-          before: 1,
-          after: 1,
-          error: 0
-        }],
-        before: 0,
-        after: 0,
-        error: 0
-      });
-      t.end();
-    });
-
-    listener.currentName = 'then continuation';
-  });
-});
-
-test('instanceof', function diferTest(t) {
-  var p = Promise.accept();
-
-  t.ok(p instanceof Promise, 'instanceof should work on wrapped Promise');
-  t.ok(p instanceof unwrappedPromise, 'instanceof should work on unwrapped Promise');
-  t.end()
-});
-
-test('then chain with promise', function(t) {
-  var listener = addListner();
-
-  listener.currentName = 'accept';
-  var promise = Promise.accept(10);
+  listener.currentName = 'accept';
+  var promise = Promise.resolve(10);
 
   promise
     .then(function(val) {
@@ -1278,113 +930,6 @@ test('then chain with promise', function(t) {
   }
 });
 
-test('multi chain with promise', function(t) {
-  var listener = addListner();
-
-  listener.currentName = 'accept';
-  var promise = Promise.accept(10);
-
-  promise
-    .chain(function(val) {
-      return new Promise(function wait(accept) {
-        listener.currentName = 'nextTick in nested promise';
-        process.nextTick(function() {
-          listener.currentName = 'accept from nextTick';
-          accept(val);
-        });
-      });
-    })
-    .chain(function validate(val) {
-      t.strictEqual(val, 10);
-      t.strictEqual(this, global);
-
-      listener.currentName = 'setTimeout in 2nd chain';
-      setTimeout(function() {
-        t.deepEqual(listener.root, expected);
-        t.end();
-      });
-
-      listener.currentName = '2nd then continuation';
-    });
-
-  process.removeAsyncListener(listener.listener);
-
-  // Promise resolution changed slightly in node v6,
-  // now resolve/reject wraps again on completion.
-  var children = []
-  if (nodeVersion[0] >= 6) {
-    children.push({
-      name: 'accept from nextTick',
-      children: [],
-      before: 0,
-      after: 0,
-      error: 0
-    })
-  }
-  children.push(
-    {
-      name: 'setTimeout in 2nd chain',
-      children: [],
-      before: 1,
-      after: 0,
-      error: 0
-    },
-    {
-      name: '2nd then continuation',
-      children: [],
-      before: 0,
-      after: 0,
-      error: 0
-    }
-  )
-
-  var expected = {
-    name: 'root',
-    children: [
-      {
-        name: 'accept',
-        children: [
-          {
-            name: 'nextTick in nested promise',
-            children: [
-              {
-                name: 'accept from nextTick',
-                children: children,
-                before: children.length - 1,
-                after: children.length - 1,
-                error: 0
-              }
-            ],
-            before: 1,
-            after: 1,
-            error: 0
-          }
-        ],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'accept',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'accept',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      }
-    ],
-    before: 0,
-    after: 0,
-    error: 0
-  }
-});
-
 test('then chain with rejected promise', function(t) {
   var listener = addListner();
 
@@ -1522,14 +1067,14 @@ test('then chain with rejected promise', function(t) {
   }
 });
 
-test('multi chain with rejected promise', function(t) {
+test('multi catch with promise', function(t) {
   var listener = addListner();
 
   listener.currentName = 'reject';
   var promise = Promise.reject(10);
 
   promise
-    .chain(fail, function(val) {
+    .catch(function(val) {
       return new Promise(function wait(accept, reject) {
         listener.currentName = 'nextTick in nested promise';
         process.nextTick(function() {
@@ -1538,11 +1083,11 @@ test('multi chain with rejected promise', function(t) {
         });
       });
     })
-    .chain(fail, function validate(val) {
+    .catch(function validate(val) {
       t.strictEqual(val, 10);
       t.strictEqual(this, global);
 
-      listener.currentName = 'setTimeout in 2nd chain';
+      listener.currentName = 'setTimeout in 2nd catch';
       setTimeout(function() {
         // some version of iojs use nextTick for some parts of its async
         if (listener.root.children.length === 2) {
@@ -1559,14 +1104,9 @@ test('multi chain with rejected promise', function(t) {
         t.end();
       });
 
-      listener.currentName = '2nd chain continuation';
+      listener.currentName = '2nd catch continuation';
     });
 
-  function fail() {
-    t.fail('should not be called');
-    t.end();
-  }
-
   process.removeAsyncListener(listener.listener);
 
   // Promise resolution changed slightly in node v6,
@@ -1583,14 +1123,14 @@ test('multi chain with rejected promise', function(t) {
   }
   children.push(
     {
-      name: 'setTimeout in 2nd chain',
+      name: 'setTimeout in 2nd catch',
       children: [],
       before: 1,
       after: 0,
       error: 0
     },
     {
-      name: '2nd chain continuation',
+      name: '2nd catch continuation',
       children: [],
       before: 0,
       after: 0,
@@ -1624,13 +1164,6 @@ test('multi chain with rejected promise', function(t) {
         after: 1,
         error: 0
       },
-      {
-        name: 'reject',
-        children: [],
-        before: 0,
-        after: 0,
-        error: 0
-      },
       {
         name: 'reject',
         children: [],
@@ -1638,13 +1171,6 @@ test('multi chain with rejected promise', function(t) {
         after: 1,
         error: 0
       },
-      {
-        name: 'reject',
-        children: [],
-        before: 0,
-        after: 0,
-        error: 0
-      },
       {
         name: 'reject',
         children: [],
@@ -1659,165 +1185,47 @@ test('multi chain with rejected promise', function(t) {
   }
 });
 
-test('multi catch with promise', function(t) {
+test('throw in executor', function(t) {
   var listener = addListner();
 
-  listener.currentName = 'reject';
-  var promise = Promise.reject(10);
-
-  promise
-    .catch(function(val) {
-      return new Promise(function wait(accept, reject) {
-        listener.currentName = 'nextTick in nested promise';
-        process.nextTick(function() {
-          listener.currentName = 'reject from nextTick';
-          reject(val);
-        });
-      });
-    })
-    .catch(function validate(val) {
-      t.strictEqual(val, 10);
-      t.strictEqual(this, global);
-
-      listener.currentName = 'setTimeout in 2nd catch';
-      setTimeout(function() {
-        // some version of iojs use nextTick for some parts of its async
-        if (listener.root.children.length === 2) {
-          expected.children.splice(1, 0, {
-            name: 'reject',
-            children: [],
-            before: 1,
-            after: 1,
-            error: 0
-          })
-        }
+  var promise = new Promise(function unsafe() {
+    listener.currentName = 'throw';
+    throw 10;
+  });
 
-        t.deepEqual(listener.root, expected);
-        t.end();
-      });
+  promise.catch(function(val) {
+    t.equal(val, 10, 'should match thrown value')
+    if (listener.root.children.length === 2) {
+      expected.children.splice(1, 0, {
+        name: 'throw',
+        children: [],
+        before: 1,
+        after: 0,
+        error: 0
+      })
+    }
 
-      listener.currentName = '2nd catch continuation';
-    });
+    t.deepEqual(listener.root, expected);
+    t.end();
+  });
 
   process.removeAsyncListener(listener.listener);
 
-  // Promise resolution changed slightly in node v6,
-  // now resolve/reject wraps again on completion.
-  var children = []
-  if (nodeVersion[0] >= 6) {
-    children.push({
-      name: 'reject from nextTick',
-      children: [],
-      before: 0,
-      after: 0,
-      error: 0
-    })
-  }
-  children.push(
-    {
-      name: 'setTimeout in 2nd catch',
-      children: [],
-      before: 1,
-      after: 0,
-      error: 0
-    },
-    {
-      name: '2nd catch continuation',
-      children: [],
-      before: 0,
-      after: 0,
-      error: 0
-    }
-  )
-
-  var expected = {
-    name: 'root',
-    children: [
-      {
-        name: 'reject',
-        children: [
-          {
-            name: 'nextTick in nested promise',
-            children: [
-              {
-                name: 'reject from nextTick',
-                children: children,
-                before: children.length - 1,
-                after: children.length - 1,
-                error: 0
-              }
-            ],
-            before: 1,
-            after: 1,
-            error: 0
-          }
-        ],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'reject',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      },
-      {
-        name: 'reject',
-        children: [],
-        before: 1,
-        after: 1,
-        error: 0
-      }
-    ],
-    before: 0,
-    after: 0,
-    error: 0
-  }
-});
-
-test('throw in executor', function(t) {
-  var listener = addListner();
-
-  var promise = new Promise(function unsafe() {
-    listener.currentName = 'throw';
-    throw 10;
-  });
-
-  promise.catch(function(val) {
-    t.equal(val, 10, 'should match thrown value')
-    if (listener.root.children.length === 2) {
-      expected.children.splice(1, 0, {
-        name: 'throw',
-        children: [],
-        before: 1,
-        after: 0,
-        error: 0
-      })
-    }
-
-    t.deepEqual(listener.root, expected);
-    t.end();
-  });
-
-  process.removeAsyncListener(listener.listener);
-
-  var expected = {
-    name: 'root',
-    children: [
-      {
-        name: 'throw',
-        children: [
-        ],
-        before: 1,
-        after: 0,
-        error: 0
-      }
-    ],
-    before: 0,
-    after: 0,
-    error: 0
+  var expected = {
+    name: 'root',
+    children: [
+      {
+        name: 'throw',
+        children: [
+        ],
+        before: 1,
+        after: 0,
+        error: 0
+      }
+    ],
+    before: 0,
+    after: 0,
+    error: 0
   }
 });
 
@@ -2174,3 +1582,619 @@ function addListner() {
     return false;
   }
 }
+
+// for the following,
+//
+// https://github.com/v8/v8/commits/master/src/js/promise-extra.js
+//
+// is helpful context -- none of these are part of ES2015 promises, and were
+// set up to be removed.
+
+// Node.js <v7 exposed Promise.defer as a way of getting at the raw "promise
+// capability", which is to say a deferred execution context that exposes the
+// `.resolve` and `.reject` functions. The preferred way to get direct access
+// to these functions is the "revealing constructor" pattern – to capture the
+// two callbacks when creating a new Promise. The arguments for and against
+// exposing these functions are somewhat arcane and subjective, but regardless,
+// Promise.defer isn't part of ES2015 promises, and as such was removed from V8
+// in the Node.js v7 timeframe.
+if (typeof Promise.defer === 'function') {
+  test('Promise.defer', function diferTest(t) {
+    var listener = addListner();
+
+    listener.currentName = 'defer';
+    var p = Promise.defer();
+    listener.currentName = 'resolve';
+    p.resolve(123);
+    listener.currentName = 'reject';
+    p.reject(456);
+
+    p.promise.then(function then(value) {
+      listener.currentName = 'nextTick';
+      process.nextTick(function next() {
+        process.removeAsyncListener(listener.listener);
+        t.equal(value, 123);
+        t.deepEqual(listener.root, {
+          name: 'root',
+          children: [{
+            name: 'resolve',
+            children: [
+              {
+                name: 'nextTick',
+                children: [],
+                before: 1,
+                after: 0,
+                error: 0
+              },
+              {
+                name: 'then continuation',
+                children: [],
+                before: 0,
+                after: 0,
+                error: 0
+              }
+            ],
+            before: 1,
+            after: 1,
+            error: 0
+          },
+          {
+            name: 'reject',
+            children: [],
+            before: 1,
+            after: 1,
+            error: 0
+          }],
+          before: 0,
+          after: 0,
+          error: 0
+        });
+        t.end();
+      });
+
+      listener.currentName = 'then continuation';
+    });
+  });
+}
+
+// In Node.js <v7, Promise.accept is an alias for Promise.resolve.
+if (typeof Promise.accept === 'function') {
+  test('Promise.accept', function acceptTest(t) {
+    var listener = addListner();
+
+    listener.currentName = 'accept';
+    var p = Promise.accept(123);
+
+    p.then(function then(value) {
+      listener.currentName = 'nextTick';
+      process.nextTick(function next() {
+        t.equal(value, 123);
+        t.deepEqual(listener.root, {
+          name: 'root',
+          children: [{
+            name: 'accept',
+            children: [
+              {
+                name: 'nextTick',
+                children: [],
+                before: 1,
+                after: 0,
+                error: 0
+              },
+              {
+                name: 'then continuation',
+                children: [],
+                before: 0,
+                after: 0,
+                error: 0
+              }
+            ],
+            before: 1,
+            after: 1,
+            error: 0
+          },
+          {
+            name: 'accept',
+            children: [],
+            before: 1,
+            after: 1,
+            error: 0
+          }],
+          before: 0,
+          after: 0,
+          error: 0
+        });
+        t.end();
+      });
+
+      listener.currentName = 'then continuation';
+    });
+
+    process.removeAsyncListener(listener.listener);
+  });
+}
+
+// In Node.js v6 (and possibly v4), Promise.prototype.chain is merely an alias
+// for Promise.prototype.then. In Node.js v7+, it has been completely removed.
+if (typeof Promise.prototype.chain === 'function') {
+  test('chain', function chainTest(t) {
+    var listener = addListner();
+
+    var promise = new Promise(function(accept, reject) {
+      listener.currentName = 'accept';
+      accept(10);
+    });
+
+    promise.chain(function(val) {
+      listener.currentName = 'nextTick in first chain';
+      process.nextTick(function() {
+        t.strictEqual(val, 10);
+      });
+      listener.currentName = 'first chain continuation';
+    });
+
+    listener.currentName = 'setImmediate in root';
+    setImmediate(function() {
+      promise.chain(function(val) {
+        t.strictEqual(val, 10);
+        t.strictEqual(this, global);
+        listener.currentName = 'setTimeout in 2nd chain';
+        setTimeout(function() {
+          t.deepEqual(listener.root, expected);
+          t.end();
+        });
+        listener.currentName = '2nd chain continuation';
+      });
+    });
+
+    process.removeAsyncListener(listener.listener);
+
+    var expected = {
+      name: 'root',
+      children: [
+        {
+          name: 'accept',
+          children: [
+            {
+              name: 'nextTick in first chain',
+              children: [],
+              before: 1,
+              after: 1,
+              error: 0
+            },
+            {
+              name: 'first chain continuation',
+              children: [],
+              before: 0,
+              after: 0,
+              error: 0
+            },
+            {
+              name: 'setTimeout in 2nd chain',
+              children: [],
+              before: 1,
+              after: 0,
+              error: 0
+            },
+            {
+              name: '2nd chain continuation',
+              children: [],
+              before: 0,
+              after: 0,
+              error: 0
+            }
+          ],
+          before: 2,
+          after: 2,
+          error: 0
+        },
+        {
+          name: 'accept',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'setImmediate in root',
+          children: [
+            {
+              name: 'first chain continuation',
+              children: [],
+              before: 1,
+              after: 1,
+              error: 0
+            }
+          ],
+          before: 1,
+          after: 1,
+          error: 0
+        }
+      ],
+      before: 0,
+      after: 0,
+      error: 0
+    }
+  });
+
+  test('future chains', function futureChainTest(t) {
+    var listener = addListner();
+
+    listener.currentName = 'resolve';
+    var promise = Promise.resolve();
+
+    promise
+      .then(function() { listener.currentName = '1st then'; })
+      .then(function() { listener.currentName = '2nd then'; })
+      .then(function() { listener.currentName = '3rd then'; });
+
+    promise
+      .chain(function() { listener.currentName = '1st chain'; })
+      .chain(function() { listener.currentName = '2nd chain'; })
+      .chain(function() { listener.currentName = '3rd chain'; });
+
+    listener.currentName = 'setTimeout';
+    setTimeout(function() {
+      t.deepEqual(listener.root, expected);
+      t.end();
+    });
+
+    process.removeAsyncListener(listener.listener);
+
+    var expected = {
+      name: 'root',
+      children: [
+        {
+          name: 'resolve',
+          children: [
+            {
+              name: '1st then',
+              children: [
+                {
+                  name: '2nd then',
+                  children: [
+                    {
+                      name: '3rd then',
+                      children: [],
+                      before: 0,
+                      after: 0,
+                      error: 0
+                    }
+                  ],
+                  before: 1,
+                  after: 1,
+                  error: 0
+                }
+              ],
+              before: 1,
+              after: 1,
+              error: 0
+            },
+            {
+              name: '1st chain',
+              children: [
+                {
+                  name: '2nd chain',
+                  children: [
+                    {
+                      name: '3rd chain',
+                      children: [],
+                      before: 0,
+                      after: 0,
+                      error: 0
+                    }
+                  ],
+                  before: 1,
+                  after: 1,
+                  error: 0
+                }
+              ],
+              before: 1,
+              after: 1,
+              error: 0
+            }
+          ],
+          before: 2,
+          after: 2,
+          error: 0
+        },
+        {
+          name: 'resolve',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'resolve',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'resolve',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'resolve',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'resolve',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'resolve',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'setTimeout',
+          children: [],
+          before: 1,
+          after: 0,
+          error: 0
+        }
+      ],
+      before: 0,
+      after: 0,
+      error: 0
+    }
+  });
+
+  test('multi chain with promise', function(t) {
+    var listener = addListner();
+
+    listener.currentName = 'accept';
+    var promise = Promise.accept(10);
+
+    promise
+      .chain(function(val) {
+        return new Promise(function wait(accept) {
+          listener.currentName = 'nextTick in nested promise';
+          process.nextTick(function() {
+            listener.currentName = 'accept from nextTick';
+            accept(val);
+          });
+        });
+      })
+      .chain(function validate(val) {
+        t.strictEqual(val, 10);
+        t.strictEqual(this, global);
+
+        listener.currentName = 'setTimeout in 2nd chain';
+        setTimeout(function() {
+          t.deepEqual(listener.root, expected);
+          t.end();
+        });
+
+        listener.currentName = '2nd then continuation';
+      });
+
+    process.removeAsyncListener(listener.listener);
+
+    // Promise resolution changed slightly in node v6,
+    // now resolve/reject wraps again on completion.
+    var children = []
+    if (nodeVersion[0] >= 6) {
+      children.push({
+        name: 'accept from nextTick',
+        children: [],
+        before: 0,
+        after: 0,
+        error: 0
+      })
+    }
+    children.push(
+      {
+        name: 'setTimeout in 2nd chain',
+        children: [],
+        before: 1,
+        after: 0,
+        error: 0
+      },
+      {
+        name: '2nd then continuation',
+        children: [],
+        before: 0,
+        after: 0,
+        error: 0
+      }
+    )
+
+    var expected = {
+      name: 'root',
+      children: [
+        {
+          name: 'accept',
+          children: [
+            {
+              name: 'nextTick in nested promise',
+              children: [
+                {
+                  name: 'accept from nextTick',
+                  children: children,
+                  before: children.length - 1,
+                  after: children.length - 1,
+                  error: 0
+                }
+              ],
+              before: 1,
+              after: 1,
+              error: 0
+            }
+          ],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'accept',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'accept',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        }
+      ],
+      before: 0,
+      after: 0,
+      error: 0
+    }
+  });
+
+  test('multi chain with rejected promise', function(t) {
+    var listener = addListner();
+
+    listener.currentName = 'reject';
+    var promise = Promise.reject(10);
+
+    promise
+      .chain(fail, function(val) {
+        return new Promise(function wait(accept, reject) {
+          listener.currentName = 'nextTick in nested promise';
+          process.nextTick(function() {
+            listener.currentName = 'reject from nextTick';
+            reject(val);
+          });
+        });
+      })
+      .chain(fail, function validate(val) {
+        t.strictEqual(val, 10);
+        t.strictEqual(this, global);
+
+        listener.currentName = 'setTimeout in 2nd chain';
+        setTimeout(function() {
+          // some version of iojs use nextTick for some parts of its async
+          if (listener.root.children.length === 2) {
+            expected.children.splice(1, 0, {
+              name: 'reject',
+              children: [],
+              before: 1,
+              after: 1,
+              error: 0
+            })
+          }
+
+          t.deepEqual(listener.root, expected);
+          t.end();
+        });
+
+        listener.currentName = '2nd chain continuation';
+      });
+
+    function fail() {
+      t.fail('should not be called');
+      t.end();
+    }
+
+    process.removeAsyncListener(listener.listener);
+
+    // Promise resolution changed slightly in node v6,
+    // now resolve/reject wraps again on completion.
+    var children = []
+    if (nodeVersion[0] >= 6) {
+      children.push({
+        name: 'reject from nextTick',
+        children: [],
+        before: 0,
+        after: 0,
+        error: 0
+      })
+    }
+    children.push(
+      {
+        name: 'setTimeout in 2nd chain',
+        children: [],
+        before: 1,
+        after: 0,
+        error: 0
+      },
+      {
+        name: '2nd chain continuation',
+        children: [],
+        before: 0,
+        after: 0,
+        error: 0
+      }
+    )
+
+    var expected = {
+      name: 'root',
+      children: [
+        {
+          name: 'reject',
+          children: [
+            {
+              name: 'nextTick in nested promise',
+              children: [
+                {
+                  name: 'reject from nextTick',
+                  children: children,
+                  before: children.length - 1,
+                  after: children.length - 1,
+                  error: 0
+                }
+              ],
+              before: 1,
+              after: 1,
+              error: 0
+            }
+          ],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'reject',
+          children: [],
+          before: 0,
+          after: 0,
+          error: 0
+        },
+        {
+          name: 'reject',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        },
+        {
+          name: 'reject',
+          children: [],
+          before: 0,
+          after: 0,
+          error: 0
+        },
+        {
+          name: 'reject',
+          children: [],
+          before: 1,
+          after: 1,
+          error: 0
+        }
+      ],
+      before: 0,
+      after: 0,
+      error: 0
+    }
+  });
+}