selenium-webdriver 3.6.0 → 4.0.0-alpha.1

package/test/lib/promise_test.js

@@ -21,7 +21,6 @@ const assert = require('assert');
 
 const testutil = require('./testutil');
 const promise = require('../../lib/promise');
-const {enablePromiseManager, promiseManagerSuite} = require('../../lib/test/promise');
 
 // Aliases for readability.
 const NativePromise = Promise;
@@ -75,1035 +74,601 @@ describe('promise', function() {
     return p;
   }
 
-  enablePromiseManager(() => {
-    it('testCanDetectPromiseLikeObjects', function() {
-      assertIsPromise(new promise.Promise(function(fulfill) {
-        fulfill();
-      }));
-      assertIsPromise(new promise.Deferred().promise);
-      assertIsPromise(Promise.resolve(123));
-      assertIsPromise({then:function() {}});
-
-      assertNotPromise(new promise.Deferred());
-      assertNotPromise(undefined);
-      assertNotPromise(null);
-      assertNotPromise('');
-      assertNotPromise(true);
-      assertNotPromise(false);
-      assertNotPromise(1);
-      assertNotPromise({});
-      assertNotPromise({then:1});
-      assertNotPromise({then:true});
-      assertNotPromise({then:''});
+  describe('fullyResolved', function() {
+    it('primitives', function() {
+      function runTest(value) {
+        var callback, errback;
+        return promise.fullyResolved(value)
+            .then((resolved) => assert.equal(value, resolved));
+      }
+      return runTest(true)
+         .then(() => runTest(function() {}))
+         .then(() => runTest(null))
+         .then(() => runTest(123))
+         .then(() => runTest('foo bar'))
+         .then(() => runTest(undefined));
     });
 
-    describe('then', function() {
-      it('returnsOwnPromiseIfNoCallbacksWereGiven', function() {
-        var deferred = new promise.Deferred();
-        assert.equal(deferred.promise, deferred.promise.then());
-        assert.equal(deferred.promise, deferred.promise.catch());
-        assert.equal(deferred.promise, promise.when(deferred.promise));
-      });
-
-      it('stillConsideredUnHandledIfNoCallbacksWereGivenOnCallsToThen', function() {
-        promise.rejected(new StubError).then();
-        var handler = callbackHelper(assertIsStubError);
-
-        // so tearDown() doesn't throw
-        app.removeAllListeners();
-        app.on(promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION, handler);
-        return NativePromise.resolve()
-            // Macro yield so the uncaught exception has a chance to trigger.
-            .then(() => new NativePromise(resolve => setTimeout(resolve, 0)))
-            .then(() => handler.assertCalled());
+    it('arrayOfPrimitives', function() {
+      var fn = function() {};
+      var array = [true, fn, null, 123, '', undefined, 1];
+      return promise.fullyResolved(array).then(function(resolved) {
+        assert.equal(array, resolved);
+        assert.deepEqual([true, fn, null, 123, '', undefined, 1],
+            resolved);
       });
     });
 
-    describe('finally', function() {
-      it('nonFailingCallbackDoesNotSuppressOriginalError', function() {
-        var done = callbackHelper(assertIsStubError);
-        return promise.rejected(new StubError).
-            finally(function() {}).
-            catch(done).
-            finally(done.assertCalled);
-      });
-
-      it('failingCallbackSuppressesOriginalError', function() {
-        var done = callbackHelper(assertIsStubError);
-        return promise.rejected(new Error('original')).
-            finally(throwStubError).
-            catch(done).
-            finally(done.assertCalled);
-      });
-
-      it('callbackThrowsAfterFulfilledPromise', function() {
-        var done = callbackHelper(assertIsStubError);
-        return promise.fulfilled().
-            finally(throwStubError).
-            catch(done).
-            finally(done.assertCalled);
-      });
-
-      it('callbackReturnsRejectedPromise', function() {
-        var done = callbackHelper(assertIsStubError);
-        return promise.fulfilled().
-            finally(function() {
-              return promise.rejected(new StubError);
-            }).
-            catch(done).
-            finally(done.assertCalled);
-      });
+    it('nestedArrayOfPrimitives', function() {
+      var fn = function() {};
+      var array = [true, [fn, null, 123], '', undefined];
+      return promise.fullyResolved(array)
+          .then(function(resolved) {
+            assert.equal(array, resolved);
+            assert.deepEqual([true, [fn, null, 123], '', undefined], resolved);
+            assert.deepEqual([fn, null, 123], resolved[1]);
+          });
     });
 
-    describe('cancel', function() {
-      it('passesTheCancellationReasonToReject', function() {
-        var d = new promise.Deferred();
-        var res = d.promise.then(assert.fail, function(e) {
-          assert.ok(e instanceof promise.CancellationError);
-          assert.equal('because i said so', e.message);
-        });
-        d.promise.cancel('because i said so');
-        return res;
-      });
-
-      describe('can cancel original promise from its child;', function() {
-        it('child created by then()', function() {
-          var d = new promise.Deferred();
-          var p = d.promise.then(assert.fail, function(e) {
-            assert.ok(e instanceof promise.CancellationError);
-            assert.equal('because i said so', e.message);
-            return 123;
+    it('arrayWithPromisedPrimitive', function() {
+      return promise.fullyResolved([Promise.resolve(123)])
+          .then(function(resolved) {
+            assert.deepEqual([123], resolved);
           });
+    });
 
-          p.cancel('because i said so');
-          return p.then(v => assert.equal(123, v));
-        });
-
-        it('child linked by resolving with parent', function() {
-          let parent = promise.defer();
-          let child = new promise.Promise(resolve => resolve(parent.promise));
-          child.cancel('all done');
-
-          return parent.promise.then(
-              () => assert.fail('expected a cancellation'),
-              e => {
-                assert.ok(e instanceof promise.CancellationError);
-                assert.equal('all done', e.message);
-              });
-        });
-
-        it('grand child through thenable chain', function() {
-          let p = new promise.Promise(function() {/* never resolve*/});
-
-          let noop = function() {};
-          let gc = p.then(noop).then(noop).then(noop);
-          gc.cancel('stop!');
-
-          return p.then(
-              () => assert.fail('expected to be cancelled'),
-              (e) => {
-                assert.ok(e instanceof promise.CancellationError);
-                assert.equal('stop!', e.message);
-              });
-        });
-
-        it('grand child through thenable chain started at resolve', function() {
-          function noop() {}
-
-          let parent = promise.defer();
-          let child = new promise.Promise(resolve => resolve(parent.promise));
-          let grandChild = child.then(noop).then(noop).then(noop);
-          grandChild.cancel('all done');
-
-          return parent.promise.then(
-              () => assert.fail('expected a cancellation'),
-              e => {
-                assert.ok(e instanceof promise.CancellationError);
-                assert.equal('all done', e.message);
-              });
-        });
-
-        it('"parent" is a CancellableThenable', function() {
-          function noop() {}
-
-          class FakeThenable {
-            constructor(p) {
-              this.promise = p;
-            }
-
-            cancel(reason) {
-              this.promise.cancel(reason);
-            }
-
-            then(cb, eb) {
-              let result = this.promise.then(cb, eb);
-              return new FakeThenable(result);
-            }
-          }
-          promise.CancellableThenable.addImplementation(FakeThenable);
-
-          let root = new promise.Promise(noop);
-          let thenable = new FakeThenable(root);
-          assert.ok(promise.Thenable.isImplementation(thenable));
-          assert.ok(promise.CancellableThenable.isImplementation(thenable));
-
-          let child = new promise.Promise(resolve => resolve(thenable));
-          assert.ok(child instanceof promise.Promise);
-          child.cancel('stop!');
-
-          function assertStopped(p) {
-            return p.then(
-                () => assert.fail('not stopped!'),
-                (e) => {
-                  assert.ok(e instanceof promise.CancellationError);
-                  assert.equal('stop!', e.message);
-                });
-          }
-
-          return assertStopped(child).then(() => assertStopped(root));
-        });
-      });
-
-      it('canCancelATimeout', function() {
-        var p = promise.delayed(25)
-            .then(assert.fail, (e) => e instanceof promise.CancellationError);
-        setTimeout(() => p.cancel(), 20);
-        p.cancel();
-        return p;
-      });
+    it('promiseResolvesToPrimitive', function() {
+      return promise.fullyResolved(Promise.resolve(123))
+          .then((resolved) => assert.equal(123, resolved));
+    });
 
-      it('can cancel timeout from grandchild', function() {
-      });
+    it('promiseResolvesToArray', function() {
+      var fn = function() {};
+      var array = [true, [fn, null, 123], '', undefined];
+      var aPromise = Promise.resolve(array);
 
-      it('cancelIsANoopOnceAPromiseHasBeenFulfilled', function() {
-        var p = promise.fulfilled(123);
-        p.cancel();
-        return p.then((v) => assert.equal(123, v));
+      var result = promise.fullyResolved(aPromise);
+      return result.then(function(resolved) {
+        assert.equal(array, resolved);
+        assert.deepEqual([true, [fn, null, 123], '', undefined],
+            resolved);
+        assert.deepEqual([fn, null, 123], resolved[1]);
       });
+    });
 
-      it('cancelIsANoopOnceAPromiseHasBeenRejected', function() {
-        var p = promise.rejected(new StubError);
-        p.cancel();
-
-        var pair = callbackPair(null, assertIsStubError);
-        return p.then(assert.fail, assertIsStubError);
-      });
+    it('promiseResolvesToArrayWithPromises', function() {
+      var nestedPromise = Promise.resolve(123);
+      var aPromise = Promise.resolve([true, nestedPromise]);
+      return promise.fullyResolved(aPromise)
+          .then(function(resolved) {
+            assert.deepEqual([true, 123], resolved);
+          });
+    });
 
-      it('noopCancelTriggeredOnCallbackOfResolvedPromise', function() {
-        var d = promise.defer();
-        var p = d.promise.then();
+    it('rejectsIfArrayPromiseRejects', function() {
+      var nestedPromise = createRejectedPromise(new StubError);
+      var aPromise = Promise.resolve([true, nestedPromise]);
 
-        d.fulfill();
-        p.cancel();  // This should not throw.
-        return p;    // This should not trigger a failure.
-      });
+      var pair = callbackPair(null, assertIsStubError);
+      return promise.fullyResolved(aPromise)
+          .then(assert.fail, assertIsStubError);
     });
-  });
 
-  promiseManagerSuite(() => {
-    describe('fulfilled', function() {
-      it('returns input value if it is already a valid promise', function() {
-        let p = promise.createPromise(function() {});
-        let r = promise.fulfilled(p);
-        assert.strictEqual(p, r);
-      });
+    it('rejectsOnFirstArrayRejection', function() {
+      var e1 = new Error('foo');
+      var e2 = new Error('bar');
+      var aPromise = Promise.resolve([
+        createRejectedPromise(e1),
+        createRejectedPromise(e2)
+      ]);
+
+      return promise.fullyResolved(aPromise)
+          .then(assert.fail, function(error) {
+            assert.strictEqual(e1, error);
+          });
+    });
 
-      it('creates a new promise fulfilled with input', function() {
-        return promise.fulfilled(1234).then(v => assert.equal(1234, v));
-      });
+    it('rejectsIfNestedArrayPromiseRejects', function() {
+      var aPromise = Promise.resolve([
+        Promise.resolve([
+          createRejectedPromise(new StubError)
+        ])
+      ]);
 
-      it('can convert thenables to valid promise', function() {
-        let thenable = {then: function(cb) {cb(1234)}};
-        let p = promise.fulfilled(thenable);
-        assert.notStrictEqual(thenable, p);
-        return p.then(v => assert.equal(1234, v));
-      });
+      return promise.fullyResolved(aPromise)
+          .then(assert.fail, assertIsStubError);
     });
 
-    describe('when', function() {
-      it('ReturnsAResolvedPromiseIfGivenANonPromiseValue', function() {
-        var ret = promise.when('abc');
-        assertIsPromise(ret);
-        return ret.then((value) => assert.equal('abc', value));
-      });
+    it('simpleHash', function() {
+      var hash = {'a': 123};
+      return promise.fullyResolved(hash)
+          .then(function(resolved) {
+            assert.strictEqual(hash, resolved);
+            assert.deepEqual(hash, {'a': 123});
+          });
+    });
 
-      it('PassesRawErrorsToCallbacks', function() {
-        var error = new Error('boo!');
-        return promise.when(error, function(value) {
-          assert.equal(error, value);
-        });
-      });
+    it('nestedHash', function() {
+      var nestedHash = {'foo':'bar'};
+      var hash = {'a': 123, 'b': nestedHash};
 
-      it('WaitsForValueToBeResolvedBeforeInvokingCallback', function() {
-        let d = defer();
-        let callback;
-        let result = promise.when(d.promise, callback = callbackHelper(function(value) {
-          assert.equal('hi', value);
-        }));
-        callback.assertNotCalled();
-        d.resolve('hi');
-        return result.then(callback.assertCalled);
-      });
+      return promise.fullyResolved(hash)
+          .then(function(resolved) {
+            assert.strictEqual(hash, resolved);
+            assert.deepEqual({'a': 123, 'b': {'foo': 'bar'}}, resolved);
+            assert.strictEqual(nestedHash, resolved['b']);
+          });
     });
 
-    describe('fullyResolved', function() {
-      it('primitives', function() {
-        function runTest(value) {
-          var callback, errback;
-          return promise.fullyResolved(value)
-              .then((resolved) => assert.equal(value, resolved));
-        }
-        return runTest(true)
-           .then(() => runTest(function() {}))
-           .then(() => runTest(null))
-           .then(() => runTest(123))
-           .then(() => runTest('foo bar'))
-           .then(() => runTest(undefined));
-      });
+    it('promiseResolvesToSimpleHash', function() {
+      var hash = {'a': 123};
+      var aPromise = Promise.resolve(hash);
 
-      it('arrayOfPrimitives', function() {
-        var fn = function() {};
-        var array = [true, fn, null, 123, '', undefined, 1];
-        return promise.fullyResolved(array).then(function(resolved) {
-          assert.equal(array, resolved);
-          assert.deepEqual([true, fn, null, 123, '', undefined, 1],
-              resolved);
-        });
-      });
+      return promise.fullyResolved(aPromise)
+          .then((resolved) => assert.strictEqual(hash, resolved));
+    });
 
-      it('nestedArrayOfPrimitives', function() {
-        var fn = function() {};
-        var array = [true, [fn, null, 123], '', undefined];
-        return promise.fullyResolved(array)
-            .then(function(resolved) {
-              assert.equal(array, resolved);
-              assert.deepEqual([true, [fn, null, 123], '', undefined], resolved);
-              assert.deepEqual([fn, null, 123], resolved[1]);
-            });
-      });
+    it('promiseResolvesToNestedHash', function() {
+      var nestedHash = {'foo':'bar'};
+      var hash = {'a': 123, 'b': nestedHash};
+      var aPromise = Promise.resolve(hash);
 
-      it('arrayWithPromisedPrimitive', function() {
-        return promise.fullyResolved([Promise.resolve(123)])
-            .then(function(resolved) {
-              assert.deepEqual([123], resolved);
-            });
-      });
+      return promise.fullyResolved(aPromise)
+          .then(function(resolved) {
+            assert.strictEqual(hash, resolved);
+            assert.strictEqual(nestedHash, resolved['b']);
+            assert.deepEqual(hash, {'a': 123, 'b': {'foo': 'bar'}});
+          });
+    });
 
-      it('promiseResolvesToPrimitive', function() {
-        return promise.fullyResolved(Promise.resolve(123))
-            .then((resolved) => assert.equal(123, resolved));
+    it('promiseResolvesToHashWithPromises', function() {
+      var aPromise = Promise.resolve({
+          'a': Promise.resolve(123)
       });
 
-      it('promiseResolvesToArray', function() {
-        var fn = function() {};
-        var array = [true, [fn, null, 123], '', undefined];
-        var aPromise = Promise.resolve(array);
-
-        var result = promise.fullyResolved(aPromise);
-        return result.then(function(resolved) {
-          assert.equal(array, resolved);
-          assert.deepEqual([true, [fn, null, 123], '', undefined],
-              resolved);
-          assert.deepEqual([fn, null, 123], resolved[1]);
-        });
-      });
+      return promise.fullyResolved(aPromise)
+          .then(function(resolved) {
+            assert.deepEqual({'a': 123}, resolved);
+          });
+    });
 
-      it('promiseResolvesToArrayWithPromises', function() {
-        var nestedPromise = Promise.resolve(123);
-        var aPromise = Promise.resolve([true, nestedPromise]);
-        return promise.fullyResolved(aPromise)
-            .then(function(resolved) {
-              assert.deepEqual([true, 123], resolved);
-            });
+    it('rejectsIfHashPromiseRejects', function() {
+      var aPromise = Promise.resolve({
+          'a': createRejectedPromise(new StubError)
       });
 
-      it('rejectsIfArrayPromiseRejects', function() {
-        var nestedPromise = createRejectedPromise(new StubError);
-        var aPromise = Promise.resolve([true, nestedPromise]);
+      return promise.fullyResolved(aPromise)
+          .then(assert.fail, assertIsStubError);
+    });
 
-        var pair = callbackPair(null, assertIsStubError);
-        return promise.fullyResolved(aPromise)
-            .then(assert.fail, assertIsStubError);
+    it('rejectsIfNestedHashPromiseRejects', function() {
+      var aPromise = Promise.resolve({
+          'a': {'b': createRejectedPromise(new StubError)}
       });
 
-      it('rejectsOnFirstArrayRejection', function() {
-        var e1 = new Error('foo');
-        var e2 = new Error('bar');
-        var aPromise = Promise.resolve([
-          createRejectedPromise(e1),
-          createRejectedPromise(e2)
-        ]);
-
-        return promise.fullyResolved(aPromise)
-            .then(assert.fail, function(error) {
-              assert.strictEqual(e1, error);
-            });
-      });
+      return promise.fullyResolved(aPromise)
+          .then(assert.fail, assertIsStubError);
+    });
 
-      it('rejectsIfNestedArrayPromiseRejects', function() {
-        var aPromise = Promise.resolve([
-          Promise.resolve([
-            createRejectedPromise(new StubError)
-          ])
-        ]);
+    it('instantiatedObject', function() {
+      function Foo() {
+        this.bar = 'baz';
+      }
+      var foo = new Foo;
 
-        return promise.fullyResolved(aPromise)
-            .then(assert.fail, assertIsStubError);
+      return promise.fullyResolved(foo).then(function(resolvedFoo) {
+        assert.equal(foo, resolvedFoo);
+        assert.ok(resolvedFoo instanceof Foo);
+        assert.deepEqual(new Foo, resolvedFoo);
       });
+    });
 
-      it('simpleHash', function() {
-        var hash = {'a': 123};
-        return promise.fullyResolved(hash)
-            .then(function(resolved) {
-              assert.strictEqual(hash, resolved);
-              assert.deepEqual(hash, {'a': 123});
-            });
+    it('withEmptyArray', function() {
+      return promise.fullyResolved([]).then(function(resolved) {
+        assert.deepEqual([], resolved);
       });
+    });
 
-      it('nestedHash', function() {
-        var nestedHash = {'foo':'bar'};
-        var hash = {'a': 123, 'b': nestedHash};
-
-        return promise.fullyResolved(hash)
-            .then(function(resolved) {
-              assert.strictEqual(hash, resolved);
-              assert.deepEqual({'a': 123, 'b': {'foo': 'bar'}}, resolved);
-              assert.strictEqual(nestedHash, resolved['b']);
-            });
+    it('withEmptyHash', function() {
+      return promise.fullyResolved({}).then(function(resolved) {
+        assert.deepEqual({}, resolved);
       });
+    });
 
-      it('promiseResolvesToSimpleHash', function() {
-        var hash = {'a': 123};
-        var aPromise = Promise.resolve(hash);
-
-        return promise.fullyResolved(aPromise)
-            .then((resolved) => assert.strictEqual(hash, resolved));
-      });
+    it('arrayWithPromisedHash', function() {
+      var obj = {'foo': 'bar'};
+      var array = [Promise.resolve(obj)];
 
-      it('promiseResolvesToNestedHash', function() {
-        var nestedHash = {'foo':'bar'};
-        var hash = {'a': 123, 'b': nestedHash};
-        var aPromise = Promise.resolve(hash);
-
-        return promise.fullyResolved(aPromise)
-            .then(function(resolved) {
-              assert.strictEqual(hash, resolved);
-              assert.strictEqual(nestedHash, resolved['b']);
-              assert.deepEqual(hash, {'a': 123, 'b': {'foo': 'bar'}});
-            });
+      return promise.fullyResolved(array).then(function(resolved) {
+        assert.deepEqual(resolved, [obj]);
       });
+    });
+  });
 
-      it('promiseResolvesToHashWithPromises', function() {
-        var aPromise = Promise.resolve({
-            'a': Promise.resolve(123)
-        });
-
-        return promise.fullyResolved(aPromise)
-            .then(function(resolved) {
-              assert.deepEqual({'a': 123}, resolved);
-            });
-      });
+  describe('finally', function() {
+    it('successful callback does not suppress original error', async () => {
+      let p = Promise.reject(new StubError);
+      let called = false;
+
+      try {
+        await promise.finally(p, function() { called = true; });
+        fail('should have thrown');
+      } catch (e) {
+        assertIsStubError(e);
+        assert.ok(called);
+      }
+    });
 
-      it('rejectsIfHashPromiseRejects', function() {
-        var aPromise = Promise.resolve({
-            'a': createRejectedPromise(new StubError)
-        });
+    it('failing callback suppresses original error', async () => {
+      let p = Promise.reject(Error('original'));
+      let called = false;
 
-        return promise.fullyResolved(aPromise)
-            .then(assert.fail, assertIsStubError);
-      });
+      try {
+        await promise.finally(p, throwStubError);
+        fail('should have thrown');
+      } catch (e) {
+        assertIsStubError(e);
+      }
+    });
 
-      it('rejectsIfNestedHashPromiseRejects', function() {
-        var aPromise = Promise.resolve({
-            'a': {'b': createRejectedPromise(new StubError)}
-        });
+    it('callback throws after fulfilled promise', async () => {
+      try {
+        await promise.finally(Promise.resolve(), throwStubError);
+        fail('should have thrown');
+      } catch (e) {
+        assertIsStubError(e);
+      }
+    });
 
-        return promise.fullyResolved(aPromise)
-            .then(assert.fail, assertIsStubError);
-      });
+    it('callback returns rejected promise', async () => {
+      try {
+        await promise.finally(
+            Promise.resolve(), () => Promise.reject(new StubError));
+        fail('should have thrown');
+      } catch (e) {
+        assertIsStubError(e);
+      }
+    });
 
-      it('instantiatedObject', function() {
-        function Foo() {
-          this.bar = 'baz';
-        }
-        var foo = new Foo;
+    it('returned promise resolves with callback result', async () => {
+      let value =
+          await promise.finally(Promise.resolve(1), () => 2);
+      assert.equal(value, 2);
+    });
+  });
 
-        return promise.fullyResolved(foo).then(function(resolvedFoo) {
-          assert.equal(foo, resolvedFoo);
-          assert.ok(resolvedFoo instanceof Foo);
-          assert.deepEqual(new Foo, resolvedFoo);
-        });
-      });
+  describe('checkedNodeCall', function() {
+    it('functionThrows', function() {
+      return promise.checkedNodeCall(throwStubError)
+          .then(assert.fail, assertIsStubError);
+    });
 
-      it('withEmptyArray', function() {
-        return promise.fullyResolved([]).then(function(resolved) {
-          assert.deepEqual([], resolved);
-        });
-      });
+    it('functionReturnsAnError', function() {
+      return promise.checkedNodeCall(function(callback) {
+        callback(new StubError);
+      }).then(assert.fail, assertIsStubError);
+    });
 
-      it('withEmptyHash', function() {
-        return promise.fullyResolved({}).then(function(resolved) {
-          assert.deepEqual({}, resolved);
-        });
-      });
+    it('functionReturnsSuccess', function() {
+      var success = 'success!';
+      return promise.checkedNodeCall(function(callback) {
+        callback(null, success);
+      }).then((value) => assert.equal(success, value));
+    });
 
-      it('arrayWithPromisedHash', function() {
-        var obj = {'foo': 'bar'};
-        var array = [Promise.resolve(obj)];
+    it('functionReturnsAndThrows', function() {
+      var error = new Error('boom');
+      var error2 = new Error('boom again');
+      return promise.checkedNodeCall(function(callback) {
+        callback(error);
+        throw error2;
+      }).then(assert.fail, (e) => assert.equal(error, e));
+    });
 
-        return promise.fullyResolved(array).then(function(resolved) {
-          assert.deepEqual(resolved, [obj]);
-        });
-      });
+    it('functionThrowsAndReturns', function() {
+      var error = new Error('boom');
+      var error2 = new Error('boom again');
+      return promise.checkedNodeCall(function(callback) {
+        setTimeout(() => callback(error), 10);
+        throw error2;
+      }).then(assert.fail, (e) => assert.equal(error2, e));
     });
+  });
 
-    describe('checkedNodeCall', function() {
-      it('functionThrows', function() {
-        return promise.checkedNodeCall(throwStubError)
-            .then(assert.fail, assertIsStubError);
+  describe('map', function() {
+    it('(base case)', function() {
+      var a = [1, 2, 3];
+      return promise.map(a, function(value, index, a2) {
+        assert.equal(a, a2);
+        assert.equal('number', typeof index, 'not a number');
+        return value + 1;
+      }).then(function(value) {
+        assert.deepEqual([2, 3, 4], value);
       });
+    });
 
-      it('functionReturnsAnError', function() {
-        return promise.checkedNodeCall(function(callback) {
-          callback(new StubError);
-        }).then(assert.fail, assertIsStubError);
-      });
+    it('omitsDeleted', function() {
+      var a = [0, 1, 2, 3, 4, 5, 6];
+      delete a[1];
+      delete a[3];
+      delete a[4];
+      delete a[6];
 
-      it('functionReturnsSuccess', function() {
-        var success = 'success!';
-        return promise.checkedNodeCall(function(callback) {
-          callback(null, success);
-        }).then((value) => assert.equal(success, value));
-      });
+      var expected = [0, 1, 4, 9, 16, 25, 36];
+      delete expected[1];
+      delete expected[3];
+      delete expected[4];
+      delete expected[6];
 
-      it('functionReturnsAndThrows', function() {
-        var error = new Error('boom');
-        var error2 = new Error('boom again');
-        return promise.checkedNodeCall(function(callback) {
-          callback(error);
-          throw error2;
-        }).then(assert.fail, (e) => assert.equal(error, e));
+      return promise.map(a, function(value) {
+        return value * value;
+      }).then(function(value) {
+        assert.deepEqual(expected, value);
       });
+    });
 
-      it('functionThrowsAndReturns', function() {
-        var error = new Error('boom');
-        var error2 = new Error('boom again');
-        return promise.checkedNodeCall(function(callback) {
-          setTimeout(() => callback(error), 10);
-          throw error2;
-        }).then(assert.fail, (e) => assert.equal(error2, e));
+    it('emptyArray', function() {
+      return promise.map([], function(value) {
+        return value + 1;
+      }).then(function(value) {
+        assert.deepEqual([], value);
       });
     });
 
-    describe('all', function() {
-      it('(base case)', function() {
-        let deferredObjs = [defer(), defer()];
-        var a = [
-            0, 1,
-            deferredObjs[0].promise,
-            deferredObjs[1].promise,
-            4, 5, 6
-        ];
-        delete a[5];
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual([0, 1, 2, 3, 4, undefined, 6], value);
-        });
-
-        var result = promise.all(a).then(pair.callback, pair.errback);
-        pair.assertNeither();
-
-        deferredObjs[0].resolve(2);
-        pair.assertNeither();
-
-        deferredObjs[1].resolve(3);
-        return result.then(() => pair.assertCallback());
+    it('inputIsPromise', function() {
+      var input = defer();
+      var result = promise.map(input.promise, function(value) {
+        return value + 1;
       });
 
-      it('empty array', function() {
-        return promise.all([]).then((a) => assert.deepEqual([], a));
+      var pair = callbackPair(function(value) {
+        assert.deepEqual([2, 3, 4], value);
       });
+      result = result.then(pair.callback, pair.errback);
 
-      it('usesFirstRejection', function() {
-        let deferredObjs = [defer(), defer()];
-        let a = [deferredObjs[0].promise, deferredObjs[1].promise];
+      setTimeout(function() {
+        pair.assertNeither();
+        input.resolve([1, 2, 3]);
+      }, 10);
 
-        var result = promise.all(a).then(assert.fail, assertIsStubError);
-        deferredObjs[1].reject(new StubError);
-        setTimeout(() => deferredObjs[0].reject(Error('ignored')), 0);
-        return result;
-      });
+      return result;
     });
 
-    describe('map', function() {
-      it('(base case)', function() {
-        var a = [1, 2, 3];
-        return promise.map(a, function(value, index, a2) {
-          assert.equal(a, a2);
-          assert.equal('number', typeof index, 'not a number');
-          return value + 1;
-        }).then(function(value) {
-          assert.deepEqual([2, 3, 4], value);
-        });
-      });
+    it('waitsForFunctionResultToResolve', function() {
+      var innerResults = [
+        defer(),
+        defer()
+      ];
 
-      it('omitsDeleted', function() {
-        var a = [0, 1, 2, 3, 4, 5, 6];
-        delete a[1];
-        delete a[3];
-        delete a[4];
-        delete a[6];
-
-        var expected = [0, 1, 4, 9, 16, 25, 36];
-        delete expected[1];
-        delete expected[3];
-        delete expected[4];
-        delete expected[6];
-
-        return promise.map(a, function(value) {
-          return value * value;
-        }).then(function(value) {
-          assert.deepEqual(expected, value);
-        });
+      var result = promise.map([1, 2], function(value, index) {
+        return innerResults[index].promise;
       });
 
-      it('emptyArray', function() {
-        return promise.map([], function(value) {
-          return value + 1;
-        }).then(function(value) {
-          assert.deepEqual([], value);
-        });
+      var pair = callbackPair(function(value) {
+        assert.deepEqual(['a', 'b'], value);
       });
+      result = result.then(pair.callback, pair.errback);
 
-      it('inputIsPromise', function() {
-        var input = defer();
-        var result = promise.map(input.promise, function(value) {
-          return value + 1;
-        });
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual([2, 3, 4], value);
-        });
-        result = result.then(pair.callback, pair.errback);
-
-        setTimeout(function() {
-          pair.assertNeither();
-          input.resolve([1, 2, 3]);
-        }, 10);
+      return NativePromise.resolve()
+          .then(function() {
+            pair.assertNeither();
+            innerResults[0].resolve('a');
+          })
+          .then(function() {
+            pair.assertNeither();
+            innerResults[1].resolve('b');
+            return result;
+          })
+          .then(pair.assertCallback);
+    });
 
-        return result;
-      });
+    it('rejectsPromiseIfFunctionThrows', function() {
+      return promise.map([1], throwStubError)
+          .then(assert.fail, assertIsStubError);
+    });
 
-      it('waitsForFunctionResultToResolve', function() {
-        var innerResults = [
-          defer(),
-          defer()
-        ];
-
-        var result = promise.map([1, 2], function(value, index) {
-          return innerResults[index].promise;
-        });
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual(['a', 'b'], value);
-        });
-        result = result.then(pair.callback, pair.errback);
-
-        return NativePromise.resolve()
-            .then(function() {
-              pair.assertNeither();
-              innerResults[0].resolve('a');
-            })
-            .then(function() {
-              pair.assertNeither();
-              innerResults[1].resolve('b');
-              return result;
-            })
-            .then(pair.assertCallback);
-      });
+    it('rejectsPromiseIfFunctionReturnsRejectedPromise', function() {
+      return promise.map([1], function() {
+        return createRejectedPromise(new StubError);
+      }).then(assert.fail, assertIsStubError);
+    });
 
-      it('rejectsPromiseIfFunctionThrows', function() {
-        return promise.map([1], throwStubError)
-            .then(assert.fail, assertIsStubError);
+    it('stopsCallingFunctionIfPreviousIterationFailed', function() {
+      var count = 0;
+      return promise.map([1, 2, 3, 4], function() {
+        count++;
+        if (count == 3) {
+          throw new StubError;
+        }
+      }).then(assert.fail, function(e) {
+        assertIsStubError(e);
+        assert.equal(3, count);
       });
+    });
 
-      it('rejectsPromiseIfFunctionReturnsRejectedPromise', function() {
-        return promise.map([1], function() {
-          return createRejectedPromise(new StubError);
-        }).then(assert.fail, assertIsStubError);
+    it('rejectsWithFirstRejectedPromise', function() {
+      var innerResult = [
+          Promise.resolve(),
+          createRejectedPromise(new StubError),
+          createRejectedPromise(Error('should be ignored'))
+      ];
+      var count = 0;
+      return promise.map([1, 2, 3, 4], function(value, index) {
+        count += 1;
+        return innerResult[index];
+      }).then(assert.fail, function(e) {
+        assertIsStubError(e);
+        assert.equal(2, count);
       });
+    });
 
-      it('stopsCallingFunctionIfPreviousIterationFailed', function() {
-        var count = 0;
-        return promise.map([1, 2, 3, 4], function() {
-          count++;
-          if (count == 3) {
-            throw new StubError;
-          }
-        }).then(assert.fail, function(e) {
-          assertIsStubError(e);
-          assert.equal(3, count);
-        });
+    it('preservesOrderWhenMapReturnsPromise', function() {
+      var deferreds = [
+        defer(),
+        defer(),
+        defer(),
+        defer()
+      ];
+      var result = promise.map(deferreds, function(value) {
+        return value.promise;
       });
 
-      it('rejectsWithFirstRejectedPromise', function() {
-        var innerResult = [
-            Promise.resolve(),
-            createRejectedPromise(new StubError),
-            createRejectedPromise(Error('should be ignored'))
-        ];
-        var count = 0;
-        return promise.map([1, 2, 3, 4], function(value, index) {
-          count += 1;
-          return innerResult[index];
-        }).then(assert.fail, function(e) {
-          assertIsStubError(e);
-          assert.equal(2, count);
-        });
+      var pair = callbackPair(function(value) {
+        assert.deepEqual([0, 1, 2, 3], value);
       });
+      result = result.then(pair.callback, pair.errback);
 
-      it('preservesOrderWhenMapReturnsPromise', function() {
-        var deferreds = [
-          defer(),
-          defer(),
-          defer(),
-          defer()
-        ];
-        var result = promise.map(deferreds, function(value) {
-          return value.promise;
-        });
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual([0, 1, 2, 3], value);
-        });
-        result = result.then(pair.callback, pair.errback);
-
-        return Promise.resolve()
-            .then(function() {
-              pair.assertNeither();
-              for (let i = deferreds.length; i > 0; i -= 1) {
-                deferreds[i - 1].resolve(i - 1);
-              }
-              return result;
-            }).then(pair.assertCallback);
-      });
+      return Promise.resolve()
+          .then(function() {
+            pair.assertNeither();
+            for (let i = deferreds.length; i > 0; i -= 1) {
+              deferreds[i - 1].resolve(i - 1);
+            }
+            return result;
+          }).then(pair.assertCallback);
     });
+  });
 
-    describe('filter', function() {
-      it('basicFiltering', function() {
-        var a = [0, 1, 2, 3];
-        return promise.filter(a, function(val, index, a2) {
-          assert.equal(a, a2);
-          assert.equal('number', typeof index, 'not a number');
-          return val > 1;
-        }).then(function(val) {
-          assert.deepEqual([2, 3], val);
-        });
+  describe('filter', function() {
+    it('basicFiltering', function() {
+      var a = [0, 1, 2, 3];
+      return promise.filter(a, function(val, index, a2) {
+        assert.equal(a, a2);
+        assert.equal('number', typeof index, 'not a number');
+        return val > 1;
+      }).then(function(val) {
+        assert.deepEqual([2, 3], val);
       });
+    });
 
-      it('omitsDeleted', function() {
-        var a = [0, 1, 2, 3, 4, 5, 6];
-        delete a[3];
-        delete a[4];
-
-        return promise.filter(a, function(value) {
-          return value > 1 && value < 6;
-        }).then(function(val) {
-          assert.deepEqual([2, 5], val);
-        });
-      });
+    it('omitsDeleted', function() {
+      var a = [0, 1, 2, 3, 4, 5, 6];
+      delete a[3];
+      delete a[4];
 
-      it('preservesInputs', function() {
-        var a = [0, 1, 2, 3];
-
-        return promise.filter(a, function(value, i, a2) {
-          assert.equal(a, a2);
-          // Even if a function modifies the input array, the original value
-          // should be inserted into the new array.
-          a2[i] = a2[i] - 1;
-          return a2[i] >= 1;
-        }).then(function(val) {
-          assert.deepEqual([2, 3], val);
-        });
+      return promise.filter(a, function(value) {
+        return value > 1 && value < 6;
+      }).then(function(val) {
+        assert.deepEqual([2, 5], val);
       });
+    });
 
-      it('inputIsPromise', function() {
-        var input = defer();
-        var result = promise.filter(input.promise, function(value) {
-          return value > 1 && value < 3;
-        });
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual([2], value);
-        });
-        result = result.then(pair.callback, pair.errback);
-        return NativePromise.resolve()
-            .then(function() {
-              pair.assertNeither();
-              input.resolve([1, 2, 3]);
-              return result;
-            })
-            .then(pair.assertCallback);
-      });
+    it('preservesInputs', function() {
+      var a = [0, 1, 2, 3];
 
-      it('waitsForFunctionResultToResolve', function() {
-        var innerResults = [
-          defer(),
-          defer()
-        ];
-
-        var result = promise.filter([1, 2], function(value, index) {
-          return innerResults[index].promise;
-        });
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual([2], value);
-        });
-        result = result.then(pair.callback, pair.errback);
-        return NativePromise.resolve()
-            .then(function() {
-              pair.assertNeither();
-              innerResults[0].resolve(false);
-            })
-            .then(function() {
-              pair.assertNeither();
-              innerResults[1].resolve(true);
-              return result;
-            })
-            .then(pair.assertCallback);
+      return promise.filter(a, function(value, i, a2) {
+        assert.equal(a, a2);
+        // Even if a function modifies the input array, the original value
+        // should be inserted into the new array.
+        a2[i] = a2[i] - 1;
+        return a2[i] >= 1;
+      }).then(function(val) {
+        assert.deepEqual([2, 3], val);
       });
+    });
 
-      it('rejectsPromiseIfFunctionReturnsRejectedPromise', function() {
-        return promise.filter([1], function() {
-          return createRejectedPromise(new StubError);
-        }).then(assert.fail, assertIsStubError);
+    it('inputIsPromise', function() {
+      var input = defer();
+      var result = promise.filter(input.promise, function(value) {
+        return value > 1 && value < 3;
       });
 
-      it('stopsCallingFunctionIfPreviousIterationFailed', function() {
-        var count = 0;
-        return promise.filter([1, 2, 3, 4], function() {
-          count++;
-          if (count == 3) {
-            throw new StubError;
-          }
-        }).then(assert.fail, function(e) {
-          assertIsStubError(e);
-          assert.equal(3, count);
-        });
+      var pair = callbackPair(function(value) {
+        assert.deepEqual([2], value);
       });
+      result = result.then(pair.callback, pair.errback);
+      return NativePromise.resolve()
+          .then(function() {
+            pair.assertNeither();
+            input.resolve([1, 2, 3]);
+            return result;
+          })
+          .then(pair.assertCallback);
+    });
 
-      it('rejectsWithFirstRejectedPromise', function() {
-        var innerResult = [
-          Promise.resolve(),
-          createRejectedPromise(new StubError),
-          createRejectedPromise(Error('should be ignored'))
-        ];
+    it('waitsForFunctionResultToResolve', function() {
+      var innerResults = [
+        defer(),
+        defer()
+      ];
 
-        return promise.filter([1, 2, 3, 4], function(value, index) {
-          assert.ok(index < innerResult.length);
-          return innerResult[index];
-        }).then(assert.fail, assertIsStubError);
+      var result = promise.filter([1, 2], function(value, index) {
+        return innerResults[index].promise;
       });
 
-      it('preservesOrderWhenFilterReturnsPromise', function() {
-        var deferreds = [
-          defer(),
-          defer(),
-          defer(),
-          defer()
-        ];
-        var result = promise.filter([0, 1, 2, 3], function(value, index) {
-          return deferreds[index].promise;
-        });
-
-        var pair = callbackPair(function(value) {
-          assert.deepEqual([1, 2], value);
-        });
-        result = result.then(pair.callback, pair.errback);
-
-        return NativePromise.resolve()
-            .then(function() {
-              pair.assertNeither();
-              for (let i = deferreds.length - 1; i >= 0; i -= 1) {
-                deferreds[i].resolve(i > 0 && i < 3);
-              }
-              return result;
-            }).then(pair.assertCallback);
+      var pair = callbackPair(function(value) {
+        assert.deepEqual([2], value);
       });
-    });
-  });
-
-  enablePromiseManager(() => {
-    it('firesUncaughtExceptionEventIfRejectionNeverHandled', function() {
-      promise.rejected(new StubError);
-      var handler = callbackHelper(assertIsStubError);
-
-      // so tearDown() doesn't throw
-      app.removeAllListeners();
-      app.on(promise.ControlFlow.EventType.UNCAUGHT_EXCEPTION, handler);
-
+      result = result.then(pair.callback, pair.errback);
       return NativePromise.resolve()
-          // Macro yield so the uncaught exception has a chance to trigger.
-          .then(() => new NativePromise(resolve => setTimeout(resolve, 0)))
-          .then(handler.assertCalled);
+          .then(function() {
+            pair.assertNeither();
+            innerResults[0].resolve(false);
+          })
+          .then(function() {
+            pair.assertNeither();
+            innerResults[1].resolve(true);
+            return result;
+          })
+          .then(pair.assertCallback);
     });
 
-    it('cannotResolveADeferredWithItself', function() {
-      var deferred = new promise.Deferred();
-      assert.throws(() => deferred.fulfill(deferred));
-      assert.throws(() => deferred.reject(deferred));
+    it('rejectsPromiseIfFunctionReturnsRejectedPromise', function() {
+      return promise.filter([1], function() {
+        return createRejectedPromise(new StubError);
+      }).then(assert.fail, assertIsStubError);
     });
 
-    describe('testLongStackTraces', function() {
-      beforeEach(() => promise.LONG_STACK_TRACES = false);
-      afterEach(() => promise.LONG_STACK_TRACES = false);
-
-      it('doesNotAppendStackIfFeatureDisabled', function() {
-        promise.LONG_STACK_TRACES = false;
-
-        var error = Error('hello');
-        var originalStack = error.stack;
-        return promise.rejected(error).
-            then(fail).
-            then(fail).
-            then(fail).
-            then(fail, function(e) {
-              assert.equal(error, e);
-              assert.equal(originalStack, e.stack);
-            });
+    it('stopsCallingFunctionIfPreviousIterationFailed', function() {
+      var count = 0;
+      return promise.filter([1, 2, 3, 4], function() {
+        count++;
+        if (count == 3) {
+          throw new StubError;
+        }
+      }).then(assert.fail, function(e) {
+        assertIsStubError(e);
+        assert.equal(3, count);
       });
+    });
 
-      function getStackMessages(error) {
-        return error.stack.split(/\n/).filter(function(line) {
-          return /^From: /.test(line);
-        });
-      }
-
-      it('appendsInitialPromiseCreation_resolverThrows', function() {
-        promise.LONG_STACK_TRACES = true;
-
-        var error = Error('hello');
-        var originalStack = '(placeholder; will be overwritten later)';
-
-        return new promise.Promise(function() {
-          try {
-            throw error;
-          } catch (e) {
-            originalStack = e.stack;
-            throw e;
-          }
-        }).then(fail, function(e) {
-          assert.strictEqual(error, e);
-          if (typeof originalStack !== 'string') {
-            return;
-          }
-          assert.notEqual(originalStack, e.stack);
-          assert.equal(e.stack.indexOf(originalStack), 0,
-              'should start with original stack');
-          assert.deepEqual(['From: ManagedPromise: new'], getStackMessages(e));
-        });
-      });
+    it('rejectsWithFirstRejectedPromise', function() {
+      var innerResult = [
+        Promise.resolve(),
+        createRejectedPromise(new StubError),
+        createRejectedPromise(Error('should be ignored'))
+      ];
+
+      return promise.filter([1, 2, 3, 4], function(value, index) {
+        assert.ok(index < innerResult.length);
+        return innerResult[index];
+      }).then(assert.fail, assertIsStubError);
+    });
 
-      it('appendsInitialPromiseCreation_rejectCalled', function() {
-        promise.LONG_STACK_TRACES = true;
-
-        var error = Error('hello');
-        var originalStack = error.stack;
-
-        return new promise.Promise(function(_, reject) {
-          reject(error);
-        }).then(fail, function(e) {
-          assert.equal(error, e);
-          if (typeof originalStack !== 'string') {
-            return;
-          }
-          assert.notEqual(originalStack, e.stack);
-          assert.equal(e.stack.indexOf(originalStack), 0,
-              'should start with original stack');
-          assert.deepEqual(['From: ManagedPromise: new'], getStackMessages(e));
-        });
+    it('preservesOrderWhenFilterReturnsPromise', function() {
+      var deferreds = [
+        defer(),
+        defer(),
+        defer(),
+        defer()
+      ];
+      var result = promise.filter([0, 1, 2, 3], function(value, index) {
+        return deferreds[index].promise;
       });
 
-      it('appendsEachStepToRejectionError', function() {
-        promise.LONG_STACK_TRACES = true;
-
-        var error = Error('hello');
-        var originalStack = '(placeholder; will be overwritten later)';
-
-        return new promise.Promise(function() {
-          try {
-            throw error;
-          } catch (e) {
-            originalStack = e.stack;
-            throw e;
-          }
-        }).
-        then(fail).
-        catch(function(e) { throw e; }).
-        then(fail).
-        catch(function(e) { throw e; }).
-        then(fail, function(e) {
-          assert.equal(error, e);
-          if (typeof originalStack !== 'string') {
-            return;
-          }
-          assert.notEqual(originalStack, e.stack);
-          assert.equal(e.stack.indexOf(originalStack), 0,
-              'should start with original stack');
-          assert.deepEqual([
-            'From: ManagedPromise: new',
-            'From: Promise: then',
-            'From: Promise: catch',
-            'From: Promise: then',
-            'From: Promise: catch',
-          ], getStackMessages(e));
-        });
+      var pair = callbackPair(function(value) {
+        assert.deepEqual([1, 2], value);
       });
+      result = result.then(pair.callback, pair.errback);
 
-      it('errorOccursInCallbackChain', function() {
-        promise.LONG_STACK_TRACES = true;
-
-        var error = Error('hello');
-        var originalStack = '(placeholder; will be overwritten later)';
-
-        return promise.fulfilled().
-            then(function() {}).
-            then(function() {}).
-            then(function() {
-              try {
-                throw error;
-              } catch (e) {
-                originalStack = e.stack;
-                throw e;
-              }
-            }).
-            catch(function(e) { throw e; }).
-            then(fail, function(e) {
-              assert.equal(error, e);
-              if (typeof originalStack !== 'string') {
-                return;
-              }
-              assert.notEqual(originalStack, e.stack);
-              assert.equal(e.stack.indexOf(originalStack), 0,
-                  'should start with original stack');
-              assert.deepEqual([
-                'From: Promise: then',
-                'From: Promise: catch',
-              ], getStackMessages(e));
-            });
-      });
+      return NativePromise.resolve()
+          .then(function() {
+            pair.assertNeither();
+            for (let i = deferreds.length - 1; i >= 0; i -= 1) {
+              deferreds[i].resolve(i > 0 && i < 3);
+            }
+            return result;
+          }).then(pair.assertCallback);
     });
   });
-
-  it('testAddThenableImplementation', function() {
-    function tmp() {}
-    assert.ok(!promise.Thenable.isImplementation(new tmp()));
-    promise.Thenable.addImplementation(tmp);
-    assert.ok(promise.Thenable.isImplementation(new tmp()));
-
-    class tmpClass {}
-    assert.ok(!promise.Thenable.isImplementation(new tmpClass()));
-    promise.Thenable.addImplementation(tmpClass);
-    assert.ok(promise.Thenable.isImplementation(new tmpClass()));
-  });
 });