Link to the correct repo in release notes

Add issue links to release notes
bump version to 3.2.0
2018-08-08 17:41:24 -07:00 · 2018-08-08 17:39:10 -07:00 · 2018-08-08 17:33:50 -07:00 · 2018-07-24 17:55:44 -07:00 · 2018-07-20 07:58:17 -07:00 · 2018-06-18 17:55:24 -07:00
77 changed files with 2852 additions and 420 deletions
--- a/.jshintrc
+++ b/.jshintrc
@@ -1,9 +1,17 @@
 {
  "bitwise": true,
  "curly": true,
+  "globals": {
+    "clearTimeout": false,
+    "console": false,
+    "getJasmineRequireObj": true,
+    "jasmineRequire": true,
+    "setTimeout": false
+  },
  "immed": true,
  "newcap": true,
  "trailing": true,
  "loopfunc": true,
-  "quotmark": "single"
-}
+  "quotmark": "single",
+  "undef": true
+}
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,8 +2,11 @@ language: ruby
 cache: bundler
 sudo: false

-rvm: 2.2.2
+rvm: 2.5

+before_install:
+  - gem update --system
+  - gem install bundler
 script: $TEST_COMMAND

 env:
@@ -11,9 +14,6 @@ env:
    - USE_SAUCE=true
    - NOKOGIRI_USE_SYSTEM_LIBRARIES=true
    - TEST_COMMAND="bash travis-core-script.sh"
-    - JASMINE_BROWSER="firefox"
-    - SAUCE_OS="Linux"
-    - SAUCE_BROWSER_VERSION=''
    - secure: WSPWhlnC4mWSnSPquX+m1/BCu5ch5NygkaHuM2Nea7lD8oS3XLX8QncZZAsQ4lnNfqoDDuBOizG0AESiqNvE4y6x5qvLLTS6q+ce255ZEMZ71TBdZgDEEvGMEjOPPsVXiXyTQOP1lwOPlrbZvaPgWV7e11KIBab6DfFcQpnvDgo=
    - secure: SW7CJhZnwaNT749Gdnhvqb5rbXlAOsygUAzh9qhtyvbqXKkmJdBIEsO01YF6pbju1X2twE9JvWCOxeZju43NgQChJlPsGbjY2j3k/TdQeTAJesQe2K7ytwghunI30gjEovtRH0T3w1EmcKPH8yj5eBIcB2OYoJHx8KEC7e68q1g=

@@ -31,6 +31,10 @@ matrix:
    - env:
      - USE_SAUCE=false
      - TEST_COMMAND="bash travis-node-script.sh v9"
+    - env:
+      - JASMINE_BROWSER="firefox"
+      - SAUCE_OS="Linux"
+      - SAUCE_BROWSER_VERSION=''
    - env:
      - JASMINE_BROWSER="safari"
      - SAUCE_OS="OS X 10.12"
@@ -43,10 +47,6 @@ matrix:
      - JASMINE_BROWSER="safari"
      - SAUCE_OS="OS X 10.10"
      - SAUCE_BROWSER_VERSION=8
-    - env:
-      - JASMINE_BROWSER="safari"
-      - SAUCE_OS="OS X 10.9"
-      - SAUCE_BROWSER_VERSION=7
    - env:
      - JASMINE_BROWSER="MicrosoftEdge"
      - SAUCE_OS="Windows 10"
@@ -66,7 +66,3 @@ matrix:
    - env:
      - JASMINE_BROWSER="phantomjs"
      - USE_SAUCE=false
-    - env:
-      - USE_SAUCE=false
-      - JASMINE_BROWSER="phantomjs"
-      - TEST_COMMAND="bash travis-docs-script.sh"
--- a/README.md
+++ b/README.md
@@ -1,15 +1,16 @@
 <a name="README">[<img src="https://rawgithub.com/jasmine/jasmine/master/images/jasmine-horizontal.svg" width="400px" />](http://jasmine.github.io)</a>

 [![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)

 # A JavaScript Testing Framework

 Jasmine is a Behavior Driven Development testing framework for JavaScript. It does not rely on browsers, DOM, or any JavaScript framework. Thus it's suited for websites, [Node.js](http://nodejs.org) projects, or anywhere that JavaScript can run.

 Documentation & guides live here: [http://jasmine.github.io](http://jasmine.github.io/)
-For a quick start guide of Jasmine 2.x, see the beginning of [http://jasmine.github.io/edge/introduction.html](http://jasmine.github.io/edge/introduction.html)
+For a quick start guide of Jasmine, see the beginning of [http://jasmine.github.io/edge/introduction.html](http://jasmine.github.io/edge/introduction.html)

-Upgrading from Jasmine 1.x? Check out the [2.0 release notes](https://github.com/jasmine/jasmine/blob/v2.0.0/release_notes/20.md) for a list of what's new (including breaking interface changes). You can also read the [upgrade guide](http://jasmine.github.io/2.0/upgrading.html).
+Upgrading from Jasmine 2.x? Check out the [3.0 release notes](https://github.com/jasmine/jasmine/blob/v3.0.0/release_notes/3.0.md) for a list of what's new (including breaking changes).

 ## Contributing

@@ -73,4 +74,4 @@ Jasmine tests itself across many browsers (Safari, Chrome, Firefox, PhantomJS, M
 * [Christian Williams](mailto:antixian666@gmail.com), Cloud Foundry
 * Sheel Choksi

-Copyright (c) 2008-2017 Pivotal Labs. This software is licensed under the MIT License.
+Copyright (c) 2008-2018 Pivotal Labs. This software is licensed under the MIT License.
--- a/jasmine-core.gemspec
+++ b/jasmine-core.gemspec
@@ -14,7 +14,7 @@ Gem::Specification.new do |s|
  s.rubyforge_project = "jasmine-core"
  s.license = "MIT"

-  s.files         = Dir.glob("./lib/**/*") + Dir.glob("./lib/jasmine-core/spec/**/*.js")
+  s.files         = Dir.glob("./lib/**/*")
  s.require_paths = ["lib"]
  s.add_development_dependency "rake"
  s.add_development_dependency "sauce-connect"
--- a/lib/jasmine-core/boot.js
+++ b/lib/jasmine-core/boot.js
@@ -78,6 +78,9 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

  var throwingExpectationFailures = queryString.getParam("throwFailures");
  env.throwOnExpectationFailure(throwingExpectationFailures);
+  
+  var hideDisabled = queryString.getParam("hideDisabled");
+  env.hideDisabled(hideDisabled); 

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

--- a/lib/jasmine-core/boot/boot.js
+++ b/lib/jasmine-core/boot/boot.js
@@ -56,6 +56,9 @@

  var throwingExpectationFailures = queryString.getParam("throwFailures");
  env.throwOnExpectationFailure(throwingExpectationFailures);
+  
+  var hideDisabled = queryString.getParam("hideDisabled");
+  env.hideDisabled(hideDisabled); 

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

--- a/lib/jasmine-core/boot/node_boot.js
+++ b/lib/jasmine-core/boot/node_boot.js
@@ -1,7 +1,7 @@
 module.exports = function(jasmineRequire) {
  var jasmine = jasmineRequire.core(jasmineRequire);

-  var env = jasmine.getEnv();
+  var env = jasmine.getEnv({suppressLoadErrors: true});

  var jasmineInterface = jasmineRequire.interface(jasmine, env);

--- a/lib/jasmine-core/jasmine-html.js
+++ b/lib/jasmine-core/jasmine-html.js
@@ -25,7 +25,6 @@ jasmineRequire.html = function(j$) {
  j$.HtmlReporter = jasmineRequire.HtmlReporter(j$);
  j$.QueryString = jasmineRequire.QueryString();
  j$.HtmlSpecFilter = jasmineRequire.HtmlSpecFilter();
-  j$.matchers.toHaveClass = jasmineRequire.toHaveClass(j$);
 };

 jasmineRequire.HtmlReporter = function(j$) {
@@ -149,7 +148,7 @@ jasmineRequire.HtmlReporter = function(j$) {
      }

      symbols.appendChild(createDom('li', {
-          className: noExpectations(result) ? 'jasmine-empty' : 'jasmine-' + result.status,
+          className: this.displaySpecInCorrectFormat(result),
          id: 'spec_' + result.id,
          title: result.fullName
        }
@@ -162,10 +161,22 @@ jasmineRequire.HtmlReporter = function(j$) {
      addDeprecationWarnings(result);
    };

+    this.displaySpecInCorrectFormat = function(result) {
+      return noExpectations(result) ? 'jasmine-empty' : this.resultStatus(result.status);
+    };
+
+    this.resultStatus = function(status) {
+      if(status === 'excluded') {
+        return env.hidingDisabled() ?  'jasmine-excluded-no-display' : 'jasmine-excluded';
+      } 
+      return 'jasmine-' + status; 
+    };
+
    this.jasmineDone = function(doneResult) {
      var banner = find('.jasmine-banner');
      var alert = find('.jasmine-alert');
      var order = doneResult && doneResult.order;
+      var i;
      alert.appendChild(createDom('span', {className: 'jasmine-duration'}, 'finished in ' + timer.elapsed() / 1000 + 's'));

      banner.appendChild(optionsMenu(env));
@@ -352,7 +363,14 @@ jasmineRequire.HtmlReporter = function(j$) {
              id: 'jasmine-random-order',
              type: 'checkbox'
            }),
-            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-random-order' }, 'run tests in random order'))
+            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-random-order' }, 'run tests in random order')),
+          createDom('div', { className: 'jasmine-hide-disabled' },
+            createDom('input', {
+              className: 'jasmine-disabled',
+              id: 'jasmine-hide-disabled',
+              type: 'checkbox'
+            }),
+            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-hide-disabled' }, 'hide disabled tests'))
        )
      );

@@ -374,6 +392,12 @@ jasmineRequire.HtmlReporter = function(j$) {
        navigateWithNewParam('random', !env.randomTests());
      };

+      var hideDisabled = optionsMenuDom.querySelector('#jasmine-hide-disabled');
+      hideDisabled.checked = env.hidingDisabled();
+      hideDisabled.onclick = function() {
+        navigateWithNewParam('hideDisabled', !env.hidingDisabled());
+      };
+
      var optionsTrigger = optionsMenuDom.querySelector('.jasmine-trigger'),
        optionsPayload = optionsMenuDom.querySelector('.jasmine-payload'),
        isOpen = /\bjasmine-open\b/;
@@ -600,37 +624,3 @@ jasmineRequire.QueryString = function() {

  return QueryString;
 };
-
-jasmineRequire.toHaveClass = function(j$) {
-  /**
-   * {@link expect} the actual value to be a DOM element that has the expected class
-   * @function
-   * @name matchers#toHaveClass
-   * @param {Object} expected - The class name to test for
-   * @example
-   * var el = document.createElement('div');
-   * el.className = 'foo bar baz';
-   * expect(el).toHaveClass('bar');
-   */
-  function toHaveClass(util, customEqualityTesters) {
-    return {
-      compare: function(actual, expected) {
-        if (!isElement(actual)) {
-          throw new Error(j$.pp(actual) + ' is not a DOM element');
-        }
-
-        return {
-          pass: actual.classList.contains(expected)
-        };
-      }
-    };
-  }
-
-  function isElement(maybeEl) {
-    return maybeEl &&
-      maybeEl.classList &&
-      j$.isFunction_(maybeEl.classList.contains);
-  }
-
-  return toHaveClass;
-};
--- a/lib/jasmine-core/jasmine.css
+++ b/lib/jasmine-core/jasmine.css
@@ -20,6 +20,7 @@ body { overflow-y: scroll; }
 .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-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-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; }
@@ -33,13 +34,7 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-bar.jasmine-passed { background-color: #007069; }
 .jasmine_html-reporter .jasmine-bar.jasmine-incomplete { background-color: #bababa; }
 .jasmine_html-reporter .jasmine-bar.jasmine-skipped { background-color: #bababa; }
-<<<<<<< HEAD
-||||||| merged common ancestors
-.jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; }
-=======
-.jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; }
 .jasmine_html-reporter .jasmine-bar.jasmine-warning { background-color: #ba9d37; color: #333; }
->>>>>>> master
 .jasmine_html-reporter .jasmine-bar.jasmine-menu { background-color: #fff; color: #aaa; }
 .jasmine_html-reporter .jasmine-bar.jasmine-menu a { color: #333; }
 .jasmine_html-reporter .jasmine-bar a { color: white; }
@@ -60,6 +55,6 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-failures .jasmine-spec-detail { margin-bottom: 28px; }
 .jasmine_html-reporter .jasmine-failures .jasmine-spec-detail .jasmine-description { background-color: #ca3a11; color: white; }
 .jasmine_html-reporter .jasmine-failures .jasmine-spec-detail .jasmine-description a { color: white; }
-.jasmine_html-reporter .jasmine-result-message { padding-top: 14px; color: #333; white-space: pre; }
+.jasmine_html-reporter .jasmine-result-message { padding-top: 14px; color: #333; white-space: pre-wrap; }
 .jasmine_html-reporter .jasmine-result-message span.jasmine-result { display: block; }
 .jasmine_html-reporter .jasmine-stack-trace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666; border: 1px solid #ddd; background: white; white-space: pre; }
--- a/lib/jasmine-core/jasmine.js
+++ b/lib/jasmine-core/jasmine.js
--- a/lib/jasmine-core/node_boot.js
+++ b/lib/jasmine-core/node_boot.js
@@ -23,7 +23,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 module.exports = function(jasmineRequire) {
  var jasmine = jasmineRequire.core(jasmineRequire);

-  var env = jasmine.getEnv();
+  var env = jasmine.getEnv({suppressLoadErrors: true});

  var jasmineInterface = jasmineRequire.interface(jasmine, env);

--- a/lib/jasmine-core/spec
+++ b/lib/jasmine-core/spec
@@ -1 +0,0 @@
-../../spec
--- a/lib/jasmine-core/version.rb
+++ b/lib/jasmine-core/version.rb
@@ -4,6 +4,6 @@
 #
 module Jasmine
  module Core
-    VERSION = "3.0.0"
+    VERSION = "3.2.0"
  end
 end
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
  "name": "jasmine-core",
  "license": "MIT",
-  "version": "3.0.0",
+  "version": "3.2.0",
  "repository": {
    "type": "git",
    "url": "https://github.com/jasmine/jasmine.git"
@@ -26,7 +26,8 @@
    "grunt-contrib-compress": "^1.3.0",
    "grunt-contrib-concat": "^1.0.1",
    "grunt-contrib-jshint": "^1.0.0",
-    "jasmine": "^2.5.0",
+    "jasmine": "^3.0.0",
+    "jsdom": "^9.12.0",
    "load-grunt-tasks": "^0.4.0",
    "shelljs": "^0.7.0",
    "temp": "~0.8.1"
--- a/release_notes/3.0.md
+++ b/release_notes/3.0.md
@@ -10,7 +10,7 @@ There is also a 2.99 release of Jasmine that will present deprecation warnings f

 * Replace old "catch exceptions" logic with proper fail fast with error reporting
  - Fixes [#414](https://github.com/jasmine/jasmine/issues/414)
-  - Fixes [jasmine/jasmine-npm#16](https://github.com/jasmine/jasmine/jasmine-npm/issues/16)
+  - Fixes [jasmine/jasmine-npm#16](https://github.com/jasmine/jasmine-npm/issues/16)

 * Detect an Error passed to `done` and add an expectation failure
  - Fixes [#567](https://github.com/jasmine/jasmine/issues/567)
@@ -29,6 +29,13 @@ There is also a 2.99 release of Jasmine that will present deprecation warnings f

 * Default to running tests in random order

+* Additionally, Jasmine 3.0 drops support for older browsers and environments. Notably:
+  - Internet Explorer 8 and 9
+  - Ruby 1.x (for the Ruby gem)
+  - Rails 3.x (for the Ruby gem)
+  - Python 2.x (for the Python wheel)
+  - Nodejs 0.x (for the NPM package)
+
 ## Changes

 * Remove node modules from python wheel, and update languages
--- a/release_notes/3.1.0.md
+++ b/release_notes/3.1.0.md
@@ -0,0 +1,54 @@
+# Jasmine-Core 3.1 Release Notes
+
+## Summary
+
+This release contains a number of fixes and pull requests
+
+## Pull Requests and Issues
+
+* Display error properties for failed specs
+  - Merges [#1516](https://github.com/jasmine/jasmine/issues/1516) from @jbunton-atlassian
+
+* Allow node to report load time errors
+  - Fixes [#1519](https://github.com/jasmine/jasmine/issues/1519)
+
+* Fixing missing semi-colons
+  - Merges [#1512](https://github.com/jasmine/jasmine/issues/1512) from @Sylhare
+
+* Fixed release notes link
+
+* Added matchers: truthy, falsy, empty and notEmpty
+  - Merges [#1460](https://github.com/jasmine/jasmine/issues/1460) from @sjolicoeur
+
+* Add API docs for async reporters
+
+* Return <anonymous> for functions that have no actual words between keyword and (
+  - Also fixes a potential catastrophic backtracking if someone has
+  severely damaged their own `toString` during test execution.
+
+* Moved toHaveClass matcher into core so that it can be used in Karma
+  - Fixes [#1503](https://github.com/jasmine/jasmine/issues/1503)
+
+* allow adding a deprecation object
+  - Merges [#1498](https://github.com/jasmine/jasmine/issues/1498) from @UziTech
+
+* Add CodeTriage badge to jasmine/jasmine
+  - Merges [#1505](https://github.com/jasmine/jasmine/issues/1505) from @codetriage-readme-bot
+
+* Resolve merge conflict
+  - Merges [#1501](https://github.com/jasmine/jasmine/issues/1501) from @aptx4869
+  - Fixes [#1500](https://github.com/jasmine/jasmine/issues/1500)
+
+* Fix release note typo
+  - Merges [#1499](https://github.com/jasmine/jasmine/issues/1499) @bcaudan
+
+* Only show deprecation for catch exceptions if you tell Jasmine not to catch
+  - Fixes [#1497](https://github.com/jasmine/jasmine/issues/1497)
+
+* Add notes for environments that have lost support
+  - Fixes [#1495](https://github.com/jasmine/jasmine/issues/1495)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_
--- a/release_notes/3.2.0.md
+++ b/release_notes/3.2.0.md
@@ -0,0 +1,83 @@
+# Jasmine-Core 3.2 Release Notes
+
+## Summary
+
+This release contains a number of fixes and pull requests
+
+## Changes
+
+* Add spyOnAllFunctions function
+  - Merges [#1581](https://github.com/jasmine/jasmine/issues/1581) from @aeisenberg
+  - Fixes [#1421](https://github.com/jasmine/jasmine/issues/1421)
+
+
+* Improve timeout error message
+  - Merges [#1567](https://github.com/jasmine/jasmine/issues/1567) from @ikonst
+
+
+* Fix JSDoc naming for Env functions
+  - See [#1565](https://github.com/jasmine/jasmine/issues/1565)
+
+
+* Add documentation for more public functions on Env
+  - Fixes [#1565](https://github.com/jasmine/jasmine/issues/1565)
+
+
+* Added a basic set of async matchers
+  - Fixes [#1447](https://github.com/jasmine/jasmine/issues/1447)
+  - Fixes [#1547](https://github.com/jasmine/jasmine/issues/1547)
+
+
+* Properly cascade StopExecutionError's up the tree
+  - Fixes [#1563](https://github.com/jasmine/jasmine/issues/1563)
+
+
+* Implemented hiding of disabled specs
+  - Merges [#1561](https://github.com/jasmine/jasmine/issues/1561) from @SamFare
+
+
+* Line-break long expectation failure messages
+  - See [#296](https://github.com/jasmine/jasmine/issues/296)
+
+
+* Better detection of DOM Nodes for equality
+  - Fixes [#1172](https://github.com/jasmine/jasmine/issues/1172)
+
+
+* Fix typo from `incimplete` to `incomplete`
+  - Merges [#1555](https://github.com/jasmine/jasmine/issues/1555) from @yinm
+
+
+* Allow omitting the name argument: `createSpy(func)`
+  - Merges [#1551](https://github.com/jasmine/jasmine/issues/1551) from @riophae
+
+
+* name new global status stuff correctly in API docs
+
+
+* Check for accidental global variable creation
+
+
+* Fixed global variable leak
+  - Fixes [#1534](https://github.com/jasmine/jasmine/issues/1534)
+
+
+* Correctly format stack traces for errors with multiline messages
+  - Fixes [#1526](https://github.com/jasmine/jasmine/issues/1526)
+
+
+* Change message for extra elements at end of actual array
+  - Merges [#1527](https://github.com/jasmine/jasmine/issues/1527) from @majidmade
+  - Fixes [#1485](https://github.com/jasmine/jasmine/issues/1485)
+
+
+* Report unhandled rejections as globalErrors.
+  - Merges [#1521](https://github.com/jasmine/jasmine/issues/1521) from @johnjbarton
+
+
+* add some links to more tutorials from the api docs
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_
--- a/spec/core/AsyncExpectationSpec.js
+++ b/spec/core/AsyncExpectationSpec.js
@@ -0,0 +1,288 @@
+describe('AsyncExpectation', function() {
+  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); }
+      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'});
+      }
+      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({
+          util: jasmineUnderTest.matchersUtil,
+          actual: actual,
+          addExpectationResult: addExpectationResult
+        });
+
+      return expectation.not.toBeResolved().then(function() {
+        expect(addExpectationResult).toHaveBeenCalledWith(false, 
+          jasmine.objectContaining({
+            passed: false,
+            message: 'Expected a promise not to be resolved.'
+          })
+        );
+      });
+    });
+
+    it('converts a fail to a pass', function() {
+      jasmine.getEnv().requirePromises();
+
+      var addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        actual = Promise.reject(),
+        expectation = jasmineUnderTest.AsyncExpectation.factory({
+          util: jasmineUnderTest.matchersUtil,
+          actual: actual,
+          addExpectationResult: addExpectationResult
+        });
+
+      return expectation.not.toBeResolved().then(function() {
+        expect(addExpectationResult).toHaveBeenCalledWith(true, 
+          jasmine.objectContaining({
+            passed: true,
+            message: ''
+          })
+        );
+      });
+    });
+  });
+
+  it('propagates rejections from the comparison function', function() {
+    jasmine.getEnv().requirePromises();
+    var error = new Error('AsyncExpectationSpec failure');
+
+    spyOn(jasmineUnderTest.AsyncExpectation.prototype, 'toBeResolved')
+      .and.returnValue(Promise.reject(error));
+
+    var addExpectationResult = jasmine.createSpy('addExpectationResult'),
+      actual = dummyPromise(),
+      expectation = new jasmineUnderTest.AsyncExpectation({
+        actual: actual,
+        addExpectationResult: addExpectationResult
+      });
+
+    return expectation.toBeResolved()
+      .then(
+        function() { fail('Expected a rejection'); },
+        function(e) { expect(e).toBe(error); }
+      );
+  });
+
+  function dummyPromise() {
+    return new Promise(function(resolve, reject) {
+    });
+  }
+});
--- a/spec/core/ClockSpec.js
+++ b/spec/core/ClockSpec.js
@@ -669,7 +669,7 @@ describe("Clock (acceptance)", function() {
    expect(global.Date().getTime()).toEqual(baseTime.getTime() + 5);

    expect(actualTimes).toEqual([baseTime.getTime(), baseTime.getTime() + 1, baseTime.getTime() + 3]);
-  })
+  });

  it('correctly clears a scheduled timeout while the Clock is advancing', function () {
    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
--- a/spec/core/EnvSpec.js
+++ b/spec/core/EnvSpec.js
@@ -197,4 +197,24 @@ describe("Env", function() {
      }).not.toThrow();
    });
  });
+
+  describe('when not constructed with suppressLoadErrors: true', function() {
+    it('installs a global error handler on construction', function() {
+      var globalErrors = jasmine.createSpyObj('globalErrors', ['install', 'pushListener', 'popListener']);
+      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
+      new jasmineUnderTest.Env();
+      expect(globalErrors.install).toHaveBeenCalled();
+    });
+  });
+
+  describe('when constructed with suppressLoadErrors: true', function() {
+    it('does not install a global error handler until execute is called', function() {
+      var globalErrors = jasmine.createSpyObj('globalErrors', ['install', 'pushListener', 'popListener']);
+      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
+      env = new jasmineUnderTest.Env({suppressLoadErrors: true});
+      expect(globalErrors.install).not.toHaveBeenCalled();
+      env.execute();
+      expect(globalErrors.install).toHaveBeenCalled();
+    });
+  });
 });
--- a/spec/core/ExceptionFormatterSpec.js
+++ b/spec/core/ExceptionFormatterSpec.js
@@ -56,6 +56,7 @@ describe("ExceptionFormatter", function() {

    it("filters Jasmine stack frames from V8 style traces", function() {
      var error = {
+        message: 'nope',
        stack: 'Error: nope\n' +
          '    at fn1 (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
          '    at fn2 (http://localhost:8888/__jasmine__/jasmine.js:4320:20)\n' +
@@ -113,8 +114,38 @@ describe("ExceptionFormatter", function() {
      }
    });

+    it("handles multiline error messages in this environment", function() {
+      var error, i, msg = "an error\nwith two lines";
+      try { throw new Error(msg); } catch(e) { error = e; }
+
+      if (error.stack.indexOf(msg) === -1) {
+        pending("Stack traces don't have messages in this environment");
+      }
+      var subject = new jasmineUnderTest.ExceptionFormatter({
+        jasmineFile: jasmine.util.jasmineFile()
+      });
+      var result = subject.stack(error);
+      var lines = result.split('\n');
+
+      expect(lines[0]).toMatch(/an error/);
+      expect(lines[1]).toMatch(/with two lines/);
+      expect(lines[2]).toMatch(/ExceptionFormatterSpec.js/);
+      expect(lines[3]).toMatch(/<Jasmine>/);
+    });
+
    it("returns null if no Error provided", function() {
      expect(new jasmineUnderTest.ExceptionFormatter().stack()).toBeNull();
    });
+
+    it("includes error properties in stack", function() {
+      var error;
+      try { throw new Error("an error") } catch(e) { error = e; }
+      error.someProperty = 'hello there';
+
+      var result = new jasmineUnderTest.ExceptionFormatter().stack(error);
+
+      expect(result).toMatch(/error properties:.*someProperty.*hello there/);
+    });
+
  });
 });
--- a/spec/core/ExpectationResultSpec.js
+++ b/spec/core/ExpectationResultSpec.js
@@ -44,6 +44,21 @@ describe("buildExpectationResult", function() {
    expect(result.stack).toEqual('foo');
  });

+  it("delegates stack formatting to the provided formatter if there was a provided errorForStack", function() {
+    var fakeError = {stack: 'foo'},
+      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
+
+    var result = jasmineUnderTest.buildExpectationResult(
+      {
+        passed: false,
+        errorForStack: fakeError,
+        stackFormatter: stackFormatter
+      });
+
+    expect(stackFormatter).toHaveBeenCalledWith(fakeError);
+    expect(result.stack).toEqual('foo');
+  });
+
  it("matcherName returns passed matcherName", function() {
    var result = jasmineUnderTest.buildExpectationResult({matcherName: 'some-value'});
    expect(result.matcherName).toBe('some-value');
--- a/spec/core/GlobalErrorsSpec.js
+++ b/spec/core/GlobalErrorsSpec.js
@@ -78,7 +78,7 @@ describe("GlobalErrors", function() {
    errors.uninstall();
  });

-  it("works in node.js", function() {
+  it("reports uncaughtException in node.js", function() {
    var fakeGlobal = {
          process: {
            on: jasmine.createSpy('process.on'),
@@ -107,4 +107,34 @@ describe("GlobalErrors", function() {
    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith('uncaughtException', addedListener);
    expect(fakeGlobal.process.on).toHaveBeenCalledWith('uncaughtException', 'foo');
  });
+
+  it("reports unhandledRejection in node.js", function() {
+    var fakeGlobal = {
+          process: {
+            on: jasmine.createSpy('process.on'),
+            removeListener: jasmine.createSpy('process.removeListener'),
+            listeners: jasmine.createSpy('process.listeners').and.returnValue(['foo']),
+            removeAllListeners: jasmine.createSpy('process.removeAllListeners')
+          }
+        },
+        handler = jasmine.createSpy('errorHandler'),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+    errors.install();
+    expect(fakeGlobal.process.on).toHaveBeenCalledWith('unhandledRejection', jasmine.any(Function));
+    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith('unhandledRejection');
+    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith('unhandledRejection');
+
+    errors.pushListener(handler);
+
+    var addedListener = fakeGlobal.process.on.calls.argsFor(0)[1];
+    addedListener(new Error('bar'));
+
+    expect(handler).toHaveBeenCalledWith(new Error('bar'));
+
+    errors.uninstall();
+
+    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith('unhandledRejection', addedListener);
+    expect(fakeGlobal.process.on).toHaveBeenCalledWith('unhandledRejection', 'foo');
+  });
 });
--- a/spec/core/QueueRunnerSpec.js
+++ b/spec/core/QueueRunnerSpec.js
@@ -183,7 +183,7 @@ describe("QueueRunner", function() {

    it("sets a timeout if requested for asynchronous functions so they don't go on forever", function() {
      var timeout = 3,
-        beforeFn = { fn: function(done) { }, type: 'before', timeout: function() { return timeout; } },
+        beforeFn = { fn: function(done) { }, type: 'before', timeout: timeout },
        queueableFn = { fn: jasmine.createSpy('fn'), type: 'queueable' },
        onComplete = jasmine.createSpy('onComplete'),
        onException = jasmine.createSpy('onException'),
@@ -304,7 +304,7 @@ describe("QueueRunner", function() {
    });

    it("continues running functions when an exception is thrown in async code without timing out", function() {
-      var queueableFn = { fn: function(done) { throwAsync(); }, timeout: function() { return 1; } },
+      var queueableFn = { fn: function(done) { throwAsync(); }, timeout: 1 },
        nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
        onException = jasmine.createSpy('onException'),
        globalErrors = { pushListener: jasmine.createSpy('pushListener'), popListener: jasmine.createSpy('popListener') },
@@ -481,15 +481,18 @@ describe("QueueRunner", function() {
      var queueableFn = { fn: function() { throw new Error("error"); } },
        nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
        cleanupFn = { fn: jasmine.createSpy("cleanup") },
+        onComplete = jasmine.createSpy("onComplete"),
        queueRunner = new jasmineUnderTest.QueueRunner({
          queueableFns: [queueableFn, nextQueueableFn],
          cleanupFns: [cleanupFn],
+          onComplete: onComplete,
          completeOnFirstError: true
        });

      queueRunner.execute();
      expect(nextQueueableFn.fn).not.toHaveBeenCalled();
      expect(cleanupFn.fn).toHaveBeenCalled();
+      expect(onComplete).toHaveBeenCalledWith(jasmine.any(jasmineUnderTest.StopExecutionError));
    });

    it("does not skip when a cleanup function throws", function() {
--- a/spec/core/SpyRegistrySpec.js
+++ b/spec/core/SpyRegistrySpec.js
@@ -214,6 +214,97 @@ describe("SpyRegistry", function() {
    });
  });

+  describe("#spyOnAllFunctions", function() {
+    it("checks for the existence of the object", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry();
+      expect(function() {
+        spyRegistry.spyOnAllFunctions(void 0);
+      }).toThrowError(/spyOnAllFunctions could not find an object to spy upon/);
+    });
+
+    it("overrides all writable and configurable functions of the object", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: function() {
+        return 'I am a spy';
+      }});
+      var createNoop = function() { return function() { /**/}; };
+      var noop1 = createNoop();
+      var noop2 = createNoop();
+      var noop3 = createNoop();
+      var noop4 = createNoop();
+      var noop5 = createNoop();
+
+      var parent = {
+        notSpied1: noop1
+      };
+      var subject = Object.create(parent);
+      Object.defineProperty(subject, 'spied1', {
+        value: noop1,
+        writable: true,
+        configurable: true,
+        enumerable: true
+      });
+      Object.defineProperty(subject, 'spied2', {
+        value: noop2,
+        writable: true,
+        configurable: true,
+        enumerable: true
+      });
+      var _spied3 = noop3;
+      Object.defineProperty(subject, 'spied3', {
+        configurable: true,
+        set: function (val) {
+          _spied3 = val;
+        },
+        get: function() {
+          return _spied3;
+        },
+        enumerable: true
+      });
+      subject.spied4 = noop4;
+      Object.defineProperty(subject, 'notSpied2', {
+        value: noop2,
+        writable: false,
+        configurable: true,
+        enumerable: true
+      });
+      Object.defineProperty(subject, 'notSpied3', {
+        value: noop3,
+        writable: true,
+        configurable: false,
+        enumerable: true
+      });
+      Object.defineProperty(subject, 'notSpied4', {
+        configurable: false,
+        set: function(val) { /**/ },
+        get: function() {
+          return noop4;
+        },
+        enumerable: true
+      });
+      Object.defineProperty(subject, 'notSpied5', {
+        value: noop5,
+        writable: true,
+        configurable: true,
+        enumerable: false
+      });
+      subject.notSpied6 = 6;
+
+      var spiedObject = spyRegistry.spyOnAllFunctions(subject);
+
+      expect(subject.notSpied1).toBe(noop1);
+      expect(subject.notSpied2).toBe(noop2);
+      expect(subject.notSpied3).toBe(noop3);
+      expect(subject.notSpied4).toBe(noop4);
+      expect(subject.notSpied5).toBe(noop5);
+      expect(subject.notSpied6).toBe(6);
+      expect(subject.spied1).toBe('I am a spy');
+      expect(subject.spied2).toBe('I am a spy');
+      expect(subject.spied3).toBe('I am a spy');
+      expect(subject.spied4).toBe('I am a spy');
+      expect(spiedObject).toBe(subject);
+    });
+  });
+
  describe("#clearSpies", function() {
    it("restores the original functions on the spied-upon objects", function() {
      var spies = [],
--- a/spec/core/SpySpec.js
+++ b/spec/core/SpySpec.js
@@ -20,6 +20,18 @@ describe('Spies', function () {
      expect(spy.bob).toEqual("test");
    });

+    it("should allow you to omit the name argument and only pass the originalFn argument", function() {
+      var fn = function test() {};
+      var spy = env.createSpy(fn);
+
+      // IE doesn't do `.name`
+      if (fn.name === "test") {
+        expect(spy.and.identity).toEqual("test");
+      } else {
+        expect(spy.and.identity).toEqual("unknown");
+      }
+    })
+
    it("warns the user that we intend to overwrite an existing property", function() {
      TestClass.prototype.someFunction.and = "turkey";

--- a/spec/core/StackTraceSpec.js
+++ b/spec/core/StackTraceSpec.js
@@ -1,11 +1,14 @@
 describe("StackTrace", function() {
  it("understands Chrome/IE/Edge style traces", function() {
-    var raw = 
-      'Error: nope\n' +
-      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
-      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)';
+    var error = {
+      message: 'nope',
+      stack:
+        'Error: nope\n' +
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+        '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
+    };

-    var result = new jasmineUnderTest.StackTrace(raw);
+    var result = new jasmineUnderTest.StackTrace(error);

    expect(result.message).toEqual('Error: nope');
    expect(result.style).toEqual('v8');
@@ -25,13 +28,36 @@ describe("StackTrace", function() {
    ]);
  });

+  it("understands Chrome/IE/Edge style traces with multiline messages", function() {
+    var error = {
+      message: 'line 1\nline 2',
+      stack:
+        'Error: line 1\nline 2\n' +
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+        '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
+    };
+
+    var result = new jasmineUnderTest.StackTrace(error);
+
+    expect(result.message).toEqual('Error: line 1\nline 2');
+    var rawFrames = result.frames.map(function(f) { return f.raw; });
+    expect(rawFrames).toEqual([
+      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+    ]);
+  });
+
  it("understands Node style traces", function() {
-    var raw = 'Error\n' +
-      '  at /somewhere/jasmine/lib/jasmine-core/jasmine.js:4255:9\n' +
-      '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)\n' +
-      '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)\n' +
-      '  at runCallback (timers.js:672:20)';
-    var result = new jasmineUnderTest.StackTrace(raw);
+    var error = {
+      message: 'nope',
+      stack:
+        'Error\n' +
+        '  at /somewhere/jasmine/lib/jasmine-core/jasmine.js:4255:9\n' +
+        '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)\n' +
+        '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)\n' +
+        '  at runCallback (timers.js:672:20)'
+    };
+    var result = new jasmineUnderTest.StackTrace(error);

    expect(result.message).toEqual('Error');
    expect(result.style).toEqual('v8');
@@ -64,10 +90,13 @@ describe("StackTrace", function() {
  });

  it("understands Safari/Firefox/Phantom-OS X style traces", function() {
-    var raw = 
-      'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
-      'run@http://localhost:8888/__jasmine__/jasmine.js:4320:27';
-    var result = new jasmineUnderTest.StackTrace(raw);
+    var error = {
+      message: 'nope',
+      stack:
+        'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+        'run@http://localhost:8888/__jasmine__/jasmine.js:4320:27'
+    };
+    var result = new jasmineUnderTest.StackTrace(error);

    expect(result.message).toBeFalsy();
    expect(result.style).toEqual('webkit');
@@ -88,20 +117,26 @@ describe("StackTrace", function() {
  });

  it("does not mistake gibberish for Safari/Firefox/Phantom-OS X style traces", function() {
-    var raw = 'randomcharsnotincludingwhitespace';
-    var result = new jasmineUnderTest.StackTrace(raw);
+    var error = {
+      message: 'nope',
+      stack: 'randomcharsnotincludingwhitespace'
+    };
+    var result = new jasmineUnderTest.StackTrace(error);
    expect(result.style).toBeNull();
    expect(result.frames).toEqual([
-      { raw: raw }
+      { raw: error.stack }
    ]);
  });

  it("understands Phantom-Linux style traces", function() {
-    var raw = 
-      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
-      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)';
+    var error = {
+      message: 'nope',
+      stack: 
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+        '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
+    };

-    var result = new jasmineUnderTest.StackTrace(raw);
+    var result = new jasmineUnderTest.StackTrace(error);

    expect(result.message).toBeFalsy();
    expect(result.style).toEqual('v8');
@@ -122,10 +157,13 @@ describe("StackTrace", function() {
  });

  it("ignores blank lines", function() {
-    var raw = 
-      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n';
+    var error = {
+      message: 'nope',
+      stack:
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n'
+    };

-    var result = new jasmineUnderTest.StackTrace(raw);
+    var result = new jasmineUnderTest.StackTrace(error);

    expect(result.frames).toEqual([
      {
@@ -138,12 +176,15 @@ describe("StackTrace", function() {
  });

  it("omits properties except 'raw' for frames that are not understood", function() {
-    var raw = 
-      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
-      '    but this is quite unexpected\n' +
-      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)';
+    var error = {
+      message: 'nope',
+      stack:
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+        '    but this is quite unexpected\n' +
+        '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
+    };

-    var result = new jasmineUnderTest.StackTrace(raw);
+    var result = new jasmineUnderTest.StackTrace(error);
    expect(result.style).toEqual('v8');
    expect(result.frames).toEqual([
      {
--- a/spec/core/TreeProcessorSpec.js
+++ b/spec/core/TreeProcessorSpec.js
@@ -297,7 +297,7 @@ describe("TreeProcessor", function() {
    node.getResult.and.returnValue({ my: 'result' });

    queueRunner.calls.mostRecent().args[0].onComplete();
-    expect(nodeComplete).toHaveBeenCalledWith(node, { my: 'result' }, nodeDone);
+    expect(nodeComplete).toHaveBeenCalledWith(node, { my: 'result' }, jasmine.any(Function));
  });

  it("runs a node with children", function() {
@@ -328,6 +328,37 @@ describe("TreeProcessor", function() {
    expect(leaf2.execute).toHaveBeenCalledWith('bar', false);
  });

+  it("cascades errors up the tree", function() {
+    var leaf = new Leaf(),
+        node = new Node({ children: [leaf] }),
+        root = new Node({ children: [node] }),
+        queueRunner = jasmine.createSpy('queueRunner'),
+        nodeComplete = jasmine.createSpy('nodeComplete'),
+        processor = new jasmineUnderTest.TreeProcessor({
+          tree: root,
+          runnableIds: [node.id],
+          nodeComplete: nodeComplete,
+          queueRunnerFactory: queueRunner
+        }),
+        treeComplete = jasmine.createSpy('treeComplete'),
+        nodeDone = jasmine.createSpy('nodeDone');
+
+    processor.execute(treeComplete);
+    var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
+    queueableFns[0].fn(nodeDone);
+
+    queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
+    expect(queueableFns.length).toBe(2);
+
+    queueableFns[1].fn('foo');
+    expect(leaf.execute).toHaveBeenCalledWith('foo', false);
+
+    queueRunner.calls.mostRecent().args[0].onComplete('things');
+    expect(nodeComplete).toHaveBeenCalled();
+    nodeComplete.calls.mostRecent().args[2]();
+    expect(nodeDone).toHaveBeenCalledWith('things');
+  });
+
  it("runs an excluded node with leaf", function() {
    var leaf1 = new Leaf(),
        node = new Node({ children: [leaf1] }),
@@ -361,7 +392,7 @@ describe("TreeProcessor", function() {
    node.getResult.and.returnValue({ im: 'disabled' });

    queueRunner.calls.mostRecent().args[0].onComplete();
-    expect(nodeComplete).toHaveBeenCalledWith(node, { im: 'disabled' }, nodeDone);
+    expect(nodeComplete).toHaveBeenCalledWith(node, { im: 'disabled' }, jasmine.any(Function));
  });

  it("runs beforeAlls for a node with children", function() {
--- a/spec/core/UserContextSpec.js
+++ b/spec/core/UserContextSpec.js
@@ -32,7 +32,7 @@ describe("UserContext", function() {
    describe('when using a regular object as parameter', function() {
      beforeEach(function() {
        this.context = {};
-        this.value = 'value'
+        this.value = 'value';
        this.context.key = this.value;
        this.cloned = jasmineUnderTest.UserContext.fromExisting(this.context);
      });
--- a/spec/core/asymmetric_equality/EmptySpec.js
+++ b/spec/core/asymmetric_equality/EmptySpec.js
@@ -0,0 +1,51 @@
+describe("Empty", function () {
+  it("matches an empty object", function () {
+    var empty = new jasmineUnderTest.Empty();
+
+    expect(empty.asymmetricMatch({})).toBe(true);
+    expect(empty.asymmetricMatch({undefined: false})).toBe(false);
+  });
+
+  it("matches an empty array", function () {
+    var empty = new jasmineUnderTest.Empty();
+
+    expect(empty.asymmetricMatch([])).toBe(true);
+    expect(empty.asymmetricMatch([1, 12, 3])).toBe(false);
+  });
+
+  it("matches an empty string", function () {
+    var empty = new jasmineUnderTest.Empty();
+
+    expect(empty.asymmetricMatch("")).toBe(true);
+    expect(empty.asymmetricMatch('')).toBe(true);
+    expect(empty.asymmetricMatch('12312')).toBe(false);
+  });
+
+  it("matches an empty map", function () {
+    jasmine.getEnv().requireFunctioningMaps();
+    var empty = new jasmineUnderTest.Empty();
+    var fullMap = new Map();
+    fullMap.set('thing', 2);
+
+    expect(empty.asymmetricMatch(new Map())).toBe(true);
+    expect(empty.asymmetricMatch(fullMap)).toBe(false);
+  });
+
+  it("matches an empty set", function () {
+    jasmine.getEnv().requireFunctioningSets();
+    var empty = new jasmineUnderTest.Empty();
+    var fullSet = new Set();
+    fullSet.add(3);
+
+    expect(empty.asymmetricMatch(new Set())).toBe(true);
+    expect(empty.asymmetricMatch(fullSet)).toBe(false);
+  });
+
+  it("matches an empty typed array", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+    var empty = new jasmineUnderTest.Empty();
+
+    expect(empty.asymmetricMatch(new Int16Array())).toBe(true);
+    expect(empty.asymmetricMatch(new Int16Array([1,2]))).toBe(false);
+  });
+});
--- a/spec/core/asymmetric_equality/FalsySpec.js
+++ b/spec/core/asymmetric_equality/FalsySpec.js
@@ -0,0 +1,38 @@
+describe("Falsy", function() {
+    it("is true for an empty string", function() {
+        var falsy = new jasmineUnderTest.Falsy();
+
+        expect(falsy.asymmetricMatch("")).toBe(true);
+        expect(falsy.asymmetricMatch('')).toBe(true);
+        expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
+    });
+
+    it("is false for a number that is 0", function() {
+        var falsy = new jasmineUnderTest.Falsy(Number);
+
+        expect(falsy.asymmetricMatch(1)).toBe(false);
+        expect(falsy.asymmetricMatch(0)).toBe(true);
+        expect(falsy.asymmetricMatch(-23)).toBe(false);
+        expect(falsy.asymmetricMatch(-3.1)).toBe(false);
+    });
+
+    it("is true for a null or undefined", function() {
+        var falsy = new jasmineUnderTest.Falsy(Function);
+
+        expect(falsy.asymmetricMatch(null)).toBe(true);
+        expect(falsy.asymmetricMatch(undefined )).toBe(true);
+    });
+
+    it("is true for NaN", function() {
+        var falsy = new jasmineUnderTest.Falsy(Object);
+
+        expect(falsy.asymmetricMatch(NaN)).toBe(true);
+    });
+
+    it("is true for a false Boolean", function() {
+        var falsy = new jasmineUnderTest.Falsy(Boolean);
+
+        expect(falsy.asymmetricMatch(false)).toBe(true);
+        expect(falsy.asymmetricMatch(true)).toBe(false);
+    });
+});
--- a/spec/core/asymmetric_equality/NotEmptySpec.js
+++ b/spec/core/asymmetric_equality/NotEmptySpec.js
@@ -0,0 +1,53 @@
+describe("NotEmpty", function () {
+  it("matches a non empty object", function () {
+    var notEmpty = new jasmineUnderTest.NotEmpty();
+
+    expect(notEmpty.asymmetricMatch({undefined: false})).toBe(true);
+    expect(notEmpty.asymmetricMatch({})).toBe(false);
+  });
+
+  it("matches a non empty array", function () {
+    var notEmpty = new jasmineUnderTest.NotEmpty();
+
+    expect(notEmpty.asymmetricMatch([1, 12, 3])).toBe(true);
+    expect(notEmpty.asymmetricMatch([])).toBe(false);
+  });
+
+  it("matches a non empty string", function () {
+    var notEmpty = new jasmineUnderTest.NotEmpty();
+
+    expect(notEmpty.asymmetricMatch('12312')).toBe(true);
+    expect(notEmpty.asymmetricMatch("")).toBe(false);
+    expect(notEmpty.asymmetricMatch('')).toBe(false);
+  });
+
+  it("matches a non empty map", function () {
+    jasmine.getEnv().requireFunctioningMaps();
+    var notEmpty = new jasmineUnderTest.NotEmpty();
+    var fullMap = new Map();
+    fullMap.set('one', 1);
+    var emptyMap = new Map();
+
+    expect(notEmpty.asymmetricMatch(fullMap)).toBe(true);
+    expect(notEmpty.asymmetricMatch(emptyMap)).toBe(false);
+  });
+
+  it("matches a non empty set", function () {
+    jasmine.getEnv().requireFunctioningSets();
+    var notEmpty = new jasmineUnderTest.NotEmpty();
+    var filledSet = new Set();
+    filledSet.add(1);
+    var emptySet = new Set();
+
+    expect(notEmpty.asymmetricMatch(filledSet)).toBe(true);
+    expect(notEmpty.asymmetricMatch(emptySet)).toBe(false);
+  });
+
+  it("matches a non empty typed array", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+    var notEmpty = new jasmineUnderTest.NotEmpty();
+
+    expect(notEmpty.asymmetricMatch(new Int16Array([1,2,3]))).toBe(true);
+    expect(notEmpty.asymmetricMatch(new Int16Array())).toBe(false);
+  });
+});
--- a/spec/core/asymmetric_equality/TruthySpec.js
+++ b/spec/core/asymmetric_equality/TruthySpec.js
@@ -0,0 +1,63 @@
+describe("Truthy", function () {
+  it("is true for a non empty string", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch("foo")).toBe(true);
+    expect(truthy.asymmetricMatch("")).toBe(false);
+  });
+
+  it("is true for a number that is not 0", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch(1)).toBe(true);
+    expect(truthy.asymmetricMatch(0)).toBe(false);
+    expect(truthy.asymmetricMatch(-23)).toBe(true);
+    expect(truthy.asymmetricMatch(-3.1)).toBe(true);
+  });
+
+  it("is true for a function", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch(function () {
+    })).toBe(true);
+  });
+
+  it("is true for an Object", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch({})).toBe(true);
+  });
+
+  it("is true for a truthful Boolean", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch(true)).toBe(true);
+    expect(truthy.asymmetricMatch(false)).toBe(false);
+  });
+
+  it("is true for an empty object", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch({})).toBe(true);
+  });
+
+  it("is true for an empty array", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch([])).toBe(true);
+  });
+
+  it("is true for a date", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch(new Date())).toBe(true);
+  });
+
+  it("is true for a infiniti", function () {
+    var truthy = new jasmineUnderTest.Truthy();
+
+    expect(truthy.asymmetricMatch(Infinity)).toBe(true);
+    expect(truthy.asymmetricMatch(-Infinity)).toBe(true);
+  });
+});
+
--- a/spec/core/integration/CustomMatchersSpec.js
+++ b/spec/core/integration/CustomMatchersSpec.js
@@ -121,7 +121,7 @@ describe("Custom Matchers (Integration)", function() {

    var specExpectations = function(result) {
      expect(result.status).toEqual('passed');
-    }
+    };

    env.addReporter({ specDone: specExpectations, jasmineDone: done });
    env.execute();
--- a/spec/core/integration/EnvSpec.js
+++ b/spec/core/integration/EnvSpec.js
@@ -892,7 +892,7 @@ describe("Env integration", function() {
      };

      env.describe('test suite', function() {
-        env.beforeAll(function() { env.spyOn(testObj, 'foo');})
+        env.beforeAll(function() { env.spyOn(testObj, 'foo');});

        env.it('spec 0', function() {
          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
@@ -940,10 +940,10 @@ describe("Env integration", function() {
  });

  it("Mock clock can be installed and used in tests", function(done) {
-    var globalSetTimeout = jasmine.createSpy('globalSetTimeout'),
+    var globalSetTimeout = jasmine.createSpy('globalSetTimeout').and.callFake(function(cb, t) { setTimeout(cb, t); }),
        delayedFunctionForGlobalClock = jasmine.createSpy('delayedFunctionForGlobalClock'),
        delayedFunctionForMockClock = jasmine.createSpy('delayedFunctionForMockClock'),
-        env = new jasmineUnderTest.Env({global: { setTimeout: globalSetTimeout }});
+        env = new jasmineUnderTest.Env({global: { setTimeout: globalSetTimeout, clearTimeout: clearTimeout, setImmediate: function(cb) { setTimeout(cb, 0); } }});

    var assertions = function() {
      expect(delayedFunctionForMockClock).toHaveBeenCalled();
@@ -1005,6 +1005,25 @@ describe("Env integration", function() {

  describe("with a mock clock", function() {
    var realSetTimeout;
+    function createMockedEnv() {
+      // explicitly pass in timing functions so we can make sure that clear stack always works
+      // no matter how long the suite in the spec is
+      return new jasmineUnderTest.Env({ global: {
+          setTimeout: function(cb, t) {
+            var stack = jasmine.util.errorWithStack().stack;
+            if (stack.indexOf('ClearStack') >= 0) {
+              realSetTimeout(cb, t);
+            } else {
+              setTimeout(cb, t);
+            }
+          },
+          clearTimeout: clearTimeout,
+          setInterval: setInterval,
+          clearInterval: clearInterval,
+          setImmediate: function(cb) { realSetTimeout(cb, 0); }
+        }});
+    }
+
    beforeEach(function() {
      this.originalTimeout = jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL;
      realSetTimeout = setTimeout;
@@ -1019,7 +1038,7 @@ describe("Env integration", function() {
    });

    it("should wait a default interval before failing specs that haven't called done yet", function(done) {
-      var env = new jasmineUnderTest.Env(),
+      var env = createMockedEnv(),
          reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]);

      reporter.specDone.and.callFake(function(result) {
@@ -1048,7 +1067,7 @@ describe("Env integration", function() {
    });

    it("should not use the mock clock for asynchronous timeouts", function(done){
-      var env = new jasmineUnderTest.Env(),
+      var env = createMockedEnv(),
        reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]),
        clock = env.clock;

@@ -1086,28 +1105,16 @@ describe("Env integration", function() {
    });

    it('should wait a custom interval before reporting async functions that fail to call done', function(done) {
-      var env = new jasmineUnderTest.Env(),
-          reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone', 'suiteDone', 'specDone']),
-          timeoutFailure = (/^Error: Timeout - Async callback was not invoked within timeout specified by jasmine\.DEFAULT_TIMEOUT_INTERVAL\./);
+      var env = createMockedEnv(),
+          reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone', 'suiteDone', 'specDone']);

-      reporter.specDone.and.callFake(function(r) {
-        realSetTimeout(function() {
-          jasmine.clock().tick(1);
-        }, 0);
-      });
-
-      reporter.suiteDone.and.callFake(function(r) {
-        realSetTimeout(function() {
-          jasmine.clock().tick(1);
-        }, 0);
-      });
-
-      reporter.jasmineDone.and.callFake(function() {
-        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('suite beforeAll', [ timeoutFailure ]);
-        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('suite afterAll', [ timeoutFailure ]);
-        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite beforeEach times out', [ timeoutFailure ]);
-        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite afterEach times out', [ timeoutFailure ]);
-        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite it times out', [ timeoutFailure ]);
+      reporter.jasmineDone.and.callFake(function(r) {
+        expect(r.failedExpectations).toEqual([]);
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('suite beforeAll', [ /^Error: Timeout - Async callback was not invoked within 5000ms \(custom timeout\)/ ]);
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('suite afterAll', [ /^Error: Timeout - Async callback was not invoked within 2000ms \(custom timeout\)/ ]);
+        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite beforeEach times out', [/^Error: Timeout - Async callback was not invoked within 1000ms \(custom timeout\)/]);
+        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite afterEach times out', [ /^Error: Timeout - Async callback was not invoked within 4000ms \(custom timeout\)/ ]);
+        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite it times out', [ /^Error: Timeout - Async callback was not invoked within 6000ms \(custom timeout\)/ ]);

        jasmine.clock().tick(1);
        realSetTimeout(done);
@@ -1616,7 +1623,7 @@ describe("Env integration", function() {
  });

  it("should be possible to get full name from a spec", function() {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        topLevelSpec, nestedSpec, doublyNestedSpec;

    env.describe("my tests", function() {
@@ -1638,7 +1645,7 @@ describe("Env integration", function() {
  });

  it("Custom equality testers should be per spec", function(done) {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        reporter = jasmine.createSpyObj('fakeReporter', [
          "jasmineDone",
          "specDone"
@@ -1672,7 +1679,7 @@ describe("Env integration", function() {
  });

  it("Custom equality testers should be per suite", function(done) {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        reporter = jasmine.createSpyObj('fakeReporter', [
          "jasmineDone",
          "specDone"
@@ -1715,7 +1722,7 @@ describe("Env integration", function() {
  });

  it("Custom equality testers for toContain should be per spec", function(done) {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        reporter = jasmine.createSpyObj('fakeReporter', [
          "jasmineDone",
          "specDone"
@@ -1766,7 +1773,7 @@ describe("Env integration", function() {
  });

  it("Custom equality testers for toContain should be per suite", function(done) {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        reporter = jasmine.createSpyObj('fakeReporter', [
          "jasmineDone",
          "specDone"
@@ -1809,7 +1816,7 @@ describe("Env integration", function() {
  });

  it("Custom matchers should be per spec", function(done) {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        matchers = {
          toFoo: function() {}
        };
@@ -1831,7 +1838,7 @@ describe("Env integration", function() {
  });

  it("Custom matchers should be per suite", function(done) {
-    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+    var env = new jasmineUnderTest.Env(),
        matchers = {
          toFoo: function() {}
        };
@@ -2060,11 +2067,13 @@ describe("Env integration", function() {
    env.execute();
  });

-  describe('If suppressLoadErrors was called', function() {
-    it('does not report or handle errors that occur during loading', function(done) {
+  describe('If suppressLoadErrors: true was passed', function() {
+    it('does not install a global error handler during loading', function(done) {
+      var originalOnerror = jasmine.createSpy('original onerror')
      var global = {
        setTimeout: function(fn, delay) { setTimeout(fn, delay) },
-        clearTimeout: function(fn, delay) { clearTimeout(fn, delay) }
+        clearTimeout: function(fn, delay) { clearTimeout(fn, delay) },
+        onerror: originalOnerror
      };
      spyOn(jasmineUnderTest, 'getGlobal').and.returnValue(global);
      var globalErrors = new jasmineUnderTest.GlobalErrors(global);
@@ -2072,17 +2081,16 @@ describe("Env integration", function() {
      globalErrors.pushListener(onerror);
      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);

-      var env = new jasmineUnderTest.Env(),
+      var env = new jasmineUnderTest.Env({suppressLoadErrors: true});
        reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);

      reporter.jasmineDone.and.callFake(function(e) {
        expect(e.failedExpectations).toEqual([]);
-        expect(onerror).toHaveBeenCalledWith('Uncaught Error: ENOCHEESE');
+        expect(originalOnerror).toHaveBeenCalledWith('Uncaught Error: ENOCHEESE');
        done();
      });

      env.addReporter(reporter);
-      env.suppressLoadErrors(true);
      global.onerror('Uncaught Error: ENOCHEESE');

      env.execute();
@@ -2303,6 +2311,9 @@ describe("Env integration", function() {
    var env = new jasmineUnderTest.Env(),
      reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);

+    // prevent deprecation from being desplayed
+    spyOn(console, "error");
+
    reporter.jasmineDone.and.callFake(function(result) {
      expect(result.deprecationWarnings).toEqual([
        jasmine.objectContaining({ message: 'top level deprecation' })
@@ -2341,4 +2352,167 @@ describe("Env integration", function() {

    env.execute();
  });
+
+  it('should report deprecation stack with an error object', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
+      reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']),
+      topLevelError, suiteLevelError, specLevelError;
+
+      try { throw new Error('top level deprecation') } catch (err) { topLevelError = err; }
+      try { throw new Error('suite level deprecation') } catch (err) { suiteLevelError = err; }
+      try { throw new Error('spec level deprecation') } catch (err) { specLevelError = err; }
+
+    // prevent deprecation from being desplayed
+    spyOn(console, "error");
+
+    reporter.jasmineDone.and.callFake(function(result) {
+      expect(result.deprecationWarnings).toEqual([
+        jasmine.objectContaining({
+          message: topLevelError.message,
+          stack: exceptionFormatter.stack(topLevelError)
+        })
+      ]);
+
+      expect(reporter.suiteDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        fullName: 'suite',
+        deprecationWarnings: [
+          jasmine.objectContaining({
+            message: suiteLevelError.message,
+            stack: exceptionFormatter.stack(suiteLevelError)
+          })
+        ]
+      }));
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        fullName: 'suite spec',
+        deprecationWarnings: [
+          jasmine.objectContaining({
+            message: specLevelError.message,
+            stack: exceptionFormatter.stack(specLevelError)
+          })
+        ]
+      }));
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.deprecated(topLevelError);
+
+    env.describe('suite', function() {
+      env.beforeAll(function() {
+        env.deprecated(suiteLevelError);
+      });
+
+      env.it('spec', function() {
+        env.deprecated(specLevelError);
+      });
+    });
+
+    env.execute();
+  });
+
+  it('supports async matchers', function(done) {
+    jasmine.getEnv().requirePromises();
+
+    var env = new jasmineUnderTest.Env(),
+        specDone = jasmine.createSpy('specDone'),
+        suiteDone = jasmine.createSpy('suiteDone');
+
+    env.addReporter({
+      specDone: specDone,
+      suiteDone: suiteDone,
+      jasmineDone: function(result) {
+        expect(result.failedExpectations).toEqual([jasmine.objectContaining({
+            message: 'Expected a promise to be rejected.'
+        })]);
+
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'has an async failure',
+          failedExpectations: [jasmine.objectContaining({
+            message: 'Expected a promise to be rejected.'
+          })]
+        }));
+
+        expect(suiteDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'a suite',
+          failedExpectations: [jasmine.objectContaining({
+            message: 'Expected a promise to be rejected.'
+          })]
+        }));
+
+        done();
+      }
+    });
+
+    function fail(innerDone) {
+      var resolve;
+      var p = new Promise(function(res, rej) { resolve = res });
+      env.expectAsync(p).toBeRejected().then(innerDone);
+      resolve();
+    }
+
+    env.afterAll(fail);
+    env.describe('a suite', function() {
+      env.afterAll(fail);
+      env.it('has an async failure', fail);
+    });
+
+    env.execute();
+  });
+
+  it('provides custom equality testers to async matchers', function(done) {
+    jasmine.getEnv().requirePromises();
+
+    var env = new jasmineUnderTest.Env(),
+        specDone = jasmine.createSpy('specDone');
+
+    env.addReporter({
+      specDone: specDone,
+      jasmineDone: function() {
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'has an async failure',
+          failedExpectations: []
+        }));
+        done();
+      }
+    });
+
+    env.it('has an async failure', function() {
+      env.addCustomEqualityTester(function() { return true; });
+      var p = Promise.resolve('something');
+      return env.expectAsync(p).toBeResolvedTo('something else');
+    });
+
+    env.execute();
+  });
+
+  it('includes useful stack frames in async matcher failures', function(done) {
+    jasmine.getEnv().requirePromises();
+
+    var env = new jasmineUnderTest.Env(),
+        specDone = jasmine.createSpy('specDone');
+
+    env.addReporter({
+      specDone: specDone,
+      jasmineDone: function() {
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          failedExpectations: [jasmine.objectContaining({
+            stack: jasmine.stringMatching('EnvSpec.js')
+          })]
+        }));
+        done();
+      }
+    });
+
+    env.it('has an async failure', function() {
+      env.addCustomEqualityTester(function() { return true; });
+      var p = Promise.resolve();
+      return env.expectAsync(p).toBeRejected();
+    });
+
+    env.execute();
+  });
 });
--- a/spec/core/integration/SpecRunningSpec.js
+++ b/spec/core/integration/SpecRunningSpec.js
@@ -952,13 +952,17 @@ describe("spec running", function () {
    it("does not run further specs when one fails", function(done) {
      var actions = [];

-      env.it('fails', function() {
-        actions.push('fails');
-        env.expect(1).toBe(2);
+      env.describe('wrapper', function() {
+        env.it('fails', function() {
+          actions.push('fails');
+          env.expect(1).toBe(2);
+        });
      });

-      env.it('does not run', function() {
-        actions.push('does not run');
+      env.describe('holder', function() {
+        env.it('does not run', function() {
+          actions.push('does not run');
+        });
      });

      env.randomizeTests(false);
--- a/spec/core/matchers/matchersUtilSpec.js
+++ b/spec/core/matchers/matchersUtilSpec.js
@@ -145,7 +145,7 @@ describe("matchersUtil", function() {
        actual = { b: 1 };

      expect(jasmineUnderTest.matchersUtil.equals(actual, expected)).toBe(false);
-    })
+    });

    it("fails when comparing an empty object to an empty array (issue #114)", function() {
      var emptyObject = {},
@@ -211,11 +211,11 @@ describe("matchersUtil", function() {
          return;
        }
        var a = document.createElement("div");
-        a.setAttribute("test-attr", "attr-value")
+        a.setAttribute("test-attr", "attr-value");
        a.appendChild(document.createTextNode('test'));

        var b = document.createElement("div");
-        b.setAttribute("test-attr", "attr-value2")
+        b.setAttribute("test-attr", "attr-value2");
        b.appendChild(document.createTextNode('test'));

        expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(false);
--- a/spec/core/matchers/toBeGreaterThanOrEqualSpec.js
+++ b/spec/core/matchers/toBeGreaterThanOrEqualSpec.js
@@ -14,7 +14,7 @@ describe("toBeGreaterThanOrEqual", function() {

    result = matcher.compare(1.0, 1.0);
    expect(result.pass).toBe(true);
-  })
+  });

  it("fails when actual < expected", function() {
    var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
--- a/spec/core/matchers/toEqualSpec.js
+++ b/spec/core/matchers/toEqualSpec.js
@@ -95,7 +95,7 @@ describe("toEqual", function() {
      expected = {x: {}},
      message =
        "Expected $.x not to have properties\n" +
-        "    y: 'foo bar'"
+        "    y: 'foo bar'";

    expect(compareEquals(actual, expected).message).toEqual(message);
  });
@@ -570,50 +570,67 @@ describe("toEqual", function() {
    expect(compareEquals(actual, expected).pass).toBe(true);
  });

-  function isNotRunningInBrowser() {
-    return typeof document === 'undefined'
-  }
-
-  it("reports mismatches between DOM nodes with different tags", function() {
-    if(isNotRunningInBrowser()) {
-      return;
+  describe('DOM nodes', function() {
+    function isNotRunningInBrowser() {
+      return typeof document === 'undefined'
    }

-    var actual = {a: document.createElement('div')},
-      expected = {a: document.createElement('p')},
+    beforeEach(function(done) {
+      this.nonBrowser = isNotRunningInBrowser();
+      if (this.nonBrowser) {
+        var jsdom = require('jsdom');
+        var self = this;
+        jsdom.env('', function(err, win) {
+          if (err) {
+            done.fail(err);
+          } else {
+            jasmineUnderTest.getGlobal().Node = win.Node;
+            self.doc = win.document;
+            done();
+          }
+        });
+      } else {
+        this.doc = document;
+        done();
+      }
+    });
+
+    afterEach(function() {
+      if (this.nonBrowser) {
+        delete jasmineUnderTest.getGlobal().Node;
+      }
+    });
+
+    it("reports mismatches between DOM nodes with different tags", function() {
+      var actual = {a: this.doc.createElement('div')},
+      expected = {a: this.doc.createElement('p')},
      message = 'Expected $.a = <div> to equal <p>.';

-    expect(compareEquals(actual, expected).message).toEqual(message);
-  });
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });

-  it('reports mismatches between DOM nodes with different content', function() {
-    if(isNotRunningInBrowser()) {
-      return;
-    }
+    it('reports mismatches between DOM nodes with different content', function() {
+      var nodeA = this.doc.createElement('div'),
+      nodeB = this.doc.createElement('div');

-    var nodeA = document.createElement('div'),
-      nodeB = document.createElement('div');
+      nodeA.setAttribute('thing', 'foo');
+      nodeB.setAttribute('thing', 'bar');

-    nodeA.innerText = 'foo'
-    nodeB.innerText = 'bar'
-
-    var actual = {a: nodeA},
+      expect(nodeA.isEqualNode(nodeB)).toBe(false);
+      var actual = {a: nodeA},
      expected = {a: nodeB},
-      message = 'Expected $.a = <div>...</div> to equal <div>...</div>.';
+      message = 'Expected $.a = <div thing="foo"> to equal <div thing="bar">.';

-    expect(compareEquals(actual, expected).message).toEqual(message);
-  })
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });

-  it("reports mismatches between a DOM node and a bare Object", function() {
-    if(isNotRunningInBrowser()) {
-      return;
-    }
-
-    var actual = {a: document.createElement('div')},
+    it("reports mismatches between a DOM node and a bare Object", function() {
+      var actual = {a: this.doc.createElement('div')},
      expected = {a: {}},
      message = 'Expected $.a = <div> to equal Object({  }).';

-    expect(compareEquals(actual, expected).message).toEqual(message);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
  });

  it("reports asymmetric mismatches", function() {
@@ -658,7 +675,7 @@ describe("toEqual", function() {
      boolean: false,
      notDefined: 0,
      aNull: void 0
-    }
+    };

    var expected = {
      foo: [
@@ -675,7 +692,7 @@ describe("toEqual", function() {
      boolean: true,
      notDefined: void 0,
      aNull: null
-    }
+    };

    var message =
      'Expected $.foo[0].bar = 1 to equal 2.\n' +
@@ -690,19 +707,19 @@ describe("toEqual", function() {
      'Expected $.inf = -Infinity to equal Infinity.\n' +
      'Expected $.boolean = false to equal true.\n' +
      'Expected $.notDefined = 0 to equal undefined.\n' +
-      'Expected $.aNull = undefined to equal null.'
+      'Expected $.aNull = undefined to equal null.';

    expect(compareEquals(actual, expected).message).toEqual(message);
-  })
+  });

  describe("different length arrays", function() {
    it("actual array is longer", function() {
      var actual = [1, 1, 2, 3, 5],
        expected = [1, 1, 2, 3],
        message = 'Expected $.length = 5 to equal 4.\n' +
-          'Expected $[4] = 5 to equal undefined.';
+          'Unexpected $[4] = 5 in array.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

@@ -712,7 +729,38 @@ describe("toEqual", function() {
        message = 'Expected $.length = 4 to equal 5.\n' +
          'Expected $[4] = undefined to equal 5.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("undefined in middle of actual array", function() {
+      var actual = [1, void 0, 3],
+        expected = [1, 2, 3],
+        message = 'Expected $[1] = undefined to equal 2.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("undefined in middle of expected array", function() {
+      var actual = [1, 2, 3],
+        expected = [1, void 0, 3],
+        message = 'Expected $[1] = 2 to equal undefined.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("actual array is longer by 4 elements", function() {
+      var actual = [1, 1, 2, 3, 5, 8, 13],
+        expected = [1, 1, 2],
+        message = 'Expected $.length = 7 to equal 3.\n' +
+          'Unexpected $[3] = 3 in array.\n' +
+          'Unexpected $[4] = 5 in array.\n' +
+          'Unexpected $[5] = 8 in array.\n' +
+          'Unexpected $[6] = 13 in array.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

@@ -725,7 +773,7 @@ describe("toEqual", function() {
          'Expected $[5] = undefined to equal 8.\n' +
          'Expected $[6] = undefined to equal 13.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

@@ -736,27 +784,47 @@ describe("toEqual", function() {
          'Expected $[0] = 1 to equal 2.\n' +
          'Expected $[1] = undefined to equal 3.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

-    it("object with nested array", function() {
+    it("object with nested array (actual longer than expected)", function() {
      var actual = { values: [1, 1, 2, 3] },
        expected = { values: [1, 1, 2] },
        message = 'Expected $.values.length = 4 to equal 3.\n' +
-          'Expected $.values[3] = 3 to equal undefined.';
+          'Unexpected $.values[3] = 3 in array.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

-    it("array with nested object", function() {
+    it("object with nested array (expected longer than actual)", function() {
+      var actual = { values: [1, 1, 2] },
+        expected = { values: [1, 1, 2, 3] },
+        message = 'Expected $.values.length = 3 to equal 4.\n' +
+          'Expected $.values[3] = undefined to equal 3.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("array with unexpected nested object", function() {
      var actual = [1, 1, 2, { value: 3 }],
        expected = [1, 1, 2],
        message = 'Expected $.length = 4 to equal 3.\n' +
-          'Expected $[3] = Object({ value: 3 }) to equal undefined.';
+          'Unexpected $[3] = Object({ value: 3 }) in array.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("array with missing nested object", function() {
+      var actual = [1, 1, 2],
+        expected = [1, 1, 2, { value: 3 }],
+        message = 'Expected $.length = 3 to equal 4.\n' +
+          'Expected $[3] = undefined to equal Object({ value: 3 }).';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

@@ -767,9 +835,9 @@ describe("toEqual", function() {
          'Expected $[0][1] = undefined to equal 1.\n' +
          'Expected $[1].length = 2 to equal 1.\n' +
          'Expected $[1][0] = 1 to equal 2.\n' +
-          'Expected $[1][1] = 2 to equal undefined.';
+          'Unexpected $[1][1] = 2 in array.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });

@@ -778,7 +846,7 @@ describe("toEqual", function() {
        expected = [1, 2, void 0],
        message = 'Expected $.length = 2 to equal 3.';

-      expect(compareEquals(actual, expected).pass).toBe(false)
+      expect(compareEquals(actual, expected).pass).toBe(false);
      expect(compareEquals(actual, expected).message).toEqual(message);
    });
  })
--- a/spec/core/matchers/toHaveClassSpec.js
+++ b/spec/core/matchers/toHaveClassSpec.js
@@ -1,16 +1,38 @@
 describe('toHaveClass', function() {
+  beforeEach(function(done) {
+    this.createElementWithClassName = function(className) {
+      var el = this.doc.createElement('div');
+      el.className = className;
+      return el;
+    };
+
+    if (typeof document !== 'undefined') {
+      this.doc = document;
+      done();
+    } else {
+      var jsdom = require('jsdom');
+      var self = this;
+      jsdom.env('', function(err, win) {
+        if (err) {
+          done.fail(err);
+        } else {
+          self.doc = win.document;
+          done();
+        }
+      });
+    }
+  });
+
  it('fails for a DOM element that lacks the expected class', function() {
    var matcher = jasmineUnderTest.matchers.toHaveClass(),
-      result = matcher.compare(document.createElement('div'), 'foo');
+      result = matcher.compare(this.createElementWithClassName(''), 'foo');

    expect(result.pass).toBe(false);
  });

  it('passes for a DOM element that has the expected class', function() {
    var matcher = jasmineUnderTest.matchers.toHaveClass(),
-      el = document.createElement('div');
-
-    el.className = 'foo bar baz';
+      el = this.createElementWithClassName('foo bar baz');

    expect(matcher.compare(el, 'foo').pass).toBe(true);
    expect(matcher.compare(el, 'bar').pass).toBe(true);
@@ -19,9 +41,7 @@ describe('toHaveClass', function() {

  it('fails for a DOM element that only has other classes', function() {
    var matcher = jasmineUnderTest.matchers.toHaveClass(),
-      el = document.createElement('div');
-
-    el.className = 'foo bar';
+      el = this.createElementWithClassName('foo bar');

    expect(matcher.compare(el, 'fo').pass).toBe(false);
  });
@@ -37,8 +57,9 @@ describe('toHaveClass', function() {
      matcher.compare(undefined, 'foo');
    }).toThrowError('undefined is not a DOM element');

+    var textNode = this.doc.createTextNode('');
    expect(function() {
-      matcher.compare(document.createTextNode(''), 'foo')
+      matcher.compare(textNode, 'foo')
    }).toThrowError('HTMLNode is not a DOM element');

    expect(function() {
--- a/spec/helpers/promises.js
+++ b/spec/helpers/promises.js
@@ -0,0 +1,8 @@
+(function(env) {
+  env.requirePromises = function() {
+    if (typeof Promise !== 'function') {
+      env.pending("Environment does not support promises");
+    }
+  };
+})(jasmine.getEnv());
+
--- a/spec/html/HtmlReporterSpec.js
+++ b/spec/html/HtmlReporterSpec.js
@@ -103,7 +103,6 @@ describe("HtmlReporter", function() {
          createTextNode: function() { return document.createTextNode.apply(document, arguments); }
        });
      reporter.initialize();
-
      reporter.specDone({id: 789, status: "excluded", fullName: "symbols should have titles", passedExpectations: [], failedExpectations: []});

      var specEl = container.querySelector('.jasmine-symbol-summary li');
@@ -696,7 +695,85 @@ describe("HtmlReporter", function() {
        expect(navigateHandler).toHaveBeenCalledWith('throwFailures', false);
      });
    });
+    describe("UI for hiding disabled specs", function() {
+      it("should be unchecked if not hiding disabled specs", 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(false);
+        reporter.initialize();
+        reporter.jasmineDone({});
+
+        var disabledUI = container.querySelector(".jasmine-disabled");
+        expect(disabledUI.checked).toBe(false);
+      });
+
+      it("should be checked if hiding 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.jasmineDone({});
+
+        var disabledUI = container.querySelector(".jasmine-disabled");
+        expect(disabledUI.checked).toBe(true);
+      });
+
+      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: []
+          });
+
+        
+
+        var specEl = container.querySelector('.jasmine-symbol-summary li');
+        expect(specEl.getAttribute("class")).toEqual("jasmine-excluded-no-display");
+      });
+    });
    describe("UI for running tests in random order", function() {
      it("should be unchecked if not randomizing", function() {
        var env = new jasmineUnderTest.Env(),
@@ -1047,7 +1124,7 @@ describe("HtmlReporter", function() {
      beforeEach(function() {
        env = new jasmineUnderTest.Env();
        container = document.createElement("div");
-        var getContainer = function() { return container; }
+        var getContainer = function() { return container; };
        reporter = new jasmineUnderTest.HtmlReporter({
          env: env,
          getContainer: getContainer,
--- a/spec/html/PrettyPrintHtmlSpec.js
+++ b/spec/html/PrettyPrintHtmlSpec.js
@@ -24,4 +24,11 @@ describe("jasmineUnderTest.pp (HTML Dependent)", function () {
      expect(jasmineUnderTest.pp(err)).toMatch(/Not enough arguments/);
    }
  });
+
+  it("should stringify HTML element with text and attributes", function() {
+    var el = document.createElement('div');
+    el.setAttribute('things', 'foo');
+    el.innerHTML = 'foo';
+    expect(jasmineUnderTest.pp(el)).toEqual('<div things="foo">...</div>');
+  });
 });
--- a/spec/javascripts/support/jasmine_selenium_runner.yml
+++ b/spec/javascripts/support/jasmine_selenium_runner.yml
@@ -6,10 +6,10 @@ sauce:
  name: jasmine-core <%= Time.now.to_s %>
  username: <%= ENV['SAUCE_USERNAME'] %>
  access_key: <%= ENV['SAUCE_ACCESS_KEY'] %>
-  build: <%= ENV['TRAVIS_BUILD_NUMBER'] || 'Ran locally' %>
+  build: Core <%= ENV['TRAVIS_BUILD_NUMBER'] || 'Ran locally' %>
  tags:
-    - <%= ENV['TRAVIS_RUBY_VERSION'] || RUBY_VERSION %>
-    - CI
+    - Jasmine-Core
+    - "<%= ENV['TRAVIS_JOB_NUMBER'] %>"
  tunnel_identifier: <%= ENV['TRAVIS_JOB_NUMBER'] ? %Q("#{ENV['TRAVIS_JOB_NUMBER']}") : nil %>
  os: <%= ENV['SAUCE_OS'] %>
  browser_version: "<%= ENV['SAUCE_BROWSER_VERSION'] %>"
--- a/spec/support/jasmine.json
+++ b/spec/support/jasmine.json
@@ -11,6 +11,7 @@
    "helpers/checkForSymbol.js",
    "helpers/checkForTypedArrays.js",
    "helpers/integrationMatchers.js",
+    "helpers/promises.js",
    "helpers/nodeDefineJasmineUnderTest.js"
  ],
  "random": true
--- a/spec/support/jasmine.yml
+++ b/spec/support/jasmine.yml
@@ -24,6 +24,7 @@ helpers:
  - 'helpers/checkForSymbol.js'
  - 'helpers/checkForTypedArrays.js'
  - 'helpers/integrationMatchers.js'
+  - 'helpers/promises.js'
  - 'helpers/defineJasmineUnderTest.js'
 spec_files:
  - '**/*[Ss]pec.js'
--- a/src/core/AsyncExpectation.js
+++ b/src/core/AsyncExpectation.js
@@ -0,0 +1,153 @@
+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/Clock.js
+++ b/src/core/Clock.js
@@ -1,5 +1,6 @@
 getJasmineRequireObj().Clock = function() {

+  /* global process */
  var NODE_JS = typeof process !== 'undefined' && process.versions && typeof process.versions.node === 'string';

  /**
--- a/src/core/Env.js
+++ b/src/core/Env.js
@@ -13,9 +13,9 @@ getJasmineRequireObj().Env = function(j$) {

    var totalSpecsDefined = 0;

-    var realSetTimeout = j$.getGlobal().setTimeout;
-    var realClearTimeout = j$.getGlobal().clearTimeout;
-    var clearStack = j$.getClearStack(j$.getGlobal());
+    var realSetTimeout = global.setTimeout;
+    var realClearTimeout = global.clearTimeout;
+    var clearStack = j$.getClearStack(global);
    this.clock = new j$.Clock(global, function () { return new j$.DelayedFunctionScheduler(); }, new j$.MockDate(global));

    var runnableResources = {};
@@ -26,6 +26,7 @@ getJasmineRequireObj().Env = function(j$) {
    var throwOnExpectationFailure = false;
    var stopOnSpecFailure = false;
    var random = true;
+    var hidingDisabled = false;
    var seed = null;
    var handlingLoadErrors = true;
    var hasFailures = false;
@@ -38,17 +39,29 @@ getJasmineRequireObj().Env = function(j$) {
      return currentSpec || currentSuite();
    };

-    var globalErrors = new j$.GlobalErrors();
-    globalErrors.install();
-    globalErrors.pushListener(function(message, filename, lineno) {
-      topSuite.result.failedExpectations.push({
-        passed: false,
-        globalErrorType: 'load',
-        message: message,
-        filename: filename,
-        lineno: lineno
+    var globalErrors = null;
+
+    var installGlobalErrors = function() {
+      if (globalErrors) {
+        return;
+      }
+
+      globalErrors = new j$.GlobalErrors();
+      globalErrors.install();
+    };
+
+    if (!options.suppressLoadErrors) {
+      installGlobalErrors();
+      globalErrors.pushListener(function(message, filename, lineno) {
+        topSuite.result.failedExpectations.push({
+          passed: false,
+          globalErrorType: 'load',
+          message: message,
+          filename: filename,
+          lineno: lineno
+        });
      });
-    });
+    }

    this.specFilter = function() {
      return true;
@@ -104,6 +117,19 @@ getJasmineRequireObj().Env = function(j$) {
      }
    };

+    var asyncExpectationFactory = function(actual, spec) {
+      return j$.AsyncExpectation.factory({
+        util: j$.matchersUtil,
+        customEqualityTesters: runnableResources[spec.id].customEqualityTesters,
+        actual: actual,
+        addExpectationResult: addExpectationResult
+      });
+
+      function addExpectationResult(passed, result) {
+        return spec.addExpectationResult(passed, result);
+      }
+    };
+
    var defaultResourcesForRunnable = function(id, parentRunnableId) {
      var resources = {spies: [], customEqualityTesters: [], customMatchers: {}, customSpyStrategies: {}};

@@ -162,6 +188,13 @@ getJasmineRequireObj().Env = function(j$) {
    var maximumSpecCallbackDepth = 20;
    var currentSpecCallbackDepth = 0;

+    /**
+     * Sets whether Jasmine should throw an Error when an expectation fails.
+     * This causes a spec to only have one expectation failure.
+     * @name Env#throwOnExpectationFailure
+     * @function
+     * @param {Boolean} value Whether to throw when a expectation fails
+     */
    this.throwOnExpectationFailure = function(value) {
      throwOnExpectationFailure = !!value;
    };
@@ -170,6 +203,12 @@ getJasmineRequireObj().Env = function(j$) {
      return throwOnExpectationFailure;
    };

+    /**
+     * Set whether to stop suite execution when a spec fails
+     * @name Env#stopOnSpecFailure
+     * @function
+     * @param {Boolean} value Whether to stop suite execution when a spec fails
+     */
    this.stopOnSpecFailure = function(value) {
      stopOnSpecFailure = !!value;
    };
@@ -178,6 +217,12 @@ getJasmineRequireObj().Env = function(j$) {
      return stopOnSpecFailure;
    };

+    /**
+     * Set whether to randomize test execution order
+     * @name Env#randomizeTests
+     * @function
+     * @param {Boolean} value Whether to randomize execution order
+     */
    this.randomizeTests = function(value) {
      random = !!value;
    };
@@ -186,6 +231,12 @@ getJasmineRequireObj().Env = function(j$) {
      return random;
    };

+    /**
+     * Set the random number seed for spec randomization
+     * @name Env#seed
+     * @function
+     * @param {Number} value The seed value
+     */
    this.seed = function(value) {
      if (value) {
        seed = value;
@@ -193,18 +244,23 @@ getJasmineRequireObj().Env = function(j$) {
      return seed;
    };

-    this.suppressLoadErrors = function() {
-      if (handlingLoadErrors) {
-        globalErrors.popListener();
-      }
-      handlingLoadErrors = false;
+    this.hidingDisabled = function(value) {
+      return hidingDisabled;
    };

-    this.deprecated = function(msg) {
+    /**
+     * @name Env#hideDisabled
+     * @function
+     */
+    this.hideDisabled = function(value) {
+      hidingDisabled = !!value;
+    };
+
+    this.deprecated = function(deprecation) {
      var runnable = currentRunnable() || topSuite;
-      runnable.addDeprecationWarning(msg);
-      if(typeof console !== 'undefined' && typeof console.warn !== 'undefined') {
-        console.error('DEPRECATION: ' + msg);
+      runnable.addDeprecationWarning(deprecation);
+      if(typeof console !== 'undefined' && typeof console.error === 'function') {
+        console.error('DEPRECATION:', deprecation);
      }
    };

@@ -233,6 +289,7 @@ getJasmineRequireObj().Env = function(j$) {
      id: getNextSuiteId(),
      description: 'Jasmine__TopLevel__Suite',
      expectationFactory: expectationFactory,
+      asyncExpectationFactory: asyncExpectationFactory,
      expectationResultFactory: expectationResultFactory
    });
    defaultResourcesForRunnable(topSuite.id);
@@ -245,6 +302,7 @@ getJasmineRequireObj().Env = function(j$) {
    /**
     * This represents the available reporter callback for an object passed to {@link Env#addReporter}.
     * @interface Reporter
+     * @see custom_reporter
     */
    var reporter = new j$.ReportDispatcher([
      /**
@@ -252,6 +310,9 @@ getJasmineRequireObj().Env = function(j$) {
       * @function
       * @name Reporter#jasmineStarted
       * @param {JasmineStartedInfo} suiteInfo Information about the full Jasmine suite that is being run
+       * @param {Function} [done] Used to specify to Jasmine that this callback is asynchronous and Jasmine should wait until it has been called before moving on.
+       * @returns {} Optionally return a Promise instead of using `done` to cause Jasmine to wait for completion.
+       * @see async
       */
      'jasmineStarted',
      /**
@@ -259,6 +320,9 @@ getJasmineRequireObj().Env = function(j$) {
       * @function
       * @name Reporter#jasmineDone
       * @param {JasmineDoneInfo} suiteInfo Information about the full Jasmine suite that just finished running.
+       * @param {Function} [done] Used to specify to Jasmine that this callback is asynchronous and Jasmine should wait until it has been called before moving on.
+       * @returns {} Optionally return a Promise instead of using `done` to cause Jasmine to wait for completion.
+       * @see async
       */
      'jasmineDone',
      /**
@@ -266,6 +330,9 @@ getJasmineRequireObj().Env = function(j$) {
       * @function
       * @name Reporter#suiteStarted
       * @param {SuiteResult} result Information about the individual {@link describe} being run
+       * @param {Function} [done] Used to specify to Jasmine that this callback is asynchronous and Jasmine should wait until it has been called before moving on.
+       * @returns {} Optionally return a Promise instead of using `done` to cause Jasmine to wait for completion.
+       * @see async
       */
      'suiteStarted',
      /**
@@ -275,6 +342,9 @@ getJasmineRequireObj().Env = function(j$) {
       * @function
       * @name Reporter#suiteDone
       * @param {SuiteResult} result
+       * @param {Function} [done] Used to specify to Jasmine that this callback is asynchronous and Jasmine should wait until it has been called before moving on.
+       * @returns {} Optionally return a Promise instead of using `done` to cause Jasmine to wait for completion.
+       * @see async
       */
      'suiteDone',
      /**
@@ -282,6 +352,9 @@ getJasmineRequireObj().Env = function(j$) {
       * @function
       * @name Reporter#specStarted
       * @param {SpecResult} result Information about the individual {@link it} being run
+       * @param {Function} [done] Used to specify to Jasmine that this callback is asynchronous and Jasmine should wait until it has been called before moving on.
+       * @returns {} Optionally return a Promise instead of using `done` to cause Jasmine to wait for completion.
+       * @see async
       */
      'specStarted',
      /**
@@ -291,13 +364,16 @@ getJasmineRequireObj().Env = function(j$) {
       * @function
       * @name Reporter#specDone
       * @param {SpecResult} result
+       * @param {Function} [done] Used to specify to Jasmine that this callback is asynchronous and Jasmine should wait until it has been called before moving on.
+       * @returns {} Optionally return a Promise instead of using `done` to cause Jasmine to wait for completion.
+       * @see async
       */
      'specDone'
    ], queueRunnerFactory);

    this.execute = function(runnablesToRun) {
      var self = this;
-      this.suppressLoadErrors();
+      installGlobalErrors();

      if(!runnablesToRun) {
        if (focusedRunnables.length) {
@@ -379,8 +455,8 @@ getJasmineRequireObj().Env = function(j$) {
          /**
           * Information passed to the {@link Reporter#jasmineDone} event.
           * @typedef JasmineDoneInfo
-           * @property {OverallStatus} - The overall result of the sute: 'passed', 'failed', or 'incomplete'.
-           * @property {IncompleteReason} - Explanation of why the suite was incimplete.
+           * @property {OverallStatus} overallStatus - The overall result of the sute: 'passed', 'failed', or 'incomplete'.
+           * @property {IncompleteReason} incompleteReason - Explanation of why the suite was incomplete.
           * @property {Order} order - Information about the ordering (random or not) of this execution of the suite.
           * @property {Expectation[]} failedExpectations - List of expectations that failed in an {@link afterAll} at the global level.
           * @property {Expectation[]} deprecationWarnings - List of deprecation warnings that occurred at the global level.
@@ -407,10 +483,22 @@ getJasmineRequireObj().Env = function(j$) {
      reporter.addReporter(reporterToAdd);
    };

+    /**
+     * Provide a fallback reporter if no other reporters have been specified.
+     * @name Env#provideFallbackReporter
+     * @function
+     * @param {Reporter} reporterToAdd The reporter
+     * @see custom_reporter
+     */
    this.provideFallbackReporter = function(reporterToAdd) {
      reporter.provideFallbackReporter(reporterToAdd);
    };

+    /**
+     * Clear all registered reporters
+     * @name Env#clearReporters
+     * @function
+     */
    this.clearReporters = function() {
      reporter.clearReporters();
    };
@@ -450,6 +538,11 @@ getJasmineRequireObj().Env = function(j$) {
    };

    this.createSpy = function(name, originalFn) {
+      if (arguments.length === 1 && j$.isFunction_(name)) {
+        originalFn = name;
+        name = originalFn.name;
+      }
+
      return spyFactory.createSpy(name, originalFn);
    };

@@ -483,6 +576,7 @@ getJasmineRequireObj().Env = function(j$) {
        description: description,
        parentSuite: currentDeclarationSuite,
        expectationFactory: expectationFactory,
+        asyncExpectationFactory: asyncExpectationFactory,
        expectationResultFactory: expectationResultFactory,
        throwOnExpectationFailure: throwOnExpectationFailure
      });
@@ -576,6 +670,7 @@ getJasmineRequireObj().Env = function(j$) {
        id: getNextSpecId(),
        beforeAndAfterFns: beforeAndAfterFns(suite),
        expectationFactory: expectationFactory,
+        asyncExpectationFactory: asyncExpectationFactory,
        resultCallback: specResultCallback,
        getSpecName: function(spec) {
          return getSpecName(spec, suite);
@@ -587,7 +682,7 @@ getJasmineRequireObj().Env = function(j$) {
        userContext: function() { return suite.clonedSharedUserContext(); },
        queueableFn: {
          fn: fn,
-          timeout: function() { return timeout || j$.DEFAULT_TIMEOUT_INTERVAL; }
+          timeout: timeout || 0
        },
        throwOnExpectationFailure: throwOnExpectationFailure
      });
@@ -657,12 +752,20 @@ getJasmineRequireObj().Env = function(j$) {
      return currentRunnable().expect(actual);
    };

+    this.expectAsync = function(actual) {
+      if (!currentRunnable()) {
+        throw new Error('\'expectAsync\' was used when there was no current spec, this could be because an asynchronous test timed out');
+      }
+
+      return currentRunnable().expectAsync(actual);
+    };
+
    this.beforeEach = function(beforeEachFunction, timeout) {
      ensureIsNotNested('beforeEach');
      ensureIsFunctionOrAsync(beforeEachFunction, 'beforeEach');
      currentDeclarationSuite.beforeEach({
        fn: beforeEachFunction,
-        timeout: function() { return timeout || j$.DEFAULT_TIMEOUT_INTERVAL; }
+        timeout: timeout || 0
      });
    };

@@ -671,7 +774,7 @@ getJasmineRequireObj().Env = function(j$) {
      ensureIsFunctionOrAsync(beforeAllFunction, 'beforeAll');
      currentDeclarationSuite.beforeAll({
        fn: beforeAllFunction,
-        timeout: function() { return timeout || j$.DEFAULT_TIMEOUT_INTERVAL; }
+        timeout: timeout || 0
      });
    };

@@ -681,7 +784,7 @@ getJasmineRequireObj().Env = function(j$) {
      afterEachFunction.isCleanup = true;
      currentDeclarationSuite.afterEach({
        fn: afterEachFunction,
-        timeout: function() { return timeout || j$.DEFAULT_TIMEOUT_INTERVAL; }
+        timeout: timeout || 0
      });
    };

@@ -690,7 +793,7 @@ getJasmineRequireObj().Env = function(j$) {
      ensureIsFunctionOrAsync(afterAllFunction, 'afterAll');
      currentDeclarationSuite.afterAll({
        fn: afterAllFunction,
-        timeout: function() { return timeout || j$.DEFAULT_TIMEOUT_INTERVAL; }
+        timeout: timeout || 0
      });
    };

@@ -712,11 +815,11 @@ getJasmineRequireObj().Env = function(j$) {
        message += ': ';
        if (error.message) {
          message += error.message;
-        } else if (jasmine.isString_(error)) {
+        } else if (j$.isString_(error)) {
          message += error;
        } else {
          // pretty print all kind of objects. This includes arrays.
-          message += jasmine.pp(error);
+          message += j$.pp(error);
        }
      }

--- a/src/core/ExceptionFormatter.js
+++ b/src/core/ExceptionFormatter.js
@@ -27,20 +27,24 @@ getJasmineRequireObj().ExceptionFormatter = function(j$) {
        return null;
      }

-      var stackTrace = new j$.StackTrace(error.stack);
+      var stackTrace = new j$.StackTrace(error);
      var lines = filterJasmine(stackTrace);
+      var result = '';

      if (stackTrace.message) {
        lines.unshift(stackTrace.message);
      }

-      return lines.join('\n');
+      result += formatProperties(error);
+      result += lines.join('\n');
+
+      return result;
    };

    function filterJasmine(stackTrace) {
      var result = [],
        jasmineMarker = stackTrace.style === 'webkit' ? '<Jasmine>' : '    at <Jasmine>';
- 
+
      stackTrace.frames.forEach(function(frame) {
        if (frame.file && frame.file !== jasmineFile) {
          result.push(frame.raw);
@@ -48,9 +52,33 @@ getJasmineRequireObj().ExceptionFormatter = function(j$) {
          result.push(jasmineMarker);
        }
      });
- 
+
      return result;
    }
+
+    function formatProperties(error) {
+      if (!(error instanceof Object)) {
+        return;
+      }
+
+      var ignored = ['name', 'message', 'stack', 'fileName', 'sourceURL', 'line', 'lineNumber', 'column', 'description'];
+      var result = {};
+      var empty = true;
+
+      for (var prop in error) {
+        if (j$.util.arrayContains(ignored, prop)) {
+          continue;
+        }
+        result[prop] = error[prop];
+        empty = false;
+      }
+
+      if (!empty) {
+        return 'error properties: ' + j$.pp(result) + '\n';
+      }
+
+      return '';
+    }
  }

  return ExceptionFormatter;
--- a/src/core/Expectation.js
+++ b/src/core/Expectation.js
@@ -21,7 +21,7 @@ getJasmineRequireObj().Expectation = function() {
    return function() {
      var args = Array.prototype.slice.call(arguments, 0),
        expected = args.slice(0),
-        message = '';
+        message;

      args.unshift(this.actual);

@@ -39,20 +39,7 @@ getJasmineRequireObj().Expectation = function() {
      }

      var result = matcherCompare.apply(null, args);
-
-      if (!result.pass) {
-        if (!result.message) {
-          args.unshift(this.isNot);
-          args.unshift(name);
-          message = this.util.buildFailureMessage.apply(null, args);
-        } else {
-          if (Object.prototype.toString.apply(result.message) === '[object Function]') {
-            message = result.message();
-          } else {
-            message = result.message;
-          }
-        }
-      }
+      message = Expectation.finalizeMessage(this.util, name, this.isNot, args, result);

      if (expected.length == 1) {
        expected = expected[0];
@@ -73,6 +60,23 @@ getJasmineRequireObj().Expectation = function() {
    };
  };

+  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]') {
+        return result.message();
+      } else {
+        return result.message;
+      }
+    } else {
+      args = args.slice();
+      args.unshift(isNot);
+      args.unshift(name);
+      return util.buildFailureMessage.apply(null, args);
+    }
+  };
+
  Expectation.addCoreMatchers = function(matchers) {
    var prototype = Expectation.prototype;
    for (var matcherName in matchers) {
--- a/src/core/ExpectationResult.js
+++ b/src/core/ExpectationResult.js
@@ -45,10 +45,16 @@ getJasmineRequireObj().buildExpectationResult = function() {

      var error = options.error;
      if (!error) {
-        try {
-          throw new Error(message());
-        } catch (e) {
-          error = e;
+        if (options.errorForStack) {
+          error = options.errorForStack;
+        } else if (options.stack) {
+          error = options;
+        } else {
+          try {
+            throw new Error(message());
+          } catch (e) {
+            error = e;
+          }
        }
      }
      return stackFormatter(error);
--- a/src/core/GlobalErrors.js
+++ b/src/core/GlobalErrors.js
@@ -13,18 +13,29 @@ getJasmineRequireObj().GlobalErrors = function(j$) {
      }
    };

+    this.originalHandlers = {};
+    this.installOne_ = function installOne_(errorType) {
+      this.originalHandlers[errorType] = global.process.listeners(errorType);
+      global.process.removeAllListeners(errorType);
+      global.process.on(errorType, onerror);
+
+      this.uninstall = function uninstall() {
+        var errorTypes = Object.keys(this.originalHandlers);
+        for (var iType = 0; iType < errorTypes.length; iType++) {
+          var errorType = errorTypes[iType];
+          global.process.removeListener(errorType, onerror);
+          for (var i = 0; i < this.originalHandlers[errorType].length; i++) {
+            global.process.on(errorType, this.originalHandlers[errorType][i]);
+          }
+          delete this.originalHandlers[errorType];
+        }
+      };
+    };
+
    this.install = function install() {
      if (global.process && global.process.listeners && j$.isFunction_(global.process.on)) {
-        var originalHandlers = global.process.listeners('uncaughtException');
-        global.process.removeAllListeners('uncaughtException');
-        global.process.on('uncaughtException', onerror);
-
-        this.uninstall = function uninstall() {
-          global.process.removeListener('uncaughtException', onerror);
-          for (var i = 0; i < originalHandlers.length; i++) {
-            global.process.on('uncaughtException', originalHandlers[i]);
-          }
-        };
+        this.installOne_('uncaughtException');
+        this.installOne_('unhandledRejection');
      } else {
        var originalHandler = global.onerror;
        global.onerror = onerror;
--- a/src/core/PrettyPrinter.js
+++ b/src/core/PrettyPrinter.js
@@ -233,8 +233,8 @@ getJasmineRequireObj().pp = function(j$) {
    if (el.innerHTML === '') {
      this.append(el.outerHTML.replace(closingTag, ''));
    } else {
-      var tagEnd = el.outerHTML.indexOf(el.innerHTML);
-      this.append(el.outerHTML.substring(0, tagEnd));
+      var tagEnd = el.outerHTML.indexOf('>');
+      this.append(el.outerHTML.substring(0, tagEnd + 1));
      this.append('...' + closingTag);
    }
  };
--- a/src/core/QueueRunner.js
+++ b/src/core/QueueRunner.js
@@ -105,12 +105,16 @@ getJasmineRequireObj().QueueRunner = function(j$) {

    self.globalErrors.pushListener(handleError);

-    if (queueableFn.timeout) {
+    if (queueableFn.timeout !== undefined) {
+      var timeoutInterval = queueableFn.timeout || j$.DEFAULT_TIMEOUT_INTERVAL;
      timeoutId = self.setTimeout(function() {
-        var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
+        var error = new Error(
+          'Timeout - Async callback was not invoked within ' + timeoutInterval + 'ms ' +
+          (queueableFn.timeout ? '(custom timeout)' : '(set by jasmine.DEFAULT_TIMEOUT_INTERVAL)')
+        );
        onException(error);
        next();
-      }, queueableFn.timeout());
+      }, timeoutInterval);
    }

    try {
@@ -159,7 +163,7 @@ getJasmineRequireObj().QueueRunner = function(j$) {
        return;
      }

-      self.errored = result.errored;
+      self.errored = self.errored || result.errored;

      if (this.completeOnFirstError && result.errored) {
        this.skipToCleanup(iterativeIndex);
--- a/src/core/Spec.js
+++ b/src/core/Spec.js
@@ -1,6 +1,7 @@
 getJasmineRequireObj().Spec = function(j$) {
  function Spec(attrs) {
    this.expectationFactory = attrs.expectationFactory;
+    this.asyncExpectationFactory = attrs.asyncExpectationFactory;
    this.resultCallback = attrs.resultCallback || function() {};
    this.id = attrs.id;
    this.description = attrs.description || '';
@@ -57,6 +58,10 @@ getJasmineRequireObj().Spec = function(j$) {
    return this.expectationFactory(actual, this);
  };

+  Spec.prototype.expectAsync = function(actual) {
+    return this.asyncExpectationFactory(actual, this);
+  };
+
  Spec.prototype.execute = function(onComplete, excluded) {
    var self = this;

@@ -152,8 +157,11 @@ getJasmineRequireObj().Spec = function(j$) {
    return this.getSpecName(this);
  };

-  Spec.prototype.addDeprecationWarning = function(msg) {
-    this.result.deprecationWarnings.push(this.expectationResultFactory({ message: msg }));
+  Spec.prototype.addDeprecationWarning = function(deprecation) {
+    if (typeof deprecation === 'string') {
+      deprecation = { message: deprecation };
+    }
+    this.result.deprecationWarnings.push(this.expectationResultFactory(deprecation));
  };

  var extractCustomPendingMessage = function(e) {
@@ -174,5 +182,6 @@ getJasmineRequireObj().Spec = function(j$) {
 };

 if (typeof window == void 0 && typeof exports == 'object') {
+  /* globals exports */
  exports.Spec = jasmineRequire.Spec;
 }
--- a/src/core/SpyRegistry.js
+++ b/src/core/SpyRegistry.js
@@ -120,6 +120,23 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
      return spy;
    };

+    this.spyOnAllFunctions = function(obj) {
+      if (j$.util.isUndefined(obj)) {
+        throw new Error('spyOnAllFunctions could not find an object to spy upon');
+      }
+
+      for (var prop in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, prop) && obj[prop] instanceof Function) {
+          var descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+          if ((descriptor.writable || descriptor.set) && descriptor.configurable) {
+            this.spyOn(obj, prop);
+          }
+        }
+      }
+
+      return obj;
+    };
+
    this.clearSpies = function() {
      var spies = currentSpies();
      for (var i = spies.length - 1; i >= 0; i--) {
--- a/src/core/StackTrace.js
+++ b/src/core/StackTrace.js
@@ -1,13 +1,14 @@
 getJasmineRequireObj().StackTrace = function(j$) {
-  function StackTrace(rawTrace) {
-    var lines = rawTrace
+  function StackTrace(error) {
+    var lines = error.stack
      .split('\n')
      .filter(function(line) { return line !== ''; });

-    if (lines[0].match(/^Error/)) {
-      this.message = lines.shift();
-    } else {
-      this.message = undefined;
+    var extractResult = extractMessage(error.message, lines);
+
+    if (extractResult) {
+      this.message = extractResult.message;
+      lines = extractResult.remainder;
    }

    var parseResult = tryParseFrames(lines);
@@ -75,6 +76,34 @@ getJasmineRequireObj().StackTrace = function(j$) {
      }
    }
  }
+
+  function extractMessage(message, stackLines) {
+    var len = messagePrefixLength(message, stackLines);
+
+    if (len > 0) {
+      return {
+        message: stackLines.slice(0, len).join('\n'),
+        remainder: stackLines.slice(len)
+      };
+    }
+  }
+
+  function messagePrefixLength(message, stackLines) {
+    if (!stackLines[0].match(/^Error/)) {
+      return 0;
+    }
+
+    var messageLines = message.split('\n');
+    var i;
+
+    for (i = 1; i < messageLines.length; i++) {
+      if (messageLines[i] !== stackLines[i]) {
+        return 0;
+      }
+    }
+
+    return messageLines.length;
+  }
  
  return StackTrace;
 };
--- a/src/core/Suite.js
+++ b/src/core/Suite.js
@@ -5,6 +5,7 @@ getJasmineRequireObj().Suite = function(j$) {
    this.parentSuite = attrs.parentSuite;
    this.description = attrs.description;
    this.expectationFactory = attrs.expectationFactory;
+    this.asyncExpectationFactory = attrs.asyncExpectationFactory;
    this.expectationResultFactory = attrs.expectationResultFactory;
    this.throwOnExpectationFailure = !!attrs.throwOnExpectationFailure;

@@ -37,6 +38,10 @@ getJasmineRequireObj().Suite = function(j$) {
    return this.expectationFactory(actual, this);
  };

+  Suite.prototype.expectAsync = function(actual) {
+    return this.asyncExpectationFactory(actual, this);
+  };
+
  Suite.prototype.getFullName = function() {
    var fullName = [];
    for (var parentSuite = this; parentSuite; parentSuite = parentSuite.parentSuite) {
@@ -148,8 +153,11 @@ getJasmineRequireObj().Suite = function(j$) {
    }
  };

-  Suite.prototype.addDeprecationWarning = function(msg) {
-    this.result.deprecationWarnings.push(this.expectationResultFactory({ message: msg }));
+  Suite.prototype.addDeprecationWarning = function(deprecation) {
+    if (typeof deprecation === 'string') {
+      deprecation = { message: deprecation };
+    }
+    this.result.deprecationWarnings.push(this.expectationResultFactory(deprecation));
  };

  function isFailure(args) {
@@ -160,5 +168,6 @@ getJasmineRequireObj().Suite = function(j$) {
 };

 if (typeof window == void 0 && typeof exports == 'object') {
+  /* globals exports */
  exports.Suite = jasmineRequire.Suite;
 }
--- a/src/core/TreeProcessor.js
+++ b/src/core/TreeProcessor.js
@@ -174,8 +174,11 @@ getJasmineRequireObj().TreeProcessor = function() {

            queueRunnerFactory({
              onComplete: function () {
+                var args = Array.prototype.slice.call(arguments, [0]);
                node.cleanupBeforeAfter();
-                nodeComplete(node, node.getResult(), done);
+                nodeComplete(node, node.getResult(), function() {
+                  done.apply(undefined, args);
+                });
              },
              queueableFns: [onStart].concat(wrapChildren(node, segmentNumber)),
              userContext: node.sharedUserContext(),
--- a/src/core/asymmetric_equality/Any.js
+++ b/src/core/asymmetric_equality/Any.js
@@ -32,6 +32,7 @@ getJasmineRequireObj().Any = function(j$) {
    }

    /* jshint -W122 */
+    /* global Symbol */
    if (typeof Symbol != 'undefined' && this.expectedObject == Symbol) {
      return typeof other == 'symbol';
    }
--- a/src/core/asymmetric_equality/ArrayContaining.js
+++ b/src/core/asymmetric_equality/ArrayContaining.js
@@ -19,7 +19,7 @@ getJasmineRequireObj().ArrayContaining = function(j$) {
  };

  ArrayContaining.prototype.jasmineToString = function () {
-    return '<jasmine.arrayContaining(' + jasmine.pp(this.sample) +')>';
+    return '<jasmine.arrayContaining(' + j$.pp(this.sample) +')>';
  };

  return ArrayContaining;
--- a/src/core/asymmetric_equality/Empty.js
+++ b/src/core/asymmetric_equality/Empty.js
@@ -0,0 +1,25 @@
+getJasmineRequireObj().Empty = function (j$) {
+
+  function Empty() {}
+
+  Empty.prototype.asymmetricMatch = function (other) {
+    if (j$.isString_(other) || j$.isArray_(other) || j$.isTypedArray_(other)) {
+      return other.length === 0;
+    }
+
+    if (j$.isMap(other) || j$.isSet(other)) {
+      return other.size === 0;
+    }
+
+    if (j$.isObject_(other)) {
+      return Object.keys(other).length === 0;
+    }
+    return false;
+  };
+
+  Empty.prototype.jasmineToString = function () {
+    return '<jasmine.empty>';
+  };
+
+  return Empty;
+};
--- a/src/core/asymmetric_equality/Falsy.js
+++ b/src/core/asymmetric_equality/Falsy.js
@@ -0,0 +1,14 @@
+getJasmineRequireObj().Falsy = function(j$) {
+
+  function Falsy() {}
+
+  Falsy.prototype.asymmetricMatch = function(other) {
+    return !other;
+  };
+
+  Falsy.prototype.jasmineToString = function() {
+    return '<jasmine.falsy>';
+  };
+
+  return Falsy;
+};
--- a/src/core/asymmetric_equality/NotEmpty.js
+++ b/src/core/asymmetric_equality/NotEmpty.js
@@ -0,0 +1,26 @@
+getJasmineRequireObj().NotEmpty = function (j$) {
+
+  function NotEmpty() {}
+
+  NotEmpty.prototype.asymmetricMatch = function (other) {
+    if (j$.isString_(other) || j$.isArray_(other) || j$.isTypedArray_(other)) {
+      return other.length !== 0;
+    }
+
+    if (j$.isMap(other) || j$.isSet(other)) {
+      return other.size !== 0;
+    }
+
+    if (j$.isObject_(other)) {
+      return Object.keys(other).length !== 0;
+    }
+
+    return false;
+  };
+
+  NotEmpty.prototype.jasmineToString = function () {
+    return '<jasmine.notEmpty>';
+  };
+
+  return NotEmpty;
+};
--- a/src/core/asymmetric_equality/Truthy.js
+++ b/src/core/asymmetric_equality/Truthy.js
@@ -0,0 +1,14 @@
+getJasmineRequireObj().Truthy = function(j$) {
+
+  function Truthy() {}
+
+  Truthy.prototype.asymmetricMatch = function(other) {
+    return !!other;
+  };
+
+  Truthy.prototype.jasmineToString = function() {
+    return '<jasmine.truthy>';
+  };
+
+  return Truthy;
+};
--- a/src/core/base.js
+++ b/src/core/base.js
@@ -101,7 +101,14 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
  };

  j$.isDomNode = function(obj) {
-    return obj.nodeType > 0;
+    // Node is a function, because constructors
+    return typeof jasmineGlobal.Node !== 'undefined' ?
+      obj instanceof jasmineGlobal.Node :
+          obj !== null &&
+          typeof obj === 'object' &&
+          typeof obj.nodeType === 'number' &&
+          typeof obj.nodeName === 'string';
+    // return obj.nodeType > 0;
  };

  j$.isMap = function(obj) {
@@ -113,7 +120,7 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
  };

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

  j$.fnNameFor = function(func) {
@@ -121,8 +128,8 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
      return func.name;
    }

-    var matches = func.toString().match(/^\s*function\s*(\w*)\s*\(/) ||
-      func.toString().match(/^\s*\[object\s*(\w*)Constructor\]/);
+    var matches = func.toString().match(/^\s*function\s*(\w+)\s*\(/) ||
+      func.toString().match(/^\s*\[object\s*(\w+)Constructor\]/);

    return matches ? matches[1] : '<anonymous>';
  };
@@ -148,6 +155,38 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
    return new j$.Anything();
  };

+  /**
+   * Get a matcher, usable in any {@link matchers|matcher} that uses Jasmine's equality (e.g. {@link matchers#toEqual|toEqual}, {@link matchers#toContain|toContain}, or {@link matchers#toHaveBeenCalledWith|toHaveBeenCalledWith}),
+   * that will succeed if the actual value being compared is `true` or anything truthy.
+   * @name jasmine.truthy
+   * @function
+   */
+  j$.truthy = function() {return new j$.Truthy();};
+
+  /**
+   * Get a matcher, usable in any {@link matchers|matcher} that uses Jasmine's equality (e.g. {@link matchers#toEqual|toEqual}, {@link matchers#toContain|toContain}, or {@link matchers#toHaveBeenCalledWith|toHaveBeenCalledWith}),
+   * that will succeed if the actual value being compared is  `null`, `undefined`, `0`, `false` or anything falsey.
+   * @name jasmine.falsy
+   * @function
+   */
+  j$.falsy = function() {return new j$.Falsy();};
+
+  /**
+   * Get a matcher, usable in any {@link matchers|matcher} that uses Jasmine's equality (e.g. {@link matchers#toEqual|toEqual}, {@link matchers#toContain|toContain}, or {@link matchers#toHaveBeenCalledWith|toHaveBeenCalledWith}),
+   * that will succeed if the actual value being compared is empty.
+   * @name jasmine.empty
+   * @function
+   */
+  j$.empty = function() {return new j$.Empty();};
+
+  /**
+   * Get a matcher, usable in any {@link matchers|matcher} that uses Jasmine's equality (e.g. {@link matchers#toEqual|toEqual}, {@link matchers#toContain|toContain}, or {@link matchers#toHaveBeenCalledWith|toHaveBeenCalledWith}),
+   * that will succeed if the actual value being compared is not empty.
+   * @name jasmine.notEmpty
+   * @function
+   */
+  j$.notEmpty = function() {return new j$.NotEmpty();};
+
  /**
   * Get a matcher, usable in any {@link matchers|matcher} that uses Jasmine's equality (e.g. {@link matchers#toEqual|toEqual}, {@link matchers#toContain|toContain}, or {@link matchers#toHaveBeenCalledWith|toHaveBeenCalledWith}),
   * that will succeed if the actual value being compared contains at least the keys and values.
--- a/src/core/matchers/matchersUtil.js
+++ b/src/core/matchers/matchersUtil.js
@@ -225,8 +225,14 @@ getJasmineRequireObj().matchersUtil = function(j$) {
      });

      for (i = 0; i < aLength || i < bLength; i++) {
+        var formatter = false;
        diffBuilder.withPath(i, function() {
-          result = eq(i < aLength ? a[i] : void 0, i < bLength ? b[i] : void 0, aStack, bStack, customTesters, diffBuilder) && result;
+          if (i >= bLength) {
+            diffBuilder.record(a[i], void 0, actualArrayIsLongerFormatter);
+            result = false;
+          } else {
+            result = eq(i < aLength ? a[i] : void 0, i < bLength ? b[i] : void 0, aStack, bStack, customTesters, diffBuilder) && result;
+          }
        });
      }
      if (!result) {
@@ -452,6 +458,13 @@ getJasmineRequireObj().matchersUtil = function(j$) {
      ', but was ' + j$.pp(actual) + '.';
  }

+  function actualArrayIsLongerFormatter(actual, expected, path) {
+    return 'Unexpected ' +
+      path + (path.depth() ? ' = ' : '') +
+      j$.pp(actual) +
+      ' in array.';
+  }
+
  function formatKeyValuePairs(obj) {
    var formatted = '';
    for (var key in obj) {
--- a/src/core/matchers/requireMatchers.js
+++ b/src/core/matchers/requireMatchers.js
@@ -21,6 +21,7 @@ getJasmineRequireObj().requireMatchers = function(jRequire, j$) {
      'toHaveBeenCalledBefore',
      'toHaveBeenCalledTimes',
      'toHaveBeenCalledWith',
+      'toHaveClass',
      'toMatch',
      'toThrow',
      'toThrowError',
--- a/src/core/matchers/toHaveClass.js
+++ b/src/core/matchers/toHaveClass.js
@@ -1,4 +1,4 @@
-jasmineRequire.toHaveClass = function(j$) {
+getJasmineRequireObj().toHaveClass = function(j$) {
  /**
   * {@link expect} the actual value to be a DOM element that has the expected class
   * @function
--- a/src/core/requireCore.js
+++ b/src/core/requireCore.js
@@ -1,4 +1,5 @@
 var getJasmineRequireObj = (function (jasmineGlobal) {
+  /* globals exports, global, module, window */
  var jasmineRequire;

  if (typeof module !== 'undefined' && module.exports && typeof exports !== 'undefined') {
@@ -37,6 +38,7 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
    j$.StackTrace = jRequire.StackTrace(j$);
    j$.ExceptionFormatter = jRequire.ExceptionFormatter(j$);
    j$.Expectation = jRequire.Expectation();
+    j$.AsyncExpectation = jRequire.AsyncExpectation(j$);
    j$.buildExpectationResult = jRequire.buildExpectationResult();
    j$.JsApiReporter = jRequire.JsApiReporter();
    j$.matchersUtil = jRequire.matchersUtil(j$);
@@ -63,6 +65,11 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
    j$.ObjectPath = jRequire.ObjectPath(j$);
    j$.GlobalErrors = jRequire.GlobalErrors(j$);

+    j$.Truthy = jRequire.Truthy(j$);
+    j$.Falsy = jRequire.Falsy(j$);
+    j$.Empty = jRequire.Empty(j$);
+    j$.NotEmpty = jRequire.NotEmpty(j$);
+
    j$.matchers = jRequire.requireMatchers(jRequire, j$);

    return j$;
--- a/src/core/requireInterface.js
+++ b/src/core/requireInterface.js
@@ -63,6 +63,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     * @param {String} description Textual description of what this spec is checking
     * @param {implementationCallback} [testFunction] Function that contains the code of your test. If not provided the test will be `pending`.
     * @param {Int} [timeout={@link jasmine.DEFAULT_TIMEOUT_INTERVAL}] Custom timeout for an async spec.
+     * @see async
     */
    it: function() {
      return env.it.apply(env, arguments);
@@ -92,6 +93,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     * @param {String} description Textual description of what this spec is checking.
     * @param {implementationCallback} testFunction Function that contains the code of your test.
     * @param {Int} [timeout={@link jasmine.DEFAULT_TIMEOUT_INTERVAL}] Custom timeout for an async spec.
+     * @see async
     */
    fit: function() {
      return env.fit.apply(env, arguments);
@@ -104,6 +106,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     * @global
     * @param {implementationCallback} [function] Function that contains the code to setup your specs.
     * @param {Int} [timeout={@link jasmine.DEFAULT_TIMEOUT_INTERVAL}] Custom timeout for an async beforeEach.
+     * @see async
     */
    beforeEach: function() {
      return env.beforeEach.apply(env, arguments);
@@ -116,6 +119,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     * @global
     * @param {implementationCallback} [function] Function that contains the code to teardown your specs.
     * @param {Int} [timeout={@link jasmine.DEFAULT_TIMEOUT_INTERVAL}] Custom timeout for an async afterEach.
+     * @see async
     */
    afterEach: function() {
      return env.afterEach.apply(env, arguments);
@@ -130,6 +134,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     * @global
     * @param {implementationCallback} [function] Function that contains the code to setup your specs.
     * @param {Int} [timeout={@link jasmine.DEFAULT_TIMEOUT_INTERVAL}] Custom timeout for an async beforeAll.
+     * @see async
     */
    beforeAll: function() {
      return env.beforeAll.apply(env, arguments);
@@ -144,6 +149,7 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     * @global
     * @param {implementationCallback} [function] Function that contains the code to teardown your specs.
     * @param {Int} [timeout={@link jasmine.DEFAULT_TIMEOUT_INTERVAL}] Custom timeout for an async afterAll.
+     * @see async
     */
    afterAll: function() {
      return env.afterAll.apply(env, arguments);
@@ -161,6 +167,25 @@ getJasmineRequireObj().interface = function(jasmine, env) {
      return env.expect(actual);
    },

+    /**
+     * Create an asynchronous expectation for a spec. Note that the matchers
+     * that are provided by an asynchronous expectation all return promises
+     * which must be either returned from the spec or waited for using `await`
+     * in order for Jasmine to associate them with the correct spec.
+     * @name expectAsync
+     * @function
+     * @global
+     * @param {Object} actual - Actual computed value to test expectations against.
+     * @return {async-matchers}
+     * @example
+     * await expectAsync(somePromise).toBeResolved();
+     * @example
+     * return expectAsync(somePromise).toBeResolved();
+     */
+    expectAsync: function(actual) {
+      return env.expectAsync(actual);
+    },
+
    /**
     * Mark a spec as pending, expectation results will be ignored.
     * @name pending
@@ -210,6 +235,18 @@ getJasmineRequireObj().interface = function(jasmine, env) {
      return env.spyOnProperty(obj, methodName, accessType);
    },

+    /**
+     * Installs spies on all writable and configurable properties of an object.
+     * @name spyOnProperty
+     * @function
+     * @global
+     * @param {Object} obj - The object upon which to install the {@link Spy}s
+     * @returns {Object} the spied object
+     */
+    spyOnAllFunctions: function(obj) {
+      return env.spyOnAllFunctions(obj);
+    },
+
    jsApiReporter: new jasmine.JsApiReporter({
      timer: new jasmine.Timer()
    }),
--- a/src/core/util.js
+++ b/src/core/util.js
@@ -112,7 +112,7 @@ getJasmineRequireObj().util = function(j$) {
    return false;
  }

-  function errorWithStack() {
+  util.errorWithStack = function errorWithStack () {
    // Don't throw and catch if we don't have to, because it makes it harder
    // for users to debug their code with exception breakpoints.
    var error = new Error();
@@ -127,10 +127,10 @@ getJasmineRequireObj().util = function(j$) {
    } catch (e) {
      return e;
    }
-  }
+  };

  function callerFile() {
-    var trace = new j$.StackTrace(errorWithStack().stack);
+    var trace = new j$.StackTrace(util.errorWithStack());
    return trace.frames[2].file;
  }

--- a/src/html/HtmlReporter.js
+++ b/src/html/HtmlReporter.js
@@ -119,7 +119,7 @@ jasmineRequire.HtmlReporter = function(j$) {
      }

      symbols.appendChild(createDom('li', {
-          className: noExpectations(result) ? 'jasmine-empty' : 'jasmine-' + result.status,
+          className: this.displaySpecInCorrectFormat(result),
          id: 'spec_' + result.id,
          title: result.fullName
        }
@@ -132,10 +132,22 @@ jasmineRequire.HtmlReporter = function(j$) {
      addDeprecationWarnings(result);
    };

+    this.displaySpecInCorrectFormat = function(result) {
+      return noExpectations(result) ? 'jasmine-empty' : this.resultStatus(result.status);
+    };
+
+    this.resultStatus = function(status) {
+      if(status === 'excluded') {
+        return env.hidingDisabled() ?  'jasmine-excluded-no-display' : 'jasmine-excluded';
+      } 
+      return 'jasmine-' + status; 
+    };
+
    this.jasmineDone = function(doneResult) {
      var banner = find('.jasmine-banner');
      var alert = find('.jasmine-alert');
      var order = doneResult && doneResult.order;
+      var i;
      alert.appendChild(createDom('span', {className: 'jasmine-duration'}, 'finished in ' + timer.elapsed() / 1000 + 's'));

      banner.appendChild(optionsMenu(env));
@@ -322,7 +334,14 @@ jasmineRequire.HtmlReporter = function(j$) {
              id: 'jasmine-random-order',
              type: 'checkbox'
            }),
-            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-random-order' }, 'run tests in random order'))
+            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-random-order' }, 'run tests in random order')),
+          createDom('div', { className: 'jasmine-hide-disabled' },
+            createDom('input', {
+              className: 'jasmine-disabled',
+              id: 'jasmine-hide-disabled',
+              type: 'checkbox'
+            }),
+            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-hide-disabled' }, 'hide disabled tests'))
        )
      );

@@ -344,6 +363,12 @@ jasmineRequire.HtmlReporter = function(j$) {
        navigateWithNewParam('random', !env.randomTests());
      };

+      var hideDisabled = optionsMenuDom.querySelector('#jasmine-hide-disabled');
+      hideDisabled.checked = env.hidingDisabled();
+      hideDisabled.onclick = function() {
+        navigateWithNewParam('hideDisabled', !env.hidingDisabled());
+      };
+
      var optionsTrigger = optionsMenuDom.querySelector('.jasmine-trigger'),
        optionsPayload = optionsMenuDom.querySelector('.jasmine-payload'),
        isOpen = /\bjasmine-open\b/;
--- a/src/html/_HTMLReporter.scss
+++ b/src/html/_HTMLReporter.scss
@@ -135,7 +135,7 @@ body {
        }
      }

-        &.jasmine-excluded {
+       &.jasmine-excluded {
          font-size: 14px;

          &:before {
@@ -144,6 +144,11 @@ body {
          }
        }

+        &.jasmine-excluded-no-display {
+          font-size: 14px;
+          display: none;
+        }
+
      &.jasmine-pending {
        line-height: 17px;
        &:before {
@@ -294,7 +299,7 @@ body {

      &.jasmine-excluded a {
        color: $neutral-color;
-      }
+      } 
    }
  }

@@ -332,7 +337,7 @@ body {

    color: $text-color;

-    white-space: pre;
+    white-space: pre-wrap;
  }

  .jasmine-result-message span.jasmine-result {
--- a/src/html/requireHtml.js
+++ b/src/html/requireHtml.js
@@ -3,5 +3,4 @@ jasmineRequire.html = function(j$) {
  j$.HtmlReporter = jasmineRequire.HtmlReporter(j$);
  j$.QueryString = jasmineRequire.QueryString();
  j$.HtmlSpecFilter = jasmineRequire.HtmlSpecFilter();
-  j$.matchers.toHaveClass = jasmineRequire.toHaveClass(j$);
 };
--- a/travis-docs-script.sh
+++ b/travis-docs-script.sh
@@ -1,12 +0,0 @@
-#!/bin/bash -e
-
-set -e
-
-git clone https://github.com/jasmine/jasmine.github.io.git
-
-cd jasmine.github.io
-export BUNDLE_GEMFILE=$PWD/Gemfile
-bundle
-
-bundle exec rake update_edge_jasmine
-bundle exec rake phantom
Author	SHA1	Message	Date
Gregg Van Hove	83ba2eb4d6	Link to the correct repo in release notes	2018-08-08 17:41:24 -07:00
Gregg Van Hove	87865f00a3	Add issue links to release notes	2018-08-08 17:39:10 -07:00
Gregg Van Hove	112672c4a9	bump version to 3.2.0	2018-08-08 17:33:50 -07:00
Gregg Van Hove	3a52c444f8	Merge branch 'aeisenberg-spy-all' - Merges #1581 from @aeisenberg - Fixes #1421	2018-07-24 17:55:44 -07:00
Andrew Eisenberg	f62eb3b1a8	Add spyOnAllFunctions function This function will spy on all writable and configurable functionss of an object that is passed in. It can be used like this: spyOnAllFunctions(obj); This commit addresses https://github.com/jasmine/jasmine/issues/1421	2018-07-20 07:58:17 -07:00
Gregg Van Hove	110c092c9e	Fix regular expressions for different browsers	2018-06-18 17:55:24 -07:00
Gregg Van Hove	8bb0e2d494	Merge branch 'ikonst-set-timeout-error-message' - Merges #1567 from @ikonst	2018-06-18 17:37:39 -07:00
Ilya Konstantinov	8c1b80daae	Improve Jasmine timeout error message	2018-06-18 17:36:43 -07:00
Gregg Van Hove	e2895a92dc	Fix JSDoc naming for Env functions - See #1565	2018-06-06 17:13:52 -07:00
Gregg Van Hove	03998c1b20	Add documentation for more public functions on Env - Fixes #1565	2018-06-05 17:13:58 -07:00
Steve Gravrock	9472df0db4	Added a basic set of async matchers - Fixes #1447 - Fixes #1547	2018-06-04 21:07:44 -07:00
Gregg Van Hove	8f7327cb4d	Properly cascade StopExecutionError's up the tree - Fixes #1563	2018-05-30 17:32:14 -07:00
Gregg Van Hove	3636014917	Merge branch 'hide-grey-specs' of https://github.com/SamFare/jasmine into SamFare-hide-grey-specs - Merges #1561 from @SamFare	2018-05-23 17:15:40 -07:00
SamFare	92d33c79c7	Implemented hiding of disabled specs	2018-05-22 13:30:33 +01:00
Steve Gravrock	e2d9eefccd	Line-break long expectation failure messages This makes failures somewhat easier to read. We still preserve whitespace within lines to make whitespace-only failures readable, e.g. expect('foo bar').toEqual('foo bar'). See #296.	2018-05-12 09:42:38 -07:00
Gregg Van Hove	ced2b114e4	Better detection of DOM Nodes for equality - Also use JSDom if a real one isn't present to get some more coverage there - Fixes #1172	2018-05-04 18:01:08 -07:00
Gregg Van Hove	f7097281c9	IE doesn't support `.name` on a function	2018-05-03 17:34:15 -07:00
Gregg Van Hove	01a1113387	Merge branch 'yinm-fix-typo' - Merges #1555 from @yinm	2018-05-03 17:21:18 -07:00
yinm	4d0b47ac4c	Fix typo from `incimplete` to `incomplete`	2018-05-03 17:46:49 +09:00
Gregg Van Hove	d6cfc4a9b5	Merge branch 'riophae-master' - Merges #1551 from @riophae	2018-05-02 17:52:03 -07:00
Fangzhou Li	fbcdbf5ab1	Allow omitting the name argument: `createSpy(func)`	2018-04-29 06:07:22 +08:00
Gregg Van Hove	7e14a97371	Explicitly pass in timing functions in mock clock integration specs - This way we can make sure that clear stack always works no matter how long the suite in the spec is [fixes #153518103]	2018-04-23 17:25:11 -07:00
Gregg Van Hove	c440d13754	Use the same global for everything in Env - No longer use `getGlobal` for clearStack and QueueRunner	2018-04-13 17:14:48 -07:00
Gregg Van Hove	8e8f09b41f	Force reinstall bundler and include firefox again	2018-04-03 17:33:20 -07:00
Gregg Van Hove	1decb14807	Ensure rubygems is up-to-date on travis - See travis-ci/travis-ci#8969	2018-04-03 17:13:27 -07:00
Gregg Van Hove	a978f50f1d	name new global status stuff correctly in API docs	2018-04-02 17:20:39 -07:00
Steve Gravrock	74287c578c	Check for accidental global variable creation	2018-03-25 12:01:50 -07:00
Steve Gravrock	7f1cdc2d02	Fixed global variable leak - Fixes #1534	2018-03-25 12:00:56 -07:00
Steve Gravrock	847a959b13	Merge branch 'handle-rejection' of https://github.com/johnjbarton/jasmine - Merges #1521 from @johnjbarton	2018-03-24 19:49:58 -07:00
Steve Gravrock	05015a8b3e	Correctly format stack traces for errors with multiline messages - Fixes #1526	2018-03-10 12:03:08 -08:00
Steve Gravrock	6f960d8662	Merge branch 'better-array-errors' of https://github.com/majidmade/jasmine - Merges #1527 from @majidmade - Fixes #1485	2018-03-10 07:42:34 -08:00
Majid Razvi	11b8b59e03	Change message for extra elements at end of actual array. #1485	2018-03-10 00:05:07 -07:00
johnjbarton	f1ebe05f1d	Report unhandled rejections as globalErrors. Extend existing support for uncaughtExceptions to unhandledRejections now that many tests are async.	2018-03-01 16:47:50 -08:00
Gregg Van Hove	85b2a8c6c4	add some links to more tutorials from the api docs	2018-03-01 10:48:18 -08:00
Gregg Van Hove	557fb4ed72	proper links in release notes	2018-02-27 12:01:28 -08:00
Gregg Van Hove	ee52023b3d	Bump version to 3.1	2018-02-27 11:57:20 -08:00
Gregg Van Hove	91296a44f2	Remove Safari 7 from Travis matrix	2018-02-27 11:10:07 -08:00
Gregg Van Hove	1923461b09	Ignore more browser fields when formatting Errors - description from IE - column from Safari	2018-02-27 09:52:19 -08:00
Gregg Van Hove	71116d3957	don't lock to 2.99 in dev	2018-02-27 09:33:10 -08:00
Gregg Van Hove	63cc7cafc8	Use Jasmine's arrayContains, instead of includes for better support	2018-02-26 17:57:37 -08:00
Gregg Van Hove	fdecf02472	Merge branch 'print_exception_properties' of https://github.com/jbunton-atlassian/jasmine into jbunton-atlassian-print_exception_properties - Merges #1516 from @jbunton-atlassian	2018-02-26 17:48:28 -08:00
Gregg Van Hove	11f4d894a6	Merge branch 'node-load-errors' - See #1519	2018-02-26 16:44:45 -08:00
James Bunton	1149d4edde	Use j$.pp instead of JSON.stringify() for pretty printing	2018-02-27 10:22:06 +11:00
James Bunton	9ee85c35d2	Remove duplicate ignored property	2018-02-27 10:21:50 +11:00
Steve Gravrock	0367ca5294	Merge branch 'patch-closing-statement' of https://github.com/Sylhare/jasmine - Merges #1512 from @Sylhare	2018-02-23 19:17:50 -08:00
James Bunton	763a83c833	Display error properties for failed specs	2018-02-23 14:43:47 +11:00
sylhare	7fb53dcdfa	Fixing missing semi-colons	2018-02-21 09:01:24 -05:00
sgravrock	a9a112e88f	Fixed release notes link	2018-02-18 21:08:52 -08:00
sgravrock	0184808a86	Updated README for 3.0	2018-02-18 21:06:51 -08:00
Steve Gravrock	1ac2a6f608	Allow node to report load time errors [Fixes #153466462]	2018-02-17 15:45:42 -08:00
Gregg Van Hove	785f62c7a0	Fix naming and check functions for empty/notEmpty specs	2018-02-15 17:43:03 -08:00
Gregg Van Hove	d8c154a2c6	Update empty and notEmpty specs for better IE11 support	2018-02-15 17:23:44 -08:00
Gregg Van Hove	c974c4740c	Merge branch 'master' of https://github.com/sjolicoeur/jasmine into sjolicoeur-master - Merges #1460 from @sjolicoeur	2018-02-15 16:00:33 -08:00
Gregg Van Hove	2b27bd393f	Add API docs for async reporters	2018-02-15 14:36:29 -08:00
Gregg Van Hove	3b77f38188	Return <anonymous> for functions that have no actual words between keyword and ( - Also fixes a potential catastrophic backtracking if someone has severely damaged their own `toString` during test execution.	2018-02-15 12:31:10 -08:00
Steve Gravrock	11827572d3	Moved toHaveClass matcher into core so that it can be used in Karma - Fixes #1503	2018-02-13 17:09:42 -08:00
Gregg Van Hove	8326ecf919	Merge branch 'deprecation-object' of https://github.com/UziTech/jasmine into UziTech-deprecation-object - Merges #1498 from @UziTech	2018-02-13 16:57:24 -08:00
Gregg Van Hove	cd6a0de852	Merge pull request #1505 from codetriage-readme-bot/codetriage-badge Add CodeTriage badge to jasmine/jasmine	2018-02-13 09:48:37 -08:00
codetriage-readme-bot	148d94558d	Add CodeTriage badge to jasmine/jasmine Adds a badge showing the number of people helping this repo on CodeTriage. [![Open Source Helpers](https://www.codetriage.com/jasmine/jasmine/badges/users.svg)](https://www.codetriage.com/jasmine/jasmine) ## What is CodeTriage? CodeTriage is an Open Source app that is designed to make contributing to Open Source projects easier. It works by sending subscribers a few open issues in their inbox. If subscribers get busy, there is an algorithm that backs off issue load so they do not get overwhelmed [Read more about the CodeTriage project](https://www.codetriage.com/what). ## Why am I getting this PR? Your project was picked by the human, @schneems. They selected it from the projects submitted to https://www.codetriage.com and hand edited the PR. How did your project get added to [CodeTriage](https://www.codetriage.com/what)? Roughly 8 months ago, [alopezsanchez](https://github.com/alopezsanchez) added this project to CodeTriage in order to start contributing. Since then, 2 people have subscribed to help this repo. ## What does adding a badge accomplish? Adding a badge invites people to help contribute to your project. It also lets developers know that others are invested in the longterm success and maintainability of the project. You can see an example of a CodeTriage badge on these popular OSS READMEs: - [![](https://www.codetriage.com/rails/rails/badges/users.svg)](https://www.codetriage.com/rails/rails) https://github.com/rails/rails - [![](https://www.codetriage.com/crystal-lang/crystal/badges/users.svg)](https://www.codetriage.com/crystal-lang/crystal) https://github.com/crystal-lang/crystal ## Have a question or comment? While I am a bot, this PR was manually reviewed and monitored by a human - @schneems. My job is writing commit messages and handling PR logistics. If you have any questions, you can reply back to this PR and they will be answered by @schneems. If you do not want a badge right now, no worries, close the PR, you will not hear from me again. Thanks for making your project Open Source! Any feedback is greatly appreciated.	2018-02-13 10:29:49 -06:00
Gregg Van Hove	83beca6899	Merge branch '2.99-patch'	2018-02-09 09:32:09 -08:00
Gregg Van Hove	3c6308f1dc	Don't include the specs in the ruby gem - Bump to 2.99.2 for gem	2018-02-09 09:22:35 -08:00
Tony Brix	6193bc113b	throw errors	2018-02-08 15:12:14 -06:00
Gregg Van Hove	fa6a80b76e	Merge branch 'master' of https://github.com/aptx4869/jasmine into aptx4869-master - Merges #1501 from @aptx4869	2018-02-08 10:22:36 -08:00
Gregg Van Hove	c861f6c6c2	Merge pull request #1499 from bcaudan/patch-1 Fix release note typo	2018-02-08 10:16:57 -08:00
aptx4869	4fcd4099ad	Resolve merge conflict Fixes #1500	2018-02-08 15:07:29 +08:00
Bastien Caudan	1d495587ff	Fix release note typo	2018-02-08 08:02:13 +01:00
Tony Brix	c859128537	add tests	2018-02-07 23:58:26 -06:00
Tony Brix	a8a5b839ab	allow adding a deprecation object	2018-02-07 22:44:32 -06:00
Gregg Van Hove	4e5d947faa	Also lock for selenium runner	2018-02-07 14:58:14 -08:00
Gregg Van Hove	c2603efeb4	Specify Jasmine Gem 2.99 tag for bundle install	2018-02-07 14:55:28 -08:00
Gregg Van Hove	fbec3cc230	Only show deprecation for catch exceptions if you tell Jasmine not to catch - Fixes #1497	2018-02-07 14:47:10 -08:00
Gregg Van Hove	1acbd1ef96	Add notes for environments that have lost support - #1495	2018-02-07 09:19:33 -08:00
Gregg Van Hove	3d8e379fa6	bump dev dependency for npm	2018-02-06 15:37:21 -08:00
Gregg Van Hove	55267e11f6	Make sure ruby version is a string when passing to sauce labs	2018-02-06 13:37:12 -08:00
Gregg Van Hove	09a6e3714a	Bump travis ruby version	2018-02-06 12:29:12 -08:00
Gregg Van Hove	8ec4d54685	no longer run specs for docs in CI	2018-02-06 11:54:25 -08:00
sjolicoeur	d90e20eb15	Added matchers: truthy, falsy, empty and notEmpty	2017-12-07 17:49:16 -08:00