Bump version to 3.3.0

Add api docs for .not and .withContext
Merge branch 'expect-context'
2018-10-25 09:47:09 -07:00 · 2018-10-24 16:49:31 -07:00 · 2018-10-24 16:32:28 -07:00 · 2018-10-24 16:17:30 -07:00 · 2018-10-23 16:02:31 -07:00 · 2018-10-22 16:42:36 -07:00
44 changed files with 2471 additions and 930 deletions
--- a/README.md
+++ b/README.md
@@ -2,6 +2,7 @@

 [![Build Status](https://travis-ci.org/jasmine/jasmine.svg?branch=master)](https://travis-ci.org/jasmine/jasmine)
 [![Open Source Helpers](https://www.codetriage.com/jasmine/jasmine/badges/users.svg)](https://www.codetriage.com/jasmine/jasmine)
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fjasmine%2Fjasmine.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fjasmine%2Fjasmine?ref=badge_shield)

 # A JavaScript Testing Framework

@@ -75,3 +76,7 @@ Jasmine tests itself across many browsers (Safari, Chrome, Firefox, PhantomJS, M
 * Sheel Choksi

 Copyright (c) 2008-2018 Pivotal Labs. This software is licensed under the MIT License.
+
+
+## License
+[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fjasmine%2Fjasmine.svg?type=large)](https://app.fossa.io/projects/git%2Bgithub.com%2Fjasmine%2Fjasmine?ref=badge_large)
--- a/lib/jasmine-core/boot.js
+++ b/lib/jasmine-core/boot.js
@@ -73,24 +73,21 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  var filterSpecs = !!queryString.getParam("spec");

-  var stoppingOnSpecFailure = queryString.getParam("failFast");
-  env.stopOnSpecFailure(stoppingOnSpecFailure);
-
-  var throwingExpectationFailures = queryString.getParam("throwFailures");
-  env.throwOnExpectationFailure(throwingExpectationFailures);
-  
-  var hideDisabled = queryString.getParam("hideDisabled");
-  env.hideDisabled(hideDisabled); 
+  var config = {
+    failFast: queryString.getParam("failFast"),
+    oneFailurePerSpec: queryString.getParam("oneFailurePerSpec"),
+    hideDisabled: queryString.getParam("hideDisabled")
+  };

  var random = queryString.getParam("random");

  if (random !== undefined && random !== "") {
-    env.randomizeTests(random);
+    config.random = random;
  }

  var seed = queryString.getParam("seed");
  if (seed) {
-    env.seed(seed);
+    config.seed = seed;
  }

  /**
@@ -121,10 +118,12 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    filterString: function() { return queryString.getParam("spec"); }
  });

-  env.specFilter = function(spec) {
+  config.specFilter = function(spec) {
    return specFilter.matches(spec.getFullName());
  };

+  env.configure(config);
+
  /**
   * Setting up timing functions to be able to be overridden. Certain browsers (Safari, IE 8, phantomjs) require this hack.
   */
--- a/lib/jasmine-core/boot/boot.js
+++ b/lib/jasmine-core/boot/boot.js
@@ -51,24 +51,21 @@

  var filterSpecs = !!queryString.getParam("spec");

-  var stoppingOnSpecFailure = queryString.getParam("failFast");
-  env.stopOnSpecFailure(stoppingOnSpecFailure);
-
-  var throwingExpectationFailures = queryString.getParam("throwFailures");
-  env.throwOnExpectationFailure(throwingExpectationFailures);
-  
-  var hideDisabled = queryString.getParam("hideDisabled");
-  env.hideDisabled(hideDisabled); 
+  var config = {
+    failFast: queryString.getParam("failFast"),
+    oneFailurePerSpec: queryString.getParam("oneFailurePerSpec"),
+    hideDisabled: queryString.getParam("hideDisabled")
+  };

  var random = queryString.getParam("random");

  if (random !== undefined && random !== "") {
-    env.randomizeTests(random);
+    config.random = random;
  }

  var seed = queryString.getParam("seed");
  if (seed) {
-    env.seed(seed);
+    config.seed = seed;
  }

  /**
@@ -99,10 +96,12 @@
    filterString: function() { return queryString.getParam("spec"); }
  });

-  env.specFilter = function(spec) {
+  config.specFilter = function(spec) {
    return specFilter.matches(spec.getFullName());
  };

+  env.configure(config);
+
  /**
   * Setting up timing functions to be able to be overridden. Certain browsers (Safari, IE 8, phantomjs) require this hack.
   */
--- a/lib/jasmine-core/jasmine-html.js
+++ b/lib/jasmine-core/jasmine-html.js
@@ -80,7 +80,7 @@ jasmineRequire.HtmlReporter = function(j$) {


  function HtmlReporter(options) {
-    var env = options.env || {},
+    var config = function() { return (options.env && options.env.configuration()) || {}; },
      getContainer = options.getContainer,
      createElement = options.createElement,
      createTextNode = options.createTextNode,
@@ -167,9 +167,9 @@ jasmineRequire.HtmlReporter = function(j$) {

    this.resultStatus = function(status) {
      if(status === 'excluded') {
-        return env.hidingDisabled() ?  'jasmine-excluded-no-display' : 'jasmine-excluded';
-      } 
-      return 'jasmine-' + status; 
+        return config().hideDisabled ? 'jasmine-excluded-no-display' : 'jasmine-excluded';
+      }
+      return 'jasmine-' + status;
    };

    this.jasmineDone = function(doneResult) {
@@ -179,7 +179,7 @@ jasmineRequire.HtmlReporter = function(j$) {
      var i;
      alert.appendChild(createDom('span', {className: 'jasmine-duration'}, 'finished in ' + timer.elapsed() / 1000 + 's'));

-      banner.appendChild(optionsMenu(env));
+      banner.appendChild(optionsMenu(config()));

      if (stateBuilder.specsExecuted < totalSpecsDefined) {
        var skippedMessage = 'Ran ' + stateBuilder.specsExecuted + ' of ' + totalSpecsDefined + ' specs - run all';
@@ -339,7 +339,7 @@ jasmineRequire.HtmlReporter = function(j$) {
      }
    }

-    function optionsMenu(env) {
+    function optionsMenu(config) {
      var optionsMenuDom = createDom('div', { className: 'jasmine-run-options' },
        createDom('span', { className: 'jasmine-trigger' }, 'Options'),
        createDom('div', { className: 'jasmine-payload' },
@@ -375,27 +375,27 @@ jasmineRequire.HtmlReporter = function(j$) {
      );

      var failFastCheckbox = optionsMenuDom.querySelector('#jasmine-fail-fast');
-      failFastCheckbox.checked = env.stoppingOnSpecFailure();
+      failFastCheckbox.checked = config.failFast;
      failFastCheckbox.onclick = function() {
-        navigateWithNewParam('failFast', !env.stoppingOnSpecFailure());
+        navigateWithNewParam('failFast', !config.failFast);
      };

      var throwCheckbox = optionsMenuDom.querySelector('#jasmine-throw-failures');
-      throwCheckbox.checked = env.throwingExpectationFailures();
+      throwCheckbox.checked = config.oneFailurePerSpec;
      throwCheckbox.onclick = function() {
-        navigateWithNewParam('throwFailures', !env.throwingExpectationFailures());
+        navigateWithNewParam('throwFailures', !config.oneFailurePerSpec);
      };

      var randomCheckbox = optionsMenuDom.querySelector('#jasmine-random-order');
-      randomCheckbox.checked = env.randomTests();
+      randomCheckbox.checked = config.random;
      randomCheckbox.onclick = function() {
-        navigateWithNewParam('random', !env.randomTests());
+        navigateWithNewParam('random', !config.random);
      };

      var hideDisabled = optionsMenuDom.querySelector('#jasmine-hide-disabled');
-      hideDisabled.checked = env.hidingDisabled();
+      hideDisabled.checked = config.hideDisabled;
      hideDisabled.onclick = function() {
-        navigateWithNewParam('hideDisabled', !env.hidingDisabled());
+        navigateWithNewParam('hideDisabled', !config.hideDisabled);
      };

      var optionsTrigger = optionsMenuDom.querySelector('.jasmine-trigger'),
--- a/lib/jasmine-core/jasmine.css
+++ b/lib/jasmine-core/jasmine.css
@@ -1,3 +1,4 @@
+@charset "UTF-8";
 body { overflow-y: scroll; }

 .jasmine_html-reporter { background-color: #eee; padding: 5px; margin: -8px; font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333; }
@@ -15,16 +16,16 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-symbol-summary { overflow: hidden; *zoom: 1; margin: 14px 0; }
 .jasmine_html-reporter .jasmine-symbol-summary li { display: inline-block; height: 10px; width: 14px; font-size: 16px; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-passed { font-size: 14px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-passed:before { color: #007069; content: "\02022"; }
+.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-passed:before { color: #007069; content: "•"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed { line-height: 9px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed:before { color: #ca3a11; content: "\d7"; font-weight: bold; margin-left: -1px; }
+.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed:before { color: #ca3a11; content: "×"; font-weight: bold; margin-left: -1px; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-excluded { font-size: 14px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-excluded:before { color: #bababa; content: "\02022"; }
+.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-excluded:before { color: #bababa; content: "•"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-excluded-no-display { font-size: 14px; display: none; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-pending { line-height: 17px; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-pending:before { color: #ba9d37; content: "*"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-empty { font-size: 14px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-empty:before { color: #ba9d37; content: "\02022"; }
+.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-empty:before { color: #ba9d37; content: "•"; }
 .jasmine_html-reporter .jasmine-run-options { float: right; margin-right: 5px; border: 1px solid #8a4182; color: #8a4182; position: relative; line-height: 20px; }
 .jasmine_html-reporter .jasmine-run-options .jasmine-trigger { cursor: pointer; padding: 8px 16px; }
 .jasmine_html-reporter .jasmine-run-options .jasmine-payload { position: absolute; display: none; right: -1px; border: 1px solid #8a4182; background-color: #eee; white-space: nowrap; padding: 4px 8px; }
@@ -49,6 +50,11 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-empty a { color: #ba9d37; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-pending a { color: #ba9d37; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-excluded a { color: #bababa; }
+.jasmine_html-reporter .jasmine-specs li.jasmine-passed a:before { content: "• "; }
+.jasmine_html-reporter .jasmine-specs li.jasmine-failed a:before { content: "× "; }
+.jasmine_html-reporter .jasmine-specs li.jasmine-empty a:before { content: "* "; }
+.jasmine_html-reporter .jasmine-specs li.jasmine-pending a:before { content: "• "; }
+.jasmine_html-reporter .jasmine-specs li.jasmine-excluded a:before { content: "• "; }
 .jasmine_html-reporter .jasmine-description + .jasmine-suite { margin-top: 0; }
 .jasmine_html-reporter .jasmine-suite { margin-top: 14px; }
 .jasmine_html-reporter .jasmine-suite a { color: #333; }
--- a/lib/jasmine-core/jasmine.js
+++ b/lib/jasmine-core/jasmine.js
--- a/lib/jasmine-core/version.rb
+++ b/lib/jasmine-core/version.rb
@@ -4,6 +4,6 @@
 #
 module Jasmine
  module Core
-    VERSION = "3.2.0"
+    VERSION = "3.3.0"
  end
 end
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
  "name": "jasmine-core",
  "license": "MIT",
-  "version": "3.2.0",
+  "version": "3.3.0",
  "repository": {
    "type": "git",
    "url": "https://github.com/jasmine/jasmine.git"
@@ -16,7 +16,7 @@
    "test": "grunt jshint execSpecsInNode"
  },
  "description": "Official packaging of Jasmine's core files for use by Node.js projects.",
-  "homepage": "http://jasmine.github.io",
+  "homepage": "https://jasmine.github.io",
  "main": "./lib/jasmine-core.js",
  "devDependencies": {
    "glob": "~7.1.2",
--- a/release_notes/3.2.1.md
+++ b/release_notes/3.2.1.md
@@ -0,0 +1,11 @@
+# Jasmine-Core 3.2.1 Release Notes
+
+## Changes
+
+* Correctly expose `spyOnAllFunctions`
+  - See [#1581](https://github.com/jasmine/jasmine/issues/1581)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_
--- a/release_notes/3.3.0.md
+++ b/release_notes/3.3.0.md
@@ -0,0 +1,47 @@
+# Jasmine Core 3.3 Release Notes
+
+## Summary
+
+This release includes a new way to configure Jasmine, the ability to provide additional
+context with your expectations, and other things
+
+## Changes
+
+* Added expect().withContext() to provide additional information in failure messages
+* Implement `withContext` for async expectations too
+  - Fixes [#641](https://github.com/jasmine/jasmine/issues/641)
+
+* New asynchronous matcher `toBeRejectedWith`
+  - Merges [#1615](https://github.com/jasmine/jasmine/issues/1615) from @codymikol
+  - Closes [#1600](https://github.com/jasmine/jasmine/issues/1600)
+  - Fixes [#1595](https://github.com/jasmine/jasmine/issues/1595)
+
+* Show a tip for `toBe` failures for how to get deep equality
+  - Merges [#1616](https://github.com/jasmine/jasmine/issues/1616) from @tdurtshi
+  - Fixes [#1614](https://github.com/jasmine/jasmine/issues/1614)
+
+* `expectAsync` now works with non-native promies
+  - Merges [#1613](https://github.com/jasmine/jasmine/issues/1613) from @codymikol
+  - Fixes [#1612](https://github.com/jasmine/jasmine/issues/1612)
+
+
+* Show status marks next to spec description in HTML reporter
+  - Merges [#1610](https://github.com/jasmine/jasmine/issues/1610) from @m1010j
+  - Fixes [#1596](https://github.com/jasmine/jasmine/issues/1596)
+
+* Show error messages for `Error`s without a name
+  - Merges [#1601](https://github.com/jasmine/jasmine/issues/1601) from @nitobuendia
+  - Fixes [#1594](https://github.com/jasmine/jasmine/issues/1594)
+
+* Optimized clearTimeout cpu usage
+  - Merges [#1599](https://github.com/jasmine/jasmine/issues/1599) from @Havunen
+
+* Introduce a configuration object to `Env` deprecating old single use functions
+  - [finishes #159158038](http://www.pivotaltracker.com/story/159158038)
+
+* Specify https for github urls in package.json
+  - Merges [#1597](https://github.com/jasmine/jasmine/issues/1597) @limonte
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_
--- a/spec/core/AsyncExpectationSpec.js
+++ b/spec/core/AsyncExpectationSpec.js
@@ -1,235 +1,39 @@
 describe('AsyncExpectation', function() {
+  beforeEach(function() {
+    jasmineUnderTest.Expectation.addAsyncCoreMatchers(jasmineUnderTest.asyncMatchers);
+  });
+
  describe('Factory', function() {
    it('throws an Error if promises are not available', function() {
      var thenable = {then: function() {}},
        options = {global: {}, actual: thenable}
-      function f() { jasmineUnderTest.AsyncExpectation.factory(options); }
+      function f() { jasmineUnderTest.Expectation.asyncFactory(options); }
      expect(f).toThrowError('expectAsync is unavailable because the environment does not support promises.');
    });

    it('throws an Error if the argument is not a promise', function() {
      jasmine.getEnv().requirePromises();
      function f() {
-        jasmineUnderTest.AsyncExpectation.factory({actual: 'not a promise'});
+        jasmineUnderTest.Expectation.asyncFactory({actual: 'not a promise'});
      }
      expect(f).toThrowError('Expected expectAsync to be called with a promise.');
    });
  });

-  describe('#toBeResolved', function() {
-    it('passes if the actual is resolved', function() {
-      jasmine.getEnv().requirePromises();
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = Promise.resolve(),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeResolved().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(true, {
-          matcherName: 'toBeResolved',
-          passed: true,
-          message: '',
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-
-    it('fails if the actual is rejected', function() {
-      jasmine.getEnv().requirePromises();
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = Promise.reject('AsyncExpectationSpec rejection'),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeResolved().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false, {
-          matcherName: 'toBeResolved',
-          passed: false,
-          message: 'Expected a promise to be resolved.',
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-  });
-
-  describe('#toBeRejected', function() {
-    it('passes if the actual is rejected', function() {
-      jasmine.getEnv().requirePromises();
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = Promise.reject('AsyncExpectationSpec rejection'),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeRejected().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(true, {
-          matcherName: 'toBeRejected',
-          passed: true,
-          message: '',
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-
-    it('fails if the actual is resolved', function() {
-      jasmine.getEnv().requirePromises();
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = Promise.resolve(),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeRejected().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false, {
-          matcherName: 'toBeRejected',
-          passed: false,
-          message: 'Expected a promise to be rejected.',
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-  });
-
-  describe('#toBeResolvedTo', function() {
-    it('passes if the promise is resolved to the expected value', function() {
-      jasmine.getEnv().requirePromises();
-
-      var actual = Promise.resolve({foo: 42});
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeResolvedTo({foo: 42}).then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(true, {
-          matcherName: 'toBeResolvedTo',
-          passed: true,
-          message: '',
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-
-    it('fails if the promise is rejected', function() {
-      jasmine.getEnv().requirePromises();
-
-      var actual = Promise.reject('AsyncExpectationSpec error');
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeResolvedTo('').then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false, {
-          matcherName: 'toBeResolvedTo',
-          passed: false,
-          message: "Expected a promise to be resolved to '' but it was rejected.",
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-
-    it('fails if the promise is resolved to a different value', function() {
-      jasmine.getEnv().requirePromises();
-
-      var actual = Promise.resolve({foo: 17});
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          actual: actual,
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeResolvedTo({foo: 42}).then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false, {
-          matcherName: 'toBeResolvedTo',
-          passed: false,
-          message: 'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).',
-          error: undefined,
-          errorForStack: jasmine.any(Error),
-          actual: actual
-        });
-      });
-    });
-
-    it('builds its message correctly when negated', function() {
-      jasmine.getEnv().requirePromises();
-
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        expectation = jasmineUnderTest.AsyncExpectation.factory({
-          util: jasmineUnderTest.matchersUtil,
-          actual: Promise.resolve(true),
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.not.toBeResolvedTo(true).then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false,
-          jasmine.objectContaining({
-            passed: false,
-            message: 'Expected a promise not to be resolved to true.'
-          })
-        );
-      });
-    });
-
-    it('supports custom equality testers', function() {
-      jasmine.getEnv().requirePromises();
-
-      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        expectation = new jasmineUnderTest.AsyncExpectation({
-          util: jasmineUnderTest.matchersUtil,
-          customEqualityTesters: [function() { return true; }],
-          actual: Promise.resolve('actual'),
-          addExpectationResult: addExpectationResult
-        });
-
-      return expectation.toBeResolvedTo('expected').then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(true,
-          jasmine.objectContaining({passed: true}));
-      });
-    });
-  });
-  
  describe('#not', function() {
    it('converts a pass to a fail', function() {
      jasmine.getEnv().requirePromises();

      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
        actual = Promise.resolve(),
-        expectation = jasmineUnderTest.AsyncExpectation.factory({
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
          util: jasmineUnderTest.matchersUtil,
          actual: actual,
          addExpectationResult: addExpectationResult
        });

      return expectation.not.toBeResolved().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false, 
+        expect(addExpectationResult).toHaveBeenCalledWith(false,
          jasmine.objectContaining({
            passed: false,
            message: 'Expected a promise not to be resolved.'
@@ -243,14 +47,14 @@ describe('AsyncExpectation', function() {

      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
        actual = Promise.reject(),
-        expectation = jasmineUnderTest.AsyncExpectation.factory({
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
          util: jasmineUnderTest.matchersUtil,
          actual: actual,
          addExpectationResult: addExpectationResult
        });

      return expectation.not.toBeResolved().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(true, 
+        expect(addExpectationResult).toHaveBeenCalledWith(true,
          jasmine.objectContaining({
            passed: true,
            message: ''
@@ -262,18 +66,19 @@ describe('AsyncExpectation', function() {

  it('propagates rejections from the comparison function', function() {
    jasmine.getEnv().requirePromises();
-    var error = new Error('AsyncExpectationSpec failure');
+    var error = new Error('ExpectationSpec failure');

-    spyOn(jasmineUnderTest.AsyncExpectation.prototype, 'toBeResolved')
-      .and.returnValue(Promise.reject(error));

    var addExpectationResult = jasmine.createSpy('addExpectationResult'),
      actual = dummyPromise(),
-      expectation = new jasmineUnderTest.AsyncExpectation({
+      expectation = jasmineUnderTest.Expectation.asyncFactory({
        actual: actual,
        addExpectationResult: addExpectationResult
      });

+    spyOn(expectation, 'toBeResolved')
+      .and.returnValue(Promise.reject(error));
+
    return expectation.toBeResolved()
      .then(
        function() { fail('Expected a rejection'); },
@@ -281,6 +86,121 @@ describe('AsyncExpectation', function() {
      );
  });

+  describe('#withContext', function() {
+    it("prepends the context to the generated failure message", function() {
+      jasmine.getEnv().requirePromises();
+
+      var util = {
+          buildFailureMessage: function() { return 'failure message'; }
+        },
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
+          actual: Promise.reject('rejected'),
+          addExpectationResult: addExpectationResult,
+          util: util
+        });
+
+      return expectation.withContext('Some context').toBeResolved()
+        .then(
+          function() {
+            expect(addExpectationResult).toHaveBeenCalledWith(false,
+              jasmine.objectContaining({
+                message: 'Some context: failure message'
+              }));
+          });
+    });
+
+    it("prepends the context to a custom failure message", function() {
+      jasmine.getEnv().requirePromises();
+
+      var util = {
+          buildFailureMessage: function() { return 'failure message'; }
+        },
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
+          actual: Promise.reject('b'),
+          addExpectationResult: addExpectationResult,
+          util: util
+        });
+
+      return expectation.withContext('Some context').toBeResolvedTo('a')
+        .then(
+          function() {
+            expect(addExpectationResult).toHaveBeenCalledWith(false,
+              jasmine.objectContaining({
+                message: "Some context: Expected a promise to be resolved to 'a' but it was rejected."
+              }));
+          });
+    });
+
+    it("prepends the context to a custom failure message from a function", function() {
+      pending('should actually work, but no custom matchers for async yet');
+      jasmine.getEnv().requirePromises();
+
+      var util = {
+          buildFailureMessage: function() { return 'failure message'; }
+        },
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        actual = Promise.reject(),
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
+          actual: actual,
+          addExpectationResult: addExpectationResult,
+          util: util
+        });
+
+      return expectation.withContext('Some context').toBeResolved()
+        .then(
+          function() {
+            expect(addExpectationResult).toHaveBeenCalledWith(false,
+              jasmine.objectContaining({
+                message: 'Some context: msg'
+              }));
+          });
+    });
+
+    it("works with #not", function() {
+      jasmine.getEnv().requirePromises();
+
+      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        actual = Promise.resolve(),
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
+          actual: actual,
+          addExpectationResult: addExpectationResult,
+          util: jasmineUnderTest.matchersUtil
+        });
+
+      return expectation.withContext('Some context').not.toBeResolved()
+        .then(
+          function() {
+            expect(addExpectationResult).toHaveBeenCalledWith(false,
+              jasmine.objectContaining({
+                message: 'Some context: Expected a promise not to be resolved.'
+              }));
+          });
+    });
+
+    it("works with #not and a custom message", function() {
+      jasmine.getEnv().requirePromises();
+
+      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        actual = Promise.resolve('a'),
+        expectation = jasmineUnderTest.Expectation.asyncFactory({
+          actual: actual,
+          addExpectationResult: addExpectationResult,
+          util: jasmineUnderTest.matchersUtil
+        });
+
+      return expectation.withContext('Some context').not.toBeResolvedTo('a')
+        .then(
+          function() {
+            expect(addExpectationResult).toHaveBeenCalledWith(false,
+              jasmine.objectContaining({
+                message: "Some context: Expected a promise not to be resolved to 'a'."
+              }));
+          });
+    });
+  });
+
  function dummyPromise() {
    return new Promise(function(resolve, reject) {
    });
--- a/spec/core/EnvSpec.js
+++ b/spec/core/EnvSpec.js
@@ -27,7 +27,7 @@ describe("Env", function() {
  });

  it('can configure specs to throw errors on expectation failures', function() {
-    env.throwOnExpectationFailure(true);
+    env.configure({oneFailurePerSpec: true});

    spyOn(jasmineUnderTest, 'Spec');
    env.it('foo', function() {});
@@ -37,7 +37,7 @@ describe("Env", function() {
  });

  it('can configure suites to throw errors on expectation failures', function() {
-    env.throwOnExpectationFailure(true);
+    env.configure({oneFailurePerSpec: true});

    spyOn(jasmineUnderTest, 'Suite');
    env.describe('foo', function() {});
@@ -46,6 +46,22 @@ describe("Env", function() {
    }));
  });

+  it('defaults to multiple failures for specs', function() {
+    spyOn(jasmineUnderTest, 'Spec');
+      env.it('bar', function() {});
+    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(jasmine.objectContaining({
+      throwOnExpectationFailure: false
+    }));
+  });
+
+  it('defaults to multiple failures for suites', function() {
+    spyOn(jasmineUnderTest, 'Suite');
+    env.describe('foo', function() {});
+    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(jasmine.objectContaining({
+      throwOnExpectationFailure: false
+    }));
+  });
+
  describe('#describe', function () {
    it("throws an error when given arguments", function() {
      expect(function() {
--- a/spec/core/ExceptionFormatterSpec.js
+++ b/spec/core/ExceptionFormatterSpec.js
@@ -37,6 +37,28 @@ describe("ExceptionFormatter", function() {
      expect(message).toEqual('A Classic Mistake: you got your foo in my bar');
    });

+    it('formats unnamed exceptions with message', function() {
+      var unnamedError = {message: 'This is an unnamed error message.'};
+
+      var exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
+          message = exceptionFormatter.message(unnamedError);
+
+      expect(message).toEqual('This is an unnamed error message.');
+    });
+
+    it('formats empty exceptions with toString format', function() {
+      var EmptyError = function() {};
+      EmptyError.prototype.toString = function() {
+        return '[EmptyError]';
+      };
+      var emptyError = new EmptyError();
+
+      var exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
+          message = exceptionFormatter.message(emptyError);
+
+      expect(message).toEqual('[EmptyError] thrown');
+    });
+
    it("formats thrown exceptions that aren't errors", function() {
      var thrown = "crazy error",
          exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
--- a/spec/core/ExpectationFilterChainSpec.js
+++ b/spec/core/ExpectationFilterChainSpec.js
@@ -0,0 +1,113 @@
+describe('ExpectationFilterChain', function() {
+  describe('#addFilter', function() {
+    it('returns a new filter chain with the added filter', function() {
+      var first = jasmine.createSpy('first'),
+        second = jasmine.createSpy('second'),
+        orig = new jasmineUnderTest.ExpectationFilterChain({
+          modifyFailureMessage: first
+        }),
+        added = orig.addFilter({selectComparisonFunc: second});
+
+      added.modifyFailureMessage();
+      expect(first).toHaveBeenCalled();
+      added.selectComparisonFunc();
+      expect(second).toHaveBeenCalled();
+    });
+
+    it('does not modify the original filter chain', function() {
+      var orig = new jasmineUnderTest.ExpectationFilterChain({}),
+        f = jasmine.createSpy('f');
+
+      orig.addFilter({selectComparisonFunc: f});
+
+      orig.selectComparisonFunc();
+      expect(f).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('#selectComparisonFunc', function() {
+    describe('When no filters have #selectComparisonFunc', function() {
+      it('returns undefined', function() {
+        var chain = new jasmineUnderTest.ExpectationFilterChain();
+        chain.addFilter({});
+        expect(chain.selectComparisonFunc()).toBeUndefined();
+      });
+    });
+
+    describe('When some filters have #selectComparisonFunc', function() {
+      it('calls the first filter that has #selectComparisonFunc', function() {
+        var first = jasmine.createSpy('first').and.returnValue('first'),
+          second = jasmine.createSpy('second').and.returnValue('second'),
+          chain = new jasmineUnderTest.ExpectationFilterChain()
+            .addFilter({selectComparisonFunc: first})
+            .addFilter({selectComparisonFunc: second}),
+          matcher = {},
+          result;
+
+        result = chain.selectComparisonFunc(matcher);
+
+        expect(first).toHaveBeenCalledWith(matcher);
+        expect(second).not.toHaveBeenCalled();
+        expect(result).toEqual('first');
+      });
+    });
+  });
+
+  describe('#buildFailureMessage', function() {
+    describe('When no filters have #buildFailureMessage', function() {
+      it('returns undefined', function() {
+        var chain = new jasmineUnderTest.ExpectationFilterChain();
+        chain.addFilter({});
+        expect(chain.buildFailureMessage()).toBeUndefined();
+      });
+    });
+
+    describe('When some filters have #buildFailureMessage', function() {
+      it('calls the first filter that has #buildFailureMessage', function() {
+        var first = jasmine.createSpy('first').and.returnValue('first'),
+          second = jasmine.createSpy('second').and.returnValue('second'),
+          chain = new jasmineUnderTest.ExpectationFilterChain()
+            .addFilter({buildFailureMessage: first})
+            .addFilter({buildFailureMessage: second}),
+          matcherResult = {pass: false},
+          matcherName = 'foo',
+          args = [],
+          util = {},
+          result;
+
+        result = chain.buildFailureMessage(matcherResult, matcherName, args, util);
+
+        expect(first).toHaveBeenCalledWith(matcherResult, matcherName, args, util);
+        expect(second).not.toHaveBeenCalled();
+        expect(result).toEqual('first');
+      });
+    });
+  });
+
+  describe('#modifyFailureMessage', function() {
+    describe('When no filters have #modifyFailureMessage', function() {
+      it('returns the original message', function() {
+        var chain = new jasmineUnderTest.ExpectationFilterChain();
+        chain.addFilter({});
+        expect(chain.modifyFailureMessage('msg')).toEqual('msg');
+      });
+    });
+
+    describe('When some filters have #modifyFailureMessage', function() {
+      it('calls the first filter that has #modifyFailureMessage', function() {
+        var first = jasmine.createSpy('first').and.returnValue('first'),
+          second = jasmine.createSpy('second').and.returnValue('second'),
+          chain = new jasmineUnderTest.ExpectationFilterChain()
+            .addFilter({modifyFailureMessage: first})
+            .addFilter({modifyFailureMessage: second}),
+          result;
+
+        result = chain.modifyFailureMessage('original');
+
+        expect(first).toHaveBeenCalledWith('original');
+        expect(second).not.toHaveBeenCalled();
+        expect(result).toEqual('first');
+      });
+    });
+  });
+});
--- a/spec/core/ExpectationSpec.js
+++ b/spec/core/ExpectationSpec.js
@@ -6,7 +6,7 @@ describe("Expectation", function() {
      },
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers
    });

@@ -22,31 +22,25 @@ describe("Expectation", function() {

    jasmineUnderTest.Expectation.addCoreMatchers(coreMatchers);

-    expectation = new jasmineUnderTest.Expectation({});
+    expectation = jasmineUnderTest.Expectation.factory({});

    expect(expectation.toQuux).toBeDefined();
  });

-  it("Factory builds an expectation/negative expectation", function() {
-    var builtExpectation = jasmineUnderTest.Expectation.Factory();
-
-    expect(builtExpectation instanceof jasmineUnderTest.Expectation).toBe(true);
-    expect(builtExpectation.not instanceof jasmineUnderTest.Expectation).toBe(true);
-    expect(builtExpectation.not.isNot).toBe(true);
-  });
-
  it("wraps matchers's compare functions, passing in matcher dependencies", function() {
    var fakeCompare = function() { return { pass: true }; },
      matcherFactory = jasmine.createSpy("matcher").and.returnValue({ compare: fakeCompare }),
      matchers = {
        toFoo: matcherFactory
      },
-      util = {},
+      util = {
+        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
+      },
      customEqualityTesters = ['a'],
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      util: util,
      customMatchers: matchers,
      customEqualityTesters: customEqualityTesters,
@@ -74,7 +68,7 @@ describe("Expectation", function() {
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      util: util,
      customMatchers: matchers,
      actual: "an actual",
@@ -100,7 +94,7 @@ describe("Expectation", function() {
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      util: util,
      actual: "an actual",
@@ -115,7 +109,8 @@ describe("Expectation", function() {
      message: "",
      error: undefined,
      expected: "hello",
-      actual: "an actual"
+      actual: "an actual",
+      errorForStack: undefined
    });
  });

@@ -133,7 +128,7 @@ describe("Expectation", function() {
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      util: util,
      actual: "an actual",
@@ -148,7 +143,8 @@ describe("Expectation", function() {
      expected: "hello",
      actual: "an actual",
      message: "",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });

@@ -168,7 +164,7 @@ describe("Expectation", function() {
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      actual: "an actual",
      customMatchers: matchers,
      addExpectationResult: addExpectationResult
@@ -182,7 +178,8 @@ describe("Expectation", function() {
      expected: "hello",
      actual: "an actual",
      message: "I am a custom message",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });

@@ -202,7 +199,7 @@ describe("Expectation", function() {
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      actual: "an actual",
      addExpectationResult: addExpectationResult
@@ -216,7 +213,8 @@ describe("Expectation", function() {
      expected: "hello",
      actual: "an actual",
      message: "I am a custom message",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });

@@ -235,12 +233,11 @@ describe("Expectation", function() {
      actual = "an actual",
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
+      addExpectationResult: addExpectationResult
+    }).not;

    expectation.toFoo("hello");

@@ -250,7 +247,8 @@ describe("Expectation", function() {
      message: "",
      error: undefined,
      expected: "hello",
-      actual: actual
+      actual: actual,
+      errorForStack: undefined
    });
  });

@@ -269,13 +267,12 @@ describe("Expectation", function() {
      actual = "an actual",
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      actual: "an actual",
      util: util,
      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
+    }).not;

    expectation.toFoo("hello");

@@ -285,7 +282,8 @@ describe("Expectation", function() {
      expected: "hello",
      actual: actual,
      message: "default message",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });

@@ -306,12 +304,11 @@ describe("Expectation", function() {
      actual = "an actual",
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
+      addExpectationResult: addExpectationResult
+    }).not;

    expectation.toFoo("hello");

@@ -321,7 +318,8 @@ describe("Expectation", function() {
      expected: "hello",
      actual: actual,
      message: "I am a custom message",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });

@@ -338,12 +336,11 @@ describe("Expectation", function() {
      actual = "an actual",
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
+      addExpectationResult: addExpectationResult
+    }).not;

    expectation.toFoo("hello");

@@ -353,7 +350,8 @@ describe("Expectation", function() {
      expected: "hello",
      actual: actual,
      message: "",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });

@@ -375,12 +373,11 @@ describe("Expectation", function() {
      actual = "an actual",
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      customMatchers: matchers,
      actual: "an actual",
      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
+    }).not;

    expectation.toFoo("hello");

@@ -390,10 +387,11 @@ describe("Expectation", function() {
      expected: "hello",
      actual: actual,
      message: "I'm a custom message",
-      error: undefined
+      error: undefined,
+      errorForStack: undefined
    });
  });
-  
+
  it("reports a custom error message to the spec", function() {
    var customError = new Error("I am a custom error");
    var matchers = {
@@ -412,7 +410,7 @@ describe("Expectation", function() {
      addExpectationResult = jasmine.createSpy("addExpectationResult"),
      expectation;

-    expectation = new jasmineUnderTest.Expectation({
+    expectation = jasmineUnderTest.Expectation.factory({
      actual: "an actual",
      customMatchers: matchers,
      addExpectationResult: addExpectationResult
@@ -426,9 +424,222 @@ describe("Expectation", function() {
      expected: "hello",
      actual: "an actual",
      message: "I am a custom message",
-      error: customError
+      error: customError,
+      errorForStack: undefined
    });
  });

+  it("reports a custom message to the spec when a 'not' comparison fails", function() {
+    var customError = new Error("I am a custom error");
+    var matchers = {
+        toFoo: function() {
+          return {
+            compare: function() {
+              return {
+                pass: true,
+                message: "I am a custom message",
+                error: customError
+              };
+            }
+          };
+        }
+      },
+      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      expectation;
+
+    expectation = jasmineUnderTest.Expectation.factory({
+      actual: "an actual",
+      customMatchers: matchers,
+      addExpectationResult: addExpectationResult
+    }).not;
+
+    expectation.toFoo("hello");
+
+    expect(addExpectationResult).toHaveBeenCalledWith(false, {
+      matcherName: "toFoo",
+      passed: false,
+      expected: "hello",
+      actual: "an actual",
+      message: "I am a custom message",
+      error: customError,
+      errorForStack: undefined
+    });
+  });
+
+  it("reports a custom message func to the spec when a 'not' comparison fails", function() {
+    var customError = new Error("I am a custom error");
+    var matchers = {
+        toFoo: function() {
+          return {
+            compare: function() {
+              return {
+                pass: true,
+                message: function() { return "I am a custom message"; },
+                error: customError
+              };
+            }
+          };
+        }
+      },
+      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      expectation;
+
+    expectation = jasmineUnderTest.Expectation.factory({
+      actual: "an actual",
+      customMatchers: matchers,
+      addExpectationResult: addExpectationResult
+    }).not;
+
+    expectation.toFoo("hello");
+
+    expect(addExpectationResult).toHaveBeenCalledWith(false, {
+      matcherName: "toFoo",
+      passed: false,
+      expected: "hello",
+      actual: "an actual",
+      message: "I am a custom message",
+      error: customError,
+      errorForStack: undefined
+    });
+  });
+
+  describe("#withContext", function() {
+    it("prepends the context to the generated failure message", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() { return { pass: false }; }
+            };
+          }
+        },
+        util = {
+          buildFailureMessage: function() { return "failure message"; }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.factory({
+          customMatchers: matchers,
+          util: util,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+
+      expectation.withContext("Some context").toFoo("hello");
+
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: failure message"
+        })
+      );
+    });
+
+    it("prepends the context to a custom failure message", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() { return { pass: false, message: "msg" }; }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.factory({
+          customMatchers: matchers,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+
+      expectation.withContext("Some context").toFoo("hello");
+
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: msg"
+        })
+      );
+    });
+
+    it("prepends the context to a custom failure message from a function", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() {
+                return {
+                  pass: false,
+                  message: function() { return "msg"; }
+                };
+              }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.factory({
+          customMatchers: matchers,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+
+      expectation.withContext("Some context").toFoo("hello");
+
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: msg"
+        })
+      );
+    });
+
+    it("works with #not", function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() { return { pass: true }; }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.factory({
+          customMatchers: matchers,
+          util: jasmineUnderTest.matchersUtil,
+          actual: "an actual",
+          addExpectationResult: addExpectationResult
+        });
+
+      expectation.withContext("Some context").not.toFoo();
+
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: Expected 'an actual' not to foo."
+        })
+      );
+    });
+
+    it("works with #not and a custom message", function() {
+      var customError = new Error("I am a custom error");
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() {
+                return {
+                  pass: true,
+                  message: function() { return "I am a custom message"; },
+                  error: customError
+                };
+              }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        expectation = jasmineUnderTest.Expectation.factory({
+          actual: "an actual",
+          customMatchers: matchers,
+          addExpectationResult: addExpectationResult
+        });
+
+      expectation.withContext("Some context").not.toFoo("hello");
+
+      expect(addExpectationResult).toHaveBeenCalledWith(false,
+        jasmine.objectContaining({
+          message: "Some context: I am a custom message",
+        })
+      );
+    });
+  });
 });

--- a/spec/core/UtilSpec.js
+++ b/spec/core/UtilSpec.js
@@ -31,6 +31,105 @@ describe("jasmineUnderTest.util", function() {
    });
  });

+  describe("promise utils", function () {
+
+    var mockNativePromise,
+      mockPromiseLikeObject;
+
+    var mockPromiseLike = function () {this.then = function () {};};
+
+    beforeEach(function () {
+      jasmine.getEnv().requirePromises();
+      mockNativePromise = new Promise(function (res, rej) {});
+      mockPromiseLikeObject = new mockPromiseLike();
+    });
+
+    describe("isPromise", function () {
+
+      it("should return true when passed a native promise", function () {
+        expect(jasmineUnderTest.isPromise(mockNativePromise)).toBe(true);
+      });
+
+      it("should return false for promise like objects", function () {
+        expect(jasmineUnderTest.isPromise(mockPromiseLikeObject)).toBe(false);
+      });
+
+      it("should return false for strings", function () {
+        expect(jasmineUnderTest.isPromise("hello")).toBe(false);
+      });
+
+      it("should return false for numbers", function () {
+        expect(jasmineUnderTest.isPromise(3)).toBe(false);
+      });
+
+      it("should return false for null", function () {
+        expect(jasmineUnderTest.isPromise(null)).toBe(false);
+      });
+
+      it("should return false for undefined", function () {
+        expect(jasmineUnderTest.isPromise(undefined)).toBe(false);
+      });
+
+      it("should return false for arrays", function () {
+        expect(jasmineUnderTest.isPromise([])).toBe(false);
+      });
+
+      it("should return false for objects", function () {
+        expect(jasmineUnderTest.isPromise({})).toBe(false);
+      });
+
+      it("should return false for boolean values", function () {
+        expect(jasmineUnderTest.isPromise(true)).toBe(false);
+      });
+
+    });
+
+    describe("isPromiseLike", function () {
+
+      it("should return true when passed a native promise", function () {
+        expect(jasmineUnderTest.isPromiseLike(mockNativePromise)).toBe(true);
+      });
+
+      it("should return  true for promise like objects", function () {
+        expect(jasmineUnderTest.isPromiseLike(mockPromiseLikeObject)).toBe(true);
+      });
+
+      it("should return false if then is not a function", function () {
+        expect(jasmineUnderTest.isPromiseLike({then:{its:"Not a function :O"}})).toBe(false);
+      });
+
+      it("should return false for strings", function () {
+        expect(jasmineUnderTest.isPromiseLike("hello")).toBe(false);
+      });
+
+      it("should return false for numbers", function () {
+        expect(jasmineUnderTest.isPromiseLike(3)).toBe(false);
+      });
+
+      it("should return false for null", function () {
+        expect(jasmineUnderTest.isPromiseLike(null)).toBe(false);
+      });
+
+      it("should return false for undefined", function () {
+        expect(jasmineUnderTest.isPromiseLike(undefined)).toBe(false);
+      });
+
+      it("should return false for arrays", function () {
+        expect(jasmineUnderTest.isPromiseLike([])).toBe(false);
+      });
+
+      it("should return false for objects", function () {
+        expect(jasmineUnderTest.isPromiseLike({})).toBe(false);
+      });
+
+      it("should return false for boolean values", function () {
+        expect(jasmineUnderTest.isPromiseLike(true)).toBe(false);
+      });
+
+    });
+
+  });
+
  describe("isUndefined", function() {
    it("reports if a variable is defined", function() {
      var a;
--- a/spec/core/integration/CustomMatchersSpec.js
+++ b/spec/core/integration/CustomMatchersSpec.js
@@ -4,7 +4,7 @@ describe("Custom Matchers (Integration)", function() {

  beforeEach(function() {
    env = new jasmineUnderTest.Env();
-    env.randomizeTests(false);
+    env.configure({random: false});
  });

  it("allows adding more matchers local to a spec", function(done) {
--- a/spec/core/integration/CustomSpyStrategiesSpec.js
+++ b/spec/core/integration/CustomSpyStrategiesSpec.js
@@ -3,7 +3,7 @@ describe('Custom Spy Strategies (Integration)', function() {

  beforeEach(function() {
    env = new jasmineUnderTest.Env();
-    env.randomizeTests(false);
+    env.configure({random: false});
  });

  it('allows adding more strategies local to a suite', function(done) {
--- a/spec/core/integration/EnvSpec.js
+++ b/spec/core/integration/EnvSpec.js
@@ -17,7 +17,7 @@ describe("Env integration", function() {
    };

    env.addReporter({ jasmineDone: assertions});
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("A Suite", function() {
      env.it("with a spec", function() {
@@ -46,7 +46,7 @@ describe("Env integration", function() {
    };

    env.addReporter({ jasmineDone: assertions });
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("Outer suite", function() {
      env.it("an outer spec", function() {
@@ -81,7 +81,7 @@ describe("Env integration", function() {
    };

    env.addReporter({ jasmineDone: assertions });
-    env.randomizeTests(false);
+    env.configure({random: false});


    env.describe("Outer suite", function() {
@@ -200,7 +200,7 @@ describe("Env integration", function() {
    var env = new jasmineUnderTest.Env();

    env.addReporter({jasmineDone: done});
-    env.randomizeTests(false);
+    env.configure({random: false});
    env.describe("tests", function() {
      var firstTimeThrough = true, firstSpecContext, secondSpecContext;

@@ -783,9 +783,11 @@ describe("Env integration", function() {
      });
    });

-    env.specFilter = function(spec) {
-      return /^first suite/.test(spec.getFullName());
-    };
+    env.configure({
+      specFilter: function(spec) {
+        return /^first suite/.test(spec.getFullName());
+      }
+    });

    env.execute();
  });
@@ -953,7 +955,7 @@ describe("Env integration", function() {
    };

    env.addReporter({ jasmineDone: assertions });
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("tests", function() {
      env.it("test with mock clock", function() {
@@ -1476,8 +1478,7 @@ describe("Env integration", function() {
          "specStarted",
          "specDone"
        ]);
-    env.randomizeTests(true);
-    env.seed('123456');
+    env.configure({random: true, seed: '123456'});

    reporter.jasmineDone.and.callFake(function(doneArg) {
      expect(reporter.jasmineStarted).toHaveBeenCalled();
@@ -1491,7 +1492,7 @@ describe("Env integration", function() {
    });

    env.addReporter(reporter);
-    env.randomizeTests(true);
+    env.configure({random: true});
    env.execute();
  });

@@ -1662,7 +1663,7 @@ describe("Env integration", function() {
    });

    env.addReporter(reporter);
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("testing custom equality testers", function() {
      env.it("with a custom tester", function() {
@@ -1698,7 +1699,7 @@ describe("Env integration", function() {
    });

    env.addReporter(reporter);
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("testing custom equality testers", function() {
      env.beforeAll(function() { env.addCustomEqualityTester(function(a, b) { return true; }); });
@@ -1739,7 +1740,7 @@ describe("Env integration", function() {
    });

    env.addReporter(reporter);
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("testing custom equality testers", function() {
      env.it("with a custom tester", function() {
@@ -1792,7 +1793,7 @@ describe("Env integration", function() {
    });

    env.addReporter(reporter);
-    env.randomizeTests(false);
+    env.configure({random: false});

    env.describe("testing custom equality testers", function() {
      env.beforeAll(function() { env.addCustomEqualityTester(function(a, b) { return true; })});
--- a/spec/core/integration/SpecRunningSpec.js
+++ b/spec/core/integration/SpecRunningSpec.js
@@ -4,7 +4,7 @@ describe("spec running", function () {
  beforeEach(function() {
    jasmine.getEnv().registerIntegrationMatchers();
    env = new jasmineUnderTest.Env();
-    env.randomizeTests(false);
+    env.configure({random: false});
  });

  it('should assign spec ids sequentially', function() {
@@ -740,8 +740,7 @@ describe("spec running", function () {

  it("should run the tests in a consistent order when a seed is supplied", function(done) {
    var actions = [];
-    env.seed('123456');
-    env.randomizeTests(true);
+    env.configure({random: true, seed: '123456'});

    env.beforeEach(function () {
      actions.push('topSuite beforeEach');
@@ -865,7 +864,7 @@ describe("spec running", function () {
        });
      });

-      env.throwOnExpectationFailure(true);
+      env.configure({oneFailurePerSpec: true});

      var assertions = function() {
        expect(actions).toEqual([
@@ -900,7 +899,7 @@ describe("spec running", function () {
        });
      });

-      env.throwOnExpectationFailure(true);
+      env.configure({oneFailurePerSpec: true});

      var assertions = function() {
        expect(actions).toEqual([
@@ -932,6 +931,89 @@ describe("spec running", function () {
        });
      });

+      env.configure({oneFailurePerSpec: true});
+
+      var assertions = function() {
+        expect(actions).toEqual([
+          'beforeEach',
+          'afterEach'
+        ]);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.execute();
+    });
+
+    it("skips to cleanup functions after an error with deprecations", function(done) {
+      var actions = [];
+
+      spyOn(env, 'deprecated');
+
+      env.describe('Something', function() {
+        env.beforeEach(function() {
+          actions.push('outer beforeEach');
+          throw new Error("error");
+        });
+
+        env.afterEach(function() {
+          actions.push('outer afterEach');
+        });
+
+        env.describe('Inner', function() {
+          env.beforeEach(function() {
+            actions.push('inner beforeEach');
+          });
+
+          env.afterEach(function() {
+            actions.push('inner afterEach');
+          });
+
+          env.it('does it' , function() {
+            actions.push('inner it');
+          });
+        });
+      });
+
+      env.throwOnExpectationFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual([
+          'outer beforeEach',
+          'inner afterEach',
+          'outer afterEach'
+        ]);
+        expect(env.deprecated).toHaveBeenCalled();
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.execute();
+    });
+
+    it("skips to cleanup functions after done.fail is called with deprecations", function(done) {
+      var actions = [];
+
+      spyOn(env, 'deprecated');
+
+      env.describe('Something', function() {
+        env.beforeEach(function(done) {
+          actions.push('beforeEach');
+          done.fail('error');
+          actions.push('after done.fail');
+        });
+
+        env.afterEach(function() {
+          actions.push('afterEach');
+        });
+
+        env.it('does it' , function() {
+          actions.push('it');
+        });
+      });
+
      env.throwOnExpectationFailure(true);

      var assertions = function() {
@@ -939,6 +1021,42 @@ describe("spec running", function () {
          'beforeEach',
          'afterEach'
        ]);
+        expect(env.deprecated).toHaveBeenCalled();
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.execute();
+    });
+
+    it("skips to cleanup functions when an async function times out with deprecations", function(done) {
+      var actions = [];
+
+      spyOn(env, 'deprecated');
+
+      env.describe('Something', function() {
+        env.beforeEach(function(innerDone) {
+          actions.push('beforeEach');
+        }, 1);
+
+        env.afterEach(function() {
+          actions.push('afterEach');
+        });
+
+        env.it('does it' , function() {
+          actions.push('it');
+        });
+      });
+
+      env.throwOnExpectationFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual([
+          'beforeEach',
+          'afterEach'
+        ]);
+        expect(env.deprecated).toHaveBeenCalled();
        done();
      };

@@ -965,8 +1083,7 @@ describe("spec running", function () {
        });
      });

-      env.randomizeTests(false);
-      env.stopOnSpecFailure(true);
+      env.configure({random: false, failFast: true});

      var assertions = function() {
        expect(actions).toEqual(['fails']);
@@ -976,5 +1093,36 @@ describe("spec running", function () {
      env.addReporter({ jasmineDone: assertions });
      env.execute();
    });
+
+    it("does not run further specs when one fails when configured with deprecated option", function(done) {
+      var actions = [];
+
+      spyOn(env, 'deprecated');
+
+      env.describe('wrapper', function() {
+        env.it('fails', function() {
+          actions.push('fails');
+          env.expect(1).toBe(2);
+        });
+      });
+
+      env.describe('holder', function() {
+        env.it('does not run', function() {
+          actions.push('does not run');
+        });
+      });
+
+      env.configure({random: false});
+      env.stopOnSpecFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual(['fails']);
+        expect(env.deprecated).toHaveBeenCalled();
+        done();
+      };
+
+      env.addReporter({ jasmineDone: assertions });
+      env.execute();
+    });
  });
 });
--- a/spec/core/matchers/async/toBeRejectedSpec.js
+++ b/spec/core/matchers/async/toBeRejectedSpec.js
@@ -0,0 +1,23 @@
+describe('toBeRejected', function() {
+  it('passes if the actual is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('AsyncExpectationSpec rejection');
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+
+  it('fails if the actual is resolved', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+    });
+  });
+});
--- a/spec/core/matchers/async/toBeRejectedWithSpec.js
+++ b/spec/core/matchers/async/toBeRejectedWithSpec.js
@@ -0,0 +1,63 @@
+describe('#toBeRejectedWith', function () {
+  it('should return true if the promise is rejected with the expected value', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject({error: 'PEBCAK'});
+
+    return matcher.compare(actual, {error: 'PEBCAK'}).then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
+    });
+  });
+
+  it('should fail if the promise resolves', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual, '').then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
+    });
+  });
+
+  it('should fail if the promise is rejected with a different value', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('A Bad Apple');
+
+    return matcher.compare(actual, 'Some Cool Thing').then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: false,
+        message: "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'.",
+      }));
+    });
+  });
+
+  it('should build its error correctly when negated', function () {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject(true);
+
+    return matcher.compare(actual, true).then(function (result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: true,
+        message: 'Expected a promise not to be rejected with true.'
+      }));
+    });
+  });
+
+  it('should support custom equality testers', function () {
+    jasmine.getEnv().requirePromises();
+
+    var customEqualityTesters = [function() { return true; }],
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil, customEqualityTesters),
+      actual = Promise.reject('actual');
+
+    return matcher.compare(actual, 'expected').then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+});
--- a/spec/core/matchers/async/toBeResolvedSpec.js
+++ b/spec/core/matchers/async/toBeResolvedSpec.js
@@ -0,0 +1,23 @@
+describe('toBeResolved', function() {
+  it('passes if the actual is resolved', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+
+  it('fails if the actual is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('AsyncExpectationSpec rejection');
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+    });
+  });
+});
--- a/spec/core/matchers/async/toBeResolvedToSpec.js
+++ b/spec/core/matchers/async/toBeResolvedToSpec.js
@@ -0,0 +1,66 @@
+describe('#toBeResolvedTo', function() {
+  it('passes if the promise is resolved to the expected value', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve({foo: 42});
+
+    return matcher.compare(actual, {foo: 42}).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+
+  it('fails if the promise is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.reject('AsyncExpectationSpec error');
+
+    return matcher.compare(actual, '').then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: false,
+        message: "Expected a promise to be resolved to '' but it was rejected.",
+      }));
+    });
+  });
+
+  it('fails if the promise is resolved to a different value', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve({foo: 17});
+
+    return matcher.compare(actual, {foo: 42}).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: false,
+        message: 'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).',
+      }));
+    });
+  });
+
+  it('builds its message correctly when negated', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+      actual = Promise.resolve(true);
+
+    return matcher.compare(actual, true).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({
+        pass: true,
+        message: 'Expected a promise not to be resolved to true.'
+      }));
+    });
+  });
+
+  it('supports custom equality testers', function() {
+    jasmine.getEnv().requirePromises();
+
+    var customEqualityTesters = [function() { return true; }],
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil, customEqualityTesters),
+      actual = Promise.resolve('actual');
+
+    return matcher.compare(actual, 'expected').then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    });
+  });
+});
--- a/spec/core/matchers/toBeSpec.js
+++ b/spec/core/matchers/toBeSpec.js
@@ -1,17 +1,56 @@
 describe("toBe", function() {
-  it("passes when actual === expected", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(),
+  it("passes with no message when actual === expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
      result;

    result = matcher.compare(1, 1);
    expect(result.pass).toBe(true);
  });

-  it("fails when actual !== expected", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(),
+  it("passes with a custom message when expected is an array", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+      result,
+      array = [1];
+
+    result = matcher.compare(array, array);
+    expect(result.pass).toBe(true);
+    expect(result.message).toBe("Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+  });
+
+  it("passes with a custom message when expected is an object", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+      result,
+      obj = {foo: "bar"};
+
+    result = matcher.compare(obj, obj);
+    expect(result.pass).toBe(true);
+    expect(result.message).toBe("Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+  });
+
+  it("fails with no message when actual !== expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
      result;

    result = matcher.compare(1, 2);
    expect(result.pass).toBe(false);
+    expect(result.message).toBeUndefined();
+  });
+
+  it("fails with a custom message when expected is an array", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+      result;
+
+    result = matcher.compare([1], [1]);
+    expect(result.pass).toBe(false);
+    expect(result.message).toBe("Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+  });
+
+  it("fails with a custom message when expected is an object", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+      result;
+
+    result = matcher.compare({foo: "bar"}, {foo: "bar"});
+    expect(result.pass).toBe(false);
+    expect(result.message).toBe("Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
  });
 });
--- a/spec/html/HtmlReporterSpec.js
+++ b/spec/html/HtmlReporterSpec.js
@@ -518,7 +518,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.stopOnSpecFailure(true);
+        env.configure({failFast: true});

        reporter.initialize();
        reporter.jasmineDone({});
@@ -574,7 +574,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.stopOnSpecFailure(true);
+        env.configure({failFast: true});

        reporter.initialize();
        reporter.jasmineDone({});
@@ -628,7 +628,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.throwOnExpectationFailure(true);
+        env.configure({oneFailurePerSpec: true});

        reporter.initialize();
        reporter.jasmineDone({});
@@ -684,7 +684,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.throwOnExpectationFailure(true);
+        env.configure({oneFailurePerSpec: true});

        reporter.initialize();
        reporter.jasmineDone({});
@@ -713,7 +713,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.hideDisabled(false);
+        env.configure({hideDisabled: false});
        reporter.initialize();
        reporter.jasmineDone({});

@@ -738,7 +738,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.hideDisabled(true);
+        env.configure({hideDisabled: true});
        reporter.initialize();
        reporter.jasmineDone({});

@@ -748,27 +748,24 @@ describe("HtmlReporter", function() {

      it("should not display specs that have been disabled", function() {
        var env = new jasmineUnderTest.Env(),
-        container = document.createElement('div'),
-        
-        getContainer = function() {return container;},
-
-        reporter = new jasmineUnderTest.HtmlReporter({
-          env: env,
-          getContainer: getContainer,
-          createElement: function() { return document.createElement.apply(document, arguments); },
-          createTextNode: function() { return document.createTextNode.apply(document, arguments); }
-        });
-        env.hideDisabled(true);
-        reporter.initialize();
-        reporter.specDone({
-            id: 789, 
-            status: "excluded", 
-            fullName: "symbols should have titles", 
-            passedExpectations: [], 
-            failedExpectations: []
+          container = document.createElement('div'),
+          getContainer = function() {return container;},
+          reporter = new jasmineUnderTest.HtmlReporter({
+            env: env,
+            getContainer: getContainer,
+            createElement: function() { return document.createElement.apply(document, arguments); },
+            createTextNode: function() { return document.createTextNode.apply(document, arguments); }
          });

-        
+        env.configure({hideDisabled: true});
+        reporter.initialize();
+        reporter.specDone({
+            id: 789,
+            status: "excluded",
+            fullName: "symbols should have titles",
+            passedExpectations: [],
+            failedExpectations: []
+          });

        var specEl = container.querySelector('.jasmine-symbol-summary li');
        expect(specEl.getAttribute("class")).toEqual("jasmine-excluded-no-display");
@@ -792,7 +789,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.randomizeTests(false);
+        env.configure({random: false});
        reporter.initialize();
        reporter.jasmineDone({});

@@ -817,7 +814,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.randomizeTests(true);
+        env.configure({random: true});
        reporter.initialize();
        reporter.jasmineDone({});

@@ -844,7 +841,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.randomizeTests(false);
+        env.configure({random: false});
        reporter.initialize();
        reporter.jasmineDone({});

@@ -873,7 +870,7 @@ describe("HtmlReporter", function() {
            }
          });

-        env.randomizeTests(true);
+        env.configure({random: true});
        reporter.initialize();
        reporter.jasmineDone({});

--- a/src/core/AsyncExpectation.js
+++ b/src/core/AsyncExpectation.js
@@ -1,153 +0,0 @@
-getJasmineRequireObj().AsyncExpectation = function(j$) {
-  var promiseForMessage = {
-    jasmineToString: function() { return 'a promise'; }
-  };
-
-  /**
-   * Asynchronous matchers.
-   * @namespace async-matchers
-   */
-  function AsyncExpectation(options) {
-    var global = options.global || j$.getGlobal();
-    this.util = options.util || { buildFailureMessage: function() {} };
-    this.customEqualityTesters = options.customEqualityTesters || [];
-    this.addExpectationResult = options.addExpectationResult || function(){};
-    this.actual = options.actual;
-    this.isNot = options.isNot;
-
-    if (!global.Promise) {
-      throw new Error('expectAsync is unavailable because the environment does not support promises.');
-    }
-
-    if (!j$.isPromise(this.actual)) {
-      throw new Error('Expected expectAsync to be called with a promise.');
-    }
-
-    ['toBeResolved', 'toBeRejected', 'toBeResolvedTo'].forEach(wrapCompare.bind(this));
-  }
-
-  function wrapCompare(name) {
-    var compare = this[name];
-    this[name] = function() {
-      var self = this;
-      var args = Array.prototype.slice.call(arguments);
-      args.unshift(this.actual);
-
-      // Capture the call stack here, before we go async, so that it will
-      // contain frames that are relevant to the user instead of just parts
-      // of Jasmine.
-      var errorForStack = j$.util.errorWithStack();
-
-      return compare.apply(self, args).then(function(result) {
-        var message;
-
-        if (self.isNot) {
-          result.pass = !result.pass;
-        }
-
-        args[0] = promiseForMessage;
-        message = j$.Expectation.finalizeMessage(self.util, name, self.isNot, args, result);
-
-        self.addExpectationResult(result.pass, {
-          matcherName: name,
-          passed: result.pass,
-          message: message,
-          error: undefined,
-          errorForStack: errorForStack,
-          actual: self.actual
-        });
-      });
-    };
-  }
-
-  /**
-   * Expect a promise to be resolved.
-   * @function
-   * @async
-   * @name async-matchers#toBeResolved
-   * @example
-   * await expectAsync(aPromise).toBeResolved();
-   * @example
-   * return expectAsync(aPromise).toBeResolved();
-   */
-  AsyncExpectation.prototype.toBeResolved = function(actual) {
-    return actual.then(
-      function() { return {pass: true}; },
-      function() { return {pass: false}; }
-    );
-  };
-
-  /**
-   * Expect a promise to be rejected.
-   * @function
-   * @async
-   * @name async-matchers#toBeRejected
-   * @example
-   * await expectAsync(aPromise).toBeRejected();
-   * @example
-   * return expectAsync(aPromise).toBeRejected();
-   */
-  AsyncExpectation.prototype.toBeRejected = function(actual) {
-    return actual.then(
-      function() { return {pass: false}; },
-      function() { return {pass: true}; }
-    );
-  };
-
-  /**
-   * Expect a promise to be resolved to a value equal to the expected, using deep equality comparison.
-   * @function
-   * @async
-   * @name async-matchers#toBeResolvedTo
-   * @param {Object} expected - Value that the promise is expected to resolve to
-   * @example
-   * await expectAsync(aPromise).toBeResolvedTo({prop: 'value'});
-   * @example
-   * return expectAsync(aPromise).toBeResolvedTo({prop: 'value'});
-   */
-  AsyncExpectation.prototype.toBeResolvedTo = function(actualPromise, expectedValue) {
-    var self = this;
-
-    function prefix(passed) {
-      return 'Expected a promise ' +
-        (passed ? 'not ' : '') +
-        'to be resolved to ' + j$.pp(expectedValue);
-    }
-
-    return actualPromise.then(
-      function(actualValue) {
-        if (self.util.equals(actualValue, expectedValue, self.customEqualityTesters)) {
-          return {
-           pass: true,
-           message: prefix(true) + '.'
-         };
-        } else {
-          return {
-            pass: false,
-            message: prefix(false) + ' but it was resolved to ' + j$.pp(actualValue) + '.'
-          };
-        }
-      },
-      function() {
-        return {
-          pass: false,
-          message: prefix(false) + ' but it was rejected.'
-        };
-      }
-    );
-  };
-
-
-  AsyncExpectation.factory = function(options) {
-    var expect = new AsyncExpectation(options);
-
-    options = j$.util.clone(options);
-    options.isNot = true;
-    expect.not = new AsyncExpectation(options);
-
-    return expect;
-  };
-
-
-  return AsyncExpectation;
-};
--- a/src/core/Env.js
+++ b/src/core/Env.js
@@ -23,14 +23,62 @@ getJasmineRequireObj().Env = function(j$) {
    var currentSpec = null;
    var currentlyExecutingSuites = [];
    var currentDeclarationSuite = null;
-    var throwOnExpectationFailure = false;
-    var stopOnSpecFailure = false;
-    var random = true;
-    var hidingDisabled = false;
-    var seed = null;
-    var handlingLoadErrors = true;
    var hasFailures = false;

+    /**
+     * This represents the available options to configure Jasmine.
+     * Options that are not provided will use their default values
+     * @interface Configuration
+     */
+    var config = {
+      /**
+       * Whether to randomize spec execution order
+       * @name Configuration#random
+       * @type Boolean
+       * @default true
+       */
+      random: true,
+      /**
+       * Seed to use as the basis of randomization.
+       * Null causes the seed to be determined randomly at the start of execution.
+       * @name Configuration#seed
+       * @type function
+       * @default null
+       */
+      seed: null,
+      /**
+       * Whether to stop execution of the suite after the first spec failure
+       * @name Configuration#failFast
+       * @type Boolean
+       * @default false
+       */
+      failFast: false,
+      /**
+       * Whether to cause specs to only have one expectation failure.
+       * @name Configuration#oneFailurePerSpec
+       * @type Boolean
+       * @default false
+       */
+      oneFailurePerSpec: false,
+      /**
+       * Function to use to filter specs
+       * @name Configuration#specFilter
+       * @type function
+       * @default true
+       */
+      specFilter: function() {
+        return true;
+      },
+      /**
+       * Whether or not reporters should hide disabled specs from their output.
+       * Currently only supported by Jasmine's HTMLReporter
+       * @name Configuration#hideDisabled
+       * @type Boolean
+       * @default false
+       */
+      hideDisabled: false
+    };
+
    var currentSuite = function() {
      return currentlyExecutingSuites[currentlyExecutingSuites.length - 1];
    };
@@ -63,10 +111,63 @@ getJasmineRequireObj().Env = function(j$) {
      });
    }

-    this.specFilter = function() {
-      return true;
+    /**
+     * Configure your jasmine environment
+     * @name Env#configure
+     * @argument {Configuration} configuration
+     * @function
+     */
+    this.configure = function(configuration) {
+      if (configuration.specFilter) {
+        config.specFilter = configuration.specFilter;
+      }
+
+      if (configuration.hasOwnProperty('random')) {
+        config.random = !!configuration.random;
+      }
+
+      if (configuration.hasOwnProperty('seed')) {
+        config.seed = configuration.seed;
+      }
+
+      if (configuration.hasOwnProperty('failFast')) {
+        config.failFast = configuration.failFast;
+      }
+
+      if (configuration.hasOwnProperty('oneFailurePerSpec')) {
+        config.oneFailurePerSpec = configuration.oneFailurePerSpec;
+      }
+
+      if (configuration.hasOwnProperty('hideDisabled')) {
+        config.hideDisabled = configuration.hideDisabled;
+      }
    };

+    /**
+     * Get the current configuration for your jasmine environment
+     * @name Env#configuration
+     * @function
+     * @returns {Configuration}
+     */
+    this.configuration = function() {
+      var result = {};
+      for (var property in config) {
+        result[property] = config[property];
+      }
+      return result;
+    };
+
+    Object.defineProperty(this, 'specFilter', {
+      get: function() {
+        self.deprecated('Getting specFilter directly from Env is deprecated, please check the specFilter option from `configuration`');
+        return config.specFilter;
+      },
+      set: function(val) {
+        self.deprecated('Setting specFilter directly on Env is deprecated, please use the specFilter option in `configure`');
+        config.specFilter = val;
+      }
+    });
+
    this.addSpyStrategy = function(name, fn) {
      if(!currentRunnable()) {
        throw new Error('Custom spy strategies must be added in a before function or a spec');
@@ -92,6 +193,7 @@ getJasmineRequireObj().Env = function(j$) {
    };

    j$.Expectation.addCoreMatchers(j$.matchers);
+    j$.Expectation.addAsyncCoreMatchers(j$.asyncMatchers);

    var nextSpecId = 0;
    var getNextSpecId = function() {
@@ -104,7 +206,7 @@ getJasmineRequireObj().Env = function(j$) {
    };

    var expectationFactory = function(actual, spec) {
-      return j$.Expectation.Factory({
+      return j$.Expectation.factory({
        util: j$.matchersUtil,
        customEqualityTesters: runnableResources[spec.id].customEqualityTesters,
        customMatchers: runnableResources[spec.id].customMatchers,
@@ -118,7 +220,7 @@ getJasmineRequireObj().Env = function(j$) {
    };

    var asyncExpectationFactory = function(actual, spec) {
-      return j$.AsyncExpectation.factory({
+      return j$.Expectation.asyncFactory({
        util: j$.matchersUtil,
        customEqualityTesters: runnableResources[spec.id].customEqualityTesters,
        actual: actual,
@@ -194,13 +296,16 @@ getJasmineRequireObj().Env = function(j$) {
     * @name Env#throwOnExpectationFailure
     * @function
     * @param {Boolean} value Whether to throw when a expectation fails
+     * @deprecated Use the `oneFailurePerSpec` option with {@link Env#configure}
     */
    this.throwOnExpectationFailure = function(value) {
-      throwOnExpectationFailure = !!value;
+      this.deprecated('Setting throwOnExpectationFailure directly on Env is deprecated, please use the oneFailurePerSpec option in `configure`');
+      this.configure({oneFailurePerSpec: !!value});
    };

    this.throwingExpectationFailures = function() {
-      return throwOnExpectationFailure;
+      this.deprecated('Getting throwingExpectationFailures directly from Env is deprecated, please check the oneFailurePerSpec option from `configuration`');
+      return config.oneFailurePerSpec;
    };

    /**
@@ -208,13 +313,16 @@ getJasmineRequireObj().Env = function(j$) {
     * @name Env#stopOnSpecFailure
     * @function
     * @param {Boolean} value Whether to stop suite execution when a spec fails
+     * @deprecated Use the `failFast` option with {@link Env#configure}
     */
    this.stopOnSpecFailure = function(value) {
-      stopOnSpecFailure = !!value;
+      this.deprecated('Setting stopOnSpecFailure directly is deprecated, please use the failFast option in `configure`');
+      this.configure({failFast: !!value});
    };

    this.stoppingOnSpecFailure = function() {
-      return stopOnSpecFailure;
+      this.deprecated('Getting stoppingOnSpecFailure directly from Env is deprecated, please check the failFast option from `configuration`');
+      return config.failFast;
    };

    /**
@@ -222,13 +330,16 @@ getJasmineRequireObj().Env = function(j$) {
     * @name Env#randomizeTests
     * @function
     * @param {Boolean} value Whether to randomize execution order
+     * @deprecated Use the `random` option with {@link Env#configure}
     */
    this.randomizeTests = function(value) {
-      random = !!value;
+      this.deprecated('Setting randomizeTests directly is deprecated, please use the random option in `configure`');
+      config.random = !!value;
    };

    this.randomTests = function() {
-      return random;
+      this.deprecated('Getting randomTests directly from Env is deprecated, please check the random option from `configuration`');
+      return config.random;
    };

    /**
@@ -236,16 +347,19 @@ getJasmineRequireObj().Env = function(j$) {
     * @name Env#seed
     * @function
     * @param {Number} value The seed value
+     * @deprecated Use the `seed` option with {@link Env#configure}
     */
    this.seed = function(value) {
+      this.deprecated('Setting seed directly is deprecated, please use the seed option in `configure`');
      if (value) {
-        seed = value;
+        config.seed = value;
      }
-      return seed;
+      return config.seed;
    };

    this.hidingDisabled = function(value) {
-      return hidingDisabled;
+      this.deprecated('Getting hidingDisabled directly from Env is deprecated, please check the hideDisabled option from `configuration`');
+      return config.hideDisabled;
    };

    /**
@@ -253,7 +367,8 @@ getJasmineRequireObj().Env = function(j$) {
     * @function
     */
    this.hideDisabled = function(value) {
-      hidingDisabled = !!value;
+      this.deprecated('Setting hideDisabled directly is deprecated, please use the hideDisabled option in `configure`');
+      config.hideDisabled = !!value;
    };

    this.deprecated = function(deprecation) {
@@ -267,9 +382,9 @@ getJasmineRequireObj().Env = function(j$) {
    var queueRunnerFactory = function(options, args) {
      var failFast = false;
      if (options.isLeaf) {
-        failFast = throwOnExpectationFailure;
+        failFast = config.oneFailurePerSpec;
      } else if (!options.isReporter) {
-        failFast = stopOnSpecFailure;
+        failFast = config.failFast;
      }
      options.clearStack = options.clearStack || clearStack;
      options.timeout = {setTimeout: realSetTimeout, clearTimeout: realClearTimeout};
@@ -384,8 +499,8 @@ getJasmineRequireObj().Env = function(j$) {
      }

      var order = new j$.Order({
-        random: random,
-        seed: seed
+        random: config.random,
+        seed: config.seed
      });

      var processor = new j$.TreeProcessor({
@@ -415,7 +530,7 @@ getJasmineRequireObj().Env = function(j$) {
          return order.sort(node.children);
        },
        excludeNode: function(spec) {
-          return !self.specFilter(spec);
+          return !config.specFilter(spec);
        }
      });

@@ -537,6 +652,10 @@ getJasmineRequireObj().Env = function(j$) {
      return spyRegistry.spyOnProperty.apply(spyRegistry, arguments);
    };

+    this.spyOnAllFunctions = function() {
+      return spyRegistry.spyOnAllFunctions.apply(spyRegistry, arguments);
+    };
+
    this.createSpy = function(name, originalFn) {
      if (arguments.length === 1 && j$.isFunction_(name)) {
        originalFn = name;
@@ -578,7 +697,7 @@ getJasmineRequireObj().Env = function(j$) {
        expectationFactory: expectationFactory,
        asyncExpectationFactory: asyncExpectationFactory,
        expectationResultFactory: expectationResultFactory,
-        throwOnExpectationFailure: throwOnExpectationFailure
+        throwOnExpectationFailure: config.oneFailurePerSpec
      });

      return suite;
@@ -684,7 +803,7 @@ getJasmineRequireObj().Env = function(j$) {
          fn: fn,
          timeout: timeout || 0
        },
-        throwOnExpectationFailure: throwOnExpectationFailure
+        throwOnExpectationFailure: config.oneFailurePerSpec
      });

      return spec;
@@ -832,7 +951,7 @@ getJasmineRequireObj().Env = function(j$) {
        error: error && error.message ? error : null
      });

-      if (self.throwingExpectationFailures()) {
+      if (config.oneFailurePerSpec) {
        throw new Error(message);
      }
    };
--- a/src/core/ExceptionFormatter.js
+++ b/src/core/ExceptionFormatter.js
@@ -7,6 +7,8 @@ getJasmineRequireObj().ExceptionFormatter = function(j$) {

      if (error.name && error.message) {
        message += error.name + ': ' + error.message;
+      } else if (error.message) {
+        message += error.message;
      } else {
        message += error.toString() + ' thrown';
      }
--- a/src/core/Expectation.js
+++ b/src/core/Expectation.js
@@ -1,102 +1,186 @@
-getJasmineRequireObj().Expectation = function() {
+getJasmineRequireObj().Expectation = function(j$) {
+  var promiseForMessage = {
+    jasmineToString: function() { return 'a promise'; }
+  };

  /**
   * Matchers that come with Jasmine out of the box.
   * @namespace matchers
   */
  function Expectation(options) {
-    this.util = options.util || { buildFailureMessage: function() {} };
-    this.customEqualityTesters = options.customEqualityTesters || [];
-    this.actual = options.actual;
-    this.addExpectationResult = options.addExpectationResult || function(){};
-    this.isNot = options.isNot;
+    this.expector = new j$.Expector(options);

    var customMatchers = options.customMatchers || {};
    for (var matcherName in customMatchers) {
-      this[matcherName] = Expectation.prototype.wrapCompare(matcherName, customMatchers[matcherName]);
+      this[matcherName] = wrapSyncCompare(matcherName, customMatchers[matcherName]);
    }
  }

-  Expectation.prototype.wrapCompare = function(name, matcherFactory) {
-    return function() {
-      var args = Array.prototype.slice.call(arguments, 0),
-        expected = args.slice(0),
-        message;
-
-      args.unshift(this.actual);
-
-      var matcher = matcherFactory(this.util, this.customEqualityTesters),
-          matcherCompare = matcher.compare;
-
-      function defaultNegativeCompare() {
-        var result = matcher.compare.apply(null, args);
-        result.pass = !result.pass;
-        return result;
-      }
-
-      if (this.isNot) {
-        matcherCompare = matcher.negativeCompare || defaultNegativeCompare;
-      }
-
-      var result = matcherCompare.apply(null, args);
-      message = Expectation.finalizeMessage(this.util, name, this.isNot, args, result);
-
-      if (expected.length == 1) {
-        expected = expected[0];
-      }
-
-      // TODO: how many of these params are needed?
-      this.addExpectationResult(
-        result.pass,
-        {
-          matcherName: name,
-          passed: result.pass,
-          message: message,
-          error: result.error,
-          actual: this.actual,
-          expected: expected // TODO: this may need to be arrayified/sliced
-        }
-      );
-    };
+  /**
+   * Add some context for an {@link expect}
+   * @function
+   * @name matchers#withContext
+   * @param {String} message - Additional context to show when the matcher fails
+   * @return {matchers}
+   */
+  Expectation.prototype.withContext = function withContext(message) {
+    return addFilter(this, new ContextAddingFilter(message));
  };

-  Expectation.finalizeMessage = function(util, name, isNot, args, result) {
-    if (result.pass) {
-      return '';
-    } else if (result.message) {
-      if (Object.prototype.toString.apply(result.message) === '[object Function]') {
+  /**
+   * Invert the matcher following this {@link expect}
+   * @member
+   * @name matchers#not
+   * @type {matchers}
+   * @example
+   * expect(something).not.toBe(true);
+   */
+  Object.defineProperty(Expectation.prototype, 'not', {
+    get: function() {
+      return addFilter(this, syncNegatingFilter);
+    }
+  });
+
+  /**
+   * Asynchronous matchers.
+   * @namespace async-matchers
+   */
+  function AsyncExpectation(options) {
+    var global = options.global || j$.getGlobal();
+    this.expector = new j$.Expector(options);
+
+    if (!global.Promise) {
+      throw new Error('expectAsync is unavailable because the environment does not support promises.');
+    }
+
+    if (!j$.isPromiseLike(this.expector.actual)) {
+      throw new Error('Expected expectAsync to be called with a promise.');
+    }
+  }
+
+  /**
+   * Add some context for an {@link expectAsync}
+   * @function
+   * @name async-matchers#withContext
+   * @param {String} message - Additional context to show when the async matcher fails
+   * @return {async-matchers}
+   */
+  AsyncExpectation.prototype.withContext = function withContext(message) {
+    return addFilter(this, new ContextAddingFilter(message));
+  };
+
+  /**
+   * Invert the matcher following this {@link expectAsync}
+   * @member
+   * @name async-matchers#not
+   * @type {async-matchers}
+   * @example
+   * await expectAsync(myPromise).not.toBeResolved();
+   * @example
+   * return expectAsync(myPromise).not.toBeResolved();
+   */
+  Object.defineProperty(AsyncExpectation.prototype, 'not', {
+    get: function() {
+      return addFilter(this, asyncNegatingFilter);
+    }
+  });
+
+  function wrapSyncCompare(name, matcherFactory) {
+    return function() {
+      var result = this.expector.compare(name, matcherFactory, arguments);
+      this.expector.processResult(result);
+    };
+  }
+
+  function wrapAsyncCompare(name, matcherFactory) {
+    return function() {
+      var self = this;
+
+      // Capture the call stack here, before we go async, so that it will contain
+      // frames that are relevant to the user instead of just parts of Jasmine.
+      var errorForStack = j$.util.errorWithStack();
+
+      return this.expector.compare(name, matcherFactory, arguments).then(function(result) {
+        self.expector.processResult(result, errorForStack, promiseForMessage);
+      });
+    };
+  }
+
+  function addCoreMatchers(prototype, matchers, wrapper) {
+    for (var matcherName in matchers) {
+      var matcher = matchers[matcherName];
+      prototype[matcherName] = wrapper(matcherName, matcher);
+    }
+  }
+
+  function addFilter(source, filter) {
+    var result = Object.create(source);
+    result.expector = source.expector.addFilter(filter);
+    return result;
+  }
+
+  function negatedFailureMessage(result, matcherName, args, util) {
+    if (result.message) {
+      if (j$.isFunction_(result.message)) {
        return result.message();
      } else {
        return result.message;
      }
-    } else {
-      args = args.slice();
-      args.unshift(isNot);
-      args.unshift(name);
-      return util.buildFailureMessage.apply(null, args);
+    }
+
+    args = args.slice();
+    args.unshift(true);
+    args.unshift(matcherName);
+    return util.buildFailureMessage.apply(null, args);
+  }
+
+  function negate(result) {
+    result.pass = !result.pass;
+    return result;
+  }
+
+  var syncNegatingFilter = {
+    selectComparisonFunc: function(matcher) {
+      function defaultNegativeCompare() {
+        return negate(matcher.compare.apply(null, arguments));
+      }
+
+      return matcher.negativeCompare || defaultNegativeCompare;
+    },
+    buildFailureMessage: negatedFailureMessage
+  };
+
+  var asyncNegatingFilter = {
+    selectComparisonFunc: function(matcher) {
+      function defaultNegativeCompare() {
+        return matcher.compare.apply(this, arguments).then(negate);
+      }
+
+      return defaultNegativeCompare;
+    },
+    buildFailureMessage: negatedFailureMessage
+  };
+
+  function ContextAddingFilter(message) {
+    this.message = message;
+  }
+
+  ContextAddingFilter.prototype.modifyFailureMessage = function(msg) {
+    return this.message + ': ' + msg;
+  };
+
+  return {
+    factory: function(options) {
+      return new Expectation(options || {});
+    },
+    addCoreMatchers: function(matchers) {
+      addCoreMatchers(Expectation.prototype, matchers, wrapSyncCompare);
+    },
+    asyncFactory: function(options) {
+      return new AsyncExpectation(options || {});
+    },
+    addAsyncCoreMatchers: function(matchers) {
+      addCoreMatchers(AsyncExpectation.prototype, matchers, wrapAsyncCompare);
    }
  };
-
-  Expectation.addCoreMatchers = function(matchers) {
-    var prototype = Expectation.prototype;
-    for (var matcherName in matchers) {
-      var matcher = matchers[matcherName];
-      prototype[matcherName] = prototype.wrapCompare(matcherName, matcher);
-    }
-  };
-
-  Expectation.Factory = function(options) {
-    options = options || {};
-
-    var expect = new Expectation(options);
-
-    // TODO: this would be nice as its own Object - NegativeExpectation
-    // TODO: copy instead of mutate options
-    options.isNot = true;
-    expect.not = new Expectation(options);
-
-    return expect;
-  };
-
-  return Expectation;
 };
--- a/src/core/ExpectationFilterChain.js
+++ b/src/core/ExpectationFilterChain.js
@@ -0,0 +1,46 @@
+getJasmineRequireObj().ExpectationFilterChain = function() {
+  function ExpectationFilterChain(maybeFilter, prev) {
+    this.filter_ = maybeFilter;
+    this.prev_ = prev;
+  }
+
+  ExpectationFilterChain.prototype.addFilter = function(filter) {
+    return new ExpectationFilterChain(filter, this);
+  };
+
+  ExpectationFilterChain.prototype.selectComparisonFunc = function(matcher) {
+    return this.callFirst_('selectComparisonFunc', arguments).result;
+  };
+
+  ExpectationFilterChain.prototype.buildFailureMessage = function(result, matcherName, args, util) {
+    return this.callFirst_('buildFailureMessage', arguments).result;
+  };
+
+  ExpectationFilterChain.prototype.modifyFailureMessage = function(msg) {
+    var result = this.callFirst_('modifyFailureMessage', arguments).result;
+    return result || msg;
+  };
+
+  ExpectationFilterChain.prototype.callFirst_ = function(fname, args) {
+    var prevResult;
+
+    if (this.prev_) {
+      prevResult = this.prev_.callFirst_(fname, args);
+
+      if (prevResult.found) {
+        return prevResult;
+      }
+    }
+
+    if (this.filter_ && this.filter_[fname]) {
+      return {
+        found: true,
+        result: this.filter_[fname].apply(this.filter_, args)
+      };
+    }
+
+    return {found: false};
+  };
+
+  return ExpectationFilterChain;
+};
--- a/src/core/Expector.js
+++ b/src/core/Expector.js
@@ -0,0 +1,80 @@
+getJasmineRequireObj().Expector = function(j$) {
+  function Expector(options) {
+    this.util = options.util || { buildFailureMessage: function() {} };
+    this.customEqualityTesters = options.customEqualityTesters || [];
+    this.actual = options.actual;
+    this.addExpectationResult = options.addExpectationResult || function(){};
+    this.filters = new j$.ExpectationFilterChain();
+  }
+
+  Expector.prototype.instantiateMatcher = function(matcherName, matcherFactory, args) {
+    this.matcherName = matcherName;
+    this.args = Array.prototype.slice.call(args, 0);
+    this.expected = this.args.slice(0);
+
+    this.args.unshift(this.actual);
+
+    var matcher = matcherFactory(this.util, this.customEqualityTesters);
+    var comparisonFunc = this.filters.selectComparisonFunc(matcher);
+    return comparisonFunc || matcher.compare;
+  };
+
+  Expector.prototype.buildMessage = function(result) {
+    var self = this;
+
+    if (result.pass) {
+      return '';
+    }
+
+    var msg = this.filters.buildFailureMessage(result, this.matcherName, this.args, this.util, defaultMessage);
+    return this.filters.modifyFailureMessage(msg || defaultMessage());
+
+    function defaultMessage() {
+      if (!result.message) {
+        var args = self.args.slice();
+        args.unshift(false);
+        args.unshift(self.matcherName);
+        return self.util.buildFailureMessage.apply(null, args);
+      } else if (j$.isFunction_(result.message)) {
+        return result.message();
+      } else {
+        return result.message;
+      }
+    }
+  };
+
+  Expector.prototype.compare = function(matcherName, matcherFactory, args) {
+    var matcherCompare = this.instantiateMatcher(matcherName, matcherFactory, args);
+    return matcherCompare.apply(null, this.args);
+  };
+
+  Expector.prototype.addFilter = function(filter) {
+    var result = Object.create(this);
+    result.filters = this.filters.addFilter(filter);
+    return result;
+  };
+
+  Expector.prototype.processResult = function(result, errorForStack, actualOverride) {
+    this.args[0] = actualOverride || this.args[0];
+    var message = this.buildMessage(result);
+
+    if (this.expected.length === 1) {
+      this.expected = this.expected[0];
+    }
+
+    this.addExpectationResult(
+      result.pass,
+      {
+        matcherName: this.matcherName,
+        passed: result.pass,
+        message: message,
+        error: errorForStack ? undefined : result.error,
+        errorForStack: errorForStack || undefined,
+        actual: this.actual,
+        expected: this.expected // TODO: this may need to be arrayified/sliced
+      }
+    );
+  };
+
+  return Expector;
+};
--- a/src/core/QueueRunner.js
+++ b/src/core/QueueRunner.js
@@ -5,26 +5,29 @@ getJasmineRequireObj().QueueRunner = function(j$) {

  function once(fn) {
    var called = false;
-    return function() {
+    return function(arg) {
      if (!called) {
        called = true;
-        fn.apply(null, arguments);
+        // Direct call using single parameter, because cleanup/next does not need more
+        fn(arg);
      }
      return null;
    };
  }

+  function emptyFn() {}
+
  function QueueRunner(attrs) {
    var queueableFns = attrs.queueableFns || [];
    this.queueableFns = queueableFns.concat(attrs.cleanupFns || []);
    this.firstCleanupIx = queueableFns.length;
-    this.onComplete = attrs.onComplete || function() {};
+    this.onComplete = attrs.onComplete || emptyFn;
    this.clearStack = attrs.clearStack || function(fn) {fn();};
-    this.onException = attrs.onException || function() {};
+    this.onException = attrs.onException || emptyFn;
    this.userContext = attrs.userContext || new j$.UserContext();
    this.timeout = attrs.timeout || {setTimeout: setTimeout, clearTimeout: clearTimeout};
-    this.fail = attrs.fail || function() {};
-    this.globalErrors = attrs.globalErrors || { pushListener: function() {}, popListener: function() {} };
+    this.fail = attrs.fail || emptyFn;
+    this.globalErrors = attrs.globalErrors || { pushListener: emptyFn, popListener: emptyFn };
    this.completeOnFirstError = !!attrs.completeOnFirstError;
    this.errored = false;

@@ -66,7 +69,9 @@ getJasmineRequireObj().QueueRunner = function(j$) {
        next(error);
      },
      cleanup = once(function cleanup() {
-        self.clearTimeout(timeoutId);
+        if (timeoutId !== void 0) {
+          self.clearTimeout(timeoutId);
+        }
        self.globalErrors.popListener(handleError);
      }),
      next = once(function next(err) {
--- a/src/core/base.js
+++ b/src/core/base.js
@@ -120,7 +120,11 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
  };

  j$.isPromise = function(obj) {
-    return typeof jasmineGlobal.Promise !== 'undefined' && obj && obj.constructor === jasmineGlobal.Promise;
+    return typeof jasmineGlobal.Promise !== 'undefined' && !!obj && obj.constructor === jasmineGlobal.Promise;
+  };
+
+  j$.isPromiseLike = function(obj) {
+    return !!obj && j$.isFunction_(obj.then);
  };

  j$.fnNameFor = function(func) {
--- a/src/core/matchers/async/toBeRejected.js
+++ b/src/core/matchers/async/toBeRejected.js
@@ -0,0 +1,22 @@
+getJasmineRequireObj().toBeRejected = function(j$) {
+  /**
+   * Expect a promise to be rejected.
+   * @function
+   * @async
+   * @name async-matchers#toBeRejected
+   * @example
+   * await expectAsync(aPromise).toBeRejected();
+   * @example
+   * return expectAsync(aPromise).toBeRejected();
+   */
+  return function toBeResolved(util) {
+    return {
+      compare: function(actual) {
+        return actual.then(
+          function() { return {pass: false}; },
+          function() { return {pass: true}; }
+        );
+      }
+    };
+  };
+};
--- a/src/core/matchers/async/toBeRejectedWith.js
+++ b/src/core/matchers/async/toBeRejectedWith.js
@@ -0,0 +1,46 @@
+getJasmineRequireObj().toBeRejectedWith = function(j$) {
+  /**
+   * Expect a promise to be rejected with a value equal to the expected, using deep equality comparison.
+   * @function
+   * @async
+   * @name async-matchers#toBeRejectedWith
+   * @param {Object} expected - Value that the promise is expected to be rejected with
+   * @example
+   * await expectAsync(aPromise).toBeRejectedWith({prop: 'value'});
+   * @example
+   * return expectAsync(aPromise).toBeRejectedWith({prop: 'value'});
+   */
+  return function toBeRejectedWith(util, customEqualityTesters) {
+    return {
+      compare: function(actualPromise, expectedValue) {
+        function prefix(passed) {
+          return 'Expected a promise ' +
+            (passed ? 'not ' : '') +
+            'to be rejected with ' + j$.pp(expectedValue);
+        }
+
+        return actualPromise.then(
+          function() {
+          return {
+            pass: false,
+            message: prefix(false) + ' but it was resolved.'
+          };
+        },
+        function(actualValue) {
+          if (util.equals(actualValue, expectedValue, customEqualityTesters)) {
+            return {
+              pass: true,
+              message: prefix(true) + '.'
+            };
+          } else {
+            return {
+              pass: false,
+              message: prefix(false) + ' but it was rejected with ' + j$.pp(actualValue) + '.'
+            };
+          }
+        }
+        );
+      }
+    };
+  };
+};
--- a/src/core/matchers/async/toBeResolved.js
+++ b/src/core/matchers/async/toBeResolved.js
@@ -0,0 +1,22 @@
+getJasmineRequireObj().toBeResolved = function(j$) {
+  /**
+   * Expect a promise to be resolved.
+   * @function
+   * @async
+   * @name async-matchers#toBeResolved
+   * @example
+   * await expectAsync(aPromise).toBeResolved();
+   * @example
+   * return expectAsync(aPromise).toBeResolved();
+   */
+  return function toBeResolved(util) {
+    return {
+      compare: function(actual) {
+        return actual.then(
+          function() { return {pass: true}; },
+          function() { return {pass: false}; }
+        );
+      }
+    };
+  };
+};
--- a/src/core/matchers/async/toBeResolvedTo.js
+++ b/src/core/matchers/async/toBeResolvedTo.js
@@ -0,0 +1,46 @@
+getJasmineRequireObj().toBeResolvedTo = function(j$) {
+  /**
+   * Expect a promise to be resolved to a value equal to the expected, using deep equality comparison.
+   * @function
+   * @async
+   * @name async-matchers#toBeResolvedTo
+   * @param {Object} expected - Value that the promise is expected to resolve to
+   * @example
+   * await expectAsync(aPromise).toBeResolvedTo({prop: 'value'});
+   * @example
+   * return expectAsync(aPromise).toBeResolvedTo({prop: 'value'});
+   */
+  return function toBeResolvedTo(util, customEqualityTesters) {
+    return {
+      compare: function(actualPromise, expectedValue) {
+        function prefix(passed) {
+          return 'Expected a promise ' +
+            (passed ? 'not ' : '') +
+            'to be resolved to ' + j$.pp(expectedValue);
+        }
+
+        return actualPromise.then(
+          function(actualValue) {
+          if (util.equals(actualValue, expectedValue, customEqualityTesters)) {
+            return {
+              pass: true,
+              message: prefix(true) + '.'
+            };
+          } else {
+            return {
+              pass: false,
+              message: prefix(false) + ' but it was resolved to ' + j$.pp(actualValue) + '.'
+            };
+          }
+        },
+        function() {
+          return {
+            pass: false,
+            message: prefix(false) + ' but it was rejected.'
+          };
+        }
+        );
+      }
+    };
+  };
+};
--- a/src/core/matchers/requireAsyncMatchers.js
+++ b/src/core/matchers/requireAsyncMatchers.js
@@ -0,0 +1,16 @@
+getJasmineRequireObj().requireAsyncMatchers = function(jRequire, j$) {
+  var availableMatchers = [
+      'toBeResolved',
+      'toBeRejected',
+      'toBeResolvedTo',
+      'toBeRejectedWith'
+    ],
+    matchers = {};
+
+  for (var i = 0; i < availableMatchers.length; i++) {
+    var name = availableMatchers[i];
+    matchers[name] = jRequire[name](j$);
+  }
+
+  return matchers;
+};
--- a/src/core/matchers/toBe.js
+++ b/src/core/matchers/toBe.js
@@ -1,4 +1,4 @@
-getJasmineRequireObj().toBe = function() {
+getJasmineRequireObj().toBe = function(j$) {
  /**
   * {@link expect} the actual value to be `===` to the expected value.
   * @function
@@ -7,12 +7,20 @@ getJasmineRequireObj().toBe = function() {
   * @example
   * expect(thing).toBe(realThing);
   */
-  function toBe() {
+  function toBe(util) {
+    var tip = ' Tip: To check for deep equality, use .toEqual() instead of .toBe().';
+
    return {
      compare: function(actual, expected) {
-        return {
-          pass: actual === expected
+        var result = {
+          pass: actual === expected,
        };
+
+        if (typeof expected === 'object') {
+          result.message = util.buildFailureMessage('toBe', result.pass, actual, expected) + tip;
+        }
+
+        return result;
      }
    };
  }
--- a/src/core/requireCore.js
+++ b/src/core/requireCore.js
@@ -37,8 +37,9 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
    j$.Env = jRequire.Env(j$);
    j$.StackTrace = jRequire.StackTrace(j$);
    j$.ExceptionFormatter = jRequire.ExceptionFormatter(j$);
-    j$.Expectation = jRequire.Expectation();
-    j$.AsyncExpectation = jRequire.AsyncExpectation(j$);
+    j$.ExpectationFilterChain = jRequire.ExpectationFilterChain();
+    j$.Expector = jRequire.Expector(j$);
+    j$.Expectation = jRequire.Expectation(j$);
    j$.buildExpectationResult = jRequire.buildExpectationResult();
    j$.JsApiReporter = jRequire.JsApiReporter();
    j$.matchersUtil = jRequire.matchersUtil(j$);
@@ -71,6 +72,7 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
    j$.NotEmpty = jRequire.NotEmpty(j$);

    j$.matchers = jRequire.requireMatchers(jRequire, j$);
+    j$.asyncMatchers = jRequire.requireAsyncMatchers(jRequire, j$);

    return j$;
  };
--- a/src/core/requireInterface.js
+++ b/src/core/requireInterface.js
@@ -237,7 +237,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {

    /**
     * Installs spies on all writable and configurable properties of an object.
-     * @name spyOnProperty
+     * @name spyOnAllFunctions
     * @function
     * @global
     * @param {Object} obj - The object upon which to install the {@link Spy}s
--- a/src/html/HtmlReporter.js
+++ b/src/html/HtmlReporter.js
@@ -51,7 +51,7 @@ jasmineRequire.HtmlReporter = function(j$) {


  function HtmlReporter(options) {
-    var env = options.env || {},
+    var config = function() { return (options.env && options.env.configuration()) || {}; },
      getContainer = options.getContainer,
      createElement = options.createElement,
      createTextNode = options.createTextNode,
@@ -138,9 +138,9 @@ jasmineRequire.HtmlReporter = function(j$) {

    this.resultStatus = function(status) {
      if(status === 'excluded') {
-        return env.hidingDisabled() ?  'jasmine-excluded-no-display' : 'jasmine-excluded';
-      } 
-      return 'jasmine-' + status; 
+        return config().hideDisabled ? 'jasmine-excluded-no-display' : 'jasmine-excluded';
+      }
+      return 'jasmine-' + status;
    };

    this.jasmineDone = function(doneResult) {
@@ -150,7 +150,7 @@ jasmineRequire.HtmlReporter = function(j$) {
      var i;
      alert.appendChild(createDom('span', {className: 'jasmine-duration'}, 'finished in ' + timer.elapsed() / 1000 + 's'));

-      banner.appendChild(optionsMenu(env));
+      banner.appendChild(optionsMenu(config()));

      if (stateBuilder.specsExecuted < totalSpecsDefined) {
        var skippedMessage = 'Ran ' + stateBuilder.specsExecuted + ' of ' + totalSpecsDefined + ' specs - run all';
@@ -310,7 +310,7 @@ jasmineRequire.HtmlReporter = function(j$) {
      }
    }

-    function optionsMenu(env) {
+    function optionsMenu(config) {
      var optionsMenuDom = createDom('div', { className: 'jasmine-run-options' },
        createDom('span', { className: 'jasmine-trigger' }, 'Options'),
        createDom('div', { className: 'jasmine-payload' },
@@ -346,27 +346,27 @@ jasmineRequire.HtmlReporter = function(j$) {
      );

      var failFastCheckbox = optionsMenuDom.querySelector('#jasmine-fail-fast');
-      failFastCheckbox.checked = env.stoppingOnSpecFailure();
+      failFastCheckbox.checked = config.failFast;
      failFastCheckbox.onclick = function() {
-        navigateWithNewParam('failFast', !env.stoppingOnSpecFailure());
+        navigateWithNewParam('failFast', !config.failFast);
      };

      var throwCheckbox = optionsMenuDom.querySelector('#jasmine-throw-failures');
-      throwCheckbox.checked = env.throwingExpectationFailures();
+      throwCheckbox.checked = config.oneFailurePerSpec;
      throwCheckbox.onclick = function() {
-        navigateWithNewParam('throwFailures', !env.throwingExpectationFailures());
+        navigateWithNewParam('throwFailures', !config.oneFailurePerSpec);
      };

      var randomCheckbox = optionsMenuDom.querySelector('#jasmine-random-order');
-      randomCheckbox.checked = env.randomTests();
+      randomCheckbox.checked = config.random;
      randomCheckbox.onclick = function() {
-        navigateWithNewParam('random', !env.randomTests());
+        navigateWithNewParam('random', !config.random);
      };

      var hideDisabled = optionsMenuDom.querySelector('#jasmine-hide-disabled');
-      hideDisabled.checked = env.hidingDisabled();
+      hideDisabled.checked = config.hideDisabled;
      hideDisabled.onclick = function() {
-        navigateWithNewParam('hideDisabled', !env.hidingDisabled());
+        navigateWithNewParam('hideDisabled', !config.hideDisabled);
      };

      var optionsTrigger = optionsMenuDom.querySelector('.jasmine-trigger'),
--- a/src/html/_HTMLReporter.scss
+++ b/src/html/_HTMLReporter.scss
@@ -16,6 +16,11 @@ $empty-color: #eff543;
 $neutral-color: #bababa;
 $jasmine-color: #8a4182;

+$passing-mark: "\02022";
+$failing-mark: "\d7";
+$pending-mark: "*";
+$space: "\0020";
+
 $font-size: 11px;
 $large-font-size: 14px;

@@ -120,7 +125,7 @@ body {

        &:before {
          color: $passing-color;
-          content: "\02022";
+          content: $passing-mark;
        }
      }

@@ -129,7 +134,7 @@ body {

        &:before {
          color: $failing-color;
-          content: "\d7";
+          content: $failing-mark;
          font-weight: bold;
          margin-left: -1px;
        }
@@ -140,7 +145,7 @@ body {

          &:before {
            color: $neutral-color;
-            content: "\02022";
+            content: $passing-mark;
          }
        }

@@ -153,7 +158,7 @@ body {
        line-height: 17px;
        &:before {
          color: $pending-color;
-          content: "*";
+          content: $pending-mark;
        }
      }

@@ -162,7 +167,7 @@ body {

        &:before {
          color: $pending-color;
-          content: "\02022";
+          content: $passing-mark;
        }
      }
    }
@@ -303,6 +308,30 @@ body {
    }
  }

+  .jasmine-specs {
+    li {
+      &.jasmine-passed a:before {
+        content: $passing-mark + $space;
+      }
+
+      &.jasmine-failed a:before {
+        content: $failing-mark + $space;
+      }
+
+      &.jasmine-empty a:before {
+        content: $pending-mark + $space;
+      }
+
+      &.jasmine-pending a:before {
+        content: $passing-mark + $space;
+      }
+
+      &.jasmine-excluded a:before {
+        content: $passing-mark + $space;
+      } 
+    }
+  }
+
  .jasmine-description + .jasmine-suite {
    margin-top: 0;
  }
Author	SHA1	Message	Date
Gregg Van Hove	b3ccd4312c	Bump version to 3.3.0	2018-10-25 09:47:09 -07:00
Gregg Van Hove	5524207658	Add api docs for `.not` and `.withContext`	2018-10-24 16:49:31 -07:00
Gregg Van Hove	1b5e0c0c10	Merge branch 'expect-context' - Fixes #641	2018-10-24 16:32:28 -07:00
Gregg Van Hove	2d303a6e46	Merge common async/sync expectation stuff	2018-10-24 16:17:30 -07:00
Gregg Van Hove	1e47dcf2cc	Pull async matchers out to their own functions - Makes AsyncExpectation closer to Expectation	2018-10-23 16:02:31 -07:00
Gregg Van Hove	ba1e8f8008	Implement `withContext` for async expectations too	2018-10-22 16:42:36 -07:00
Gregg Van Hove	a91db0dfc2	more rejected to -> rejected with	2018-10-22 16:08:57 -07:00
Gregg Van Hove	1d130036f4	Merge branch 'master' into expect-context	2018-10-22 14:55:20 -07:00
Gregg Van Hove	e6a60a7bef	Merge branch 'codymikol-toBeRejectedWith' - Merges #1615 from @codymikol - Closes #1600 - Fixes #1595	2018-10-22 11:20:03 -07:00
Gregg Van Hove	fe042fdf82	Use toBeRejectedWith instead of toBeRejectedTo	2018-10-22 11:18:56 -07:00
Gregg Van Hove	06854fe435	Merge branch 'toBeRejectedWith' of https://github.com/codymikol/jasmine into codymikol-toBeRejectedWith	2018-10-22 11:15:05 -07:00
Gregg Van Hove	7b9fc80b8f	Merge branch 'tdurtschi-master' - Merges #1616 from @tdurtshi - Fixes #1614	2018-10-22 10:59:03 -07:00
Gregg Van Hove	3c47e71619	Also show tip for `.not` cases	2018-10-22 10:57:16 -07:00
Teagan Durtschi	7cbedcdda7	Add custom message for toBe() matcher when object equality check fails	2018-10-21 12:46:49 -04:00
Cody Mikol	3aa0115ae4	feat(toBeRejectedTo): implement toBeRejectedTo functionality add functionality to determine whether a promise has been rejected to a specific value via expectAsync Fixes: #1595	2018-10-19 23:23:42 -04:00
Gregg Van Hove	440b6934aa	Merge branch 'codymikol-assertAsync-promiseLike-support' - Merges #1613 from @codymikol - Fixes #1612	2018-10-19 16:24:30 -07:00
Cody Mikol	591bf1144b	bugfix(assertAsync): add promiseLike support for angularJS promises implement a promiseLike method so libraries using non-browser promise implementations can still utilize assertAsync functionality. Fixes: #1612	2018-10-18 21:28:32 -04:00
Gregg Van Hove	3ae61b14ad	Merge branch 'm1010j-m1010j-add-status-marks-to-standalone' - Merges #1610 from @m1010j - Fixes #1596	2018-10-01 12:25:23 -07:00
Matthias Jenny	705a6508d4	Add status marks to standalone	2018-09-26 21:10:20 -04:00
Gregg Van Hove	306882f636	Merge branch 'nitobuendia-patch-1'	2018-09-25 17:29:10 -07:00
Gregg Van Hove	16fef04629	Merge branch 'patch-1' of https://github.com/nitobuendia/jasmine into nitobuendia-patch-1 - Merges #1601 from @nitobuendia - Fixes #1594	2018-09-25 17:28:57 -07:00
Gregg Van Hove	d180c2026e	Merge branch 'master' of https://github.com/Havunen/jasmine into Havunen-master - Merges #1599 from @Havunen	2018-09-25 17:14:49 -07:00
Gregg Van Hove	92d0882a32	Introduce a configuration object to `Env` deprecating old single use functions [finishes #159158038]	2018-09-25 17:08:41 -07:00
Nito Buendia	04679622b0	Add tests for formatting empty content errors.	2018-09-13 20:02:30 +08:00
Nito Buendia	b4cd1ec1ae	Format according to style.	2018-09-13 19:48:53 +08:00
Nito Buendia	963b1cca22	Add tests for new unnamed errors.	2018-09-13 19:48:10 +08:00
Nito Buendia	d4f9b41eda	Print error message when available With the current set up, error message is only printed out when error name is available. There are situations where the ErrorEvent object does not have a `name` property, but the message is still relevant. For more details see #1594	2018-09-11 23:25:28 +08:00
Sampo Kivistö	1019b045cd	Optimized clearTimeout cpu usage	2018-09-06 21:11:05 +03:00
Gregg Van Hove	6b9ae2db7e	Merge pull request #1597 from limonte/patch-1 chore(package.json): http -> https	2018-09-04 12:27:05 -07:00
Limon Monte	33d8d2d3f4	chore(package.json): http -> https	2018-09-01 10:16:30 +03:00
Gregg Van Hove	12f56fdb7d	bump version to 3.2.1	2018-08-14 17:19:23 -07:00
Gregg Van Hove	afa18e554c	Correctly expost `spyOnAllFunctions` - See #1581	2018-08-14 17:11:50 -07:00
Gregg Van Hove	7205d07c67	Merge pull request #1588 from fossabot/master Add license scan report and status	2018-08-08 19:04:21 -07:00
fossabot	f05ab79731	Add license scan report and status Signed-off-by: fossabot <badges@fossa.io>	2018-08-07 17:47:31 -07:00
Steve Gravrock	ac07c9ea97	Simplified ExpectationFilterChain#modifyFailureMessage	2018-06-09 12:34:30 -07:00
Steve Gravrock	0842a80c68	Cleanup	2018-06-09 12:26:34 -07:00
Steve Gravrock	8a01e1f26c	.withContext() works with .not	2018-06-02 22:06:53 -07:00
Steve Gravrock	321f161ce5	Made ExpectationFilterChain immutable	2018-06-02 13:57:29 -07:00
Steve Gravrock	202a677637	ExpectationFilterChain WIP	2018-06-02 13:57:07 -07:00
Steve Gravrock	e2897ce619	Added expect().withContext() to provide additional information in failure messages	2018-05-14 21:18:55 -07:00
Steve Gravrock	282c436463	Implemented matcher negation as a filter	2018-05-13 23:01:55 -07:00
Steve Gravrock	5cc22740c9	Test the public-ish interface	2018-05-13 22:48:58 -07:00
Steve Gravrock	533bda5d24	Split Expectation#wrapCompare into several smaller functions	2018-05-13 22:48:58 -07:00
Steve Gravrock	9fe9569b24	Additional tests for negated matcher failure messages	2018-05-13 22:48:20 -07:00