Link to the correct repo in release notes

- Merges #1581 from @aeisenberg
- Fixes #1421

.codeclimate.yml

@@ -1,7 +0,0 @@
-languages:
-  JavaScript: true
-exclude_paths:
-- "lib/*"
-- "dist/*"
-- "grunt/*"
-- "images/*"

.github/CONTRIBUTING.md

@@ -16,7 +16,8 @@ Please submit pull requests via feature branches using the semi-standard workflo
 git clone git@github.com:yourUserName/jasmine.git              # Clone your fork
 cd jasmine                                                     # Change directory
 git remote add upstream https://github.com/jasmine/jasmine.git # Assign original repository to a remote named 'upstream'
-git fetch upstream                                             # Pull in changes not present in your local repository
+git fetch upstream                                             # Fetch changes not present in your local repository
+git merge upstream/master                                      # Sync local master with upstream repository
 git checkout -b my-new-feature                                 # Create your feature branch
 git commit -am 'Add some feature'                              # Commit your changes
 git push origin my-new-feature                                 # Push to the branch
@@ -40,9 +41,9 @@ Once you've pushed a feature branch to your forked repo, you're ready to open a
 
 ### Self-testing
 
-Note that Jasmine tests itself. The files in `lib` are loaded first, defining the reference `jasmine`. Then the files in `src` are loaded, defining the reference `j$`. So there are two copies of the code loaded under test.
+Note that Jasmine tests itself. The files in `lib` are loaded first, defining the reference `jasmine`. Then the files in `src` are loaded, defining the reference `jasmineUnderTest`. So there are two copies of the code loaded under test.
 
-The tests should always use `j$` to refer to the objects and functions that are being tested. But the tests can use functions on `jasmine` as needed. _Be careful how you structure any new test code_. Copy the patterns you see in the existing code - this ensures that the code you're testing is not leaking into the `jasmine` reference and vice-versa.
+The tests should always use `jasmineUnderTest` to refer to the objects and functions that are being tested. But the tests can use functions on `jasmine` as needed. _Be careful how you structure any new test code_. Copy the patterns you see in the existing code - this ensures that the code you're testing is not leaking into the `jasmine` reference and vice-versa.
 
 ### `boot.js`
 
@@ -129,11 +130,9 @@ The easiest way to run the tests in **Internet Explorer** is to run a VM that ha
 1. Ensure all specs are green in browser *and* node
 1. Ensure JSHint is green with `grunt jshint`
 1. Build `jasmine.js` with `grunt buildDistribution` and run all specs again - this ensures that your changes self-test well
-
-## Submitting a Pull Request
 1. Revert your changes to `jasmine.js` and `jasmine-html.js`
-  * We do this because `jasmine.js` and `jasmine-html.js` are auto-generated (as you've seen in the previous steps) and accepting multiple pull requests when this auto-generated file changes causes lots of headaches
-1. When we accept your pull request, we will generate these files as a separate commit and merge the entire branch into master
+    * We do this because `jasmine.js` and `jasmine-html.js` are auto-generated (as you've seen in the previous steps) and accepting multiple pull requests when this auto-generated file changes causes lots of headaches
+    * When we accept your pull request, we will generate these files as a separate commit and merge the entire branch into master
 
 Note that we use Travis for Continuous Integration. We only accept green pull requests.
 

.github/ISSUE_TEMPLATE.md

@@ -1,17 +1,44 @@
-### Are you creating an issue in the correct repository?
+## Are you creating an issue in the correct repository?
 
 - When in doubt, create an issue here.
 - If you have an issue with the Jasmine docs, file an issue in the docs repo
   here: https://github.com/jasmine/jasmine.github.io
 - This repository is for the core Jasmine framework
-- If you are using a test runner that wraps Jasmine (Jasmine npm, karma, etc),
-  consider filing an issue with that library if appropriate
+- If you are using a test runner that wraps Jasmine, consider filing an issue with that library if appropriate:
+  - [Jasmine npm](https://github.com/jasmine/jasmine-npm/issues)
+  - [Jasmine gem](https://github.com/jasmine/jasmine-gem/issues)
+  - [Jasmine py](https://github.com/jasmine/jasmine-py/issues)
+  - [Gulp Jasmine Browser](https://github.com/jasmine/gulp-jasmine-browser/issues)
+  - [Karma](https://github.com/karma-runner/karma/issues)
+  - [Grunt Contrib Jasmine](https://github.com/gruntjs/grunt-contrib-jasmine/issues)
 
-### When submitting an issue, please answer the following:
+<!--- Provide a general summary of the issue in the Title above -->
 
- - What version are you using?
- - What environment are you running Jasmine in (node, browser, etc)?
- - How are you running Jasmine (standalone, npm, karma, etc)?
- - If possible, include an example spec that demonstrates your issue.
+## Expected Behavior
+<!--- If you're describing a bug, tell us what should happen -->
+<!--- If you're suggesting a change/improvement, tell us how it should work -->
 
- Thanks for using Jasmine!
+## Current Behavior
+<!--- If describing a bug, tell us what happens instead of the expected behavior -->
+<!--- If suggesting a change/improvement, explain the difference from current behavior -->
+
+## Possible Solution
+<!--- Not obligatory, but suggest a fix/reason for the bug, -->
+<!--- or ideas how to implement the addition or change -->
+
+## Suite that reproduces the behavior (for bugs)
+<!--- Provide a sample suite that reproduces the bug. -->
+```javascript
+describe("sample", function() {
+});
+```
+## Context
+<!--- How has this issue affected you? What are you trying to accomplish? -->
+<!--- Providing context helps us come up with a solution that is most useful in the real world -->
+
+## Your Environment
+<!--- Include as many relevant details about the environment you experienced the bug in -->
+* Version used:
+* Environment name and version (e.g. Chrome 39, node.js 5.4):
+* Operating System and version (desktop or mobile):
+* Link to your project:

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,30 @@
+<!--- Provide a general summary of your changes in the Title above -->
+
+## Description
+<!--- Describe your changes in detail -->
+
+## Motivation and Context
+<!--- Why is this change required? What problem does it solve? -->
+<!--- If it fixes an open issue, please link to the issue here. -->
+
+## How Has This Been Tested?
+<!--- Please describe in detail how you tested your changes. -->
+<!--- Include details of your testing environment, and the tests you ran to -->
+<!--- see how your change affects other areas of the code, etc. -->
+
+## Types of changes
+<!--- What types of changes does your code introduce? Put an `x` in all the boxes that apply: -->
+- [ ] Bug fix (non-breaking change which fixes an issue)
+- [ ] New feature (non-breaking change which adds functionality)
+- [ ] Breaking change (fix or feature that would cause existing functionality to change)
+
+## Checklist:
+<!--- Go over all the following points, and put an `x` in all the boxes that apply. -->
+<!--- If you're unsure about any of these, don't hesitate to ask. We're here to help! -->
+- [ ] My code follows the code style of this project.
+- [ ] My change requires a change to the documentation.
+- [ ] I have updated the documentation accordingly.
+- [ ] I have read the **CONTRIBUTING** document.
+- [ ] I have added tests to cover my changes.
+- [ ] All new and existing tests passed.
+

.gitignore

@@ -11,6 +11,7 @@ site/
 .bundle
 tags
 Gemfile.lock
+package-lock.json
 pkg/*
 .sass-cache/*
 src/html/.sass-cache/*
@@ -22,3 +23,4 @@ build/
 *.egg-info/
 dist
 nbproject/
+*.iml

.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
+}

.travis.yml

@@ -1,9 +1,12 @@
 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=
 
@@ -24,7 +24,21 @@ matrix:
   include:
     - env:
       - USE_SAUCE=false
-      - TEST_COMMAND="bash travis-node-script.sh"
+      - TEST_COMMAND="bash travis-node-script.sh v4"
+    - env:
+      - USE_SAUCE=false
+      - TEST_COMMAND="bash travis-node-script.sh v8"
+    - 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"
+      - SAUCE_BROWSER_VERSION=10
     - env:
       - JASMINE_BROWSER="safari"
       - SAUCE_OS="OS X 10.11"
@@ -34,13 +48,9 @@ matrix:
       - 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="safari"
-      - SAUCE_OS="OS X 10.8"
-      - SAUCE_BROWSER_VERSION=6
+      - JASMINE_BROWSER="MicrosoftEdge"
+      - SAUCE_OS="Windows 10"
+      - SAUCE_BROWSER_VERSION="15"
     - env:
       - JASMINE_BROWSER="internet explorer"
       - SAUCE_OS="Windows 8.1"
@@ -49,14 +59,6 @@ matrix:
       - JASMINE_BROWSER="internet explorer"
       - SAUCE_OS="Windows 8"
       - SAUCE_BROWSER_VERSION=10
-    - env:
-      - JASMINE_BROWSER="internet explorer"
-      - SAUCE_OS="Windows 7"
-      - SAUCE_BROWSER_VERSION=9
-    - env:
-      - JASMINE_BROWSER="internet explorer"
-      - SAUCE_OS="Windows 7"
-      - SAUCE_BROWSER_VERSION=8
     - env:
       - JASMINE_BROWSER="chrome"
       - SAUCE_OS="Linux"
@@ -64,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"

CODE_OF_CONDUCT.md

@@ -0,0 +1,46 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at jasmine-maintainers@googlegroups.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

MANIFEST.in

@@ -1,4 +1,5 @@
 recursive-include . *.py
+prune node_modules
 include lib/jasmine-core/*.js
 include lib/jasmine-core/*.css
 include images/*.png

MIT.LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2008-2016 Pivotal Labs
+Copyright (c) 2008-2017 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,22 +1,20 @@
 <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)
-[![Code Climate](https://codeclimate.com/github/pivotal/jasmine.svg)](https://codeclimate.com/github/pivotal/jasmine)
+[![Open Source Helpers](https://www.codetriage.com/jasmine/jasmine/badges/users.svg)](https://www.codetriage.com/jasmine/jasmine)
 
-=======
-
-**A JavaScript Testing Framework**
+# 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.0, see the beginning of [http://jasmine.github.io/2.0/introduction.html](http://jasmine.github.io/2.0/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
 
-Please read the [contributors' guide](https://github.com/jasmine/jasmine/blob/master/CONTRIBUTING.md)
+Please read the [contributors' guide](https://github.com/jasmine/jasmine/blob/master/.github/CONTRIBUTING.md)
 
 ## Installation
 
@@ -32,28 +30,28 @@ For the Jasmine Python Egg:<br>
 For the Jasmine headless browser gulp plugin:<br>
 [https://github.com/jasmine/gulp-jasmine-browser](https://github.com/jasmine/gulp-jasmine-browser)
 
-To install Jasmine standalone on your local box:
+To install Jasmine standalone on your local box (where **_{#.#.#}_** below is substituted by the release number downloaded):
 
 * Download the standalone distribution for your desired release from the [releases page](https://github.com/jasmine/jasmine/releases)
 * Create a Jasmine directory in your project - `mkdir my-project/jasmine`
-* Move the dist to your project directory - `mv jasmine/dist/jasmine-standalone-2.0.0.zip my-project/jasmine`
+* Move the dist to your project directory - `mv jasmine/dist/jasmine-standalone-{#.#.#}.zip my-project/jasmine`
 * Change directory - `cd my-project/jasmine`
-* Unzip the dist - `unzip jasmine-standalone-2.0.0.zip`
+* Unzip the dist - `unzip jasmine-standalone-{#.#.#}.zip`
 
 Add the following to your HTML file:
 
 ```html
-<link rel="shortcut icon" type="image/png" href="jasmine/lib/jasmine-2.0.0/jasmine_favicon.png">
-<link rel="stylesheet" type="text/css" href="jasmine/lib/jasmine-2.0.0/jasmine.css">
+<link rel="shortcut icon" type="image/png" href="jasmine/lib/jasmine-{#.#.#}/jasmine_favicon.png">
+<link rel="stylesheet" type="text/css" href="jasmine/lib/jasmine-{#.#.#}/jasmine.css">
 
-<script type="text/javascript" src="jasmine/lib/jasmine-2.0.0/jasmine.js"></script>
-<script type="text/javascript" src="jasmine/lib/jasmine-2.0.0/jasmine-html.js"></script>
-<script type="text/javascript" src="jasmine/lib/jasmine-2.0.0/boot.js"></script>
+<script type="text/javascript" src="jasmine/lib/jasmine-{#.#.#}/jasmine.js"></script>
+<script type="text/javascript" src="jasmine/lib/jasmine-{#.#.#}/jasmine-html.js"></script>
+<script type="text/javascript" src="jasmine/lib/jasmine-{#.#.#}/boot.js"></script>
 ```
 
 ## Supported environments
 
-Jasmine tests itself across many browsers (Safari, Chrome, Firefox, PhantomJS, and new Internet Explorer) as well as node. To see the exact version tests are run against look at our [.travis.yml](https://github.com/jasmine/jasmine/blob/master/.travis.yml)
+Jasmine tests itself across many browsers (Safari, Chrome, Firefox, PhantomJS, Microsoft Edge, and new Internet Explorer) as well as nodejs. To see the exact version tests are run against look at our [.travis.yml](https://github.com/jasmine/jasmine/blob/master/.travis.yml)
 
 
 ## Support
@@ -65,15 +63,15 @@ Jasmine tests itself across many browsers (Safari, Chrome, Firefox, PhantomJS, a
 
 ## Maintainers
 
-* [Davis W. Frank](mailto:dwfrank@pivotal.io), Pivotal Labs
-* [Rajan Agaskar](mailto:rajan@pivotal.io), Pivotal Labs
 * [Gregg Van Hove](mailto:gvanhove@pivotal.io), Pivotal Labs
-* [Greg Cobb](mailto:gcobb@pivotal.io), Pivotal Labs
-* [Chris Amavisca](mailto:camavisca@pivotal.io), Pivotal Labs
 
 ### Maintainers Emeritus
 
+* [Davis W. Frank](mailto:dwfrank@pivotal.io), Pivotal Labs
+* [Rajan Agaskar](mailto:rajan@pivotal.io), Pivotal Labs
+* [Greg Cobb](mailto:gcobb@pivotal.io), Pivotal Labs
+* [Chris Amavisca](mailto:camavisca@pivotal.io), Pivotal Labs
 * [Christian Williams](mailto:antixian666@gmail.com), Cloud Foundry
 * Sheel Choksi
 
-Copyright (c) 2008-2016 Pivotal Labs. This software is licensed under the MIT License.
+Copyright (c) 2008-2018 Pivotal Labs. This software is licensed under the MIT License.

RELEASE.md

@@ -7,9 +7,7 @@ Follow the instructions in `CONTRIBUTING.md` during development.
 
 ### Git Rules
 
-Please work on feature branches.
-
-Please attempt to keep commits to `master` small, but cohesive. If a feature is contained in a bunch of small commits (e.g., it has several wip commits or small work), please squash them when merging back to `master`.
+Please attempt to keep commits to `master` small, but cohesive. If a feature is contained in a bunch of small commits (e.g., it has several wip commits or small work), please squash them when pushing to `master`.
 
 ### Version
 
@@ -40,7 +38,10 @@ When ready to release - specs are all green and the stories are done:
 
 ### Release the Python egg
 
-1. `python setup.py register sdist upload` You will need pypi credentials to upload the egg.
+Install [twine](https://github.com/pypa/twine)
+
+1. `python setup.py sdist`
+1. `twine upload dist/jasmine-core-<version>.tar.gz` You will need pypi credentials to upload the egg.
 
 ### Release the Ruby gem
 

bower.json

@@ -1,6 +1,6 @@
 {
   "name": "jasmine-core",
-  "homepage": "http://jasmine.github.io",
+  "homepage": "https://jasmine.github.io",
   "authors": [
     "slackersoft <gregg@slackersoft.net>"
   ],

grunt/config/compress.js

@@ -2,7 +2,6 @@ var standaloneLibDir = "lib/jasmine-" + jasmineVersion;
 
 function root(path) { return "./" + path; }
 function libJasmineCore(path) { return root("lib/jasmine-core/" + path); }
-function libConsole() { return "lib/console/" }
 function dist(path) { return root("dist/" + path); }
 
 module.exports = {
@@ -29,14 +28,6 @@ module.exports = {
         expand: true,
         cwd: libJasmineCore("")
       },
-      {
-        src: [
-          "console.js"
-        ],
-        dest: standaloneLibDir,
-        expand: true,
-        cwd: libConsole()
-      },
       {
         src: [ "boot.js" ],
         dest: standaloneLibDir,

grunt/config/concat.js

@@ -15,7 +15,8 @@ module.exports = {
       'src/html/HtmlReporter.js',
       'src/html/HtmlSpecFilter.js',
       'src/html/ResultsNode.js',
-      'src/html/QueryString.js'
+      'src/html/QueryString.js',
+      'src/html/**/*.js'
     ],
     dest: 'lib/jasmine-core/jasmine-html.js'
   },
@@ -44,13 +45,6 @@ module.exports = {
     src: ['lib/jasmine-core/boot/node_boot.js'],
     dest: 'lib/jasmine-core/node_boot.js'
   },
-  console: {
-    src: [
-      'src/console/requireConsole.js',
-      'src/console/ConsoleReporter.js'
-    ],
-    dest: 'lib/console/console.js'
-  },
   options: {
     banner: license(),
     process: {

jasmine-core.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name = "jasmine-core"
   s.version = Jasmine::Core::VERSION
   s.platform = Gem::Platform::RUBY
-  s.authors = ["Rajan Agaskar", "Davis W. Frank", "Gregg Van Hove"]
+  s.authors = ["Gregg Van Hove"]
   s.summary = %q{JavaScript BDD framework}
   s.description = %q{Test your JavaScript without any framework dependencies, in any environment, and with a nice descriptive syntax.}
   s.email = %q{jasmine-js@googlegroups.com}
@@ -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"

lib/console/console.js

@@ -1,190 +0,0 @@
-/*
-Copyright (c) 2008-2016 Pivotal Labs
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-*/
-function getJasmineRequireObj() {
-  if (typeof module !== 'undefined' && module.exports) {
-    return exports;
-  } else {
-    window.jasmineRequire = window.jasmineRequire || {};
-    return window.jasmineRequire;
-  }
-}
-
-getJasmineRequireObj().console = function(jRequire, j$) {
-  j$.ConsoleReporter = jRequire.ConsoleReporter();
-};
-
-getJasmineRequireObj().ConsoleReporter = function() {
-
-  var noopTimer = {
-    start: function(){},
-    elapsed: function(){ return 0; }
-  };
-
-  function ConsoleReporter(options) {
-    var print = options.print,
-      showColors = options.showColors || false,
-      onComplete = options.onComplete || function() {},
-      timer = options.timer || noopTimer,
-      specCount,
-      failureCount,
-      failedSpecs = [],
-      pendingCount,
-      ansi = {
-        green: '\x1B[32m',
-        red: '\x1B[31m',
-        yellow: '\x1B[33m',
-        none: '\x1B[0m'
-      },
-      failedSuites = [];
-
-    print('ConsoleReporter is deprecated and will be removed in a future version.');
-
-    this.jasmineStarted = function() {
-      specCount = 0;
-      failureCount = 0;
-      pendingCount = 0;
-      print('Started');
-      printNewline();
-      timer.start();
-    };
-
-    this.jasmineDone = function() {
-      printNewline();
-      for (var i = 0; i < failedSpecs.length; i++) {
-        specFailureDetails(failedSpecs[i]);
-      }
-
-      if(specCount > 0) {
-        printNewline();
-
-        var specCounts = specCount + ' ' + plural('spec', specCount) + ', ' +
-          failureCount + ' ' + plural('failure', failureCount);
-
-        if (pendingCount) {
-          specCounts += ', ' + pendingCount + ' pending ' + plural('spec', pendingCount);
-        }
-
-        print(specCounts);
-      } else {
-        print('No specs found');
-      }
-
-      printNewline();
-      var seconds = timer.elapsed() / 1000;
-      print('Finished in ' + seconds + ' ' + plural('second', seconds));
-      printNewline();
-
-      for(i = 0; i < failedSuites.length; i++) {
-        suiteFailureDetails(failedSuites[i]);
-      }
-
-      onComplete(failureCount === 0);
-    };
-
-    this.specDone = function(result) {
-      specCount++;
-
-      if (result.status == 'pending') {
-        pendingCount++;
-        print(colored('yellow', '*'));
-        return;
-      }
-
-      if (result.status == 'passed') {
-        print(colored('green', '.'));
-        return;
-      }
-
-      if (result.status == 'failed') {
-        failureCount++;
-        failedSpecs.push(result);
-        print(colored('red', 'F'));
-      }
-    };
-
-    this.suiteDone = function(result) {
-      if (result.failedExpectations && result.failedExpectations.length > 0) {
-        failureCount++;
-        failedSuites.push(result);
-      }
-    };
-
-    return this;
-
-    function printNewline() {
-      print('\n');
-    }
-
-    function colored(color, str) {
-      return showColors ? (ansi[color] + str + ansi.none) : str;
-    }
-
-    function plural(str, count) {
-      return count == 1 ? str : str + 's';
-    }
-
-    function repeat(thing, times) {
-      var arr = [];
-      for (var i = 0; i < times; i++) {
-        arr.push(thing);
-      }
-      return arr;
-    }
-
-    function indent(str, spaces) {
-      var lines = (str || '').split('\n');
-      var newArr = [];
-      for (var i = 0; i < lines.length; i++) {
-        newArr.push(repeat(' ', spaces).join('') + lines[i]);
-      }
-      return newArr.join('\n');
-    }
-
-    function specFailureDetails(result) {
-      printNewline();
-      print(result.fullName);
-
-      for (var i = 0; i < result.failedExpectations.length; i++) {
-        var failedExpectation = result.failedExpectations[i];
-        printNewline();
-        print(indent(failedExpectation.message, 2));
-        print(indent(failedExpectation.stack, 2));
-      }
-
-      printNewline();
-    }
-
-    function suiteFailureDetails(result) {
-      for (var i = 0; i < result.failedExpectations.length; i++) {
-        printNewline();
-        print(colored('red', 'An error was thrown in an afterAll'));
-        printNewline();
-        print(colored('red', 'AfterAll ' + result.failedExpectations[i].message));
-
-      }
-      printNewline();
-    }
-  }
-
-  return ConsoleReporter;
-};

lib/jasmine-core/boot.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2016 Pivotal Labs
+Copyright (c) 2008-2018 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -71,14 +71,22 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     getWindowLocation: function() { return window.location; }
   });
 
-  var catchingExceptions = queryString.getParam("catch");
-  env.catchExceptions(typeof catchingExceptions === "undefined" ? true : catchingExceptions);
+  var filterSpecs = !!queryString.getParam("spec");
+
+  var stoppingOnSpecFailure = queryString.getParam("failFast");
+  env.stopOnSpecFailure(stoppingOnSpecFailure);
 
   var throwingExpectationFailures = queryString.getParam("throwFailures");
   env.throwOnExpectationFailure(throwingExpectationFailures);
+  
+  var hideDisabled = queryString.getParam("hideDisabled");
+  env.hideDisabled(hideDisabled); 
 
   var random = queryString.getParam("random");
-  env.randomizeTests(random);
+
+  if (random !== undefined && random !== "") {
+    env.randomizeTests(random);
+  }
 
   var seed = queryString.getParam("seed");
   if (seed) {
@@ -91,14 +99,13 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
    */
   var htmlReporter = new jasmine.HtmlReporter({
     env: env,
-    onRaiseExceptionsClick: function() { queryString.navigateWithNewParam("catch", !env.catchingExceptions()); },
-    onThrowExpectationsClick: function() { queryString.navigateWithNewParam("throwFailures", !env.throwingExpectationFailures()); },
-    onRandomClick: function() { queryString.navigateWithNewParam("random", !env.randomTests()); },
+    navigateWithNewParam: function(key, value) { return queryString.navigateWithNewParam(key, value); },
     addToExistingQueryString: function(key, value) { return queryString.fullStringWithNewParam(key, value); },
     getContainer: function() { return document.body; },
     createElement: function() { return document.createElement.apply(document, arguments); },
     createTextNode: function() { return document.createTextNode.apply(document, arguments); },
-    timer: new jasmine.Timer()
+    timer: new jasmine.Timer(),
+    filterSpecs: filterSpecs
   });
 
   /**

lib/jasmine-core/boot/boot.js

@@ -49,14 +49,22 @@
     getWindowLocation: function() { return window.location; }
   });
 
-  var catchingExceptions = queryString.getParam("catch");
-  env.catchExceptions(typeof catchingExceptions === "undefined" ? true : catchingExceptions);
+  var filterSpecs = !!queryString.getParam("spec");
+
+  var stoppingOnSpecFailure = queryString.getParam("failFast");
+  env.stopOnSpecFailure(stoppingOnSpecFailure);
 
   var throwingExpectationFailures = queryString.getParam("throwFailures");
   env.throwOnExpectationFailure(throwingExpectationFailures);
+  
+  var hideDisabled = queryString.getParam("hideDisabled");
+  env.hideDisabled(hideDisabled); 
 
   var random = queryString.getParam("random");
-  env.randomizeTests(random);
+
+  if (random !== undefined && random !== "") {
+    env.randomizeTests(random);
+  }
 
   var seed = queryString.getParam("seed");
   if (seed) {
@@ -69,14 +77,13 @@
    */
   var htmlReporter = new jasmine.HtmlReporter({
     env: env,
-    onRaiseExceptionsClick: function() { queryString.navigateWithNewParam("catch", !env.catchingExceptions()); },
-    onThrowExpectationsClick: function() { queryString.navigateWithNewParam("throwFailures", !env.throwingExpectationFailures()); },
-    onRandomClick: function() { queryString.navigateWithNewParam("random", !env.randomTests()); },
+    navigateWithNewParam: function(key, value) { return queryString.navigateWithNewParam(key, value); },
     addToExistingQueryString: function(key, value) { return queryString.fullStringWithNewParam(key, value); },
     getContainer: function() { return document.body; },
     createElement: function() { return document.createElement.apply(document, arguments); },
     createTextNode: function() { return document.createTextNode.apply(document, arguments); },
-    timer: new jasmine.Timer()
+    timer: new jasmine.Timer(),
+    filterSpecs: filterSpecs
   });
 
   /**

lib/jasmine-core/boot/node_boot.js

@@ -1,10 +1,7 @@
 module.exports = function(jasmineRequire) {
   var jasmine = jasmineRequire.core(jasmineRequire);
 
-  var consoleFns = require('../console/console.js');
-  consoleFns.console(consoleFns, jasmine);
-
-  var env = jasmine.getEnv();
+  var env = jasmine.getEnv({suppressLoadErrors: true});
 
   var jasmineInterface = jasmineRequire.interface(jasmine, env);
 

lib/jasmine-core/jasmine-html.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2016 Pivotal Labs
+Copyright (c) 2008-2018 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -34,23 +34,63 @@ jasmineRequire.HtmlReporter = function(j$) {
     elapsed: function() { return 0; }
   };
 
+  function ResultsStateBuilder() {
+    this.topResults = new j$.ResultsNode({}, '', null);
+    this.currentParent = this.topResults;
+    this.specsExecuted = 0;
+    this.failureCount = 0;
+    this.pendingSpecCount = 0;
+  }
+
+  ResultsStateBuilder.prototype.suiteStarted = function(result) {
+    this.currentParent.addChild(result, 'suite');
+    this.currentParent = this.currentParent.last();
+  };
+
+  ResultsStateBuilder.prototype.suiteDone = function(result) {
+    this.currentParent.updateResult(result);
+    if (this.currentParent !== this.topResults) {
+      this.currentParent = this.currentParent.parent;
+    }
+
+    if (result.status === 'failed') {
+      this.failureCount++;
+    }
+  };
+
+  ResultsStateBuilder.prototype.specStarted = function(result) {
+  };
+
+  ResultsStateBuilder.prototype.specDone = function(result) {
+    this.currentParent.addChild(result, 'spec');
+
+    if (result.status !== 'excluded') {
+      this.specsExecuted++;
+    }
+
+    if (result.status === 'failed') {
+      this.failureCount++;
+    }
+
+    if (result.status == 'pending') {
+      this.pendingSpecCount++;
+    }
+  };
+
+
+
   function HtmlReporter(options) {
     var env = options.env || {},
       getContainer = options.getContainer,
       createElement = options.createElement,
       createTextNode = options.createTextNode,
-      onRaiseExceptionsClick = options.onRaiseExceptionsClick || function() {},
-      onThrowExpectationsClick = options.onThrowExpectationsClick || function() {},
-      onRandomClick = options.onRandomClick || function() {},
+      navigateWithNewParam = options.navigateWithNewParam || function() {},
       addToExistingQueryString = options.addToExistingQueryString || defaultQueryString,
+      filterSpecs = options.filterSpecs,
       timer = options.timer || noopTimer,
-      results = [],
-      specsExecuted = 0,
-      failureCount = 0,
-      pendingSpecCount = 0,
       htmlReporterMain,
       symbols,
-      failedSuites = [];
+      deprecationWarnings = [];
 
     this.initialize = function() {
       clearPrior();
@@ -76,140 +116,74 @@ jasmineRequire.HtmlReporter = function(j$) {
 
     var summary = createDom('div', {className: 'jasmine-summary'});
 
-    var topResults = new j$.ResultsNode({}, '', null),
-      currentParent = topResults;
+    var stateBuilder = new ResultsStateBuilder();
 
     this.suiteStarted = function(result) {
-      currentParent.addChild(result, 'suite');
-      currentParent = currentParent.last();
+      stateBuilder.suiteStarted(result);
     };
 
     this.suiteDone = function(result) {
-      if (result.status == 'failed') {
-        failedSuites.push(result);
-      }
+      stateBuilder.suiteDone(result);
 
-      if (currentParent == topResults) {
-        return;
+      if (result.status === 'failed') {
+        failures.push(failureDom(result));
       }
-
-      currentParent = currentParent.parent;
+      addDeprecationWarnings(result);
     };
 
     this.specStarted = function(result) {
-      currentParent.addChild(result, 'spec');
+      stateBuilder.specStarted(result);
     };
 
     var failures = [];
     this.specDone = function(result) {
+      stateBuilder.specDone(result);
+
       if(noExpectations(result) && typeof console !== 'undefined' && typeof console.error !== 'undefined') {
         console.error('Spec \'' + result.fullName + '\' has no expectations.');
       }
 
-      if (result.status != 'disabled') {
-        specsExecuted++;
-      }
-
       if (!symbols){
         symbols = find('.jasmine-symbol-summary');
       }
 
       symbols.appendChild(createDom('li', {
-          className: noExpectations(result) ? 'jasmine-empty' : 'jasmine-' + result.status,
+          className: this.displaySpecInCorrectFormat(result),
           id: 'spec_' + result.id,
           title: result.fullName
         }
       ));
 
-      if (result.status == 'failed') {
-        failureCount++;
-
-        var failure =
-          createDom('div', {className: 'jasmine-spec-detail jasmine-failed'},
-            createDom('div', {className: 'jasmine-description'},
-              createDom('a', {title: result.fullName, href: specHref(result)}, result.fullName)
-            ),
-            createDom('div', {className: 'jasmine-messages'})
-          );
-        var messages = failure.childNodes[1];
-
-        for (var i = 0; i < result.failedExpectations.length; i++) {
-          var expectation = result.failedExpectations[i];
-          messages.appendChild(createDom('div', {className: 'jasmine-result-message'}, expectation.message));
-          messages.appendChild(createDom('div', {className: 'jasmine-stack-trace'}, expectation.stack));
-        }
-
-        failures.push(failure);
+      if (result.status === 'failed') {
+        failures.push(failureDom(result));
       }
 
-      if (result.status == 'pending') {
-        pendingSpecCount++;
-      }
+      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(
-        createDom('div', { className: 'jasmine-run-options' },
-          createDom('span', { className: 'jasmine-trigger' }, 'Options'),
-          createDom('div', { className: 'jasmine-payload' },
-            createDom('div', { className: 'jasmine-exceptions' },
-              createDom('input', {
-                className: 'jasmine-raise',
-                id: 'jasmine-raise-exceptions',
-                type: 'checkbox'
-              }),
-              createDom('label', { className: 'jasmine-label', 'for': 'jasmine-raise-exceptions' }, 'raise exceptions')),
-            createDom('div', { className: 'jasmine-throw-failures' },
-              createDom('input', {
-                className: 'jasmine-throw',
-                id: 'jasmine-throw-failures',
-                type: 'checkbox'
-              }),
-              createDom('label', { className: 'jasmine-label', 'for': 'jasmine-throw-failures' }, 'stop spec on expectation failure')),
-            createDom('div', { className: 'jasmine-random-order' },
-              createDom('input', {
-                className: 'jasmine-random',
-                id: 'jasmine-random-order',
-                type: 'checkbox'
-              }),
-              createDom('label', { className: 'jasmine-label', 'for': 'jasmine-random-order' }, 'run tests in random order'))
-          )
-        ));
+      banner.appendChild(optionsMenu(env));
 
-      var raiseCheckbox = find('#jasmine-raise-exceptions');
-
-      raiseCheckbox.checked = !env.catchingExceptions();
-      raiseCheckbox.onclick = onRaiseExceptionsClick;
-
-      var throwCheckbox = find('#jasmine-throw-failures');
-      throwCheckbox.checked = env.throwingExpectationFailures();
-      throwCheckbox.onclick = onThrowExpectationsClick;
-
-      var randomCheckbox = find('#jasmine-random-order');
-      randomCheckbox.checked = env.randomTests();
-      randomCheckbox.onclick = onRandomClick;
-
-      var optionsMenu = find('.jasmine-run-options'),
-          optionsTrigger = optionsMenu.querySelector('.jasmine-trigger'),
-          optionsPayload = optionsMenu.querySelector('.jasmine-payload'),
-          isOpen = /\bjasmine-open\b/;
-
-      optionsTrigger.onclick = function() {
-        if (isOpen.test(optionsPayload.className)) {
-          optionsPayload.className = optionsPayload.className.replace(isOpen, '');
-        } else {
-          optionsPayload.className += ' jasmine-open';
-        }
-      };
-
-      if (specsExecuted < totalSpecsDefined) {
-        var skippedMessage = 'Ran ' + specsExecuted + ' of ' + totalSpecsDefined + ' specs - run all';
-        var skippedLink = order && order.random ? '?random=true' : '?';
+      if (stateBuilder.specsExecuted < totalSpecsDefined) {
+        var skippedMessage = 'Ran ' + stateBuilder.specsExecuted + ' of ' + totalSpecsDefined + ' specs - run all';
+        var skippedLink = addToExistingQueryString('spec', '');
         alert.appendChild(
           createDom('span', {className: 'jasmine-bar jasmine-skipped'},
             createDom('a', {href: skippedLink, title: 'Run all specs'}, skippedMessage)
@@ -217,15 +191,22 @@ jasmineRequire.HtmlReporter = function(j$) {
         );
       }
       var statusBarMessage = '';
-      var statusBarClassName = 'jasmine-bar ';
+      var statusBarClassName = 'jasmine-overall-result jasmine-bar ';
+      var globalFailures = (doneResult && doneResult.failedExpectations) || [];
+      var failed = stateBuilder.failureCount + globalFailures.length > 0;
 
-      if (totalSpecsDefined > 0) {
-        statusBarMessage += pluralize('spec', specsExecuted) + ', ' + pluralize('failure', failureCount);
-        if (pendingSpecCount) { statusBarMessage += ', ' + pluralize('pending spec', pendingSpecCount); }
-        statusBarClassName += (failureCount > 0) ? 'jasmine-failed' : 'jasmine-passed';
+      if (totalSpecsDefined > 0 || failed) {
+        statusBarMessage += pluralize('spec', stateBuilder.specsExecuted) + ', ' + pluralize('failure', stateBuilder.failureCount);
+        if (stateBuilder.pendingSpecCount) { statusBarMessage += ', ' + pluralize('pending spec', stateBuilder.pendingSpecCount); }
+      }
+
+      if (doneResult.overallStatus === 'passed') {
+        statusBarClassName += ' jasmine-passed ';
+      } else if (doneResult.overallStatus === 'incomplete') {
+        statusBarClassName += ' jasmine-incomplete ';
+        statusBarMessage = 'Incomplete: ' + doneResult.incompleteReason + ', ' + statusBarMessage;
       } else {
-        statusBarClassName += 'jasmine-skipped';
-        statusBarMessage += 'No specs found';
+        statusBarClassName += ' jasmine-failed ';
       }
 
       var seedBar;
@@ -239,63 +220,38 @@ jasmineRequire.HtmlReporter = function(j$) {
       alert.appendChild(createDom('span', {className: statusBarClassName}, statusBarMessage, seedBar));
 
       var errorBarClassName = 'jasmine-bar jasmine-errored';
-      var errorBarMessagePrefix = 'AfterAll ';
+      var afterAllMessagePrefix = 'AfterAll ';
 
-      for(var i = 0; i < failedSuites.length; i++) {
-        var failedSuite = failedSuites[i];
-        for(var j = 0; j < failedSuite.failedExpectations.length; j++) {
-          alert.appendChild(createDom('span', {className: errorBarClassName}, errorBarMessagePrefix + failedSuite.failedExpectations[j].message));
+      for(i = 0; i < globalFailures.length; i++) {
+        alert.appendChild(createDom('span', {className: errorBarClassName}, globalFailureMessage(globalFailures[i])));
+      }
+
+      function globalFailureMessage(failure) {
+        if (failure.globalErrorType === 'load') {
+          var prefix = 'Error during loading: ' + failure.message;
+
+          if (failure.filename) {
+            return prefix + ' in ' + failure.filename + ' line ' + failure.lineno;
+          } else {
+            return prefix;
+          }
+        } else {
+          return afterAllMessagePrefix + failure.message;
         }
       }
 
-      var globalFailures = (doneResult && doneResult.failedExpectations) || [];
-      for(i = 0; i < globalFailures.length; i++) {
-        var failure = globalFailures[i];
-        alert.appendChild(createDom('span', {className: errorBarClassName}, errorBarMessagePrefix + failure.message));
+      addDeprecationWarnings(doneResult);
+
+      var warningBarClassName = 'jasmine-bar jasmine-warning';
+      for(i = 0; i < deprecationWarnings.length; i++) {
+        var warning = deprecationWarnings[i];
+        alert.appendChild(createDom('span', {className: warningBarClassName}, 'DEPRECATION: ' + warning));
       }
 
       var results = find('.jasmine-results');
       results.appendChild(summary);
 
-      summaryList(topResults, summary);
-
-      function summaryList(resultsTree, domParent) {
-        var specListNode;
-        for (var i = 0; i < resultsTree.children.length; i++) {
-          var resultNode = resultsTree.children[i];
-          if (resultNode.type == 'suite') {
-            var suiteListNode = createDom('ul', {className: 'jasmine-suite', id: 'suite-' + resultNode.result.id},
-              createDom('li', {className: 'jasmine-suite-detail'},
-                createDom('a', {href: specHref(resultNode.result)}, resultNode.result.description)
-              )
-            );
-
-            summaryList(resultNode, suiteListNode);
-            domParent.appendChild(suiteListNode);
-          }
-          if (resultNode.type == 'spec') {
-            if (domParent.getAttribute('class') != 'jasmine-specs') {
-              specListNode = createDom('ul', {className: 'jasmine-specs'});
-              domParent.appendChild(specListNode);
-            }
-            var specDescription = resultNode.result.description;
-            if(noExpectations(resultNode.result)) {
-              specDescription = 'SPEC HAS NO EXPECTATIONS ' + specDescription;
-            }
-            if(resultNode.result.status === 'pending' && resultNode.result.pendingReason !== '') {
-              specDescription = specDescription + ' PENDING WITH MESSAGE: ' + resultNode.result.pendingReason;
-            }
-            specListNode.appendChild(
-              createDom('li', {
-                  className: 'jasmine-' + resultNode.result.status,
-                  id: 'spec-' + resultNode.result.id
-                },
-                createDom('a', {href: specHref(resultNode.result)}, specDescription)
-              )
-            );
-          }
-        }
-      }
+      summaryList(stateBuilder.topResults, summary);
 
       if (failures.length) {
         alert.appendChild(
@@ -325,6 +281,177 @@ jasmineRequire.HtmlReporter = function(j$) {
 
     return this;
 
+    function failureDom(result) {
+      var failure =
+        createDom('div', {className: 'jasmine-spec-detail jasmine-failed'},
+          failureDescription(result, stateBuilder.currentParent),
+          createDom('div', {className: 'jasmine-messages'})
+        );
+      var messages = failure.childNodes[1];
+
+      for (var i = 0; i < result.failedExpectations.length; i++) {
+        var expectation = result.failedExpectations[i];
+        messages.appendChild(createDom('div', {className: 'jasmine-result-message'}, expectation.message));
+        messages.appendChild(createDom('div', {className: 'jasmine-stack-trace'}, expectation.stack));
+      }
+
+      return failure;
+    }
+
+    function summaryList(resultsTree, domParent) {
+      var specListNode;
+      for (var i = 0; i < resultsTree.children.length; i++) {
+        var resultNode = resultsTree.children[i];
+        if (filterSpecs && !hasActiveSpec(resultNode)) {
+          continue;
+        }
+        if (resultNode.type === 'suite') {
+          var suiteListNode = createDom('ul', {className: 'jasmine-suite', id: 'suite-' + resultNode.result.id},
+            createDom('li', {className: 'jasmine-suite-detail jasmine-' + resultNode.result.status},
+              createDom('a', {href: specHref(resultNode.result)}, resultNode.result.description)
+            )
+          );
+
+          summaryList(resultNode, suiteListNode);
+          domParent.appendChild(suiteListNode);
+        }
+        if (resultNode.type === 'spec') {
+          if (domParent.getAttribute('class') !== 'jasmine-specs') {
+            specListNode = createDom('ul', {className: 'jasmine-specs'});
+            domParent.appendChild(specListNode);
+          }
+          var specDescription = resultNode.result.description;
+          if(noExpectations(resultNode.result)) {
+            specDescription = 'SPEC HAS NO EXPECTATIONS ' + specDescription;
+          }
+          if(resultNode.result.status === 'pending' && resultNode.result.pendingReason !== '') {
+            specDescription = specDescription + ' PENDING WITH MESSAGE: ' + resultNode.result.pendingReason;
+          }
+          specListNode.appendChild(
+            createDom('li', {
+                className: 'jasmine-' + resultNode.result.status,
+                id: 'spec-' + resultNode.result.id
+              },
+              createDom('a', {href: specHref(resultNode.result)}, specDescription)
+            )
+          );
+        }
+      }
+    }
+
+    function optionsMenu(env) {
+      var optionsMenuDom = createDom('div', { className: 'jasmine-run-options' },
+        createDom('span', { className: 'jasmine-trigger' }, 'Options'),
+        createDom('div', { className: 'jasmine-payload' },
+          createDom('div', { className: 'jasmine-stop-on-failure' },
+            createDom('input', {
+              className: 'jasmine-fail-fast',
+              id: 'jasmine-fail-fast',
+              type: 'checkbox'
+            }),
+            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-fail-fast' }, 'stop execution on spec failure')),
+          createDom('div', { className: 'jasmine-throw-failures' },
+            createDom('input', {
+              className: 'jasmine-throw',
+              id: 'jasmine-throw-failures',
+              type: 'checkbox'
+            }),
+            createDom('label', { className: 'jasmine-label', 'for': 'jasmine-throw-failures' }, 'stop spec on expectation failure')),
+          createDom('div', { className: 'jasmine-random-order' },
+            createDom('input', {
+              className: 'jasmine-random',
+              id: 'jasmine-random-order',
+              type: 'checkbox'
+            }),
+            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'))
+        )
+      );
+
+      var failFastCheckbox = optionsMenuDom.querySelector('#jasmine-fail-fast');
+      failFastCheckbox.checked = env.stoppingOnSpecFailure();
+      failFastCheckbox.onclick = function() {
+        navigateWithNewParam('failFast', !env.stoppingOnSpecFailure());
+      };
+
+      var throwCheckbox = optionsMenuDom.querySelector('#jasmine-throw-failures');
+      throwCheckbox.checked = env.throwingExpectationFailures();
+      throwCheckbox.onclick = function() {
+        navigateWithNewParam('throwFailures', !env.throwingExpectationFailures());
+      };
+
+      var randomCheckbox = optionsMenuDom.querySelector('#jasmine-random-order');
+      randomCheckbox.checked = env.randomTests();
+      randomCheckbox.onclick = function() {
+        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/;
+
+      optionsTrigger.onclick = function() {
+        if (isOpen.test(optionsPayload.className)) {
+          optionsPayload.className = optionsPayload.className.replace(isOpen, '');
+        } else {
+          optionsPayload.className += ' jasmine-open';
+        }
+      };
+
+      return optionsMenuDom;
+    }
+
+    function failureDescription(result, suite) {
+      var wrapper = createDom('div', {className: 'jasmine-description'},
+        createDom('a', {title: result.description, href: specHref(result)}, result.description)
+      );
+      var suiteLink;
+
+      while (suite && suite.parent) {
+        wrapper.insertBefore(createTextNode(' > '), wrapper.firstChild);
+        suiteLink = createDom('a', {href: suiteHref(suite)}, suite.result.description);
+        wrapper.insertBefore(suiteLink, wrapper.firstChild);
+
+        suite = suite.parent;
+      }
+
+      return wrapper;
+    }
+
+    function suiteHref(suite) {
+      var els = [];
+
+      while (suite && suite.parent) {
+        els.unshift(suite.result.description);
+        suite = suite.parent;
+      }
+
+      return addToExistingQueryString('spec', els.join(' '));
+    }
+
+    function addDeprecationWarnings(result) {
+      if (result && result.deprecationWarnings) {
+        for(var i = 0; i < result.deprecationWarnings.length; i++) {
+          var warning = result.deprecationWarnings[i].message;
+          if (!j$.util.arrayContains(warning)) {
+            deprecationWarnings.push(warning);
+          }
+        }
+      }
+    }
+
     function find(selector) {
       return getContainer().querySelector('.jasmine_html-reporter ' + selector);
     }
@@ -390,6 +517,20 @@ jasmineRequire.HtmlReporter = function(j$) {
       return (result.failedExpectations.length + result.passedExpectations.length) === 0 &&
         result.status === 'passed';
     }
+
+    function hasActiveSpec(resultNode) {
+      if (resultNode.type == 'spec' && resultNode.result.status != 'excluded') {
+        return true;
+      }
+
+      if (resultNode.type == 'suite') {
+        for (var i = 0, j = resultNode.children.length; i < j; i++) {
+          if (hasActiveSpec(resultNode.children[i])) {
+            return true;
+          }
+        }
+      }
+    }
   }
 
   return HtmlReporter;
@@ -423,6 +564,10 @@ jasmineRequire.ResultsNode = function() {
     this.last = function() {
       return this.children[this.children.length - 1];
     };
+
+    this.updateResult = function(result) {
+      this.result = result;
+    };
   }
 
   return ResultsNode;

lib/jasmine-core/jasmine.css

@@ -18,8 +18,9 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-passed:before { color: #007069; content: "\02022"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed { line-height: 9px; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed:before { color: #ca3a11; content: "\d7"; font-weight: bold; margin-left: -1px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-disabled { font-size: 14px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-disabled:before { color: #bababa; content: "\02022"; }
+.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; }
@@ -29,10 +30,11 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-run-options .jasmine-payload { position: absolute; display: none; right: -1px; border: 1px solid #8a4182; background-color: #eee; white-space: nowrap; padding: 4px 8px; }
 .jasmine_html-reporter .jasmine-run-options .jasmine-payload.jasmine-open { display: block; }
 .jasmine_html-reporter .jasmine-bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
-.jasmine_html-reporter .jasmine-bar.jasmine-failed { background-color: #ca3a11; }
+.jasmine_html-reporter .jasmine-bar.jasmine-failed, .jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; border-bottom: 1px solid #eee; }
 .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; }
-.jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; }
+.jasmine_html-reporter .jasmine-bar.jasmine-warning { background-color: #ba9d37; color: #333; }
 .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; }
@@ -46,13 +48,13 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-failed a { color: #ca3a11; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-empty a { color: #ba9d37; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-pending a { color: #ba9d37; }
-.jasmine_html-reporter .jasmine-summary li.jasmine-disabled a { color: #bababa; }
+.jasmine_html-reporter .jasmine-summary li.jasmine-excluded a { color: #bababa; }
 .jasmine_html-reporter .jasmine-description + .jasmine-suite { margin-top: 0; }
 .jasmine_html-reporter .jasmine-suite { margin-top: 14px; }
 .jasmine_html-reporter .jasmine-suite a { color: #333; }
 .jasmine_html-reporter .jasmine-failures .jasmine-spec-detail { margin-bottom: 28px; }
-.jasmine_html-reporter .jasmine-failures .jasmine-spec-detail .jasmine-description { background-color: #ca3a11; }
+.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; }

lib/jasmine-core/node_boot.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2016 Pivotal Labs
+Copyright (c) 2008-2018 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -23,10 +23,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 module.exports = function(jasmineRequire) {
   var jasmine = jasmineRequire.core(jasmineRequire);
 
-  var consoleFns = require('../console/console.js');
-  consoleFns.console(consoleFns, jasmine);
-
-  var env = jasmine.getEnv();
+  var env = jasmine.getEnv({suppressLoadErrors: true});
 
   var jasmineInterface = jasmineRequire.interface(jasmine, env);
 

lib/jasmine-core/spec

@@ -1 +0,0 @@
-../../spec

lib/jasmine-core/version.rb

@@ -4,6 +4,6 @@
 #
 module Jasmine
   module Core
-    VERSION = "2.5.2"
+    VERSION = "3.2.0"
   end
 end

package.json

@@ -1,7 +1,7 @@
 {
   "name": "jasmine-core",
   "license": "MIT",
-  "version": "2.5.2",
+  "version": "3.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -19,14 +19,15 @@
   "homepage": "http://jasmine.github.io",
   "main": "./lib/jasmine-core.js",
   "devDependencies": {
-    "glob": "~7.0.5",
+    "glob": "~7.1.2",
     "grunt": "^1.0.1",
     "grunt-cli": "^1.2.0",
     "grunt-contrib-compass": "^1.1.1",
     "grunt-contrib-compress": "^1.3.0",
     "grunt-contrib-concat": "^1.0.1",
     "grunt-contrib-jshint": "^1.0.0",
-    "jasmine": "^2.4.0",
+    "jasmine": "^3.0.0",
+    "jsdom": "^9.12.0",
     "load-grunt-tasks": "^0.4.0",
     "shelljs": "^0.7.0",
     "temp": "~0.8.1"

release_notes/2.6.0.md

@@ -0,0 +1,108 @@
+# Jasmine 2.6.0 Release Notes
+
+## Summary
+
+This release contains a number of fixes and pull requests.
+
+## Pull Requests & Issues
+
+Updating introduction url to last version
+  - Merges [#1316](https://github.com/jasmine/jasmine/issues/1316) from @rachelcarmena
+
+* Throw a recognizable Error message when `fail` outside of a spec.
+  - Fixes [#1017](https://github.com/jasmine/jasmine/issues/1017)
+
+* Allow the matcher provide a custom error message
+  - Merges [#1298](https://github.com/jasmine/jasmine/issues/1298) from @deckar01
+  - Fixes [#1123](https://github.com/jasmine/jasmine/issues/1123)
+
+* Fix the order in which afterAll hooks are run to match afterEach
+  - Merges [#1312](https://github.com/jasmine/jasmine/issues/1312) from @gdborton
+  - Fixes [#1311](https://github.com/jasmine/jasmine/issues/1311)
+
+* Add matchers for positive and negative infinity
+  - Merges [#1300](https://github.com/jasmine/jasmine/issues/1300) from @toubou91
+  - Fixes [#1294](https://github.com/jasmine/jasmine/issues/1294)
+
+* Add a first pass at JSDocs for the intended public API
+  - Fixes [#596](https://github.com/jasmine/jasmine/issues/596)
+
+* Pretty print objects passed to fail method
+  - Merges [#1283](https://github.com/jasmine/jasmine/issues/1283) from @mmmichl
+  - Fixes [#1090](https://github.com/jasmine/jasmine/issues/1090)
+
+* Properly check for Error constructor from a different frame
+  - Merges [#1275](https://github.com/jasmine/jasmine/issues/1275) from @anseki
+  - Fixes [#1252](https://github.com/jasmine/jasmine/issues/1252)
+
+* Add toHaveBeenCalledBefore matcher
+  - Merges [#1242](https://github.com/jasmine/jasmine/issues/1242) from @DamienCassou
+
+* Collect unhandled exceptions and pass them to the current runnable
+  - Fixes [#529](https://github.com/jasmine/jasmine/issues/529)
+  - Fixes [#937](https://github.com/jasmine/jasmine/issues/937)
+
+* Nicer error messages for `spyOn` when `null` is provided
+  - Fixes [#1258](https://github.com/jasmine/jasmine/issues/1258)
+
+* Require arguments to beforeEach, it, etc, to be actual functions
+  - Merges [#1222](https://github.com/jasmine/jasmine/issues/1222) from @voithos
+  - Fixes [#1004](https://github.com/jasmine/jasmine/issues/1004)
+
+* Update MIT.LICENSE for new year
+    - Merges [#1249](https://github.com/jasmine/jasmine/issues/1249) from @Scottkao85
+
+* Update README.md for new year
+  - Merges [#1248](https://github.com/jasmine/jasmine/issues/1248) from @Nebojsaa
+
+* Remove unused `message` param from Suite#pend
+  - See [#1132](https://github.com/jasmine/jasmine/issues/1132)
+
+* Fix bug where before/afterAll were being executed in disabled suites.
+  - Merges [#1225](https://github.com/jasmine/jasmine/issues/1225) from @voithos
+  - Fixes [#1175](https://github.com/jasmine/jasmine/issues/1175)
+
+* Make toEqual matcher report the difference between objects
+  - Merges [#1163](https://github.com/jasmine/jasmine/issues/1163) from @benchristel
+  - Fixes [#675](https://github.com/jasmine/jasmine/issues/675)
+  - Merges [#1236](https://github.com/jasmine/jasmine/issues/1236) from @benchristel
+
+
+* Implement spies for get/set functions on accessor properties
+  - Merges [#1203](https://github.com/jasmine/jasmine/issues/1203) from @celluj34
+  - Merges [#1008](https://github.com/jasmine/jasmine/issues/1008) from @smacker
+  - Fixes [#943](https://github.com/jasmine/jasmine/issues/943)
+
+* When the HtmlReporter has a 'spec' query param, the spec list only shows matching specs/suites
+  - Merges [#1046](https://github.com/jasmine/jasmine/issues/1046) from @d-reinhold
+  - Fixes [#510](https://github.com/jasmine/jasmine/issues/510)
+
+* createSpyObj may use object for method/response shorthand
+  - Merges [#1101](https://github.com/jasmine/jasmine/issues/1101) from @mbildner
+
+* Separate clear stack and run it after each spec
+  - Fixes [#985](https://github.com/jasmine/jasmine/issues/985)
+  - Fixes [#945](https://github.com/jasmine/jasmine/issues/945)
+  - Fixes [#366](https://github.com/jasmine/jasmine/issues/366)
+
+* Now spies preserve original function arity
+  - Merges [#1055](https://github.com/jasmine/jasmine/issues/1055) from @kapke
+  - Fixes [#991](https://github.com/jasmine/jasmine/issues/991)
+
+* Added support for ES6 sets to toContain and toEqual.
+  - Merges [#1067](https://github.com/jasmine/jasmine/issues/1067) from @alur
+
+* Correctly pretty print objects from other contexts (e.g. iframes) and which do not override toString
+  - Merges [#1091](https://github.com/jasmine/jasmine/issues/1091) from @thatfulvioguy
+  - Fixes [#1087](https://github.com/jasmine/jasmine/issues/1087)
+
+* Pass custom testers to asymmetric testers
+  - Merges [#1139](https://github.com/jasmine/jasmine/issues/1139) from @joeyparrish
+  - Fixes [#1138](https://github.com/jasmine/jasmine/issues/1138)
+
+* Fix bad url in README
+  - Merges [#1215](https://github.com/jasmine/jasmine/issues/1215) from @mattc41190
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.6.1.md

@@ -0,0 +1,31 @@
+# Jasmine 2.6.1 Release Notes
+
+## Summary
+
+This is a patch release to fix some regressions in the 2.6.0 release
+
+## Pull Requests & Issues
+
+* Update README.md to make installation instructions more version-agnostic
+  - Merges #1319 from @reinrl
+
+* Check for `process.listeners` as well, for GlobalErrors
+  - Fixes #1333
+
+* allow explicit undefined as function for `it` and `xit`
+  - Merges #1329 from @UziTech
+  - Fixes #1328
+
+* remove eval to create spy wrapper
+  - Merges #1330 from @UziTech
+  - Fixes #1325
+
+* iterate through keys with a regular for loop
+  - Merges #1326 from @seanparmelee
+  - Fixes #1321
+  - Fixes #1324
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.6.2.md

@@ -0,0 +1,23 @@
+# Jasmine 2.6.2 Release Notes
+
+## Summary
+
+This is a patch release to fix some regressions and performance problems in the 2.6.0 release
+
+## Changes
+
+* Clear the stack if onmessage is called before the previous invocation finishes
+  - Fixes #1327
+  - Fixes jasmine/gulp-jasmine-browser#48
+
+* Correctly route errors that occur while a QueueRunner is clearing stack
+  - Merges #1352 from @sgravrock
+  - Fixes #1344
+  - Fixes #1349
+
+* Don't mask errors that occur when no handlers are installed
+  - Merges #1347 from @sgravrock
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.6.3.md

@@ -0,0 +1,17 @@
+# Jasmine 2.6.3 Release Notes
+
+## Summary
+
+This is a patch release to fix some regressions and performance problems in the 2.6.0 release
+
+## Changes
+
+* Make sure the queue runner goes async for async specs
+  - Fixes [#1327](https://github.com/jasmine/jasmine/issues/1327)
+  - Fixes [#1334](https://github.com/jasmine/jasmine/issues/1334)
+  - Fixes [jasmine/gulp-jasmine-browser#48](https://github.com/jasmine/gulp-jasmine-browser/issues/48)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.6.4.md

@@ -0,0 +1,17 @@
+# Jasmine 2.6.4 Release Notes
+
+## Summary
+
+This is a patch release to fix some regressions and performance problems in the 2.6.0 release
+
+## Changes
+
+* Break into a `setTimeout` every once in a while allowing the CPU to run other things that used the real `setTimeout`
+  - Fixes [#1327](https://github.com/jasmine/jasmine/issues/1327)
+  - See [#1334](https://github.com/jasmine/jasmine/issues/1334)
+  - Fixes [jasmine/gulp-jasmine-browser#48](https://github.com/jasmine/gulp-jasmine-browser/issues/48)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.7.0.md

@@ -0,0 +1,61 @@
+# Jasmine 2.7.0 Release Notes
+
+## Summary
+
+This release contains a number of fixes and pull requests.
+
+## Pull Requests & Issues
+
+
+* Add class UserContext
+  - Merges [#1400](https://github.com/jasmine/jasmine/issues/1400) from @darthjee
+
+* Send unfocused tests through the same queue as focused tests
+  - Merges [#1399](https://github.com/jasmine/jasmine/issues/1399) from @jberney
+
+* PrettyPrinter allows an object to have a `toString` that isn't a function
+  - Fixes [#1389](https://github.com/jasmine/jasmine/issues/1389)
+
+* Fix rounding in toBeCloseTo
+  - Fixes [#1382](https://github.com/jasmine/jasmine/issues/1382)
+
+* When stop on failure is enabled, skip subsequent it() and beforeEach(). Note: afterEach() functions are still run, because skipping them is highly likely to pollute specs that run after the failure.
+  - Fixes [#577](https://github.com/jasmine/jasmine/issues/577)
+  - Fixes [#807](https://github.com/jasmine/jasmine/issues/807)
+
+* Only clear out the `spec` param for Run all link
+  - Fixes [#1369](https://github.com/jasmine/jasmine/issues/1369)
+
+* Pretty printer will now use MAX_PRETTY_PRINT_ARRAY_LENGTH for objects
+  - Fixes [#1291](https://github.com/jasmine/jasmine/issues/1291)
+  - Fixes [#1360](https://github.com/jasmine/jasmine/issues/1360)
+
+* updated package glob from 7.0.5 to 7.1.2
+  - Merges [#1368](https://github.com/jasmine/jasmine/issues/1368) from @EsrefDurna
+
+* Fix bower.json url to be https instead of http
+  - Merges [#1365](https://github.com/jasmine/jasmine/issues/1365) from @kant
+
+* Fail when one of the arguments passed into toBeCloseTo matcher is null
+  - Merges [#1362](https://github.com/jasmine/jasmine/issues/1362) from @beatrichartz
+
+* Fixed HTML snippet in README
+  - Closes [#1366](https://github.com/jasmine/jasmine/issues/1366).
+
+* Report the random seed at the beginning and end of execution. This allows reporters to provide the seed to the user even in cases where Jasmine crashes before completing.
+  - Merges [#1348](https://github.com/jasmine/jasmine/issues/1348) from @sgravrock
+
+* Add ES6 map support to Jasmine
+  - Merges [#1340](https://github.com/jasmine/jasmine/issues/1340) from @rmehlinger
+  - Fixes [#1257](https://github.com/jasmine/jasmine/issues/1257)
+
+* Added support for async before/it/after functions that return promises and added support for ES2017 async functions
+  - Merges [#1356](https://github.com/jasmine/jasmine/issues/1356) from @sgravrock
+  - Fixes [#1336](https://github.com/jasmine/jasmine/issues/1336)
+  - Fixes [#1270](https://github.com/jasmine/jasmine/issues/1270)
+  - Fixes [#1350](https://github.com/jasmine/jasmine/issues/1350)
+  - Fixes [#1320](https://github.com/jasmine/jasmine/issues/1320)
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.8.0.md

@@ -0,0 +1,52 @@
+# Jasmine 2.8.0 Release Notes
+
+## Summary
+
+This release contains a number of fixes and pull requests.
+2.8 should be the last 2.x release of Jasmine, as we aim for 3.0.
+
+## Changes
+
+* Create CODE_OF_CONDUCT.md
+* Add jsdocs for reporter events
+* Update jsApiReporter docs to link to new suite and spec results
+* Add explicit docs for the callback function passed to `it` etc.
+* Update afterAll documentation
+
+## Pull Requests & Issues
+
+* Add 'nothing' matcher and tests
+  - Merges [#1412](https://github.com/jasmine/jasmine/issues/1412) from @ksvitkovsky
+  - Fixes [#1221](https://github.com/jasmine/jasmine/issues/1221)
+
+
+* Make toEqual matcher report the difference between array elements when arrays have different length
+  - Closes [#1375](https://github.com/jasmine/jasmine/issues/1375) from @kiewic
+
+
+* Add arrayWithExactContents asymmetric matcher
+  - Fixes [#817](https://github.com/jasmine/jasmine/issues/817)
+
+
+* Ensure no message added on asym. match success
+  - Closes [#1408](https://github.com/jasmine/jasmine/issues/1408) from @ksvitkovsky
+  - Fixes [#1388](https://github.com/jasmine/jasmine/issues/1388)
+
+
+* Better primitives detection for saveArgsByValue
+  - Closes [#1407](https://github.com/jasmine/jasmine/issues/1407) from @ksvitkovsky
+  - Fixes [#1403](https://github.com/jasmine/jasmine/issues/1403)
+
+
+* Better pretty printing for typed arrays
+  - Closes [#1404](https://github.com/jasmine/jasmine/issues/1404) from @ksvitkovsky
+  - Fixes [#1180](https://github.com/jasmine/jasmine/issues/1180)
+
+
+* Rewrite ES6 Set and Map comparison to ignore insertion order
+  - Merges [#1406](https://github.com/jasmine/jasmine/issues/1406) from @theefer
+  - Fixes [#1402](https://github.com/jasmine/jasmine/issues/1402)
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.9.0.md

@@ -0,0 +1,99 @@
+# Jasmine 2.9 Release Notes
+
+## Summary
+
+This release contains a number of fixes and pull requests.
+
+## Changes
+
+* Fixed DelayedFunctionScheduler IE 8 compatibility issue
+* Fixed SPEC HAS NO EXPECTATIONS warning in HTML reporter
+* Correctly remove spies of window.onerror on IE
+* Truncate pretty printer output that is more than j$.MAX_PRETTY_PRINT_CHARS long
+* Reduced pretty printer limits to much smaller values
+* Update contributing for new naming of `jasmineUnderTest`
+* Allowed async functions to be passed into spy#callFake
+
+## Pull Requests & Issues
+
+* Added complete support for Set also for IE11.
+  - Merges [#1478](https://github.com/jasmine/jasmine/issues/1478) from @Volox
+  - Fixes [#1355](https://github.com/jasmine/jasmine/issues/1355)
+
+
+* Added complete support for Map also for IE11.
+  - Merges [#1477](https://github.com/jasmine/jasmine/issues/1477) from @Volox
+  - Fixes [#1472](https://github.com/jasmine/jasmine/issues/1472)
+
+
+* Use timeout objects when in node
+  - Merges [#1470](https://github.com/jasmine/jasmine/issues/1470) from @chris--young
+  - Fixes [#1469](https://github.com/jasmine/jasmine/issues/1469)
+
+
+* Fixed `pending()` for `async`/promise-returning specs
+  - Fixes [#1449](https://github.com/jasmine/jasmine/issues/1449)
+  - Fixes [#1450](https://github.com/jasmine/jasmine/issues/1450)
+
+
+* Added test steps for other major node versions
+    - Merges [#1448](https://github.com/jasmine/jasmine/issues/1448) from @mrlannigan
+
+
+* Fix equality computation for ES6 Sets.
+  - Merges [#1445](https://github.com/jasmine/jasmine/issues/1445) from @b-3-n
+  - Fixes [#1444](https://github.com/jasmine/jasmine/issues/1444)
+
+
+* Add instruction to sync local master with upstream
+  - Merges [#1440](https://github.com/jasmine/jasmine/issues/1440) from aaronang
+
+
+* Add some unit tests that exercise jasmine.anything() and Map matching.
+  - Merges [#1437](https://github.com/jasmine/jasmine/issues/1437) from @voithos
+
+
+* Add special handling of asymmetric matcher objects as keys in Maps.
+  - Merges [#1436](https://github.com/jasmine/jasmine/issues/1436) from @voithos
+  - Fixes [#1432](https://github.com/jasmine/jasmine/issues/1432)
+
+
+* Add support for jasmine.any(Symbol).
+  - Merge [#1435](https://github.com/jasmine/jasmine/issues/1435) from @voithos
+  - Fixes [#1431](https://github.com/jasmine/jasmine/issues/1431)
+
+
+* Throw an error for invalid nesting of a suite functions
+  - Merges [#1411](https://github.com/jasmine/jasmine/issues/1411) from @ksvitkovsky
+  - Fixes [#1295](https://github.com/jasmine/jasmine/issues/1295)
+
+
+* Deep clone args before passing them to reporters
+  - Merges [#1424](https://github.com/jasmine/jasmine/issues/1424) from @aj-dev
+
+
+* Fix "Before Committing" section of CONTRIBUTING.md.
+  - Merges [#1429](https://github.com/jasmine/jasmine/issues/1429) from @voithos
+
+
+* Fix lint warning in CallTracker.
+  - Merges [#1428](https://github.com/jasmine/jasmine/issues/1428) from @voithos
+
+
+* clearTimeout should now correctly clear a timeout that is also scheduled to run at the same tick.
+  - Merges [#1427](https://github.com/jasmine/jasmine/issues/1427) from @leahciMic
+  - Fixes [#1426](https://github.com/jasmine/jasmine/issues/1426)
+
+
+* Add a note about `defineProperty` for `spyOnProperty`
+  - Fixes [#1415](https://github.com/jasmine/jasmine/issues/1415)
+
+
+* Add Promise checking to eq
+  - Merges [#1386](https://github.com/jasmine/jasmine/issues/1386) from @sderickson
+  - Fixes [#1314](https://github.com/jasmine/jasmine/issues/1314)
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.9.1.md

@@ -0,0 +1,15 @@
+# Jasmine Core 2.9.1 Release Notes
+
+## Summary
+
+This is a hotfix release to fix a breaking change from the 2.9.0 release
+
+## Changes
+
+* Clear timeouts when starting to process a milli instead of at the end
+  - Fixes #1482
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/2.99.md

@@ -0,0 +1,19 @@
+# Jasmine-Core 2.99 Release Notes
+
+## Summary
+
+This release is part of the upgrade path to Jasmine 3.0. It deprecates some functionality that will change.
+
+## Changes
+
+* Add ability to report deprecation warnings from within the suite and display them in the HTML reporter
+* Add deprecation messages for things that will change/break in 3.0
+* * done for async functionality will now add a failure if it is invoked with an Error
+* * Env.catchExceptions and the query param are going away, in favor of a more fully functional fail fast handler
+* * jasmine.Any(Object) will no longer match null
+* * Unhandled errors during suite load will be caught and reported as failures by Jasmine
+* * Calling execute more than once on the same spec will definitely fail in 3.0
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/3.0.md

@@ -0,0 +1,89 @@
+# Jasmine-Core 3.0 Release Notes
+
+## Summary
+
+Jasmine 3.0 is a major release of Jasmine, and as such includes some breaking changes in addition to various new features.
+
+There is also a 2.99 release of Jasmine that will present deprecation warnings for suites that will encounter different behavior in 3.0.
+
+## Breaking Changes
+
+* 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-npm/issues/16)
+
+* Detect an Error passed to `done` and add an expectation failure
+  - Fixes [#567](https://github.com/jasmine/jasmine/issues/567)
+
+* Unify status for xdescribe and xit
+  - Ensure *All's only execute if at least one child will run
+  - Specs will report a status of `excluded` instead of disabled
+  - Fixes [#1418](https://github.com/jasmine/jasmine/issues/1418)
+
+* Suite level errors all report the same way (on suiteDone)
+
+* Refactor QueueRunner and remove references to functions that Jasmine is done with
+
+* expect(null).toEqual(jasmine.any(Object)) no longer passes
+  - Fixes [#1255](https://github.com/jasmine/jasmine/issues/1255)
+
+* 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
+
+* Allow reporter callbacks to be asynchronous
+  - Fixes [#842](https://github.com/jasmine/jasmine/issues/842)
+
+* Allow adding custom spy strategies
+
+* Add the ability to specify the strategy to use for a spy based on which parameters are passed
+
+* Added links to re-run the suites containing a failing spec
+
+* Added a toHaveClass matcher
+
+* More informative pretty-printing of DOM elements
+
+* Allow jasmine-npm to handle its own load errors
+
+* Treat random= as a no-op rather than disabling randomization
+
+* Use prototype for spy strategy for better memory management
+
+* Remove console.js altogether
+
+* Add safari 10 and update readme to include edge
+
+* Determine overall status in core, not reporters
+
+* Filter Jasmine frames from stack traces
+
+* Treat afterAll errors at any level as failures
+
+* Improved reporting of load errors and afterAll errors
+  - Pass file and line number to reporters when present
+  - Show file and line number in the HTML reporter when present
+  - Visually separate adjacent errors in the HTML reporter
+
+* Report loading errors as loading errors, not afterAll errors
+
+* HTML reporter reports overall failure if there are any global errors
+
+* Fail if error events (e.g. syntax errors) occur during loading
+
+* Allow use of a predicate function to validate thrown exceptions
+
+* Check truthiness of toThrowError args, not arg count
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

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)_

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)_

setup.py

@@ -23,9 +23,6 @@ setup(
         'License :: OSI Approved :: MIT License',
         'Operating System :: OS Independent',
         'Programming Language :: Python',
-        'Programming Language :: Python :: 2',
-        'Programming Language :: Python :: 2.6',
-        'Programming Language :: Python :: 2.7',
         'Programming Language :: Python :: 3',
         'Programming Language :: Python :: 3.2',
         'Programming Language :: Python :: 3.3',

spec/console/ConsoleReporterSpec.js

@@ -1,270 +0,0 @@
-describe("ConsoleReporter", function() {
-  var out;
-
-  beforeEach(function() {
-    out = (function() {
-      var output = "";
-      return {
-        print: function(str) {
-          output += str;
-        },
-        getOutput: function() {
-          return output.replace('ConsoleReporter is deprecated and will be removed in a future version.', '');
-        },
-        clear: function() {
-          output = "";
-        }
-      };
-    }());
-  });
-
-  it("reports that the suite has started to the console", function() {
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-      print: out.print
-    });
-
-    reporter.jasmineStarted();
-
-    expect(out.getOutput()).toEqual("Started\n");
-  });
-
-  it("starts the provided timer when jasmine starts", function() {
-    var timerSpy = jasmine.createSpyObj('timer', ['start']),
-        reporter = new jasmineUnderTest.ConsoleReporter({
-          print: out.print,
-          timer: timerSpy
-        });
-
-    reporter.jasmineStarted();
-
-    expect(timerSpy.start).toHaveBeenCalled();
-  });
-
-  it("reports a passing spec as a dot", function() {
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-      print: out.print
-    });
-
-    reporter.specDone({status: "passed"});
-
-    expect(out.getOutput()).toEqual(".");
-  });
-
-  it("does not report a disabled spec", function() {
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-      print: out.print
-    });
-
-    reporter.specDone({status: "disabled"});
-
-    expect(out.getOutput()).toEqual("");
-  });
-
-  it("reports a failing spec as an 'F'", function() {
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-      print: out.print
-    });
-
-    reporter.specDone({status: "failed"});
-
-    expect(out.getOutput()).toEqual("F");
-  });
-
-  it("reports a pending spec as a '*'", function() {
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-      print: out.print
-    });
-
-    reporter.specDone({status: "pending"});
-
-    expect(out.getOutput()).toEqual("*");
-  });
-
-  it("alerts user if there are no specs", function(){
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-          print: out.print
-        });
-
-    reporter.jasmineStarted();
-    out.clear();
-    reporter.jasmineDone();
-
-    expect(out.getOutput()).toMatch(/No specs found/);
-  });
-
-  it("reports a summary when done (singular spec and time)", function() {
-    var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-        reporter = new jasmineUnderTest.ConsoleReporter({
-          print: out.print,
-          timer: timerSpy
-        });
-
-    reporter.jasmineStarted();
-    reporter.specDone({status: "passed"});
-
-    timerSpy.elapsed.and.returnValue(1000);
-
-    out.clear();
-    reporter.jasmineDone();
-
-    expect(out.getOutput()).toMatch(/1 spec, 0 failures/);
-    expect(out.getOutput()).not.toMatch(/0 pending specs/);
-    expect(out.getOutput()).toMatch("Finished in 1 second\n");
-  });
-
-  it("reports a summary when done (pluralized specs and seconds)", function() {
-    var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-        reporter = new jasmineUnderTest.ConsoleReporter({
-          print: out.print,
-          timer: timerSpy
-        });
-
-    reporter.jasmineStarted();
-    reporter.specDone({status: "passed"});
-    reporter.specDone({status: "pending"});
-    reporter.specDone({
-      status: "failed",
-      description: "with a failing spec",
-      fullName: "A suite with a failing spec",
-      failedExpectations: [
-        {
-          passed: false,
-          message: "Expected true to be false.",
-          expected: false,
-          actual: true,
-          stack: "foo\nbar\nbaz"
-        }
-      ]
-    });
-
-    out.clear();
-
-    timerSpy.elapsed.and.returnValue(100);
-
-    reporter.jasmineDone();
-
-    expect(out.getOutput()).toMatch(/3 specs, 1 failure, 1 pending spec/);
-    expect(out.getOutput()).toMatch("Finished in 0.1 seconds\n");
-  });
-
-  it("reports a summary when done that includes stack traces for a failing suite", function() {
-    var reporter = new jasmineUnderTest.ConsoleReporter({
-      print: out.print
-    });
-
-    reporter.jasmineStarted();
-    reporter.specDone({status: "passed"});
-    reporter.specDone({
-      status: "failed",
-      description: "with a failing spec",
-      fullName: "A suite with a failing spec",
-      failedExpectations: [
-        {
-          passed: false,
-          message: "Expected true to be false.",
-          expected: false,
-          actual: true,
-          stack: "foo bar baz"
-        }
-      ]
-    });
-
-    out.clear();
-
-    reporter.jasmineDone();
-
-    expect(out.getOutput()).toMatch(/true to be false/);
-    expect(out.getOutput()).toMatch(/foo bar baz/);
-  });
-
-  describe('onComplete callback', function(){
-    var onComplete, reporter;
-
-    beforeEach(function() {
-      onComplete = jasmine.createSpy('onComplete');
-      reporter = new jasmineUnderTest.ConsoleReporter({
-        print: out.print,
-        onComplete: onComplete
-      });
-      reporter.jasmineStarted();
-    });
-
-    it("is called when the suite is done", function() {
-      reporter.jasmineDone();
-      expect(onComplete).toHaveBeenCalledWith(true);
-    });
-
-    it('calls it with false if there are spec failures', function() {
-      reporter.specDone({status: "failed", failedExpectations: []});
-      reporter.jasmineDone();
-      expect(onComplete).toHaveBeenCalledWith(false);
-    });
-
-    it('calls it with false if there are suite failures', function() {
-      reporter.specDone({status: "passed"});
-      reporter.suiteDone({failedExpectations: [{ message: 'bananas' }] });
-      reporter.jasmineDone();
-      expect(onComplete).toHaveBeenCalledWith(false);
-    });
-  });
-
-  describe("with color", function() {
-    it("reports that the suite has started to the console", function() {
-      var reporter = new jasmineUnderTest.ConsoleReporter({
-        print: out.print,
-        showColors: true
-      });
-
-      reporter.jasmineStarted();
-
-      expect(out.getOutput()).toEqual("Started\n");
-    });
-
-    it("reports a passing spec as a dot", function() {
-      var reporter = new jasmineUnderTest.ConsoleReporter({
-        print: out.print,
-        showColors: true
-      });
-
-      reporter.specDone({status: "passed"});
-
-      expect(out.getOutput()).toEqual("\x1B[32m.\x1B[0m");
-    });
-
-    it("does not report a disabled spec", function() {
-      var reporter = new jasmineUnderTest.ConsoleReporter({
-        print: out.print,
-        showColors: true
-      });
-
-      reporter.specDone({status: 'disabled'});
-
-      expect(out.getOutput()).toEqual("");
-    });
-
-    it("reports a failing spec as an 'F'", function() {
-      var reporter = new jasmineUnderTest.ConsoleReporter({
-        print: out.print,
-        showColors: true
-      });
-
-      reporter.specDone({status: 'failed'});
-
-      expect(out.getOutput()).toEqual("\x1B[31mF\x1B[0m");
-    });
-
-    it("displays all afterAll exceptions", function() {
-        var reporter = new jasmineUnderTest.ConsoleReporter({
-          print: out.print,
-          showColors: true
-        });
-
-        reporter.suiteDone({ failedExpectations: [{ message: 'After All Exception' }] });
-        reporter.suiteDone({ failedExpectations: [{ message: 'Some Other Exception' }] });
-        reporter.jasmineDone();
-
-        expect(out.getOutput()).toMatch(/After All Exception/);
-        expect(out.getOutput()).toMatch(/Some Other Exception/);
-    });
-  });
-});

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) {
+    });
+  }
+});

spec/core/CallTrackerSpec.js

@@ -117,4 +117,14 @@ describe("CallTracker", function() {
     expect(callTracker.mostRecent().args[1]).not.toBe(arrayArg);
     expect(callTracker.mostRecent().args[1]).toEqual(arrayArg);
   });
+
+  it('saves primitive arguments by value', function() {
+    var callTracker = new jasmineUnderTest.CallTracker(),
+      args = [undefined, null, false, '', /\s/, 0, 1.2, NaN];
+
+    callTracker.saveArgumentsByValue();
+    callTracker.track({ object: {}, args: args });
+
+    expect(callTracker.mostRecent().args).toEqual(args);
+  });
 });

spec/core/ClearStackSpec.js

@@ -0,0 +1,137 @@
+describe("ClearStack", function() {
+  it("works in an integrationy way", function(done) {
+    var clearStack = jasmineUnderTest.getClearStack(jasmineUnderTest.getGlobal());
+
+    clearStack(function() {
+      done();
+    });
+  });
+
+  it("uses setImmediate when available", function() {
+    var setImmediate = jasmine.createSpy('setImmediate').and.callFake(function(fn) { fn() }),
+        global = { setImmediate: setImmediate },
+        clearStack = jasmineUnderTest.getClearStack(global),
+        called = false;
+
+    clearStack(function() {
+      called = true;
+    });
+
+    expect(called).toBe(true);
+    expect(setImmediate).toHaveBeenCalled();
+  });
+
+  it("uses setTimeout instead of setImmediate every 10 calls to make sure we release the CPU", function() {
+    var setImmediate = jasmine.createSpy('setImmediate'),
+        setTimeout = jasmine.createSpy('setTimeout'),
+        global = { setImmediate: setImmediate, setTimeout: setTimeout },
+        clearStack = jasmineUnderTest.getClearStack(global);
+
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+
+    expect(setImmediate).toHaveBeenCalled();
+    expect(setTimeout).not.toHaveBeenCalled();
+
+    clearStack(function() { });
+    expect(setImmediate.calls.count()).toEqual(9);
+    expect(setTimeout.calls.count()).toEqual(1);
+
+    clearStack(function() { });
+    expect(setImmediate.calls.count()).toEqual(10);
+    expect(setTimeout.calls.count()).toEqual(1);
+  });
+
+  it("uses MessageChannels when available", function() {
+    var fakeChannel = {
+          port1: {},
+          port2: { postMessage: function() { fakeChannel.port1.onmessage(); } }
+        },
+        global = { MessageChannel: function() { return fakeChannel; } },
+        clearStack = jasmineUnderTest.getClearStack(global),
+        called = false;
+
+    clearStack(function() {
+      called = true;
+    });
+
+    expect(called).toBe(true);
+  });
+
+  it("uses setTimeout instead of MessageChannel every 10 calls to make sure we release the CPU", function() {
+    var fakeChannel = {
+          port1: {},
+          port2: {
+            postMessage: jasmine.createSpy('postMessage').and.callFake(function() {
+              fakeChannel.port1.onmessage();
+            })
+          }
+        },
+        setTimeout = jasmine.createSpy('setTimeout'),
+        global = { MessageChannel: function() { return fakeChannel; }, setTimeout: setTimeout },
+        clearStack = jasmineUnderTest.getClearStack(global);
+
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+    clearStack(function() { });
+
+    expect(fakeChannel.port2.postMessage).toHaveBeenCalled();
+    expect(setTimeout).not.toHaveBeenCalled();
+
+    clearStack(function() { });
+    expect(fakeChannel.port2.postMessage.calls.count()).toEqual(9);
+    expect(setTimeout.calls.count()).toEqual(1);
+
+    clearStack(function() { });
+    expect(fakeChannel.port2.postMessage.calls.count()).toEqual(10);
+    expect(setTimeout.calls.count()).toEqual(1);
+  });
+
+  it("calls setTimeout when onmessage is called recursively", function() {
+    var fakeChannel = {
+          port1: {},
+          port2: { postMessage: function() { fakeChannel.port1.onmessage(); } }
+        },
+        setTimeout = jasmine.createSpy('setTimeout'),
+        global = {
+          MessageChannel: function() { return fakeChannel; },
+          setTimeout: setTimeout,
+        },
+        clearStack = jasmineUnderTest.getClearStack(global),
+        fn = jasmine.createSpy("second clearStack function");
+
+    clearStack(function() {
+      clearStack(fn);
+    });
+
+    expect(fn).not.toHaveBeenCalled();
+    expect(setTimeout).toHaveBeenCalledWith(fn, 0);
+  });
+
+  it("falls back to setTimeout", function() {
+    var setTimeout = jasmine.createSpy('setTimeout').and.callFake(function(fn) { fn() }),
+        global = { setTimeout: setTimeout },
+        clearStack = jasmineUnderTest.getClearStack(global),
+        called = false;
+
+    clearStack(function() {
+      called = true;
+    });
+
+    expect(called).toBe(true);
+    expect(setTimeout).toHaveBeenCalledWith(jasmine.any(Function), 0);
+  });
+});

spec/core/ClockSpec.js

@@ -1,5 +1,7 @@
 describe("Clock", function() {
 
+  var NODE_JS = typeof process !== 'undefined' && process.versions && typeof process.versions.node === 'string';
+
   it("does not replace setTimeout until it is installed", function() {
     var fakeSetTimeout = jasmine.createSpy("global setTimeout"),
       fakeGlobal = { setTimeout: fakeSetTimeout },
@@ -294,13 +296,19 @@ describe("Clock", function() {
       fakeGlobal = { setTimeout: fakeSetTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      timeout = new clock.FakeTimeout();
 
     clock.install();
     clock.setTimeout(delayedFn, 0, 'a', 'b');
 
     expect(fakeSetTimeout).not.toHaveBeenCalled();
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b']);
+
+    if (!NODE_JS) {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b']);
+    } else {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], false, timeout);
+    }
   });
 
   it("returns an id for the delayed function", function() {
@@ -312,12 +320,16 @@ describe("Clock", function() {
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
       clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
-      timeoutId;
+      timeout;
 
     clock.install();
-    timeoutId = clock.setTimeout(delayedFn, 0);
+    timeout = clock.setTimeout(delayedFn, 0);
 
-    expect(timeoutId).toEqual(123);
+    if (!NODE_JS) {
+      expect(timeout).toEqual(123);
+    } else {
+      expect(timeout.constructor.name).toEqual('FakeTimeout');
+    }
   });
 
   it("clears the scheduled function with the scheduler", function() {
@@ -342,13 +354,19 @@ describe("Clock", function() {
       fakeGlobal = { setInterval: fakeSetInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
+      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
+      timeout = new clock.FakeTimeout;
 
     clock.install();
     clock.setInterval(delayedFn, 0, 'a', 'b');
 
     expect(fakeSetInterval).not.toHaveBeenCalled();
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true);
+
+    if (!NODE_JS) {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true);
+    } else {
+      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true, timeout);
+    }
   });
 
   it("returns an id for the delayed function", function() {
@@ -360,12 +378,16 @@ describe("Clock", function() {
       delayedFn = jasmine.createSpy('delayedFn'),
       mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
       clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate),
-      intervalId;
+      interval;
 
     clock.install();
-    intervalId = clock.setInterval(delayedFn, 0);
+    interval = clock.setInterval(delayedFn, 0);
 
-    expect(intervalId).toEqual(123);
+    if (!NODE_JS) {
+      expect(interval).toEqual(123);
+    } else {
+      expect(interval.constructor.name).toEqual('FakeTimeout');
+    }
   });
 
   it("clears the scheduled function with the scheduler", function() {
@@ -389,37 +411,6 @@ describe("Clock", function() {
       clock.tick(50);
     }).toThrow();
   });
-
-  it("on IE < 9, fails if extra args are passed to fake clock", function() {
-    //fail, because this would break in IE9.
-    var fakeSetTimeout = jasmine.createSpy('setTimeout'),
-      fakeSetInterval = jasmine.createSpy('setInterval'),
-      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['scheduleFunction']),
-      fn = jasmine.createSpy('fn'),
-      fakeGlobal = {
-        setTimeout: fakeSetTimeout,
-        setInterval: fakeSetInterval
-      },
-      mockDate = { install: function() {}, tick: function() {}, uninstall: function() {} },
-      clock = new jasmineUnderTest.Clock(fakeGlobal, function () { return delayedFunctionScheduler; }, mockDate);
-
-    fakeSetTimeout.apply = null;
-    fakeSetInterval.apply = null;
-
-    clock.install();
-
-    clock.setTimeout(fn, 0);
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, []);
-    expect(function() {
-      clock.setTimeout(fn, 0, 'extra');
-    }).toThrow();
-
-    clock.setInterval(fn, 0);
-    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, [], true);
-    expect(function() {
-      clock.setInterval(fn, 0, 'extra');
-    }).toThrow();
-  });
 });
 
 describe("Clock (acceptance)", function() {
@@ -678,5 +669,42 @@ 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(),
+      global = {Date: Date, setTimeout: undefined},
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock(global, function () { return delayedFunctionScheduler; }, mockDate);
+
+    clock.install();
+
+    var timerId2;
+
+    global.setTimeout(function () {
+      global.clearTimeout(timerId2);
+    }, 100);
+
+    timerId2 = global.setTimeout(fail, 100);
+
+    clock.tick(100);
+  });
+
+  it('correctly clears a scheduled interval while the Clock is advancing', function () {
+    var delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
+      global = {Date: Date, setTimeout: undefined},
+      mockDate = new jasmineUnderTest.MockDate(global),
+      clock = new jasmineUnderTest.Clock(global, function () { return delayedFunctionScheduler; }, mockDate);
+
+    clock.install();
+
+    var timerId2;
+    var timerId1 = global.setInterval(function () {
+      global.clearInterval(timerId2);
+    }, 100);
+
+    timerId2 = global.setInterval(fail, 100);
+
+    clock.tick(400);
+  });
 });

spec/core/DelayedFunctionSchedulerSpec.js

@@ -216,21 +216,23 @@ describe("DelayedFunctionScheduler", function() {
 
   it("removes functions during a tick that runs the function", function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      fn = jasmine.createSpy('fn'),
+      spy = jasmine.createSpy('fn'),
+      spyAndRemove = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
 
-    timeoutKey = scheduler.scheduleFunction(fn, fnDelay, [], true);
-    scheduler.scheduleFunction(function () {
+    spyAndRemove.and.callFake(function() {
       scheduler.removeFunctionWithId(timeoutKey);
-    }, 2 * fnDelay);
+    });
 
-    expect(fn).not.toHaveBeenCalled();
+    scheduler.scheduleFunction(spyAndRemove, fnDelay);
 
-    scheduler.tick(3 * fnDelay);
+    timeoutKey = scheduler.scheduleFunction(spy, fnDelay, [], true);
 
-    expect(fn).toHaveBeenCalled();
-    expect(fn.calls.count()).toBe(2);
+    scheduler.tick(2 * fnDelay);
+
+    expect(spy).not.toHaveBeenCalled();
+    expect(spyAndRemove).toHaveBeenCalled();
   });
 
   it("removes functions during the first tick that runs the function", function() {
@@ -252,6 +254,22 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn.calls.count()).toBe(1);
   });
 
+  it("does not remove a function that hasn't been added yet", function() {
+    var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn'),
+      fnDelay = 10,
+      timeoutKey;
+
+    scheduler.removeFunctionWithId('foo');
+    scheduler.scheduleFunction(fn, fnDelay, [], false, 'foo');
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.tick(fnDelay + 1);
+
+    expect(fn).toHaveBeenCalled();
+  });
+
   it("updates the mockDate per scheduled time", function () {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       tickDate = jasmine.createSpy('tickDate');

spec/core/EnvSpec.js

@@ -26,15 +26,6 @@ describe("Env", function() {
     });
   });
 
-  describe('#describe', function () {
-    var spec = function(done){};
-    it("throws the error", function() {
-      expect(function() {
-        env.describe('done method', spec);
-      }).toThrow(new Error('describe does not expect any arguments'));
-    });
-  });
-
   it('can configure specs to throw errors on expectation failures', function() {
     env.throwOnExpectationFailure(true);
 
@@ -55,14 +46,175 @@ describe("Env", function() {
     }));
   });
 
+  describe('#describe', function () {
+    it("throws an error when given arguments", function() {
+      expect(function() {
+        env.describe('done method', function(done) {});
+      }).toThrowError('describe does not expect any arguments');
+    });
+
+    it('throws an error when it receives a non-fn argument', function() {
+      // Some versions of PhantomJS return [object DOMWindow] when
+      // Object.prototype.toString.apply is called with `undefined` or `null`.
+      // In a similar fashion, IE8 gives [object Object] for both `undefined`
+      // and `null`. We mostly just want these tests to check that using
+      // anything other than a function throws an error.
+      expect(function() {
+        env.describe('undefined arg', undefined);
+      }).toThrowError(/describe expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      expect(function() {
+        env.describe('null arg', null);
+      }).toThrowError(/describe expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
+
+      expect(function() {
+        env.describe('array arg', []);
+      }).toThrowError('describe expects a function argument; received [object Array]');
+      expect(function() {
+        env.describe('object arg', {});
+      }).toThrowError('describe expects a function argument; received [object Object]');
+
+      expect(function() {
+        env.describe('fn arg', function() {});
+      }).not.toThrowError('describe expects a function argument; received [object Function]');
+    });
+  });
+
+  describe('#it', function () {
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.it('undefined arg', null);
+      }).toThrowError(/it expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
+    });
+
+    it('does not throw when it is not given a fn argument', function() {
+      expect(function() {
+        env.it('pending spec');
+      }).not.toThrow();
+    });
+
+    it('accepts an async function', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      expect(function() {
+        env.it('async', jasmine.getEnv().makeAsyncAwaitFunction());
+      }).not.toThrow();
+    });
+  });
+
   describe('#xit', function() {
     it('calls spec.pend with "Temporarily disabled with xit"', function() {
       var pendSpy = jasmine.createSpy();
       spyOn(env, 'it').and.returnValue({
         pend: pendSpy
       });
-      env.xit();
+      env.xit('foo', function() {});
       expect(pendSpy).toHaveBeenCalledWith('Temporarily disabled with xit');
     });
+
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.xit('undefined arg', null);
+      }).toThrowError(/xit expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
+    });
+
+    it('does not throw when it is not given a fn argument', function() {
+      expect(function() {
+        env.xit('pending spec');
+      }).not.toThrow();
+    });
+
+    it('accepts an async function', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      expect(function() {
+        env.xit('async', jasmine.getEnv().makeAsyncAwaitFunction());
+      }).not.toThrow();
+    });
+  });
+
+  describe('#fit', function () {
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.fit('undefined arg', undefined);
+      }).toThrowError(/fit expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+    });
+  });
+
+  describe('#beforeEach', function () {
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.beforeEach(undefined);
+      }).toThrowError(/beforeEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+    });
+
+    it('accepts an async function', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      expect(function() {
+        env.beforeEach(jasmine.getEnv().makeAsyncAwaitFunction());
+      }).not.toThrow();
+    });
+  });
+
+  describe('#beforeAll', function () {
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.beforeAll(undefined);
+      }).toThrowError(/beforeAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+    });
+
+    it('accepts an async function', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      expect(function() {
+        env.beforeAll(jasmine.getEnv().makeAsyncAwaitFunction());
+      }).not.toThrow();
+    });
+  });
+
+  describe('#afterEach', function () {
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.afterEach(undefined);
+      }).toThrowError(/afterEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+    });
+
+    it('accepts an async function', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      expect(function() {
+        env.afterEach(jasmine.getEnv().makeAsyncAwaitFunction());
+      }).not.toThrow();
+    });
+  });
+
+  describe('#afterAll', function () {
+    it('throws an error when it receives a non-fn argument', function() {
+      expect(function() {
+        env.afterAll(undefined);
+      }).toThrowError(/afterAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+    });
+
+    it('accepts an async function', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      expect(function() {
+        env.afterAll(jasmine.getEnv().makeAsyncAwaitFunction());
+      }).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();
+    });
   });
 });

spec/core/ExceptionFormatterSpec.js

@@ -47,17 +47,105 @@ describe("ExceptionFormatter", function() {
   });
 
   describe("#stack", function() {
-    it("formats stack traces from Webkit, Firefox, node.js or IE10+", function() {
-      if (jasmine.getEnv().ieVersion < 10 || jasmine.getEnv().safariVersion < 6) { return; }
-
+    it("formats stack traces", function() {
       var error;
       try { throw new Error("an error") } catch(e) { error = e; }
 
       expect(new jasmineUnderTest.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
     });
 
+    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' +
+          '    at fn3 (http://localhost:8888/__jasmine__/jasmine.js:4320:20)\n' +
+          '    at fn4 (http://localhost:8888/__spec__/core/UtilSpec.js:110:19)\n'
+      };
+      var subject = new jasmineUnderTest.ExceptionFormatter({
+        jasmineFile: 'http://localhost:8888/__jasmine__/jasmine.js'
+      });
+      var result = subject.stack(error);
+      expect(result).toEqual('Error: nope\n' +
+          '    at fn1 (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+          '    at <Jasmine>\n' +
+          '    at fn4 (http://localhost:8888/__spec__/core/UtilSpec.js:110:19)'
+      );
+    });
+
+    it("filters Jamine stack frames from Webkit style traces", function() {
+      var error = {
+        stack: 'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+          'fn1@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
+          'fn2@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
+          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
+      };
+      var subject = new jasmineUnderTest.ExceptionFormatter({
+        jasmineFile: 'http://localhost:8888/__jasmine__/jasmine.js'
+      });
+      var result = subject.stack(error);
+      expect(result).toEqual(
+        'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+          '<Jasmine>\n' +
+          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
+      );
+    });
+
+    it("filters Jasmine stack frames in this environment", function() {
+      var error, i;
+      try { throw new Error("an error"); } catch(e) { error = e; }
+      var subject = new jasmineUnderTest.ExceptionFormatter({
+        jasmineFile: jasmine.util.jasmineFile()
+      });
+      var result = subject.stack(error);
+      var lines = result.split('\n');
+
+      if (lines[0].match(/an error/)) {
+        lines.shift();
+      }
+
+      expect(lines[0]).toMatch(/ExceptionFormatterSpec.js/);
+      expect(lines[1]).toMatch(/<Jasmine>/);
+
+      // Node has some number of additional frames below Jasmine.
+      for (i = 2; i < lines.length; i++) {
+        expect(lines[i]).not.toMatch(/jasmine.js/);
+      }
+    });
+
+    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/);
+    });
+
   });
 });

spec/core/ExceptionsSpec.js

@@ -5,64 +5,42 @@ describe('Exceptions:', function() {
     env = new jasmineUnderTest.Env();
   });
 
-  describe('with break on exception', function() {
-    it('should not catch the exception', function() {
-      env.catchExceptions(false);
-      env.describe('suite for break on exceptions', function() {
-        env.it('should break when an exception is thrown', function() {
-          throw new Error('I should hit a breakpoint!');
-        });
+  it('should handle exceptions thrown, but continue', function(done) {
+    var secondTest = jasmine.createSpy('second test');
+    env.describe('Suite for handles exceptions', function () {
+      env.it('should be a test that fails because it throws an exception', function() {
+        throw new Error();
       });
-      var spy = jasmine.createSpy('spy');
-
-      try {
-        env.execute();
-        spy();
-      }
-      catch (e) {}
-
-      expect(spy).not.toHaveBeenCalled();
+      env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
     });
+
+    var expectations = function() {
+      expect(secondTest).toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({ jasmineDone: expectations });
+    env.execute();
   });
 
-  describe("with catch on exception", function() {
-    it('should handle exceptions thrown, but continue', function(done) {
-      var secondTest = jasmine.createSpy('second test');
-      env.describe('Suite for handles exceptions', function () {
-        env.it('should be a test that fails because it throws an exception', function() {
-          throw new Error();
-        });
-        env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
+  it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
+    var secondDescribe = jasmine.createSpy("second describe");
+    env.describe("a suite that throws an exception", function () {
+      env.it("is a test that should pass", function () {
+        this.expect(true).toEqual(true);
       });
 
-      var expectations = function() {
-        expect(secondTest).toHaveBeenCalled();
-        done();
-      };
-
-      env.addReporter({ jasmineDone: expectations });
-      env.execute();
+      throw new Error("top level error");
     });
+    env.describe("a suite that doesn't throw an exception", secondDescribe);
 
-    it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
-      var secondDescribe = jasmine.createSpy("second describe");
-      env.describe("a suite that throws an exception", function () {
-        env.it("is a test that should pass", function () {
-         this.expect(true).toEqual(true);
-        });
+    var expectations = function() {
+      expect(secondDescribe).toHaveBeenCalled();
+      done();
+    };
 
-        throw new Error("top level error");
-      });
-      env.describe("a suite that doesn't throw an exception", secondDescribe);
-
-      var expectations = function() {
-        expect(secondDescribe).toHaveBeenCalled();
-        done();
-      };
-
-      env.addReporter({ jasmineDone: expectations });
-      env.execute();
-    });
+    env.addReporter({ jasmineDone: expectations });
+    env.execute();
   });
 });
 

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');

spec/core/ExpectationSpec.js

@@ -113,6 +113,7 @@ describe("Expectation", function() {
       matcherName: "toFoo",
       passed: true,
       message: "",
+      error: undefined,
       expected: "hello",
       actual: "an actual"
     });
@@ -146,7 +147,8 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: "an actual",
-      message: ""
+      message: "",
+      error: undefined
     });
   });
 
@@ -179,7 +181,8 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: "an actual",
-      message: "I am a custom message"
+      message: "I am a custom message",
+      error: undefined
     });
   });
 
@@ -212,7 +215,8 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: "an actual",
-      message: "I am a custom message"
+      message: "I am a custom message",
+      error: undefined
     });
   });
 
@@ -244,6 +248,7 @@ describe("Expectation", function() {
       matcherName: "toFoo",
       passed: true,
       message: "",
+      error: undefined,
       expected: "hello",
       actual: actual
     });
@@ -279,7 +284,8 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: actual,
-      message: "default message"
+      message: "default message",
+      error: undefined
     });
   });
 
@@ -314,7 +320,8 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: actual,
-      message: "I am a custom message"
+      message: "I am a custom message",
+      error: undefined
     });
   });
 
@@ -345,7 +352,8 @@ describe("Expectation", function() {
       passed: true,
       expected: "hello",
       actual: actual,
-      message: ""
+      message: "",
+      error: undefined
     });
   });
 
@@ -381,7 +389,44 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: actual,
-      message: "I'm a custom message"
+      message: "I'm a custom message",
+      error: undefined
+    });
+  });
+  
+  it("reports a custom error message to the spec", function() {
+    var customError = new Error("I am a custom error");
+    var matchers = {
+        toFoo: function() {
+          return {
+            compare: function() {
+              return {
+                pass: false,
+                message: "I am a custom message",
+                error: customError
+              };
+            }
+          };
+        }
+      },
+      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      expectation;
+
+    expectation = new jasmineUnderTest.Expectation({
+      actual: "an actual",
+      customMatchers: matchers,
+      addExpectationResult: addExpectationResult
+    });
+
+    expectation.toFoo("hello");
+
+    expect(addExpectationResult).toHaveBeenCalledWith(false, {
+      matcherName: "toFoo",
+      passed: false,
+      expected: "hello",
+      actual: "an actual",
+      message: "I am a custom message",
+      error: customError
     });
   });
 

spec/core/GlobalErrorsSpec.js

@@ -0,0 +1,140 @@
+describe("GlobalErrors", function() {
+  it("calls the added handler on error", function() {
+    var fakeGlobal = { onerror: null },
+        handler = jasmine.createSpy('errorHandler'),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+    errors.install();
+    errors.pushListener(handler);
+
+    fakeGlobal.onerror('foo');
+
+    expect(handler).toHaveBeenCalledWith('foo');
+  });
+
+  it("only calls the most recent handler", function() {
+    var fakeGlobal = { onerror: null },
+        handler1 = jasmine.createSpy('errorHandler1'),
+        handler2 = jasmine.createSpy('errorHandler2'),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+    errors.install();
+    errors.pushListener(handler1);
+    errors.pushListener(handler2);
+
+    fakeGlobal.onerror('foo');
+
+    expect(handler1).not.toHaveBeenCalled();
+    expect(handler2).toHaveBeenCalledWith('foo');
+  });
+
+  it("calls previous handlers when one is removed", function() {
+    var fakeGlobal = { onerror: null },
+        handler1 = jasmine.createSpy('errorHandler1'),
+        handler2 = jasmine.createSpy('errorHandler2'),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+    errors.install();
+    errors.pushListener(handler1);
+    errors.pushListener(handler2);
+
+    errors.popListener();
+
+    fakeGlobal.onerror('foo');
+
+    expect(handler1).toHaveBeenCalledWith('foo');
+    expect(handler2).not.toHaveBeenCalled();
+  });
+
+  it("uninstalls itself, putting back a previous callback", function() {
+    var originalCallback = jasmine.createSpy('error'),
+        fakeGlobal = { onerror: originalCallback },
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+    expect(fakeGlobal.onerror).toBe(originalCallback);
+
+    errors.install();
+
+    expect(fakeGlobal.onerror).not.toBe(originalCallback);
+
+    errors.uninstall();
+
+    expect(fakeGlobal.onerror).toBe(originalCallback);
+  });
+
+  it("rethrows the original error when there is no handler", function() {
+    var fakeGlobal = { },
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal),
+        originalError = new Error('nope');
+
+    errors.install();
+
+    try {
+      fakeGlobal.onerror(originalError);
+    } catch (e) {
+      expect(e).toBe(originalError);
+    }
+
+    errors.uninstall();
+  });
+
+  it("reports uncaughtException 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('uncaughtException', jasmine.any(Function));
+    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith('uncaughtException');
+    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith('uncaughtException');
+
+    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('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');
+  });
+});

spec/core/JsApiReporterSpec.js

@@ -192,7 +192,7 @@ describe("JsApiReporter", function() {
       };
       suiteResult2 = {
         id: 2,
-        status: 'finished'
+        status: 'passed'
       };
 
       reporter.suiteStarted(suiteStarted1);

spec/core/PrettyPrintSpec.js

@@ -14,6 +14,58 @@ describe("jasmineUnderTest.pp", function () {
     expect(jasmineUnderTest.pp(-0)).toEqual("-0");
   });
 
+  describe('stringify sets', function() {
+    it("should stringify sets properly", function() {
+      jasmine.getEnv().requireFunctioningSets();
+      var set = new Set();
+      set.add(1);
+      set.add(2);
+      expect(jasmineUnderTest.pp(set)).toEqual("Set( 1, 2 )");
+    });
+
+    it("should truncate sets with more elments than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
+      jasmine.getEnv().requireFunctioningSets();
+      var originalMaxSize = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
+
+      try {
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
+        var set = new Set();
+        set.add('a');
+        set.add('b');
+        set.add('c');
+        expect(jasmineUnderTest.pp(set)).toEqual("Set( 'a', 'b', ... )");
+      } finally {
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
+      }
+    })
+  });
+
+  describe('stringify maps', function() {
+    it("should stringify maps properly", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      var map = new Map();
+      map.set(1,2);
+      expect(jasmineUnderTest.pp(map)).toEqual("Map( [ 1, 2 ] )");
+    });
+
+    it("should truncate maps with more elments than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      var originalMaxSize = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
+
+      try {
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
+        var map = new Map();
+        map.set("a",1);
+        map.set("b",2);
+        map.set("c",3);
+        expect(jasmineUnderTest.pp(map)).toEqual("Map( [ 'a', 1 ], [ 'b', 2 ], ... )");
+      } finally {
+        jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
+      }
+    })
+  });
+
+
   describe('stringify arrays', function() {
     it("should stringify arrays properly", function() {
       expect(jasmineUnderTest.pp([1, 2])).toEqual("[ 1, 2 ]");
@@ -80,6 +132,58 @@ describe("jasmineUnderTest.pp", function () {
     }, bar: [1, 2, 3]})).toEqual("Object({ foo: Function, bar: [ 1, 2, 3 ] })");
   });
 
+  it("should truncate objects with too many keys", function () {
+    var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
+    var long = {a: 1, b: 2, c: 3};
+
+    try {
+      jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
+      expect(jasmineUnderTest.pp(long)).toEqual("Object({ a: 1, b: 2, ... })");
+    } finally {
+      jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
+    }
+  });
+
+  function withMaxChars(maxChars, fn) {
+    var originalMaxChars = jasmineUnderTest.MAX_PRETTY_PRINT_CHARS;
+
+    try {
+      jasmineUnderTest.MAX_PRETTY_PRINT_CHARS = maxChars;
+      fn();
+    } finally {
+      jasmineUnderTest.MAX_PRETTY_PRINT_CHARS = originalMaxChars;
+    }
+  }
+
+  it("should truncate outputs that are too long", function() {
+    var big = [
+      { a: 1, b: "a long string" },
+      {}
+    ];
+
+    withMaxChars(34, function() {
+      expect(jasmineUnderTest.pp(big)).toEqual("[ Object({ a: 1, b: 'a long st ...");
+    });
+  });
+
+  it("should not serialize more objects after hitting MAX_PRETTY_PRINT_CHARS", function() {
+    var a = { jasmineToString: function() { return 'object a'; } },
+      b = { jasmineToString: function() { return 'object b'; } },
+      c = { jasmineToString: jasmine.createSpy('c jasmineToString').and.returnValue('') },
+      d = { jasmineToString: jasmine.createSpy('d jasmineToString').and.returnValue('') };
+
+    withMaxChars(30, function() {
+      jasmineUnderTest.pp([{a: a, b: b, c: c}, d]);
+      expect(c.jasmineToString).not.toHaveBeenCalled();
+      expect(d.jasmineToString).not.toHaveBeenCalled();
+    });
+  });
+
+  it("should print 'null' as the constructor of an object with its own constructor property", function() {
+    expect(jasmineUnderTest.pp({constructor: function() {}})).toContain("null({");
+    expect(jasmineUnderTest.pp({constructor: 'foo'})).toContain("null({");
+  });
+
   it("should not include inherited properties when stringifying an object", function() {
     var SomeClass = function SomeClass() {};
     SomeClass.prototype.foo = "inherited foo";
@@ -145,7 +249,6 @@ describe("jasmineUnderTest.pp", function () {
     }
   });
 
-
   it('should not do HTML escaping of strings', function() {
     expect(jasmineUnderTest.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
   });
@@ -161,16 +264,21 @@ describe("jasmineUnderTest.pp", function () {
 
   it("should stringify spy objects properly", function() {
     var TestObject = {
-          someFunction: function() {}
-        },
-        env = new jasmineUnderTest.Env();
+      someFunction: function() {}
+    },
+    env = new jasmineUnderTest.Env();
 
-    var spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() {return [];}});
+    var spyRegistry = new jasmineUnderTest.SpyRegistry({
+      currentSpies: function() {return [];},
+      createSpy: function(name, originalFn) {
+        return jasmineUnderTest.Spy(name, originalFn);
+      }
+    });
 
     spyRegistry.spyOn(TestObject, 'someFunction');
     expect(jasmineUnderTest.pp(TestObject.someFunction)).toEqual("spy on someFunction");
 
-    expect(jasmineUnderTest.pp(jasmineUnderTest.createSpy("something"))).toEqual("spy on something");
+    expect(jasmineUnderTest.pp(env.createSpy("something"))).toEqual("spy on something");
   });
 
   it("should stringify objects that implement jasmineToString", function () {
@@ -187,6 +295,23 @@ describe("jasmineUnderTest.pp", function () {
     };
 
     expect(jasmineUnderTest.pp(obj)).toEqual("my toString");
+
+    // Simulate object from another global context (e.g. an iframe or Web Worker) that does not actually have a custom
+    // toString despite obj.toString !== Object.prototype.toString
+    var objFromOtherContext = {
+      foo: 'bar',
+      toString: function () { return Object.prototype.toString.call(this); }
+    };
+
+    expect(jasmineUnderTest.pp(objFromOtherContext)).toEqual("Object({ foo: 'bar', toString: Function })");
+  });
+
+  it("should stringify objects have have a toString that isn't a function", function() {
+    var obj = {
+      toString: "foo"
+    };
+
+    expect(jasmineUnderTest.pp(obj)).toEqual("Object({ toString: 'foo' })");
   });
 
   it("should stringify objects from anonymous constructors with custom toString", function () {
@@ -199,8 +324,6 @@ describe("jasmineUnderTest.pp", function () {
   });
 
   it("should handle objects with null prototype", function() {
-    if (jasmine.getEnv().ieVersion < 9) { return; }
-
     var obj = Object.create(null);
     obj.foo = 'bar';
 

spec/core/QueueRunnerSpec.js

@@ -19,6 +19,26 @@ describe("QueueRunner", function() {
     expect(calls).toEqual(['fn1', 'fn2']);
   });
 
+  it("runs cleanup functions after the others", function() {
+    var calls = [],
+      queueableFn1 = { fn: jasmine.createSpy('fn1') },
+      queueableFn2 = { fn: jasmine.createSpy('fn2') },
+      queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [queueableFn1],
+        cleanupFns: [queueableFn2]
+      });
+    queueableFn1.fn.and.callFake(function() {
+      calls.push('fn1');
+    });
+    queueableFn2.fn.and.callFake(function() {
+      calls.push('fn2');
+    });
+
+    queueRunner.execute();
+
+    expect(calls).toEqual(['fn1', 'fn2']);
+  });
+
   it("calls each function with a consistent 'this'-- an empty object", function() {
     var queueableFn1 = { fn: jasmine.createSpy('fn1') },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
@@ -31,7 +51,7 @@ describe("QueueRunner", function() {
     queueRunner.execute();
 
     var context = queueableFn1.fn.calls.first().object;
-    expect(context).toEqual({});
+    expect(context).toEqual(new jasmineUnderTest.UserContext());
     expect(queueableFn2.fn.calls.first().object).toBe(context);
     expect(asyncContext).toBe(context);
   });
@@ -115,9 +135,55 @@ describe("QueueRunner", function() {
       expect(queueableFn2.fn).toHaveBeenCalled();
     });
 
+    it("explicitly fails an async function when next is called with an Error and moves to the next function", function() {
+      var err = new Error('foo'),
+        queueableFn1 = { fn: function(done) {
+          setTimeout(function() { done(err); }, 100);
+        } },
+        queueableFn2 = { fn: jasmine.createSpy('fn2') },
+        failFn = jasmine.createSpy('fail'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn1, queueableFn2],
+          fail: failFn
+        });
+
+      queueRunner.execute();
+
+      expect(failFn).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(failFn).toHaveBeenCalledWith(err);
+      expect(queueableFn2.fn).toHaveBeenCalled();
+    });
+
+    it("does not cause an explicit fail if execution is being stopped", function() {
+      var err = new jasmineUnderTest.StopExecutionError('foo'),
+        queueableFn1 = { fn: function(done) {
+          setTimeout(function() { done(err); }, 100);
+        } },
+        queueableFn2 = { fn: jasmine.createSpy('fn2') },
+        failFn = jasmine.createSpy('fail'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn1, queueableFn2],
+          fail: failFn
+        });
+
+      queueRunner.execute();
+
+      expect(failFn).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(failFn).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).toHaveBeenCalled();
+    });
+
     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'),
@@ -189,6 +255,7 @@ describe("QueueRunner", function() {
 
       queueRunner.execute();
 
+      jasmine.clock().tick(1);
       expect(onComplete).toHaveBeenCalled();
 
       jasmine.clock().tick(jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL);
@@ -197,12 +264,13 @@ describe("QueueRunner", function() {
 
     it("only moves to the next spec the first time you call done", function() {
       var queueableFn = { fn: function(done) {done(); done();} },
-        nextQueueableFn = { fn: jasmine.createSpy('nextFn') };
-      queueRunner = new jasmineUnderTest.QueueRunner({
-        queueableFns: [queueableFn, nextQueueableFn]
-      });
+        nextQueueableFn = { fn: jasmine.createSpy('nextFn') },
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn, nextQueueableFn]
+        });
 
       queueRunner.execute();
+      jasmine.clock().tick(1);
       expect(nextQueueableFn.fn.calls.count()).toEqual(1);
     });
 
@@ -211,10 +279,10 @@ describe("QueueRunner", function() {
          setTimeout(done, 1);
          throw new Error('error!');
        } },
-        nextQueueableFn = { fn: jasmine.createSpy('nextFn') };
-      queueRunner = new jasmineUnderTest.QueueRunner({
-        queueableFns: [queueableFn, nextQueueableFn]
-      });
+       nextQueueableFn = { fn: jasmine.createSpy('nextFn') },
+       queueRunner = new jasmineUnderTest.QueueRunner({
+         queueableFns: [queueableFn, nextQueueableFn]
+       });
 
       queueRunner.execute();
       jasmine.clock().tick(1);
@@ -234,6 +302,151 @@ describe("QueueRunner", function() {
       queueRunner.execute();
       expect(doneReturn).toBe(null);
     });
+
+    it("continues running functions when an exception is thrown in async code without timing out", function() {
+      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') },
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn, nextQueueableFn],
+          onException: onException,
+          globalErrors: globalErrors
+        }),
+        throwAsync = function() {
+          globalErrors.pushListener.calls.mostRecent().args[0](new Error('foo'));
+          jasmine.clock().tick(2);
+        };
+
+      nextQueueableFn.fn.and.callFake(function() {
+        // should remove the same function that was added
+        expect(globalErrors.popListener).toHaveBeenCalledWith(globalErrors.pushListener.calls.argsFor(1)[0]);
+      });
+
+      queueRunner.execute();
+
+      function errorWithMessage(message) {
+        return {
+          asymmetricMatch: function(other) {
+            return new RegExp(message).test(other.message);
+          },
+          toString: function() {
+            return '<Error with message like "' + message + '">';
+          }
+        };
+      }
+      expect(onException).not.toHaveBeenCalledWith(errorWithMessage(/DEFAULT_TIMEOUT_INTERVAL/));
+      expect(onException).toHaveBeenCalledWith(errorWithMessage(/^foo$/));
+      expect(nextQueueableFn.fn).toHaveBeenCalled();
+    });
+
+    it("handles exceptions thrown while waiting for the stack to clear", function() {
+      var queueableFn = { fn: function(done) { done() } },
+      global = {},
+      errorListeners = [],
+      globalErrors = {
+        pushListener: function(f) { errorListeners.push(f); },
+        popListener: function() { errorListeners.pop(); }
+      },
+      clearStack = jasmine.createSpy('clearStack'),
+      onException = jasmine.createSpy('onException'),
+      queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [queueableFn],
+        globalErrors: globalErrors,
+        clearStack: clearStack,
+        onException: onException
+      }),
+      error = new Error('nope');
+
+      queueRunner.execute();
+      jasmine.clock().tick();
+      expect(clearStack).toHaveBeenCalled();
+      expect(errorListeners.length).toEqual(1);
+      errorListeners[0](error);
+      clearStack.calls.argsFor(0)[0]();
+      expect(onException).toHaveBeenCalledWith(error);
+    });
+  });
+
+  describe("with a function that returns a promise", function() {
+    function StubPromise() {}
+
+    StubPromise.prototype.then = function(resolve, reject) {
+      this.resolveHandler = resolve;
+      this.rejectHandler = reject;
+    };
+
+    beforeEach(function() {
+      jasmine.clock().install();
+    });
+
+    afterEach(function() {
+      jasmine.clock().uninstall();
+    });
+
+    it("runs the function asynchronously, advancing once the promise is settled", function() {
+      var onComplete = jasmine.createSpy('onComplete'),
+        fnCallback =  jasmine.createSpy('fnCallback'),
+        p1 = new StubPromise(),
+        p2 = new StubPromise(),
+        queueableFn1 = { fn: function() {
+          setTimeout(function() {
+            p1.resolveHandler();
+          }, 100);
+          return p1;
+        } };
+        queueableFn2 = { fn: function() {
+          fnCallback();
+          setTimeout(function() {
+            p2.resolveHandler();
+          }, 100);
+          return p2;
+        } },
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn1, queueableFn2],
+          onComplete: onComplete
+        });
+
+      queueRunner.execute();
+      expect(fnCallback).not.toHaveBeenCalled();
+      expect(onComplete).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(fnCallback).toHaveBeenCalled();
+      expect(onComplete).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(onComplete).toHaveBeenCalled();
+    });
+
+    it("handles a rejected promise like an unhandled exception", function() {
+      var promise = new StubPromise(),
+        queueableFn1 = { fn: function() {
+          setTimeout(function() {
+            promise.rejectHandler('foo')
+          }, 100);
+          return promise;
+        } },
+        queueableFn2 = { fn: jasmine.createSpy('fn2') },
+        failFn = jasmine.createSpy('fail'),
+        onExceptionCallback = jasmine.createSpy('on exception callback'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn1, queueableFn2],
+          onException: onExceptionCallback
+        });
+
+      queueRunner.execute();
+
+      expect(onExceptionCallback).not.toHaveBeenCalled();
+      expect(queueableFn2.fn).not.toHaveBeenCalled();
+
+      jasmine.clock().tick(100);
+
+      expect(onExceptionCallback).toHaveBeenCalledWith('foo');
+      expect(queueableFn2.fn).toHaveBeenCalled();
+    });
   });
 
   it("calls exception handlers when an exception is thrown in a fn", function() {
@@ -252,20 +465,6 @@ describe("QueueRunner", function() {
     expect(onExceptionCallback).toHaveBeenCalledWith(jasmine.any(Error));
   });
 
-  it("rethrows an exception if told to", function() {
-    var queueableFn = { fn: function() {
-        throw new Error('fake error');
-      } },
-      queueRunner = new jasmineUnderTest.QueueRunner({
-        queueableFns: [queueableFn],
-        catchException: function(e) { return false; }
-      });
-
-    expect(function() {
-      queueRunner.execute();
-    }).toThrowError('fake error');
-  });
-
   it("continues running the functions even after an exception is thrown in an async spec", function() {
     var queueableFn = { fn: function(done) { throw new Error("error"); } },
       nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
@@ -277,6 +476,108 @@ describe("QueueRunner", function() {
     expect(nextQueueableFn.fn).toHaveBeenCalled();
   });
 
+  describe("When configured to complete on first error", function() {
+    it("skips to cleanup functions on the first exception", 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() {
+      var queueableFn = { fn: function() { } },
+        cleanupFn1 = { fn: function() { throw new Error("error"); } },
+        cleanupFn2 = { fn: jasmine.createSpy("cleanupFn2") },
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn],
+          cleanupFns: [cleanupFn1, cleanupFn2],
+          completeOnFirstError: true
+        });
+
+      queueRunner.execute();
+      expect(cleanupFn2.fn).toHaveBeenCalled();
+    });
+
+    describe("with an asynchronous function", function() {
+      beforeEach(function() {
+        jasmine.clock().install();
+      });
+
+      afterEach(function() {
+        jasmine.clock().uninstall();
+      });
+
+
+      it("skips to cleanup functions on the first exception", function() {
+        var errorListeners = [],
+          queueableFn = { fn: function(done) {} },
+          nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
+          cleanupFn = { fn: jasmine.createSpy('cleanup') },
+          queueRunner = new jasmineUnderTest.QueueRunner({
+            globalErrors: {
+              pushListener: function(f) { errorListeners.push(f); },
+              popListener: function() { errorListeners.pop(); },
+            },
+            queueableFns: [queueableFn, nextQueueableFn],
+            cleanupFns: [cleanupFn],
+            completeOnFirstError: true,
+         });
+
+        queueRunner.execute();
+        errorListeners[errorListeners.length - 1](new Error('error'));
+        expect(nextQueueableFn.fn).not.toHaveBeenCalled();
+        expect(cleanupFn.fn).toHaveBeenCalled();
+      });
+
+      it("skips to cleanup functions when next.fail is called", function() {
+        var queueableFn = { fn: function(done) {
+            done.fail('nope');
+          } },
+          nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
+          cleanupFn = { fn: jasmine.createSpy('cleanup') },
+          queueRunner = new jasmineUnderTest.QueueRunner({
+            queueableFns: [queueableFn, nextQueueableFn],
+            cleanupFns: [cleanupFn],
+            completeOnFirstError: true,
+         });
+
+        queueRunner.execute();
+        jasmine.clock().tick();
+        expect(nextQueueableFn.fn).not.toHaveBeenCalled();
+        expect(cleanupFn.fn).toHaveBeenCalled();
+      });
+
+      it("skips to cleanup functions when next is called with an Error", function() {
+        var queueableFn = { fn: function(done) {
+            done(new Error('nope'));
+          } },
+          nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
+          cleanupFn = { fn: jasmine.createSpy('cleanup') },
+          queueRunner = new jasmineUnderTest.QueueRunner({
+            queueableFns: [queueableFn, nextQueueableFn],
+            cleanupFns: [cleanupFn],
+            completeOnFirstError: true,
+         });
+
+        queueRunner.execute();
+        jasmine.clock().tick();
+        expect(nextQueueableFn.fn).not.toHaveBeenCalled();
+        expect(cleanupFn.fn).toHaveBeenCalled();
+      });
+    });
+  });
+
   it("calls a provided complete callback when done", function() {
     var queueableFn = { fn: jasmine.createSpy('fn') },
       completeCallback = jasmine.createSpy('completeCallback'),
@@ -290,21 +591,83 @@ describe("QueueRunner", function() {
     expect(completeCallback).toHaveBeenCalled();
   });
 
-  it("calls a provided stack clearing function when done", function() {
-    var asyncFn = { fn: function(done) { done() } },
-        afterFn = { fn: jasmine.createSpy('afterFn') },
-        completeCallback = jasmine.createSpy('completeCallback'),
-        clearStack = jasmine.createSpy('clearStack'),
-        queueRunner = new jasmineUnderTest.QueueRunner({
-          queueableFns: [asyncFn, afterFn],
-          clearStack: clearStack,
-          onComplete: completeCallback
-        });
+  describe("clearing the stack", function() {
+    beforeEach(function() {
+      jasmine.clock().install();
+    });
 
-    clearStack.and.callFake(function(fn) { fn(); });
+    afterEach(function() {
+      jasmine.clock().uninstall();
+    });
 
-    queueRunner.execute();
-    expect(afterFn.fn).toHaveBeenCalled();
-    expect(clearStack).toHaveBeenCalledWith(completeCallback);
+    it("calls a provided stack clearing function when done", function() {
+      var asyncFn = { fn: function(done) { done() } },
+          afterFn = { fn: jasmine.createSpy('afterFn') },
+          completeCallback = jasmine.createSpy('completeCallback'),
+          clearStack = jasmine.createSpy('clearStack'),
+          queueRunner = new jasmineUnderTest.QueueRunner({
+            queueableFns: [asyncFn, afterFn],
+            clearStack: clearStack,
+            onComplete: completeCallback
+          });
+
+      clearStack.and.callFake(function(fn) { fn(); });
+
+      queueRunner.execute();
+      jasmine.clock().tick();
+      expect(afterFn.fn).toHaveBeenCalled();
+      expect(clearStack).toHaveBeenCalled();
+      clearStack.calls.argsFor(0)[0]();
+      expect(completeCallback).toHaveBeenCalled();
+    });
+  });
+
+  describe('when user context has not been defined', function() {
+    beforeEach(function() {
+      var fn;
+
+      this.fn = fn = jasmine.createSpy('fn1');
+      this.queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [{ fn: fn }]
+      });
+    });
+
+    it('runs the functions on the scope of a UserContext', function() {
+      var calls = [],
+          context;
+
+      this.fn.and.callFake(function() {
+        context = this;
+      });
+
+      this.queueRunner.execute();
+
+      expect(context.constructor).toBe(jasmineUnderTest.UserContext);
+    });
+  });
+
+  describe('when user context has been defined', function() {
+    beforeEach(function() {
+      var fn, context;
+
+      this.fn = fn = jasmine.createSpy('fn1');
+      this.context = context = new jasmineUnderTest.UserContext();
+      this.queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [{ fn: fn }],
+        userContext: context
+      });
+    });
+
+    it('runs the functions on the scope of a UserContext', function() {
+      var calls = [],
+          context;
+      this.fn.and.callFake(function() {
+        context = this;
+      });
+
+      this.queueRunner.execute();
+
+      expect(context).toBe(this.context);
+    });
   });
 });

spec/core/ReportDispatcherSpec.js

@@ -9,70 +9,131 @@ describe("ReportDispatcher", function() {
   });
 
   it("dispatches requested methods to added reporters", function() {
-    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
+    var queueRunnerFactory = jasmine.createSpy('queueRunner'),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
-      anotherReporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
+      anotherReporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
+      completeCallback = jasmine.createSpy('complete');
 
     dispatcher.addReporter(reporter);
     dispatcher.addReporter(anotherReporter);
 
-    dispatcher.foo(123, 456);
+    dispatcher.foo(123, 456, completeCallback);
 
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}],
+      isReporter: true
+    }));
+
+    var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
+    expect(reporter.foo.calls.mostRecent().object).toBe(reporter);
+
+    fns[1].fn();
     expect(anotherReporter.foo).toHaveBeenCalledWith(123, 456);
+    expect(anotherReporter.foo.calls.mostRecent().object).toBe(anotherReporter);
 
-    dispatcher.bar('a', 'b');
+    queueRunnerFactory.calls.reset();
 
+    dispatcher.bar('a', 'b', completeCallback);
+
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}],
+      isReporter: true
+    }));
+
+    fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns[0].fn();
     expect(reporter.bar).toHaveBeenCalledWith('a', 'b');
+
+    fns[1].fn();
     expect(anotherReporter.bar).toHaveBeenCalledWith('a', 'b');
   });
 
   it("does not dispatch to a reporter if the reporter doesn't accept the method", function() {
-    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo']),
+    var queueRunnerFactory = jasmine.createSpy('queueRunner'),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo'], queueRunnerFactory),
       reporter = jasmine.createSpyObj('reporter', ['baz']);
 
     dispatcher.addReporter(reporter);
 
-    expect(function() {
-      dispatcher.foo(123, 456);
-    }).not.toThrow();
+    dispatcher.foo(123, 456);
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: []
+    }));
   });
 
-  it("allows providing a fallback reporter in case there's no other report", function() {
-    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
-      reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
+  it("allows providing a fallback reporter in case there's no other reporter", function() {
+    var queueRunnerFactory = jasmine.createSpy('queueRunner'),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
+      reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
+      completeCallback = jasmine.createSpy('complete');
 
     dispatcher.provideFallbackReporter(reporter);
-    dispatcher.foo(123, 456);
+    dispatcher.foo(123, 456, completeCallback);
+
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
+    }));
+
+    var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
   });
 
-  it("does not call fallback reporting methods when another report is provided", function() {
-    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
+  it("does not call fallback reporting methods when another reporter is provided", function() {
+    var queueRunnerFactory = jasmine.createSpy('queueRunner'),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
-      fallbackReporter = jasmine.createSpyObj('otherReporter', ['foo', 'bar']);
+      fallbackReporter = jasmine.createSpyObj('otherReporter', ['foo', 'bar']),
+      completeCallback = jasmine.createSpy('complete');
 
     dispatcher.provideFallbackReporter(fallbackReporter);
     dispatcher.addReporter(reporter);
-    dispatcher.foo(123, 456);
+    dispatcher.foo(123, 456, completeCallback);
 
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
+    }));
+
+    var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
     expect(fallbackReporter.foo).not.toHaveBeenCalledWith(123, 456);
   });
 
   it("allows registered reporters to be cleared", function() {
-    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar']),
+    var queueRunnerFactory = jasmine.createSpy('queueRunner'),
+        dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
         reporter1 = jasmine.createSpyObj('reporter1', ['foo', 'bar']),
-        reporter2 = jasmine.createSpyObj('reporter2', ['foo', 'bar']);
+        reporter2 = jasmine.createSpyObj('reporter2', ['foo', 'bar']),
+      completeCallback = jasmine.createSpy('complete');
 
     dispatcher.addReporter(reporter1);
-    dispatcher.foo(123);
+    dispatcher.foo(123, completeCallback);
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
+    }));
+
+    var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns[0].fn();
     expect(reporter1.foo).toHaveBeenCalledWith(123);
 
     dispatcher.clearReporters();
     dispatcher.addReporter(reporter2);
-    dispatcher.bar(456);
+    dispatcher.bar(456, completeCallback);
 
+    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
+      queueableFns: [{fn: jasmine.any(Function)}],
+      isReporter: true
+    }));
+
+    fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns[0].fn();
     expect(reporter1.bar).not.toHaveBeenCalled();
     expect(reporter2.bar).toHaveBeenCalledWith(456);
   });

spec/core/SpecSpec.js

@@ -55,6 +55,7 @@ describe("Spec", function() {
 
     spec.execute();
 
+    fakeQueueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
     // TODO: due to some issue with the Pretty Printer, this line fails, but the other two pass.
     // This means toHaveBeenCalledWith on IE8 will always be broken.
 
@@ -82,6 +83,7 @@ describe("Spec", function() {
 
     spec.execute();
 
+    fakeQueueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
     expect(startCallback).toHaveBeenCalled();
   });
 
@@ -103,8 +105,26 @@ describe("Spec", function() {
 
     spec.execute();
 
-    var allSpecFns = fakeQueueRunner.calls.mostRecent().args[0].queueableFns;
-    expect(allSpecFns).toEqual([before, queueableFn, after]);
+    var options = fakeQueueRunner.calls.mostRecent().args[0];
+    expect(options.queueableFns).toEqual([{fn: jasmine.any(Function)}, before, queueableFn]);
+    expect(options.cleanupFns).toEqual([after, {fn: jasmine.any(Function)}]);
+  });
+
+  it("tells the queue runner that it's a leaf node", function() {
+    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
+      spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: function() {} },
+        beforeAndAfterFns: function() {
+          return {befores: [], afters: []}
+        },
+        queueRunnerFactory: fakeQueueRunner
+      });
+
+    spec.execute();
+
+    expect(fakeQueueRunner).toHaveBeenCalledWith(jasmine.objectContaining({
+      isLeaf: true
+    }));
   });
 
   it("is marked pending if created without a function body", function() {
@@ -122,7 +142,7 @@ describe("Spec", function() {
     expect(spec.status()).toBe('pending');
   });
 
-  it("can be disabled, but still calls callbacks", function() {
+  it("can be excluded at execution time by a parent", function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       startCallback = jasmine.createSpy('startCallback'),
       specBody = jasmine.createSpy('specBody'),
@@ -134,40 +154,22 @@ describe("Spec", function() {
         queueRunnerFactory: fakeQueueRunner
       });
 
-    spec.disable();
+    spec.execute('cally-back', true);
 
-    expect(spec.status()).toBe('disabled');
-
-    spec.execute();
-
-    expect(fakeQueueRunner).not.toHaveBeenCalled();
+    expect(fakeQueueRunner).toHaveBeenCalledWith(jasmine.objectContaining({
+      onComplete: jasmine.any(Function),
+      queueableFns: [{fn: jasmine.any(Function)}],
+      cleanupFns: [{fn: jasmine.any(Function)}]
+    }));
     expect(specBody).not.toHaveBeenCalled();
 
+    var args = fakeQueueRunner.calls.mostRecent().args[0];
+    args.queueableFns[0].fn();
     expect(startCallback).toHaveBeenCalled();
+    args.cleanupFns[0].fn();
     expect(resultCallback).toHaveBeenCalled();
-  });
 
-  it("can be disabled at execution time by a parent", function() {
-    var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      startCallback = jasmine.createSpy('startCallback'),
-      specBody = jasmine.createSpy('specBody'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        onStart:startCallback,
-        queueableFn: { fn: specBody },
-        resultCallback: resultCallback,
-        queueRunnerFactory: fakeQueueRunner
-      });
-
-    spec.execute(undefined, false);
-
-    expect(spec.result.status).toBe('disabled');
-
-    expect(fakeQueueRunner).not.toHaveBeenCalled();
-    expect(specBody).not.toHaveBeenCalled();
-
-    expect(startCallback).toHaveBeenCalled();
-    expect(resultCallback).toHaveBeenCalled();
+    expect(spec.result.status).toBe('excluded');
   });
 
   it("can be marked pending, but still calls callbacks when executed", function() {
@@ -191,9 +193,12 @@ describe("Spec", function() {
 
     spec.execute();
 
-    expect(fakeQueueRunner).not.toHaveBeenCalled();
+    expect(fakeQueueRunner).toHaveBeenCalled();
 
+    var args = fakeQueueRunner.calls.mostRecent().args[0];
+    args.queueableFns[0].fn();
     expect(startCallback).toHaveBeenCalled();
+    args.cleanupFns[0].fn('things');
     expect(resultCallback).toHaveBeenCalledWith({
       id: spec.id,
       status: 'pending',
@@ -201,8 +206,9 @@ describe("Spec", function() {
       fullName: 'a suite with a spec',
       failedExpectations: [],
       passedExpectations: [],
+      deprecationWarnings: [],
       pendingReason: ''
-    });
+    }, 'things');
   });
 
   it("should call the done callback on execution complete", function() {
@@ -219,6 +225,23 @@ describe("Spec", function() {
     expect(done).toHaveBeenCalled();
   });
 
+  it("should call the done callback with an error if the spec is failed", function() {
+    var done = jasmine.createSpy('done callback'),
+      spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: function() {} },
+        catchExceptions: function() { return false; },
+        resultCallback: function() {},
+        queueRunnerFactory: function(attrs) {
+          spec.result.status = 'failed';
+          attrs.onComplete();
+        }
+      });
+
+    spec.execute(done);
+
+    expect(done).toHaveBeenCalledWith(jasmine.any(jasmineUnderTest.StopExecutionError));
+  });
+
   it("#status returns passing by default", function() {
     var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
     expect(spec.status()).toBe('passed');
@@ -238,11 +261,12 @@ describe("Spec", function() {
   });
 
   it("keeps track of passed and failed expectations", function() {
-    var resultCallback = jasmine.createSpy('resultCallback'),
+    var fakeQueueRunner = jasmine.createSpy('queueRunner'),
+      resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: jasmine.createSpy("spec body") },
         expectationResultFactory: function (data) { return data; },
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); },
+        queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback
       });
     spec.addExpectationResult(true, 'expectation1');
@@ -250,19 +274,21 @@ describe("Spec", function() {
 
     spec.execute();
 
+    fakeQueueRunner.calls.mostRecent().args[0].cleanupFns[0].fn();
     expect(resultCallback.calls.first().args[0].passedExpectations).toEqual(['expectation1']);
     expect(resultCallback.calls.first().args[0].failedExpectations).toEqual(['expectation2']);
   });
 
   it("throws an ExpectationFailed error upon receiving a failed expectation when 'throwOnExpectationFailure' is set", function() {
-    var resultCallback = jasmine.createSpy('resultCallback'),
+    var fakeQueueRunner = jasmine.createSpy('queueRunner'),
+      resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: function() {} },
-      expectationResultFactory: function(data) { return data; },
-      queueRunnerFactory: function(attrs) { attrs.onComplete(); },
-      resultCallback: resultCallback,
-      throwOnExpectationFailure: true
-    });
+        queueableFn: { fn: function() {} },
+        expectationResultFactory: function(data) { return data; },
+        queueRunnerFactory: fakeQueueRunner,
+        resultCallback: resultCallback,
+        throwOnExpectationFailure: true
+      });
 
     spec.addExpectationResult(true, 'passed');
     expect(function() {
@@ -271,6 +297,7 @@ describe("Spec", function() {
 
     spec.execute();
 
+    fakeQueueRunner.calls.mostRecent().args[0].cleanupFns[0].fn();
     expect(resultCallback.calls.first().args[0].passedExpectations).toEqual(['passed']);
     expect(resultCallback.calls.first().args[0].failedExpectations).toEqual(['failed']);
   });
@@ -337,17 +364,20 @@ describe("Spec", function() {
   });
 
   it("should log a failure when handling an exception", function() {
-    var resultCallback = jasmine.createSpy('resultCallback'),
+    var fakeQueueRunner = jasmine.createSpy('queueRunner'),
+      resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         expectationResultFactory: function(data) { return data; },
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); },
+        queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback
       });
 
     spec.onException('foo');
     spec.execute();
 
+    var args = fakeQueueRunner.calls.mostRecent().args[0];
+    args.cleanupFns[0].fn();
     expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([{
       error: 'foo',
       matcherName: '',
@@ -358,63 +388,20 @@ describe("Spec", function() {
   });
 
   it("should not log an additional failure when handling an ExpectationFailed error", function() {
-    var resultCallback = jasmine.createSpy('resultCallback'),
+    var fakeQueueRunner = jasmine.createSpy('queueRunner'),
+      resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         expectationResultFactory: function(data) { return data; },
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); },
+        queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback
       });
 
     spec.onException(new jasmineUnderTest.errors.ExpectationFailed());
     spec.execute();
 
+    var args = fakeQueueRunner.calls.mostRecent().args[0];
+    args.cleanupFns[0].fn();
     expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([]);
   });
-
-  it("retrieves a result with updated status", function() {
-    var spec = new jasmineUnderTest.Spec({ queueableFn: { fn: function() {} } });
-
-    expect(spec.getResult().status).toBe('passed');
-  });
-
-  it("retrives a result with disabled status", function() {
-    var spec = new jasmineUnderTest.Spec({ queueableFn: { fn: function() {} } });
-    spec.disable();
-
-    expect(spec.getResult().status).toBe('disabled');
-  });
-
-  it("retrives a result with pending status", function() {
-    var spec = new jasmineUnderTest.Spec({ queueableFn: { fn: function() {} } });
-    spec.pend();
-
-    expect(spec.getResult().status).toBe('pending');
-  });
-
-  it("should not be executable when disabled", function() {
-    var spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: function() {} }
-    });
-    spec.disable();
-
-    expect(spec.isExecutable()).toBe(false);
-  });
-
-  it("should be executable when pending", function() {
-    var spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: function() {} }
-    });
-    spec.pend();
-
-    expect(spec.isExecutable()).toBe(true);
-  });
-
-  it("should be executable when not disabled or pending", function() {
-    var spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: function() {} }
-    });
-
-    expect(spec.isExecutable()).toBe(true);
-  });
 });

spec/core/SpyRegistrySpec.js

@@ -1,7 +1,11 @@
 describe("SpyRegistry", function() {
+  function createSpy(name, originalFn) {
+    return jasmineUnderTest.Spy(name, originalFn);
+  }
+
   describe("#spyOn", function() {
     it("checks for the existence of the object", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry();
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy});
       expect(function() {
         spyRegistry.spyOn(void 0, 'pants');
       }).toThrowError(/could not find an object/);
@@ -16,6 +20,22 @@ describe("SpyRegistry", function() {
         }).toThrowError(/No method name supplied/);
     });
 
+    it("checks that the object is not `null`", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry();
+      expect(function() {
+        spyRegistry.spyOn(null, 'pants');
+      }).toThrowError(/could not find an object/);
+    });
+
+    it("checks that the method name is not `null`", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
+        subject = {};
+
+      expect(function() {
+        spyRegistry.spyOn(subject, null);
+      }).toThrowError(/No method name supplied/);
+    });
+
     it("checks for the existence of the method", function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
@@ -27,7 +47,10 @@ describe("SpyRegistry", function() {
 
     it("checks if it has already been spied upon", function() {
       var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          createSpy: createSpy
+        }),
         subject = { spiedFunc: function() {} };
 
       spyRegistry.spyOn(subject, 'spiedFunc');
@@ -38,9 +61,6 @@ describe("SpyRegistry", function() {
     });
 
     it("checks if it can be spied upon", function() {
-      // IE 8 doesn't support `definePropery` on non-DOM nodes
-      if (jasmine.getEnv().ieVersion < 9) { return; }
-
       var scope = {};
 
       function myFunc() {
@@ -68,7 +88,7 @@ describe("SpyRegistry", function() {
 
     it("overrides the method on the object and returns the spy", function() {
       var originalFunctionWasCalled = false,
-        spyRegistry = new jasmineUnderTest.SpyRegistry(),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
         subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
 
       var spy = spyRegistry.spyOn(subject, 'spiedFunc');
@@ -77,10 +97,221 @@ describe("SpyRegistry", function() {
     });
   });
 
+  describe("#spyOnProperty", function() {
+    it("checks for the existence of the object", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry();
+      expect(function() {
+        spyRegistry.spyOnProperty(void 0, 'pants');
+      }).toThrowError(/could not find an object/);
+    });
+
+    it("checks that a property name was passed", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
+        subject = {};
+
+        expect(function() {
+          spyRegistry.spyOnProperty(subject);
+        }).toThrowError(/No property name supplied/);
+    });
+
+    it("checks for the existence of the method", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
+        subject = {};
+
+      expect(function() {
+        spyRegistry.spyOnProperty(subject, 'pants');
+      }).toThrowError(/property does not exist/);
+    });
+
+    it("checks for the existence of access type", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry(),
+        subject = {};
+
+      Object.defineProperty(subject, 'pants', {
+        get: function() { return 1; },
+        configurable: true
+      });
+
+      expect(function() {
+        spyRegistry.spyOnProperty(subject, 'pants', 'set');
+      }).toThrowError(/does not have access type/);
+    });
+
+    it("checks if it has already been spied upon", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+        subject = {};
+
+      Object.defineProperty(subject, 'spiedProp', {
+        get: function() { return 1; },
+        configurable: true
+      });
+
+      spyRegistry.spyOnProperty(subject, 'spiedProp');
+
+      expect(function() {
+        spyRegistry.spyOnProperty(subject, 'spiedProp');
+      }).toThrowError(/has already been spied upon/);
+    });
+
+    it("checks if it can be spied upon", function() {
+      var subject = {};
+
+      Object.defineProperty(subject, 'myProp', {
+        get: function() {}
+      });
+
+      Object.defineProperty(subject, 'spiedProp', {
+        get: function() {},
+        configurable: true
+      });
+
+      var spyRegistry = new jasmineUnderTest.SpyRegistry();
+
+      expect(function() {
+        spyRegistry.spyOnProperty(subject, 'myProp');
+      }).toThrowError(/is not declared configurable/);
+
+      expect(function() {
+        spyRegistry.spyOnProperty(subject, 'spiedProp');
+      }).not.toThrowError(/is not declared configurable/);
+    });
+
+    it("overrides the property getter on the object and returns the spy", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+        subject = {},
+        returnValue = 1;
+
+      Object.defineProperty(subject, 'spiedProperty', {
+        get: function() { return returnValue; },
+        configurable: true
+      });
+
+      expect(subject.spiedProperty).toEqual(returnValue);
+
+      var spy = spyRegistry.spyOnProperty(subject, 'spiedProperty');
+      var getter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty').get;
+
+      expect(getter).toEqual(spy);
+      expect(subject.spiedProperty).toBeUndefined();
+    });
+
+    it("overrides the property setter on the object and returns the spy", function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+        subject = {},
+        returnValue = 1;
+
+      Object.defineProperty(subject, 'spiedProperty', {
+        get: function() { return returnValue; },
+        set: function() {},
+        configurable: true
+      });
+
+      var spy = spyRegistry.spyOnProperty(subject, 'spiedProperty', 'set');
+      var setter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty').set;
+
+      expect(subject.spiedProperty).toEqual(returnValue);
+      expect(setter).toEqual(spy);
+    });
+  });
+
+  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 = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          createSpy: createSpy
+        }),
         originalFunction = function() {},
         subject = { spiedFunc: originalFunction };
 
@@ -92,7 +323,10 @@ describe("SpyRegistry", function() {
 
     it("restores the original functions, even when that spy has been replace and re-spied upon", function() {
       var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          createSpy: createSpy
+        }),
         originalFunction = function() {},
         subject = { spiedFunc: originalFunction };
 
@@ -110,11 +344,11 @@ describe("SpyRegistry", function() {
     });
 
     it("does not add a property that the spied-upon object didn't originally have", function() {
-      // IE 8 doesn't support `Object.create`
-      if (jasmine.getEnv().ieVersion < 9) { return; }
-
       var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          createSpy: createSpy
+        }),
         originalFunction = function() {},
         subjectParent = {spiedFunc: originalFunction};
 
@@ -130,11 +364,11 @@ describe("SpyRegistry", function() {
     });
 
     it("restores the original function when it\'s inherited and cannot be deleted", function() {
-      // IE 8 doesn't support `Object.create` or `Object.defineProperty`
-      if (jasmine.getEnv().ieVersion < 9) { return; }
-
       var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          createSpy: createSpy
+        }),
         originalFunction = function() {},
         subjectParent = {spiedFunc: originalFunction};
 
@@ -151,5 +385,71 @@ describe("SpyRegistry", function() {
 
       expect(jasmineUnderTest.isSpy(subject.spiedFunc)).toBe(false);
     });
+
+    it("restores window.onerror by overwriting, not deleting", function() {
+      function FakeWindow() {
+      }
+      FakeWindow.prototype.onerror = function() {};
+
+      var spies = [],
+        global = new FakeWindow(),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() { return spies; },
+          createSpy: createSpy,
+          global: global
+        });
+
+      spyRegistry.spyOn(global, 'onerror');
+      spyRegistry.clearSpies();
+      expect(global.onerror).toBe(FakeWindow.prototype.onerror);
+      expect(global.hasOwnProperty('onerror')).toBe(true);
+    });
   });
+
+    describe('spying on properties', function() {
+      it("restores the original properties on the spied-upon objects", function() {
+        var spies = [],
+          spyRegistry = new jasmineUnderTest.SpyRegistry({
+            currentSpies: function() { return spies; },
+            createSpy: createSpy
+          }),
+          originalReturn = 1,
+          subject = {};
+
+        Object.defineProperty(subject, 'spiedProp', {
+          get: function() { return originalReturn; },
+          configurable: true
+        });
+
+        spyRegistry.spyOnProperty(subject, 'spiedProp');
+        spyRegistry.clearSpies();
+
+        expect(subject.spiedProp).toBe(originalReturn);
+      });
+
+      it("does not add a property that the spied-upon object didn't originally have", function() {
+        var spies = [],
+          spyRegistry = new jasmineUnderTest.SpyRegistry({
+            currentSpies: function() { return spies; },
+            createSpy: createSpy
+          }),
+          originalReturn = 1,
+          subjectParent = {};
+
+        Object.defineProperty(subjectParent, 'spiedProp', {
+          get: function() { return originalReturn; },
+          configurable: true
+        });
+
+        var subject = Object.create(subjectParent);
+
+        expect(subject.hasOwnProperty('spiedProp')).toBe(false);
+
+        spyRegistry.spyOnProperty(subject, 'spiedProp');
+        spyRegistry.clearSpies();
+
+        expect(subject.hasOwnProperty('spiedProp')).toBe(false);
+        expect(subject.spiedProp).toBe(originalReturn);
+      });
+    });
 });

spec/core/SpySpec.js

@@ -1,4 +1,10 @@
 describe('Spies', function () {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+  });
+
   describe("createSpy", function() {
     var TestClass;
 
@@ -9,28 +15,40 @@ describe('Spies', function () {
     });
 
     it("preserves the properties of the spied function", function() {
-      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
 
       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";
 
       expect(function() {
-        jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+        env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       }).toThrowError("Jasmine spies would overwrite the 'and' and 'calls' properties on the object being spied upon");
     });
 
     it("adds a spyStrategy and callTracker to the spy", function() {
-      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
 
       expect(spy.and).toEqual(jasmine.any(jasmineUnderTest.SpyStrategy));
       expect(spy.calls).toEqual(jasmine.any(jasmineUnderTest.CallTracker));
     });
 
     it("tracks the argument of calls", function () {
-      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       var trackSpy = spyOn(spy.calls, "track");
 
       spy("arg");
@@ -39,7 +57,7 @@ describe('Spies', function () {
     });
 
     it("tracks the context of calls", function () {
-      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       var trackSpy = spyOn(spy.calls, "track");
 
       var contextObject = { spyMethod: spy };
@@ -49,7 +67,7 @@ describe('Spies', function () {
     });
 
     it("tracks the return value of calls", function () {
-      var spy = jasmineUnderTest.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
       var trackSpy = spyOn(spy.calls, "track");
 
       spy.and.returnValue("return value");
@@ -57,29 +75,115 @@ describe('Spies', function () {
 
       expect(trackSpy.calls.mostRecent().args[0].returnValue).toEqual("return value");
     });
+
+    it("preserves arity of original function", function () {
+      var functions = [
+        function nullary () {},
+        function unary (arg) {},
+        function binary (arg1, arg2) {},
+        function ternary (arg1, arg2, arg3) {},
+        function quaternary (arg1, arg2, arg3, arg4) {},
+        function quinary (arg1, arg2, arg3, arg4, arg5) {},
+        function senary (arg1, arg2, arg3, arg4, arg5, arg6) {}
+      ];
+
+      for (var arity = 0; arity < functions.length; arity++) {
+        var someFunction = functions[arity],
+            spy = env.createSpy(someFunction.name, someFunction);
+
+        expect(spy.length).toEqual(arity);
+      }
+    });
   });
 
   describe("createSpyObj", function() {
+    it("should create an object with spy methods and corresponding return values when you call jasmine.createSpyObj() with an object", function () {
+      var spyObj = env.createSpyObj('BaseName', {'method1': 42, 'method2': 'special sauce' });
+
+      expect(spyObj.method1()).toEqual(42);
+      expect(spyObj.method1.and.identity).toEqual('BaseName.method1');
+
+      expect(spyObj.method2()).toEqual('special sauce');
+      expect(spyObj.method2.and.identity).toEqual('BaseName.method2');
+    });
+
+
     it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function() {
-      var spyObj = jasmineUnderTest.createSpyObj('BaseName', ['method1', 'method2']);
+      var spyObj = env.createSpyObj('BaseName', ['method1', 'method2']);
 
       expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
-      expect(spyObj.method1.and.identity()).toEqual('BaseName.method1');
-      expect(spyObj.method2.and.identity()).toEqual('BaseName.method2');
+      expect(spyObj.method1.and.identity).toEqual('BaseName.method1');
+      expect(spyObj.method2.and.identity).toEqual('BaseName.method2');
     });
 
     it("should allow you to omit the baseName", function() {
-      var spyObj = jasmineUnderTest.createSpyObj(['method1', 'method2']);
+      var spyObj = env.createSpyObj(['method1', 'method2']);
 
       expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
-      expect(spyObj.method1.and.identity()).toEqual('unknown.method1');
-      expect(spyObj.method2.and.identity()).toEqual('unknown.method2');
+      expect(spyObj.method1.and.identity).toEqual('unknown.method1');
+      expect(spyObj.method2.and.identity).toEqual('unknown.method2');
     });
 
-    it("should throw if you do not pass an array argument", function() {
+    it("should throw if you do not pass an array or object argument", function() {
       expect(function() {
-        jasmineUnderTest.createSpyObj('BaseName');
-      }).toThrow("createSpyObj requires a non-empty array of method names to create spies for");
+        env.createSpyObj('BaseName');
+      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
+    });
+
+    it("should throw if you pass an empty array argument", function() {
+      expect(function() {
+        env.createSpyObj('BaseName', []);
+      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
+    });
+
+    it("should throw if you pass an empty object argument", function() {
+      expect(function() {
+        env.createSpyObj('BaseName', {});
+      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
+    });
+  });
+
+  it("can use different strategies for different arguments", function() {
+    var spy = env.createSpy('foo');
+    spy.and.returnValue(42);
+    spy.withArgs('baz', 'grault').and.returnValue(-1);
+    spy.withArgs('thud').and.returnValue('bob');
+
+    expect(spy('foo')).toEqual(42);
+    expect(spy('baz', 'grault')).toEqual(-1);
+    expect(spy('thud')).toEqual('bob');
+    expect(spy('baz', 'grault', 'waldo')).toEqual(42);
+  });
+
+  it("uses custom equality testers when selecting a strategy", function() {
+    var spy = env.createSpy('foo');
+    spy.and.returnValue(42);
+    spy.withArgs(jasmineUnderTest.any(String)).and.returnValue(-1);
+
+    expect(spy('foo')).toEqual(-1);
+    expect(spy({})).toEqual(42);
+  });
+
+  it("can reconfigure an argument-specific strategy", function() {
+    var spy = env.createSpy('foo');
+    spy.withArgs('foo').and.returnValue(42);
+    spy.withArgs('foo').and.returnValue(17);
+    expect(spy('foo')).toEqual(17);
+  });
+
+  describe("When withArgs is used without a base strategy", function() {
+    it("uses the matching strategy", function() {
+      var spy = env.createSpy('foo');
+      spy.withArgs('baz').and.returnValue(-1);
+
+      expect(spy('baz')).toEqual(-1);
+    });
+
+    it("throws if the args don't match", function() {
+      var spy = env.createSpy('foo');
+      spy.withArgs('bar').and.returnValue(-1);
+
+      expect(function() { spy('baz', {qux: 42}); }).toThrowError('Spy \'foo\' receieved a call with arguments [ \'baz\', Object({ qux: 42 }) ] but all configured strategies specify other arguments.');
     });
   });
 });

spec/core/SpyStrategySpec.js

@@ -3,13 +3,13 @@ describe("SpyStrategy", function() {
   it("defaults its name to unknown", function() {
     var spyStrategy = new jasmineUnderTest.SpyStrategy();
 
-    expect(spyStrategy.identity()).toEqual("unknown");
+    expect(spyStrategy.identity).toEqual("unknown");
   });
 
   it("takes a name", function() {
     var spyStrategy = new jasmineUnderTest.SpyStrategy({name: "foo"});
 
-    expect(spyStrategy.identity()).toEqual("foo");
+    expect(spyStrategy.identity).toEqual("foo");
   });
 
   it("stubs an original function, if provided", function() {
@@ -27,7 +27,7 @@ describe("SpyStrategy", function() {
         returnValue;
 
     spyStrategy.callThrough();
-    returnValue = spyStrategy.exec("foo");
+    returnValue = spyStrategy.exec(null, ["foo"]);
 
     expect(originalFn).toHaveBeenCalled();
     expect(originalFn.calls.mostRecent().args).toEqual(["foo"]);
@@ -92,12 +92,78 @@ describe("SpyStrategy", function() {
     expect(returnValue).toEqual(67);
   });
 
+  it("allows a fake async function to be called instead", function(done) {
+    jasmine.getEnv().requireAsyncAwait();
+    var originalFn = jasmine.createSpy("original"),
+        fakeFn = jasmine.createSpy("fake").and.callFake(eval("async () => { return 67; }")),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
+        returnValue;
+
+    spyStrategy.callFake(fakeFn);
+    spyStrategy.exec().then(function (returnValue) {
+      expect(originalFn).not.toHaveBeenCalled();
+      expect(fakeFn).toHaveBeenCalled();
+      expect(returnValue).toEqual(67);
+      done();
+    }).catch(function (err) {
+      done.fail(err);
+    })
+  });
+
+  it("allows a custom strategy to be used", function() {
+    var plan = jasmine.createSpy('custom strategy')
+        .and.returnValue('custom strategy result'),
+      customStrategy = jasmine.createSpy('custom strategy')
+        .and.returnValue(plan),
+      originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: originalFn,
+        customStrategies: {
+          doSomething: customStrategy
+        }
+      });
+
+    spyStrategy.doSomething(1, 2, 3);
+    expect(customStrategy).toHaveBeenCalledWith(1, 2, 3);
+    expect(spyStrategy.exec(null, ['some', 'args']))
+      .toEqual('custom strategy result');
+    expect(plan).toHaveBeenCalledWith('some', 'args');
+  });
+
+  it("throws an error if a custom strategy doesn't return a function", function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: originalFn,
+        customStrategies: {
+          doSomething: function() { return 'not a function' }
+        }
+      });
+
+    expect(function() { spyStrategy.doSomething(1, 2, 3) }).toThrowError('Spy strategy must return a function');
+  });
+
+  it("does not allow custom strategies to overwrite existing methods", function() {
+    var spyStrategy = new jasmineUnderTest.SpyStrategy({
+        fn: function() {},
+        customStrategies: {
+          exec: function() {}
+        }
+       });
+
+    expect(spyStrategy.exec).toBe(jasmineUnderTest.SpyStrategy.prototype.exec);
+  });
+
   it('throws an error when a non-function is passed to callFake strategy', function() {
     var originalFn = jasmine.createSpy('original'),
         spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
         invalidFakes = [5, 'foo', {}, true, false, null, void 0, new Date(), /.*/];
 
     spyOn(jasmineUnderTest, 'isFunction_').and.returnValue(false);
+    spyOn(jasmineUnderTest, 'isAsyncFunction_').and.returnValue(false);
+
+    expect(function () {
+      spyStrategy.callFake(function() {});
+    }).toThrowError(/^Argument passed to callFake should be a function, got/);
 
     expect(function () {
       spyStrategy.callFake(function() {});

spec/core/StackTraceSpec.js

@@ -0,0 +1,207 @@
+describe("StackTrace", function() {
+  it("understands Chrome/IE/Edge style traces", function() {
+    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(error);
+
+    expect(result.message).toEqual('Error: nope');
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        func: 'QueueRunner.run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+
+  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 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');
+    expect(result.frames).toEqual([
+      {
+        raw: '  at /somewhere/jasmine/lib/jasmine-core/jasmine.js:4255:9',
+        func: undefined,
+        file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
+        line: 4255
+      },
+      {
+        raw: '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)',
+        func: 'QueueRunner.complete [as onComplete]',
+        file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
+        line: 579
+      },
+      {
+        raw: '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)',
+        func: 'Immediate.<anonymous>',
+        file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
+        line: 4314
+      },
+      {
+        raw: '  at runCallback (timers.js:672:20)',
+        func: 'runCallback',
+        file: 'timers.js',
+        line: 672
+      }
+    ]);
+  });
+
+  it("understands Safari/Firefox/Phantom-OS X style traces", function() {
+    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');
+    expect(result.frames).toEqual([
+      {
+        raw: 'http://localhost:8888/__spec__/core/UtilSpec.js:115:28',
+        func: undefined,
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: 'run@http://localhost:8888/__jasmine__/jasmine.js:4320:27',
+        func: 'run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+
+  it("does not mistake gibberish for Safari/Firefox/Phantom-OS X style traces", function() {
+    var error = {
+      message: 'nope',
+      stack: 'randomcharsnotincludingwhitespace'
+    };
+    var result = new jasmineUnderTest.StackTrace(error);
+    expect(result.style).toBeNull();
+    expect(result.frames).toEqual([
+      { raw: error.stack }
+    ]);
+  });
+
+  it("understands Phantom-Linux style traces", function() {
+    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(error);
+
+    expect(result.message).toBeFalsy();
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        func: 'QueueRunner.run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+
+  it("ignores blank lines", function() {
+    var error = {
+      message: 'nope',
+      stack:
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n'
+    };
+
+    var result = new jasmineUnderTest.StackTrace(error);
+
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      }
+    ]);
+  });
+
+  it("omits properties except 'raw' for frames that are not understood", function() {
+    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(error);
+    expect(result.style).toEqual('v8');
+    expect(result.frames).toEqual([
+      {
+        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        func: 'UserContext.<anonymous>',
+        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
+        line: 115
+      },
+      {
+        raw: '    but this is quite unexpected'
+      },
+      {
+        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        func: 'QueueRunner.run',
+        file: 'http://localhost:8888/__jasmine__/jasmine.js',
+        line: 4320
+      }
+    ]);
+  });
+});

spec/core/SuiteSpec.js

@@ -67,11 +67,10 @@ describe("Suite", function() {
     expect(suite.afterFns).toEqual([innerAfter, outerAfter]);
   });
 
-  it('has a status of failed if any afterAll expectations have failed', function() {
+  it('has a status of failed if any expectations have failed', function() {
     var suite = new jasmineUnderTest.Suite({
       expectationResultFactory: function() { return 'hi'; }
     });
-    suite.addChild({ result: { status: 'done' } });
 
     suite.addExpectationResult(false);
     expect(suite.status()).toBe('failed');
@@ -80,14 +79,7 @@ describe("Suite", function() {
   it("retrieves a result with updated status", function() {
     var suite = new jasmineUnderTest.Suite({});
 
-    expect(suite.getResult().status).toBe('finished');
-  });
-
-  it("retrieves a result with disabled status", function() {
-    var suite = new jasmineUnderTest.Suite({});
-    suite.disable();
-
-    expect(suite.getResult().status).toBe('disabled');
+    expect(suite.getResult().status).toBe('passed');
   });
 
   it("retrieves a result with pending status", function() {
@@ -97,49 +89,11 @@ describe("Suite", function() {
     expect(suite.getResult().status).toBe('pending');
   });
 
-  it("priviledges a disabled status over pending status", function() {
-    var suite = new jasmineUnderTest.Suite({});
-    suite.disable();
-    suite.pend();
-
-    expect(suite.getResult().status).toBe('disabled');
-  });
-
-  it("is executable if not disabled", function() {
-    var suite = new jasmineUnderTest.Suite({});
-
-    expect(suite.isExecutable()).toBe(true);
-  });
-
-  it("is not executable if disabled", function() {
-    var suite = new jasmineUnderTest.Suite({});
-    suite.disable();
-
-    expect(suite.isExecutable()).toBe(false);
-  });
-
-  it("tells all children about expectation failures, even if one throws", function() {
-    var suite = new jasmineUnderTest.Suite({}),
-      child1 = { addExpectationResult: jasmine.createSpy('child1#expectationResult'), result: {} },
-      child2 = { addExpectationResult: jasmine.createSpy('child2#expectationResult'), result: {} };
-
-    suite.addChild(child1);
-    suite.addChild(child2);
-
-    child1.addExpectationResult.and.throwError('foo');
-
-    suite.addExpectationResult('stuff');
-
-    expect(child1.addExpectationResult).toHaveBeenCalledWith('stuff');
-    expect(child2.addExpectationResult).toHaveBeenCalledWith('stuff');
-  });
-
-  it("throws an ExpectationFailed when receiving a failed expectation in an afterAll when throwOnExpectationFailure is set", function() {
+  it("throws an ExpectationFailed when receiving a failed expectation when throwOnExpectationFailure is set", function() {
     var suite = new jasmineUnderTest.Suite({
       expectationResultFactory: function(data) { return data; },
       throwOnExpectationFailure: true
     });
-    suite.addChild({ result: { status: 'done' } });
 
     expect(function() {
       suite.addExpectationResult(false, 'failed');
@@ -149,12 +103,21 @@ describe("Suite", function() {
     expect(suite.result.failedExpectations).toEqual(['failed']);
   });
 
-  it("does not add an additional failure when an expectation fails in an afterAll", function(){
+  it("does not add an additional failure when an expectation fails", function(){
     var suite = new jasmineUnderTest.Suite({});
-    suite.addChild({ result: { status: 'done' } });
 
     suite.onException(new jasmineUnderTest.errors.ExpectationFailed());
 
     expect(suite.getResult().failedExpectations).toEqual([]);
-  })
+  });
+
+  describe('#sharedUserContext', function() {
+    beforeEach(function() {
+      this.suite = new jasmineUnderTest.Suite({});
+    });
+
+    it('returns a UserContext', function() {
+      expect(this.suite.sharedUserContext().constructor).toBe(jasmineUnderTest.UserContext);
+    });
+  });
 });

spec/core/TreeProcessorSpec.js

@@ -8,27 +8,24 @@ describe("TreeProcessor", function() {
     this.canBeReentered = function() {
       return !attrs.noReenter;
     };
-    this.isExecutable = function() {
-      return attrs.executable !== false;
-    };
+    this.markedPending = attrs.markedPending || false;
     this.sharedUserContext = function() {
       return attrs.userContext || {};
     };
     this.getResult = jasmine.createSpy(this.id + '#execute');
     this.beforeAllFns = attrs.beforeAllFns || [];
     this.afterAllFns = attrs.afterAllFns || [];
+    this.cleanupBeforeAfter = function() { };
   }
 
   function Leaf(attrs) {
     attrs = attrs || {};
     this.id = 'leaf' + leafNumber++;
-    this.isExecutable = function() {
-      return attrs.executable !== false;
-    };
+    this.markedPending = attrs.markedPending || false;
     this.execute = jasmine.createSpy(this.id + '#execute');
   }
 
-  it("processes a single executable leaf", function() {
+  it("processes a single leaf", function() {
     var leaf = new Leaf(),
         processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
         result = processor.processTree();
@@ -36,20 +33,22 @@ describe("TreeProcessor", function() {
     expect(result.valid).toBe(true);
 
     expect(result[leaf.id]).toEqual({
-      executable: true,
+      excluded: false,
+      willExecute: true,
       segments: jasmine.any(Array)
     });
   });
 
-  it("processes a single non-executable leaf", function() {
-    var leaf = new Leaf({ executable: false }),
+  it("processes a single pending leaf", function() {
+    var leaf = new Leaf({ markedPending: true }),
         processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
     expect(result[leaf.id]).toEqual({
-      executable: false,
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
   });
@@ -62,7 +61,26 @@ describe("TreeProcessor", function() {
     expect(result.valid).toBe(true);
 
     expect(result[leaf.id]).toEqual({
-      executable: false,
+      excluded: true,
+      willExecute: false,
+      segments: jasmine.any(Array)
+    });
+  });
+
+  it("processes a single excluded leaf", function() {
+    var leaf = new Leaf(),
+        processor = new jasmineUnderTest.TreeProcessor({
+          tree: leaf,
+          runnableIds: [leaf.id],
+          excludeNode: function(node) { return true; }
+        }),
+        result = processor.processTree();
+
+    expect(result.valid).toBe(true);
+
+    expect(result[leaf.id]).toEqual({
+      excluded: true,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
   });
@@ -76,18 +94,20 @@ describe("TreeProcessor", function() {
     expect(result.valid).toBe(true);
 
     expect(result[parent.id]).toEqual({
-      executable: true,
+      excluded: false,
+      willExecute: true,
       segments: jasmine.any(Array)
     });
 
     expect(result[leaf.id]).toEqual({
-      executable: true,
+      excluded: false,
+      willExecute: true,
       segments: jasmine.any(Array)
     });
   });
 
-  it("processes a tree with a single non-executable leaf, with the root specified", function() {
-    var leaf = new Leaf({ executable: false }),
+  it("processes a tree with a single pending leaf, with the root specified", function() {
+    var leaf = new Leaf({ markedPending: true }),
         parent = new Node({ children: [leaf] }),
         processor = new jasmineUnderTest.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
         result = processor.processTree();
@@ -95,61 +115,77 @@ describe("TreeProcessor", function() {
     expect(result.valid).toBe(true);
 
     expect(result[parent.id]).toEqual({
-      executable: false,
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
 
     expect(result[leaf.id]).toEqual({
-      executable: false,
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
   });
 
   it("processes a complicated tree with the root specified", function() {
-    var nonExecutable = new Leaf({ executable: false }),
-        executable = new Leaf({ executable: true }),
-        parent = new Node({ children: [nonExecutable, executable] }),
+    var pendingLeaf = new Leaf({ markedPending: true }),
+        executableLeaf = new Leaf({ markedPending: false }),
+        parent = new Node({ children: [pendingLeaf, executableLeaf] }),
         childless = new Node(),
-        childOfDisabled = new Leaf({ executable: true }),
-        disabledNode = new Node({ executable: false, children: [childOfDisabled] }),
-        root = new Node({ children: [parent, childless, disabledNode] }),
+        childOfPending = new Leaf({ markedPending: true }),
+        pendingNode = new Node({ markedPending: true, children: [childOfPending] }),
+        parentOfPendings = new Node({ markedPending: false, children: [childless, pendingNode] }),
+        root = new Node({ children: [parent, parentOfPendings] }),
         processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [root.id] }),
         result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
     expect(result[root.id]).toEqual({
-      executable: true,
+      excluded: false,
+      willExecute: true,
+      segments: jasmine.any(Array)
+    });
+
+    expect(result[parentOfPendings.id]).toEqual({
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
 
     expect(result[childless.id]).toEqual({
-      executable: false,
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
 
-    expect(result[nonExecutable.id]).toEqual({
-      executable: false,
+    expect(result[pendingLeaf.id]).toEqual({
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
 
-    expect(result[executable.id]).toEqual({
-      executable: true,
+    expect(result[executableLeaf.id]).toEqual({
+      excluded: false,
+      willExecute: true,
       segments: jasmine.any(Array)
     });
 
     expect(result[parent.id]).toEqual({
-      executable: true,
+      excluded: false,
+      willExecute: true,
       segments: jasmine.any(Array)
     });
 
-    expect(result[disabledNode.id]).toEqual({
-      executable: false,
+    expect(result[pendingNode.id]).toEqual({
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
 
-    expect(result[childOfDisabled.id]).toEqual({
-      executable: false,
+    expect(result[childOfPending.id]).toEqual({
+      excluded: false,
+      willExecute: false,
       segments: jasmine.any(Array)
     });
   });
@@ -218,7 +254,7 @@ describe("TreeProcessor", function() {
 
     queueRunner.calls.mostRecent().args[0].queueableFns[0].fn('foo');
 
-    expect(leaf.execute).toHaveBeenCalledWith('foo', true);
+    expect(leaf.execute).toHaveBeenCalledWith('foo', false);
   });
 
   it("runs a node with no children", function() {
@@ -248,19 +284,20 @@ describe("TreeProcessor", function() {
 
     queueRunner.calls.mostRecent().args[0].queueableFns[0].fn(nodeDone);
 
-    expect(nodeStart).toHaveBeenCalledWith(node);
     expect(queueRunner).toHaveBeenCalledWith({
       onComplete: jasmine.any(Function),
-      queueableFns: [],
+      queueableFns: [{ fn: jasmine.any(Function) }],
       userContext: { node: 'context' },
       onException: jasmine.any(Function)
     });
 
+    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn('foo');
+    expect(nodeStart).toHaveBeenCalledWith(node, 'foo');
+
     node.getResult.and.returnValue({ my: 'result' });
 
     queueRunner.calls.mostRecent().args[0].onComplete();
-    expect(nodeComplete).toHaveBeenCalledWith(node, { my: 'result' });
-    expect(nodeDone).toHaveBeenCalled();
+    expect(nodeComplete).toHaveBeenCalledWith(node, { my: 'result' }, jasmine.any(Function));
   });
 
   it("runs a node with children", function() {
@@ -282,25 +319,56 @@ describe("TreeProcessor", function() {
     queueableFns[0].fn(nodeDone);
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
-    expect(queueableFns.length).toBe(2);
+    expect(queueableFns.length).toBe(3);
 
-    queueableFns[0].fn('foo');
-    expect(leaf1.execute).toHaveBeenCalledWith('foo', true);
+    queueableFns[1].fn('foo');
+    expect(leaf1.execute).toHaveBeenCalledWith('foo', false);
 
-    queueableFns[1].fn('bar');
-    expect(leaf2.execute).toHaveBeenCalledWith('bar', true);
+    queueableFns[2].fn('bar');
+    expect(leaf2.execute).toHaveBeenCalledWith('bar', false);
   });
 
-  it("runs a disabled node", function() {
+  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], executable: false }),
+        node = new Node({ children: [leaf1] }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
         nodeStart = jasmine.createSpy('nodeStart'),
         nodeComplete = jasmine.createSpy('nodeComplete'),
         processor = new jasmineUnderTest.TreeProcessor({
           tree: root,
-          runnableIds: [node.id],
+          runnableIds: [],
           queueRunnerFactory: queueRunner,
           nodeStart: nodeStart,
           nodeComplete: nodeComplete
@@ -312,18 +380,19 @@ describe("TreeProcessor", function() {
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
     queueableFns[0].fn(nodeDone);
 
-    expect(nodeStart).toHaveBeenCalledWith(node);
-
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
-    expect(queueableFns.length).toBe(1);
+    expect(queueableFns.length).toBe(2);
 
-    queueableFns[0].fn('foo');
-    expect(leaf1.execute).toHaveBeenCalledWith('foo', false);
+    queueableFns[0].fn('bar');
+    expect(nodeStart).toHaveBeenCalledWith(node, 'bar');
+
+    queueableFns[1].fn('foo');
+    expect(leaf1.execute).toHaveBeenCalledWith('foo', true);
 
     node.getResult.and.returnValue({ im: 'disabled' });
 
     queueRunner.calls.mostRecent().args[0].onComplete();
-    expect(nodeComplete).toHaveBeenCalledWith(node, { im: 'disabled' });
+    expect(nodeComplete).toHaveBeenCalledWith(node, { im: 'disabled' }, jasmine.any(Function));
   });
 
   it("runs beforeAlls for a node with children", function() {
@@ -348,7 +417,7 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual(['beforeAll1', 'beforeAll2', { fn: jasmine.any(Function) }]);
+    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, 'beforeAll1', 'beforeAll2', { fn: jasmine.any(Function) }]);
   });
 
   it("runs afterAlls for a node with children", function() {
@@ -373,7 +442,7 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, 'afterAll1', 'afterAll2']);
+    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, { fn: jasmine.any(Function) }, 'afterAll1', 'afterAll2']);
   });
 
   it("does not run beforeAlls or afterAlls for a node with no children", function() {
@@ -397,16 +466,16 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([]);
+    expect(queueableFns).toEqual([{fn: jasmine.any(Function)}]);
   });
 
-  it("does not run beforeAlls or afterAlls for a disabled node", function() {
-    var leaf = new Leaf(),
+  it("does not run beforeAlls or afterAlls for a node with only pending children", function() {
+    var leaf = new Leaf({ markedPending: true }),
         node = new Node({
           children: [leaf],
           beforeAllFns: ['before'],
           afterAllFns: ['after'],
-          executable: false
+          markedPending: false
         }),
         root = new Node({ children: [node] }),
         queueRunner = jasmine.createSpy('queueRunner'),
@@ -424,7 +493,7 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }]);
+    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, { fn: jasmine.any(Function) }]);
   });
 
   it("runs leaves in the order specified", function() {
@@ -451,7 +520,7 @@ describe("TreeProcessor", function() {
     expect(leaf1.execute).toHaveBeenCalled();
   });
 
-  it("runs specified leaves before non-specified leaves", function() {
+  it("runs specified leaves before non-specified leaves within a parent node", function() {
     var specified = new Leaf(),
         nonSpecified = new Leaf(),
         root = new Node({ children: [nonSpecified, specified] }),
@@ -468,11 +537,11 @@ describe("TreeProcessor", function() {
     queueableFns[0].fn();
 
     expect(nonSpecified.execute).not.toHaveBeenCalled();
-    expect(specified.execute).toHaveBeenCalledWith(undefined, true);
+    expect(specified.execute).toHaveBeenCalledWith(undefined, false);
 
     queueableFns[1].fn();
 
-    expect(nonSpecified.execute).toHaveBeenCalledWith(undefined, false);
+    expect(nonSpecified.execute).toHaveBeenCalledWith(undefined, true);
   });
 
   it("runs nodes and leaves with a specified order", function() {
@@ -493,7 +562,7 @@ describe("TreeProcessor", function() {
 
     expect(specifiedLeaf.execute).not.toHaveBeenCalled();
     var nodeQueueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
-    nodeQueueableFns[0].fn();
+    nodeQueueableFns[1].fn();
 
     expect(childLeaf.execute).toHaveBeenCalled();
 
@@ -522,8 +591,8 @@ describe("TreeProcessor", function() {
     expect(queueableFns.length).toBe(5);
 
     queueableFns[0].fn();
-    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(leaf1.execute).toHaveBeenCalled();
 
     queueableFns[1].fn();
@@ -531,8 +600,8 @@ describe("TreeProcessor", function() {
 
     queueableFns[2].fn();
     expect(queueRunner.calls.count()).toBe(3);
-    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(leaf2.execute).toHaveBeenCalled();
 
     queueableFns[3].fn();
@@ -540,8 +609,8 @@ describe("TreeProcessor", function() {
 
     queueableFns[4].fn();
     expect(queueRunner.calls.count()).toBe(4);
-    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(leaf3.execute).toHaveBeenCalled();
   });
 
@@ -567,12 +636,12 @@ describe("TreeProcessor", function() {
 
     queueableFns[0].fn();
     expect(queueRunner.calls.count()).toBe(2);
-    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(2);
 
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(queueRunner.calls.count()).toBe(3);
 
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(leaf1.execute).toHaveBeenCalled();
 
     queueableFns[1].fn();
@@ -580,12 +649,12 @@ describe("TreeProcessor", function() {
 
     queueableFns[2].fn();
     expect(queueRunner.calls.count()).toBe(4);
-    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(2);
 
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(queueRunner.calls.count()).toBe(5);
 
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(leaf2.execute).toHaveBeenCalled();
 
     queueableFns[3].fn();
@@ -593,12 +662,12 @@ describe("TreeProcessor", function() {
 
     queueableFns[4].fn();
     expect(queueRunner.calls.count()).toBe(6);
-    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(1);
+    expect(queueRunner.calls.mostRecent().args[0].queueableFns.length).toBe(2);
 
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(queueRunner.calls.count()).toBe(7);
 
-    queueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
+    queueRunner.calls.mostRecent().args[0].queueableFns[1].fn();
     expect(leaf3.execute).toHaveBeenCalled();
   });
 
@@ -625,11 +694,11 @@ describe("TreeProcessor", function() {
     queueableFns[1].fn();
 
     var childFns = queueRunner.calls.mostRecent().args[0].queueableFns;
-    expect(childFns.length).toBe(2);
-    childFns[0].fn();
+    expect(childFns.length).toBe(3);
+    childFns[1].fn();
     expect(leaf2.execute).toHaveBeenCalled();
 
-    childFns[1].fn();
+    childFns[2].fn();
     expect(leaf3.execute).toHaveBeenCalled();
   });
 
@@ -691,7 +760,7 @@ describe("TreeProcessor", function() {
     expect(leaf11.execute).toHaveBeenCalled();
   });
 
-  it("runs nodes in a custom order when orderChildren is overrided", function() {
+  it("runs nodes in a custom order when orderChildren is overridden", function() {
     var leaf1 = new Leaf(),
         leaf2 = new Leaf(),
         leaf3 = new Leaf(),

spec/core/UserContextSpec.js

@@ -0,0 +1,54 @@
+describe("UserContext", function() {
+  it("Behaves just like an plain object", function() {
+    var context = new jasmineUnderTest.UserContext(),
+        properties = [];
+
+    for (var prop in context) {
+      if (obj.hasOwnProperty(prop)) {
+        properties.push(prop);
+      }
+    }
+
+    expect(properties).toEqual([]);
+  });
+
+  describe('.fromExisting', function() {
+    describe('when using an already built context as model', function() {
+      beforeEach(function() {
+        this.context = new jasmineUnderTest.UserContext();
+        this.context.key = 'value';
+        this.cloned = jasmineUnderTest.UserContext.fromExisting(this.context);
+      });
+
+      it('returns a cloned object', function() {
+        expect(this.cloned).toEqual(this.context);
+      });
+
+      it('does not return the same object', function() {
+        expect(this.cloned).not.toBe(this.context);
+      });
+    });
+
+    describe('when using a regular object as parameter', function() {
+      beforeEach(function() {
+        this.context = {};
+        this.value = 'value';
+        this.context.key = this.value;
+        this.cloned = jasmineUnderTest.UserContext.fromExisting(this.context);
+      });
+
+      it('returns an object with the same attributes', function() {
+        expect(this.cloned.key).toEqual(this.value);
+      });
+
+      it('does not return the same object', function() {
+        expect(this.cloned).not.toBe(this.context);
+      });
+
+      it('returns an UserContext', function() {
+        expect(this.cloned.constructor).toBe(jasmineUnderTest.UserContext);
+      });
+    });
+  });
+});
+

spec/core/UtilSpec.js

@@ -15,6 +15,22 @@ describe("jasmineUnderTest.util", function() {
     });
   });
 
+  describe("isObject_", function() {
+    it("should return true if the argument is an object", function() {
+      expect(jasmineUnderTest.isObject_({})).toBe(true);
+      expect(jasmineUnderTest.isObject_({an: "object"})).toBe(true);
+    });
+
+    it("should return false if the argument is not an object", function() {
+      expect(jasmineUnderTest.isObject_(undefined)).toBe(false);
+      expect(jasmineUnderTest.isObject_([])).toBe(false);
+      expect(jasmineUnderTest.isObject_(function() {})).toBe(false);
+      expect(jasmineUnderTest.isObject_('foo')).toBe(false);
+      expect(jasmineUnderTest.isObject_(5)).toBe(false);
+      expect(jasmineUnderTest.isObject_(null)).toBe(false);
+    });
+  });
+
   describe("isUndefined", function() {
     it("reports if a variable is defined", function() {
       var a;
@@ -25,4 +41,65 @@ describe("jasmineUnderTest.util", function() {
       expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(false);
     });
   });
+
+  describe("getPropertyDescriptor", function() {
+    it("get property descriptor from object", function() {
+      var obj = {prop: 1},
+        actual = jasmineUnderTest.util.getPropertyDescriptor(obj, 'prop'),
+        expected = Object.getOwnPropertyDescriptor(obj, 'prop');
+
+      expect(actual).toEqual(expected);
+    });
+
+    it("get property descriptor from object property", function() {
+      var proto = {prop: 1},
+        obj = Object.create(proto),
+        actual = jasmineUnderTest.util.getPropertyDescriptor(proto, 'prop'),
+        expected = Object.getOwnPropertyDescriptor(proto, 'prop');
+
+      expect(actual).toEqual(expected);
+    });
+  });
+
+  describe("objectDifference", function() {
+    it("given two objects A and B, returns the properties in A not present in B", function() {
+      var a = {
+        foo: 3,
+        bar: 4,
+        baz: 5
+      };
+
+      var b = {
+        bar: 6,
+        quux: 7
+      };
+
+      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({foo: 3, baz: 5})
+    });
+
+    it("only looks at own properties of both objects", function() {
+      function Foo() {}
+
+      Foo.prototype.x = 1;
+      Foo.prototype.y = 2;
+
+      var a = new Foo();
+      a.x = 1;
+
+      var b = new Foo();
+      b.y = 2;
+
+      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({x: 1});
+      expect(jasmineUnderTest.util.objectDifference(b, a)).toEqual({y: 2});
+    });
+  });
+
+  describe("jasmineFile", function() {
+    it("returns the file containing jasmine.util", function() {
+      // Chrome sometimes reports foo.js as foo.js/, so tolerate
+      // a trailing slash if present.
+      expect(jasmineUnderTest.util.jasmineFile()).toMatch(/util.js\/?$/);
+      expect(jasmine.util.jasmineFile()).toMatch(/jasmine.js\/?$/);
+    });
+  });
 });

spec/core/asymmetric_equality/AnySpec.js

@@ -29,6 +29,38 @@ describe("Any", function() {
     expect(any.asymmetricMatch(true)).toBe(true);
   });
 
+  it("matches a Map", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var any = new jasmineUnderTest.Any(Map);
+
+    expect(any.asymmetricMatch(new Map())).toBe(true);
+  });
+
+  it("matches a Set", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var any = new jasmineUnderTest.Any(Set);
+
+    expect(any.asymmetricMatch(new Set())).toBe(true);
+  });
+
+  it("matches a TypedArray", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+
+    var any = new jasmineUnderTest.Any(Uint32Array);
+
+    expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true);
+  });
+
+  it("matches a Symbol", function() {
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var any = new jasmineUnderTest.Any(Symbol);
+
+    expect(any.asymmetricMatch(Symbol())).toBe(true);
+  });
+
   it("matches another constructed object", function() {
     var Thing = function() {},
       any = new jasmineUnderTest.Any(Thing);
@@ -36,10 +68,17 @@ describe("Any", function() {
     expect(any.asymmetricMatch(new Thing())).toBe(true);
   });
 
+  it("does not treat null as an Object", function() {
+    var any = new jasmineUnderTest.Any(Object);
+
+    expect(any.asymmetricMatch(null)).toBe(false);
+  });
+
   it("jasmineToString's itself", function() {
     var any = new jasmineUnderTest.Any(Number);
 
     expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
+    expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
   });
 
   describe("when called without an argument", function() {

spec/core/asymmetric_equality/AnythingSpec.js

@@ -23,6 +23,38 @@ describe("Anything", function() {
     expect(anything.asymmetricMatch([1,2,3])).toBe(true);
   });
 
+  it("matches a Map", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(new Map())).toBe(true);
+  });
+
+  it("matches a Set", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(new Set())).toBe(true);
+  });
+
+  it("matches a TypedArray", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true);
+  });
+
+  it("matches a Symbol", function() {
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var anything = new jasmineUnderTest.Anything();
+
+    expect(anything.asymmetricMatch(Symbol())).toBe(true);
+  });
+
   it("doesn't match undefined", function() {
     var anything = new jasmineUnderTest.Anything();
 

spec/core/asymmetric_equality/ArrayContainingSpec.js

@@ -36,4 +36,17 @@ describe("ArrayContaining", function() {
 
     expect(containing.jasmineToString()).toMatch("<jasmine.arrayContaining");
   });
+
+  it("uses custom equality testers", function() {
+    var tester = function(a, b) {
+      // All "foo*" strings match each other.
+      if (typeof a == "string" && typeof b == "string" &&
+          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        return true;
+      }
+    };
+    var containing = new jasmineUnderTest.ArrayContaining(["fooVal"]);
+
+    expect(containing.asymmetricMatch(["fooBar"], [tester])).toBe(true);
+  });
 });

spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js

@@ -0,0 +1,47 @@
+describe("ArrayWithExactContents", function() {
+  it("matches an array with the same items in a different order", function() {
+    var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
+
+    expect(matcher.asymmetricMatch([2, 'a', /a/])).toBe(true);
+  });
+
+  it("does not work when not passed an array", function() {
+    var matcher = new jasmineUnderTest.ArrayWithExactContents("foo");
+
+    expect(function() {
+      matcher.asymmetricMatch([]);
+    }).toThrowError(/not 'foo'/);
+  });
+
+  it("does not match when an item is missing", function() {
+    var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
+
+    expect(matcher.asymmetricMatch(['a', 2])).toBe(false);
+    expect(matcher.asymmetricMatch(['a', 2, undefined])).toBe(false);
+  });
+
+  it("does not match when there is an extra item", function() {
+    var matcher = new jasmineUnderTest.ArrayWithExactContents(['a']);
+
+    expect(matcher.asymmetricMatch(['a', 2])).toBe(false);
+  });
+
+  it("jasmineToStrings itself", function() {
+    var matcher = new jasmineUnderTest.ArrayWithExactContents([]);
+
+    expect(matcher.jasmineToString()).toMatch("<jasmine.arrayWithExactContents");
+  });
+
+  it("uses custom equality testers", function() {
+    var tester = function(a, b) {
+      // All "foo*" strings match each other.
+      if (typeof a == "string" && typeof b == "string" &&
+          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        return true;
+      }
+    };
+    var matcher = new jasmineUnderTest.ArrayWithExactContents(["fooVal"]);
+
+    expect(matcher.asymmetricMatch(["fooBar"], [tester])).toBe(true);
+  });
+});

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);
+  });
+});

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);
+    });
+});

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);
+  });
+});

spec/core/asymmetric_equality/ObjectContainingSpec.js

@@ -57,9 +57,6 @@ describe("ObjectContaining", function() {
   });
 
   it("matches defined properties", function(){
-    // IE 8 doesn't support `definePropery` on non-DOM nodes
-    if (jasmine.getEnv().ieVersion < 9) { return; }
-
     var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
 
     var definedPropertyObject = {};
@@ -86,4 +83,17 @@ describe("ObjectContaining", function() {
 
     expect(containing.asymmetricMatch(obj)).toBe(true);
   });
+
+  it("uses custom equality testers", function() {
+    var tester = function(a, b) {
+      // All "foo*" strings match each other.
+      if (typeof a == "string" && typeof b == "string" &&
+          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        return true;
+      }
+    };
+    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+
+    expect(containing.asymmetricMatch({foo: "fooBar"}, [tester])).toBe(true);
+  });
 });

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);
+  });
+});
+

spec/core/integration/CustomMatchersSpec.js

@@ -4,6 +4,7 @@ describe("Custom Matchers (Integration)", function() {
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
+    env.randomizeTests(false);
   });
 
   it("allows adding more matchers local to a spec", function(done) {
@@ -56,6 +57,54 @@ describe("Custom Matchers (Integration)", function() {
     env.execute();
   });
 
+  it("passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers", function(done) {
+    env.it("spec using custom equality matcher", function() {
+      var customEqualityFn = function(a, b) {
+        // All "foo*" strings match each other.
+        if (typeof a == "string" && typeof b == "string" &&
+            a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+          return true;
+        }
+      };
+
+      env.addCustomEqualityTester(customEqualityFn);
+      env.expect({foo: 'fooValue'}).toEqual(jasmineUnderTest.objectContaining({foo: 'fooBar'}));
+      env.expect(['fooValue', 'things']).toEqual(jasmineUnderTest.arrayContaining(['fooBar']));
+      env.expect(['fooValue']).toEqual(jasmineUnderTest.arrayWithExactContents(['fooBar']));
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('passed');
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("displays an appropriate failure message if a custom equality matcher fails", function(done) {
+    env.it("spec using custom equality matcher", function() {
+      var customEqualityFn = function(a, b) {
+        // "foo" is not equal to anything
+        if (a === 'foo' || b === 'foo') {
+          return false;
+        }
+      };
+
+      env.addCustomEqualityTester(customEqualityFn);
+      env.expect({foo: 'foo'}).toEqual({foo: 'foo'});
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('failed');
+      expect(result.failedExpectations[0].message).toEqual(
+        "Expected $.foo = 'foo' to equal 'foo'."
+      );
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
   it("uses the negative compare function for a negative comparison, if provided", function(done) {
     env.it("spec with custom negative comparison matcher", function() {
       env.addMatchers({
@@ -72,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();

spec/core/integration/CustomSpyStrategiesSpec.js

@@ -0,0 +1,138 @@
+describe('Custom Spy Strategies (Integration)', function() {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+    env.randomizeTests(false);
+  });
+
+  it('allows adding more strategies local to a suite', function(done) {
+    var plan = jasmine.createSpy('custom strategy plan')
+      .and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy')
+      .and.returnValue(plan);
+
+    env.describe('suite defining a custom spy strategy', function() {
+      env.beforeEach(function() {
+        env.addSpyStrategy('frobnicate', strategy);
+      });
+
+      env.it('spec in the suite', function() {
+        var spy = env.createSpy('something').and.frobnicate(17);
+        expect(spy(1, 2, 3)).toEqual(42);
+        expect(strategy).toHaveBeenCalledWith(17);
+        expect(plan).toHaveBeenCalledWith(1, 2, 3);
+      });
+    });
+
+    env.it('spec without custom strategy defined', function() {
+      expect(env.createSpy('something').and.frobnicate).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+
+  it('allows adding more strategies local to a spec', function(done) {
+    var plan = jasmine.createSpy('custom strategy plan')
+      .and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy')
+      .and.returnValue(plan);
+
+    env.it('spec defining a custom spy strategy', function() {
+      env.addSpyStrategy('frobnicate', strategy);
+      var spy = env.createSpy('something').and.frobnicate(17);
+      expect(spy(1, 2, 3)).toEqual(42);
+      expect(strategy).toHaveBeenCalledWith(17);
+      expect(plan).toHaveBeenCalledWith(1, 2, 3);
+    });
+
+    env.it('spec without custom strategy defined', function() {
+      expect(env.createSpy('something').and.frobnicate).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+
+  it('allows using custom strategies on a per-argument basis', function(done) {
+    var plan = jasmine.createSpy('custom strategy plan')
+      .and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy')
+      .and.returnValue(plan);
+
+    env.it('spec defining a custom spy strategy', function() {
+      env.addSpyStrategy('frobnicate', strategy);
+      var spy = env.createSpy('something')
+        .and.returnValue('no args return')
+        .withArgs(1, 2, 3).and.frobnicate(17);
+
+      expect(spy()).toEqual('no args return');
+      expect(plan).not.toHaveBeenCalled();
+      expect(spy(1, 2, 3)).toEqual(42);
+      expect(plan).toHaveBeenCalledWith(1, 2, 3);
+    });
+
+    env.it('spec without custom strategy defined', function() {
+      expect(env.createSpy('something').and.frobnicate).toBeUndefined();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone });
+    env.execute();
+  });
+
+  it('allows multiple custom strategies to be used', function(done) {
+    var plan1 = jasmine.createSpy('plan 1').and.returnValue(42),
+      strategy1 = jasmine.createSpy('strat 1').and.returnValue(plan1),
+      plan2 = jasmine.createSpy('plan 2').and.returnValue(24),
+      strategy2 = jasmine.createSpy('strat 2').and.returnValue(plan2),
+      specDone = jasmine.createSpy('specDone');
+
+    env.beforeEach(function() {
+      env.addSpyStrategy('frobnicate', strategy1);
+      env.addSpyStrategy('jiggle', strategy2);
+    });
+
+    env.it('frobnicates', function() {
+      plan1.calls.reset();
+      plan2.calls.reset();
+      var spy = env.createSpy('spy').and.frobnicate();
+      expect(spy()).toEqual(42);
+      expect(plan1).toHaveBeenCalled();
+      expect(plan2).not.toHaveBeenCalled();
+    });
+
+    env.it('jiggles', function() {
+      plan1.calls.reset();
+      plan2.calls.reset();
+      var spy = env.createSpy('spy').and.jiggle();
+      expect(spy()).toEqual(24);
+      expect(plan1).not.toHaveBeenCalled();
+      expect(plan2).toHaveBeenCalled();
+    });
+
+    function jasmineDone(result) {
+      expect(result.overallStatus).toEqual('passed');
+      expect(specDone.calls.count()).toBe(2);
+      done();
+    }
+
+    env.addReporter({ jasmineDone: jasmineDone, specDone: specDone });
+    env.execute();
+  });
+});

spec/core/integration/SpecRunningSpec.js

@@ -1,8 +1,10 @@
-describe("jasmine spec running", function () {
+describe("spec running", function () {
   var env;
 
   beforeEach(function() {
+    jasmine.getEnv().registerIntegrationMatchers();
     env = new jasmineUnderTest.Env();
+    env.randomizeTests(false);
   });
 
   it('should assign spec ids sequentially', function() {
@@ -172,6 +174,22 @@ describe("jasmine spec running", function () {
   it("should run multiple befores and afters ordered so functions declared later are treated as more specific", function(done) {
     var actions = [];
 
+    env.beforeAll(function() {
+      actions.push('runner beforeAll1');
+    });
+
+    env.afterAll(function() {
+      actions.push('runner afterAll1');
+    });
+
+    env.beforeAll(function() {
+      actions.push('runner beforeAll2');
+    });
+
+    env.afterAll(function() {
+      actions.push('runner afterAll2');
+    });
+
     env.beforeEach(function () {
       actions.push('runner beforeEach1');
     });
@@ -212,6 +230,8 @@ describe("jasmine spec running", function () {
 
     var assertions = function() {
       var expected = [
+        "runner beforeAll1",
+        "runner beforeAll2",
         "runner beforeEach1",
         "runner beforeEach2",
         "beforeEach1",
@@ -220,7 +240,9 @@ describe("jasmine spec running", function () {
         "afterEach2",
         "afterEach1",
         "runner afterEach2",
-        "runner afterEach1"
+        "runner afterEach1",
+        "runner afterAll2",
+        "runner afterAll1"
       ];
       expect(actions).toEqual(expected);
       done();
@@ -475,7 +497,7 @@ describe("jasmine spec running", function () {
       env.execute();
     });
 
-    it('focused runnables unfocus ancestor focused suites', function() {
+    it('focused runnables unfocus ancestor focused suites', function(done) {
       var actions = [];
 
       env.fdescribe('focused suite', function() {
@@ -518,7 +540,29 @@ describe("jasmine spec running", function () {
     env.execute();
   });
 
-  it("should allow top level suites to be disabled", function() {
+  it("shouldn't run before/after functions in disabled suites", function(done) {
+    var shouldNotRun = jasmine.createSpy("shouldNotRun"),
+    suite = env.xdescribe('A disabled Suite', function() {
+      // None of the before/after functions should run.
+      env.beforeAll(shouldNotRun);
+      env.beforeEach(shouldNotRun);
+      env.afterEach(shouldNotRun);
+      env.afterAll(shouldNotRun);
+
+      env.it('spec inside a disabled suite', shouldNotRun);
+    });
+
+    var assertions = function() {
+      expect(shouldNotRun).not.toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it("should allow top level suites to be disabled", function(done) {
     var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
       otherSpec = jasmine.createSpy("otherSpec");
 
@@ -558,18 +602,16 @@ describe("jasmine spec running", function () {
 
   it("should recover gracefully when there are errors in describe functions", function(done) {
     var specs = [],
-      reporter = jasmine.createSpyObj(['specDone', 'jasmineDone']);
+      reporter = jasmine.createSpyObj(['specDone', 'suiteDone', 'jasmineDone']);
 
     reporter.specDone.and.callFake(function(result) {
       specs.push(result.fullName);
     });
 
     reporter.jasmineDone.and.callFake(function() {
-      expect(specs).toContain('outer1 inner1 should thingy');
-      expect(specs).toContain('outer1 inner1 encountered a declaration exception');
-      expect(specs).toContain('outer1 inner2 should other thingy');
-      expect(specs).toContain('outer1 encountered a declaration exception');
-      expect(specs).toContain('outer2 should xxx');
+      expect(specs).toEqual(['outer1 inner1 should thingy', 'outer1 inner2 should other thingy', 'outer2 should xxx']);
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1 inner1', [/inner error/]);
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1', [/outer error/]);
       done();
     });
 
@@ -580,7 +622,7 @@ describe("jasmine spec running", function () {
             this.expect(true).toEqual(true);
           });
 
-          throw new Error("fake error");
+          throw new Error("inner error");
         });
 
         env.describe("inner2", function() {
@@ -589,7 +631,7 @@ describe("jasmine spec running", function () {
           });
         });
 
-        throw new Error("fake error");
+        throw new Error("outer error");
 
       });
     }).not.toThrow();
@@ -698,8 +740,8 @@ describe("jasmine spec running", function () {
 
   it("should run the tests in a consistent order when a seed is supplied", function(done) {
     var actions = [];
-    env.randomizeTests(true);
     env.seed('123456');
+    env.randomizeTests(true);
 
     env.beforeEach(function () {
       actions.push('topSuite beforeEach');
@@ -794,4 +836,145 @@ describe("jasmine spec running", function () {
     env.execute();
   });
 
+  describe("When throwOnExpectationFailure is set", function() {
+    it("skips to cleanup functions after an error", function(done) {
+      var actions = [];
+
+      env.describe('Something', function() {
+        env.beforeEach(function() {
+          actions.push('outer beforeEach');
+          throw new Error("error");
+        });
+
+        env.afterEach(function() {
+          actions.push('outer afterEach');
+        });
+
+        env.describe('Inner', function() {
+          env.beforeEach(function() {
+            actions.push('inner beforeEach');
+          });
+
+          env.afterEach(function() {
+            actions.push('inner afterEach');
+          });
+
+          env.it('does it' , function() {
+            actions.push('inner it');
+          });
+        });
+      });
+
+      env.throwOnExpectationFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual([
+          'outer beforeEach',
+          'inner afterEach',
+          'outer afterEach'
+        ]);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.execute();
+    });
+
+    it("skips to cleanup functions after done.fail is called", function(done) {
+      var actions = [];
+
+      env.describe('Something', function() {
+        env.beforeEach(function(done) {
+          actions.push('beforeEach');
+          done.fail('error');
+          actions.push('after done.fail');
+        });
+
+        env.afterEach(function() {
+          actions.push('afterEach');
+        });
+
+        env.it('does it' , function() {
+          actions.push('it');
+        });
+      });
+
+      env.throwOnExpectationFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual([
+          'beforeEach',
+          'afterEach'
+        ]);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.execute();
+    });
+
+    it("skips to cleanup functions when an async function times out", function(done) {
+      var actions = [];
+
+      env.describe('Something', function() {
+        env.beforeEach(function(innerDone) {
+          actions.push('beforeEach');
+        }, 1);
+
+        env.afterEach(function() {
+          actions.push('afterEach');
+        });
+
+        env.it('does it' , function() {
+          actions.push('it');
+        });
+      });
+
+      env.throwOnExpectationFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual([
+          'beforeEach',
+          'afterEach'
+        ]);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.execute();
+    });
+  });
+
+  describe("when stopOnSpecFailure is on", function() {
+    it("does not run further specs when one fails", function(done) {
+      var actions = [];
+
+      env.describe('wrapper', function() {
+        env.it('fails', function() {
+          actions.push('fails');
+          env.expect(1).toBe(2);
+        });
+      });
+
+      env.describe('holder', function() {
+        env.it('does not run', function() {
+          actions.push('does not run');
+        });
+      });
+
+      env.randomizeTests(false);
+      env.stopOnSpecFailure(true);
+
+      var assertions = function() {
+        expect(actions).toEqual(['fails']);
+        done();
+      };
+
+      env.addReporter({ jasmineDone: assertions });
+      env.execute();
+    });
+  });
 });

spec/core/matchers/DiffBuilderSpec.js

@@ -0,0 +1,47 @@
+describe("DiffBuilder", function() {
+  it("records the actual and expected objects", function() {
+    var diffBuilder = jasmineUnderTest.DiffBuilder();
+    diffBuilder.record({x: 'actual'}, {x: 'expected'});
+
+    expect(diffBuilder.getMessage()).toEqual("Expected Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
+  });
+
+  it("prints the path at which the difference was found", function() {
+    var diffBuilder = jasmineUnderTest.DiffBuilder();
+
+    diffBuilder.withPath('foo', function() {
+      diffBuilder.record({x: 'actual'}, {x: 'expected'});
+    });
+
+    expect(diffBuilder.getMessage()).toEqual("Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
+  });
+
+  it("prints multiple messages, separated by newlines", function() {
+    var diffBuilder = jasmineUnderTest.DiffBuilder();
+
+    diffBuilder.withPath('foo', function() {
+      diffBuilder.record(1, 2);
+    });
+
+    var message =
+      "Expected $.foo = 1 to equal 2.\n" +
+      "Expected 3 to equal 4.";
+
+    diffBuilder.record(3, 4);
+    expect(diffBuilder.getMessage()).toEqual(message);
+  });
+
+  it("allows customization of the message", function() {
+    var diffBuilder = jasmineUnderTest.DiffBuilder();
+
+    function darthVaderFormatter(actual, expected, path) {
+      return "I find your lack of " + expected + " disturbing. (was " + actual + ", at " + path + ")"
+    }
+
+    diffBuilder.withPath('x', function() {
+      diffBuilder.record('bar', 'foo', darthVaderFormatter);
+    });
+
+    expect(diffBuilder.getMessage()).toEqual("I find your lack of foo disturbing. (was bar, at $.x)");
+  });
+});

spec/core/matchers/NullDiffBuilderSpec.js

@@ -0,0 +1,13 @@
+describe('NullDiffBuilder', function() {
+  it('responds to withPath() by calling the passed function', function() {
+    var spy = jasmine.createSpy('callback');
+    jasmineUnderTest.NullDiffBuilder().withPath('does not matter', spy);
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('responds to record()', function() {
+    expect(function() {
+      jasmineUnderTest.NullDiffBuilder().record('does not matter');
+    }).not.toThrow();
+  })
+});

spec/core/matchers/ObjectPathSpec.js

@@ -0,0 +1,43 @@
+describe('ObjectPath', function() {
+  var ObjectPath = jasmineUnderTest.ObjectPath;
+
+  it('represents the path to a node in an object tree', function() {
+    expect(new ObjectPath(['foo', 'bar']).toString()).toEqual('$.foo.bar');
+  });
+
+  it('has a depth', function() {
+    expect(new ObjectPath().depth()).toEqual(0);
+    expect(new ObjectPath(['foo']).depth()).toEqual(1);
+  });
+
+  it('renders numbers as array access', function() {
+    expect(new ObjectPath(['foo', 0]).toString()).toEqual('$.foo[0]');
+  });
+
+  it('renders properties that are valid identifiers with dot notation', function() {
+    expect(new ObjectPath(['foo123']).toString()).toEqual('$.foo123');
+    expect(new ObjectPath(['x_y']).toString()).toEqual('$.x_y');
+    expect(new ObjectPath(['A$B']).toString()).toEqual('$.A$B');
+  });
+
+  it('renders properties with non-identifier-safe characters with square bracket notation', function() {
+    expect(new ObjectPath(['a b c']).toString()).toEqual("$['a b c']");
+    expect(new ObjectPath(['1hello']).toString()).toEqual("$['1hello']");
+  });
+
+  it('renders as the empty string when empty', function() {
+    expect(new ObjectPath().toString()).toEqual('');
+  });
+
+  it('stringifies properties that are not strings or numbers', function() {
+    expect(new ObjectPath([{}]).toString()).toEqual("$['[object Object]']");
+  });
+
+  it('can be created based on another path', function() {
+    var root = new ObjectPath();
+    var path = root.add('foo');
+
+    expect(path.toString()).toEqual('$.foo');
+    expect(root.toString()).toEqual('');
+  })
+});

spec/core/matchers/matchersUtilSpec.js

@@ -61,13 +61,17 @@ describe("matchersUtil", function() {
       expect(jasmineUnderTest.matchersUtil.equals(foo, [undefined])).toBe(true);
     });
 
-    it("fails for Arrays that are not equivalent", function() {
+    it("fails for Arrays that have different lengths", function() {
       expect(jasmineUnderTest.matchersUtil.equals([1, 2], [1, 2, 3])).toBe(false);
     });
 
+    it("fails for Arrays that have different elements", function() {
+      expect(jasmineUnderTest.matchersUtil.equals([1, 2, 3], [1, 5, 3])).toBe(false);
+    });
+
     it("fails for Arrays whose contents are equivalent, but have differing properties", function() {
       var one = [1,2,3],
-          two = [1,2,3];
+        two = [1,2,3];
 
       one.foo = 'bar';
       two.foo = 'baz';
@@ -77,7 +81,7 @@ describe("matchersUtil", function() {
 
     it("passes for Arrays with equivalent contents and properties", function() {
       var one = [1,2,3],
-          two = [1,2,3];
+        two = [1,2,3];
 
       one.foo = 'bar';
       two.foo = 'bar';
@@ -118,7 +122,7 @@ describe("matchersUtil", function() {
 
     it("passes for Objects that are equivalent (with cycles)", function() {
       var actual = { a: "foo" },
-        expected = { a: "foo" };
+      expected = { a: "foo" };
 
       actual.b = actual;
       expected.b = actual;
@@ -136,6 +140,13 @@ describe("matchersUtil", function() {
       expect(jasmineUnderTest.matchersUtil.equals(actual, expected)).toBe(false);
     });
 
+    it("fails for Objects that have the same number of keys, but different keys/values", function () {
+      var expected = { a: undefined },
+        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 = {},
         emptyArray = [];
@@ -145,8 +156,6 @@ describe("matchersUtil", function() {
     });
 
     it("passes for equivalent frozen objects (GitHub issue #266)", function() {
-      if (jasmine.getEnv().ieVersion < 9) { return; }
-
       var a = { foo: 1 },
         b = {foo: 1 };
 
@@ -155,6 +164,16 @@ describe("matchersUtil", function() {
 
       expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
     });
+    
+    it("passes for equivalent Promises (GitHub issue #1314)", function() {
+      if (typeof Promise === 'undefined') { return; }
+
+      var p1 = new Promise(function () {}),
+        p2 = new Promise(function () {});
+
+      expect(jasmineUnderTest.matchersUtil.equals(p1, p1)).toBe(true);
+      expect(jasmineUnderTest.matchersUtil.equals(p1, p2)).toBe(false);
+    });
 
     describe("when running in a browser", function() {
       function isNotRunningInBrowser() {
@@ -180,10 +199,6 @@ describe("matchersUtil", function() {
         if (isNotRunningInBrowser()) {
           return;
         }
-        // iframe.contentWindow.eval isn't supported in ie8
-        if (jasmine.getEnv().ieVersion < 9) {
-          return;
-        }
         var iframe = document.createElement('iframe');
         document.body.appendChild(iframe);
         iframe.contentWindow.eval('window.testObject = {}');
@@ -196,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);
@@ -321,24 +336,32 @@ describe("matchersUtil", function() {
 
     it("passes for an asymmetric equality tester that returns true when a custom equality tester return false", function() {
       var asymmetricTester = { asymmetricMatch: function(other) { return true; } },
-          symmetricTester = function(a, b) { return false; };
+        symmetricTester = function(a, b) { return false; };
 
       expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, true, [symmetricTester])).toBe(true);
       expect(jasmineUnderTest.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
     });
 
+    it("passes custom equality matchers to asymmetric equality testers", function() {
+      var tester = function(a, b) {};
+      var asymmetricTester = { asymmetricMatch: jasmine.createSpy('asymmetricMatch') };
+      asymmetricTester.asymmetricMatch.and.returnValue(true);
+      var other = {};
+
+      expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, other, [tester])).toBe(true);
+      expect(asymmetricTester.asymmetricMatch).toHaveBeenCalledWith(other, [tester]);
+    });
+
     it("passes when an Any is compared to an Any that checks for the same type", function() {
       var any1 = new jasmineUnderTest.Any(Function),
-          any2 = new jasmineUnderTest.Any(Function);
+        any2 = new jasmineUnderTest.Any(Function);
 
       expect(jasmineUnderTest.matchersUtil.equals(any1, any2)).toBe(true);
     });
 
     it("passes for null prototype objects with same properties", function () {
-      if (jasmine.getEnv().ieVersion < 9) { return; }
-
       var objA = Object.create(null),
-          objB = Object.create(null);
+        objB = Object.create(null);
 
       objA.name = 'test';
       objB.name = 'test';
@@ -347,16 +370,203 @@ describe("matchersUtil", function() {
     });
 
     it("fails for null prototype objects with different properties", function () {
-      if (jasmine.getEnv().ieVersion < 9) { return; }
-
       var objA = Object.create(null),
-          objB = Object.create(null);
+        objB = Object.create(null);
 
       objA.name = 'test';
       objB.test = 'name';
 
       expect(jasmineUnderTest.matchersUtil.equals(objA, objB)).toBe(false);
     });
+
+    it("passes when comparing two empty sets", function() {
+      jasmine.getEnv().requireFunctioningSets();
+      expect(jasmineUnderTest.matchersUtil.equals(new Set(), new Set())).toBe(true);
+    });
+
+    it("passes when comparing identical sets", function() {
+      jasmine.getEnv().requireFunctioningSets();
+
+      var setA = new Set();
+      setA.add(6);
+      setA.add(5);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(5);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
+    });
+
+    it("passes when comparing identical sets with different insertion order and simple elements", function() {
+      jasmine.getEnv().requireFunctioningSets();
+
+      var setA = new Set();
+      setA.add(3);
+      setA.add(6);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(3);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
+    });
+
+    it("passes when comparing identical sets with different insertion order and complex elements 1", function() {
+      jasmine.getEnv().requireFunctioningSets();
+
+      var setA1 = new Set();
+      setA1.add(['a',3]);
+      setA1.add([6,1]);
+      var setA2 = new Set();
+      setA1.add(['y',3]);
+      setA1.add([6,1]);
+      var setA = new Set();
+      setA.add(setA1);
+      setA.add(setA2);
+
+
+      var setB1 = new Set();
+      setB1.add([6,1]);
+      setB1.add(['a',3]);
+      var setB2 = new Set();
+      setB1.add([6,1]);
+      setB1.add(['y',3]);
+      var setB = new Set();
+      setB.add(setB1);
+      setB.add(setB2);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
+    });
+
+    it("passes when comparing identical sets with different insertion order and complex elements 2", function() {
+      jasmine.getEnv().requireFunctioningSets();
+
+      var setA = new Set();
+      setA.add([[1,2], [3,4]]);
+      setA.add([[5,6], [7,8]]);
+      var setB = new Set();
+      setB.add([[5,6], [7,8]]);
+      setB.add([[1,2], [3,4]]);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
+    });
+
+    it("fails for sets with different elements", function() {
+      jasmine.getEnv().requireFunctioningSets();
+      var setA = new Set();
+      setA.add(6);
+      setA.add(3);
+      setA.add(5);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(4);
+      setB.add(5);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(false);
+    });
+
+    it("fails for sets of different size", function() {
+      jasmine.getEnv().requireFunctioningSets();
+      var setA = new Set();
+      setA.add(6);
+      setA.add(3);
+      var setB = new Set();
+      setB.add(6);
+      setB.add(4);
+      setB.add(5);
+
+      expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(false);
+    });
+
+    it("passes when comparing two empty maps", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      expect(jasmineUnderTest.matchersUtil.equals(new Map(), new Map())).toBe(true);
+    });
+
+    it("passes when comparing identical maps", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      var mapA = new Map();
+      mapA.set(6, 5);
+      var mapB = new Map();
+      mapB.set(6, 5);
+      expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(true);
+    });
+
+    it("passes when comparing identical maps with different insertion order", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      var mapA = new Map();
+      mapA.set("a", 3);
+      mapA.set(6, 1);
+      var mapB = new Map();
+      mapB.set(6, 1);
+      mapB.set("a", 3);
+      expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(true);
+    });
+
+    it("fails for maps with different elements", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      var mapA = new Map();
+      mapA.set(6, 3);
+      mapA.set(5, 1);
+      var mapB = new Map();
+      mapB.set(6, 4);
+      mapB.set(5, 1);
+
+      expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(false);
+    });
+
+    it("fails for maps of different size", function() {
+      jasmine.getEnv().requireFunctioningMaps();
+      var mapA = new Map();
+      mapA.set(6, 3);
+      var mapB = new Map();
+      mapB.set(6, 4);
+      mapB.set(5, 1);
+      expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(false);
+    });
+
+    describe("when running in an environment with array polyfills", function() {
+      var findIndexDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'findIndex');
+      if (!findIndexDescriptor) {
+        return;
+      }
+
+      beforeEach(function() {
+        Object.defineProperty(Array.prototype, 'findIndex', {
+          enumerable: true,
+          value: function (predicate) {
+            if (this === null) {
+              throw new TypeError('Array.prototype.findIndex called on null or undefined');
+            }
+
+            if (typeof predicate !== 'function') {
+              throw new TypeError('predicate must be a function');
+            }
+
+            var list = Object(this);
+            var length = list.length >>> 0;
+            var thisArg = arguments[1];
+            var value;
+
+            for (var i = 0; i < length; i++) {
+              value = list[i];
+              if (predicate.call(thisArg, value, i, list)) {
+                return i;
+              }
+            }
+
+            return -1;
+          }
+        });
+      });
+
+      afterEach(function() {
+        Object.defineProperty(Array.prototype, 'findIndex', findIndexDescriptor);
+      });
+
+      it("passes when there's an array polyfill", function() {
+        expect(['foo']).toEqual(['foo']);
+      });
+    });
   });
 
   describe("contains", function() {

spec/core/matchers/nothingSpec.js

@@ -0,0 +1,8 @@
+describe('nothing', function() {
+  it('should pass', function() {
+    var matcher = jasmineUnderTest.matchers.nothing(),
+      result = matcher.compare();
+
+    expect(result.pass).toBe(true);
+  });
+});

spec/core/matchers/toBeCloseToSpec.js

@@ -8,6 +8,9 @@ describe("toBeCloseTo", function() {
 
     result = matcher.compare(0, 0.001);
     expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.005);
+    expect(result.pass).toBe(true);
   });
 
   it("fails when not within two decimal places by default", function() {
@@ -16,6 +19,9 @@ describe("toBeCloseTo", function() {
 
     result = matcher.compare(0, 0.01);
     expect(result.pass).toBe(false);
+
+    result = matcher.compare(0, 0.05);
+    expect(result.pass).toBe(false);
   });
 
   it("accepts an optional precision argument", function() {
@@ -25,8 +31,36 @@ describe("toBeCloseTo", function() {
     result = matcher.compare(0, 0.1, 0);
     expect(result.pass).toBe(true);
 
+    result = matcher.compare(0, 0.5, 0);
+    expect(result.pass).toBe(true);
+
     result = matcher.compare(0, 0.0001, 3);
     expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.0005, 3);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.00001, 4);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.00005, 4);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when one of the arguments is null", function() {
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo();
+
+    expect(function() {
+      matcher.compare(null, null);
+    }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(null).');
+
+    expect(function() {
+      matcher.compare(0, null);
+    }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(0).toBeCloseTo(null).');
+
+    expect(function() {
+      matcher.compare(null, 0);
+    }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).');
   });
 
   it("rounds expected values", function() {
@@ -42,7 +76,15 @@ describe("toBeCloseTo", function() {
     result = matcher.compare(1.23, 1.225);
     expect(result.pass).toBe(true);
 
+    result = matcher.compare(1.23, 1.235);
+    expect(result.pass).toBe(true);
+
+    // 1.2249999 will be rounded to 1.225
     result = matcher.compare(1.23, 1.2249999);
+    expect(result.pass).toBe(true);
+
+    // 1.2249999 will be rounded to 1.224
+    result = matcher.compare(1.23, 1.2244999);
     expect(result.pass).toBe(false);
 
     result = matcher.compare(1.23, 1.234);

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(),

spec/core/matchers/toBeNegativeInfinitySpec.js

@@ -0,0 +1,31 @@
+describe("toBeNegativeInfinity", function() {
+  it("fails for anything that isn't -Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+      result;
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(Number.NaN);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(false);
+  });
+
+  it("has a custom message on failure", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+      result = matcher.compare(0);
+
+    expect(result.message()).toEqual("Expected 0 not to be -Infinity.")
+  });
+
+  it("succeeds for -Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+      result = matcher.compare(Number.NEGATIVE_INFINITY);
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected actual to be -Infinity.")
+  });
+
+});

spec/core/matchers/toBePositiveInfinitySpec.js

@@ -0,0 +1,31 @@
+describe("toBePositiveInfinity", function() {
+  it("fails for anything that isn't Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+      result;
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(Number.NaN);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(false);
+  });
+
+  it("has a custom message on failure", function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+      result = matcher.compare(0);
+
+    expect(result.message()).toEqual("Expected 0 not to be Infinity.")
+  });
+
+  it("succeeds for Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+      result = matcher.compare(Number.POSITIVE_INFINITY);
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected actual to be Infinity.")
+  });
+
+});

spec/core/matchers/toEqualSpec.js

@@ -1,20 +1,39 @@
 describe("toEqual", function() {
+  "use strict";
+
+  function compareEquals(actual, expected) {
+    var util = jasmineUnderTest.matchersUtil,
+      matcher = jasmineUnderTest.matchers.toEqual(util);
+
+    var result = matcher.compare(actual, expected);
+
+    return result;
+  }
+
   it("delegates to equals function", function() {
     var util = {
-        equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
+        equals: jasmine.createSpy('delegated-equals').and.returnValue(true),
+        buildFailureMessage: function() {
+          return 'does not matter'
+        },
+        DiffBuilder: jasmineUnderTest.matchersUtil.DiffBuilder
       },
       matcher = jasmineUnderTest.matchers.toEqual(util),
       result;
 
     result = matcher.compare(1, 1);
 
-    expect(util.equals).toHaveBeenCalledWith(1, 1, []);
+    expect(util.equals).toHaveBeenCalledWith(1, 1, [], jasmine.anything());
     expect(result.pass).toBe(true);
   });
 
   it("delegates custom equality testers, if present", function() {
     var util = {
-        equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
+        equals: jasmine.createSpy('delegated-equals').and.returnValue(true),
+        buildFailureMessage: function() {
+          return 'does not matter'
+        },
+        DiffBuilder: jasmineUnderTest.matchersUtil.DiffBuilder
       },
       customEqualityTesters = ['a', 'b'],
       matcher = jasmineUnderTest.matchers.toEqual(util, customEqualityTesters),
@@ -22,7 +41,813 @@ describe("toEqual", function() {
 
     result = matcher.compare(1, 1);
 
-    expect(util.equals).toHaveBeenCalledWith(1, 1, ['a', 'b']);
+    expect(util.equals).toHaveBeenCalledWith(1, 1, ['a', 'b'], jasmine.anything());
     expect(result.pass).toBe(true);
   });
+
+  it("reports the difference between objects that are not equal", function() {
+    var actual = {x: 1, y: 3},
+      expected = {x: 2, y: 3},
+      message = "Expected $.x = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports the difference between nested objects that are not equal", function() {
+    var actual = {x: {y: 1}},
+      expected = {x: {y: 2}},
+      message = "Expected $.x.y = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("formats property access so that it's valid JavaScript", function() {
+    var actual = {'my prop': 1},
+      expected = {'my prop': 2},
+      message = "Expected $['my prop'] = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports missing properties", function() {
+    var actual = {x: {}},
+      expected = {x: {y: 1}},
+      message =
+        "Expected $.x to have properties\n" +
+        "    y: 1";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports extra properties", function() {
+    var actual = {x: {y: 1, z: 2}},
+      expected = {x: {}},
+      message =
+        "Expected $.x not to have properties\n" +
+        "    y: 1\n" +
+        "    z: 2";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("pretty-prints properties", function() {
+    var actual = {x: {y: 'foo bar'}},
+      expected = {x: {}},
+      message =
+        "Expected $.x not to have properties\n" +
+        "    y: 'foo bar'";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports extra and missing properties together", function() {
+    var actual = {x: {y: 1, z: 2, f: 4}},
+      expected = {x: {y: 1, z: 2, g: 3}},
+      message =
+        "Expected $.x to have properties\n" +
+        "    g: 3\n" +
+        "Expected $.x not to have properties\n" +
+        "    f: 4";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports extra and missing properties of the root-level object", function() {
+    var actual = {x: 1},
+      expected = {a: 1},
+      message =
+        "Expected object to have properties\n" +
+        "    a: 1\n" +
+        "Expected object not to have properties\n" +
+        "    x: 1";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports multiple incorrect values", function() {
+    var actual = {x: 1, y: 2},
+      expected = {x: 3, y: 4},
+      message =
+        "Expected $.x = 1 to equal 3.\n" +
+        "Expected $.y = 2 to equal 4.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatch between actual child object and expected child number", function() {
+    var actual = {x: {y: 2}},
+      expected = {x: 1},
+      message = "Expected $.x = Object({ y: 2 }) to equal 1.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("uses the default failure message if actual is not an object", function() {
+    var actual = 1,
+      expected = {x: {}},
+      message = "Expected 1 to equal Object({ x: Object({  }) }).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("uses the default failure message if expected is not an object", function() {
+    var actual = {x: {}},
+      expected = 1,
+      message = "Expected Object({ x: Object({  }) }) to equal 1.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("uses the default failure message given arrays with different lengths", function() {
+    var actual = [1, 2],
+      expected = [1, 2, 3],
+      message = 'Expected $.length = 2 to equal 3.\n' +
+        'Expected $[2] = undefined to equal 3.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between elements of equal-length arrays", function() {
+    var actual = [1, 2, 5],
+      expected = [1, 2, 3],
+      message = "Expected $[2] = 5 to equal 3.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between multiple array elements", function() {
+    var actual = [2, 2, 5],
+      expected = [1, 2, 3],
+      message =
+        "Expected $[0] = 2 to equal 1.\n" +
+        "Expected $[2] = 5 to equal 3.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between properties of objects in arrays", function() {
+    var actual = [{x: 1}],
+      expected = [{x: 2}],
+      message = "Expected $[0].x = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between arrays in objects", function() {
+    var actual = {x: [1]},
+      expected = {x: [2]},
+      message =
+        "Expected $.x[0] = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between nested arrays", function() {
+    var actual = [[1]],
+      expected = [[2]],
+      message =
+        "Expected $[0][0] = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between arrays of different types", function() {
+    jasmine.getEnv().requireFunctioningTypedArrays();
+
+    var actual = new Uint32Array([1, 2, 3]),
+      expected = new Uint16Array([1, 2, 3]),
+      message = "Expected Uint32Array [ 1, 2, 3 ] to equal Uint16Array [ 1, 2, 3 ].";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving NaN", function() {
+    var actual = {x: 0},
+      expected = {x: 0/0},
+      message = "Expected $.x = 0 to equal NaN.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving regular expressions", function() {
+    var actual = {x: '1'},
+      expected = {x: /1/},
+      message = "Expected $.x = '1' to equal /1/.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving infinities", function() {
+    var actual = {x: 0},
+      expected = {x: 1/0},
+      message = "Expected $.x = 0 to equal Infinity.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving booleans", function() {
+    var actual = {x: false},
+      expected = {x: true},
+      message = "Expected $.x = false to equal true.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving strings", function() {
+    var actual = {x: 'foo'},
+      expected = {x: 'bar'},
+      message = "Expected $.x = 'foo' to equal 'bar'.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving undefined", function() {
+    var actual = {x: void 0},
+      expected = {x: 0},
+      message = "Expected $.x = undefined to equal 0.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving null", function() {
+    var actual = {x: null},
+      expected = {x: 0},
+      message = "Expected $.x = null to equal 0.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between objects with different constructors", function () {
+    function Foo() {}
+    function Bar() {}
+
+    var actual = {x: new Foo()},
+        expected = {x: new Bar()},
+        message = "Expected $.x to be a kind of Bar, but was Foo({  }).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports type mismatches at the root level", function () {
+    function Foo() {}
+    function Bar() {}
+
+    var actual = new Foo(),
+      expected = new Bar(),
+      message = "Expected object to be a kind of Bar, but was Foo({  }).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between objects with their own constructor property", function () {
+    function Foo() {}
+    function Bar() {}
+
+    var actual = {x: {constructor: 'blerf'}},
+        expected = {x: {constructor: 'ftarrh'}},
+        message = "Expected $.x.constructor = 'blerf' to equal 'ftarrh'.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between an object with a real constructor and one with its own constructor property", function () {
+    function Foo() {}
+    function Bar() {}
+
+    var actual = {x: {}},
+      expected = {x: {constructor: 'ftarrh'}},
+      message =
+        "Expected $.x to have properties\n" +
+        "    constructor: 'ftarrh'";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+    expect(compareEquals(expected, actual).message).toEqual(
+      "Expected $.x not to have properties\n    constructor: 'ftarrh'"
+    );
+  });
+
+  it("reports mismatches between 0 and -0", function() {
+    var actual = {x: 0},
+      expected = {x: -0},
+      message = "Expected $.x = 0 to equal -0.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Errors", function() {
+    var actual = {x: new Error("the error you got")},
+      expected = {x: new Error("the error you want")},
+      message = "Expected $.x = Error: the error you got to equal Error: the error you want.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Functions", function() {
+    var actual = {x: function() {}},
+      expected = {x: function() {}},
+      message = "Expected $.x = Function to equal Function.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  // == Sets ==
+
+  it("reports mismatches between Sets", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actual = new Set();
+    actual.add(1);
+    var expected = new Set();
+    expected.add(2);
+    var message = 'Expected Set( 1 ) to equal Set( 2 ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports deep mismatches within Sets", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actual = new Set();
+    actual.add({x: 1});
+    var expected = new Set();
+    expected.add({x: 2});
+    var message = 'Expected Set( Object({ x: 1 }) ) to equal Set( Object({ x: 2 }) ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets nested in objects", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actualSet = new Set();
+    actualSet.add(1);
+    var expectedSet = new Set();
+    expectedSet.add(2);
+
+    var actual = { sets: [actualSet] };
+    var expected = { sets: [expectedSet] };
+    var message = "Expected $.sets[0] = Set( 1 ) to equal Set( 2 ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets of different lengths", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actual = new Set();
+    actual.add(1);
+    actual.add(2);
+    var expected = new Set();
+    expected.add(2);
+    var message = 'Expected Set( 1, 2 ) to equal Set( 2 ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets where actual is missing a value from expected", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    // Use 'duplicate' object in actual so sizes match
+    var actual = new Set();
+    actual.add({x: 1});
+    actual.add({x: 1});
+    var expected = new Set();
+    expected.add({x: 1});
+    expected.add({x: 2});
+    var message = 'Expected Set( Object({ x: 1 }), Object({ x: 1 }) ) to equal Set( Object({ x: 1 }), Object({ x: 2 }) ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets where actual has a value missing from expected", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    // Use 'duplicate' object in expected so sizes match
+    var actual = new Set();
+    actual.add({x: 1});
+    actual.add({x: 2});
+    var expected = new Set();
+    expected.add({x: 1});
+    expected.add({x: 1});
+    var message = 'Expected Set( Object({ x: 1 }), Object({ x: 2 }) ) to equal Set( Object({ x: 1 }), Object({ x: 1 }) ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  // == Maps ==
+
+  it("does not report mismatches between deep equal Maps", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    // values are the same but with different object identity
+    var actual = new Map();
+    actual.set('a',{x:1});
+    var expected = new Map();
+    expected.set('a',{x:1});
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("reports deep mismatches within Maps", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = new Map();
+    actual.set('a',{x:1});
+    var expected = new Map();
+    expected.set('a',{x:2});
+    var message = "Expected Map( [ 'a', Object({ x: 1 }) ] ) to equal Map( [ 'a', Object({ x: 2 }) ] ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Maps nested in objects", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = {Maps:[new Map()]};
+    actual.Maps[0].set('a',1);
+    var expected = {Maps:[new Map()]};
+    expected.Maps[0].set('a',2);
+
+    var message = "Expected $.Maps[0] = Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ] ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Maps of different lengths", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = new Map();
+    actual.set('a',1);
+    var expected = new Map();
+    expected.set('a',2);
+    expected.set('b',1);
+    var message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'a', 2 ], [ 'b', 1 ] ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Maps with equal values but differing keys", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = new Map();
+    actual.set('a',1);
+    var expected = new Map();
+    expected.set('b',1);
+    var message = "Expected Map( [ 'a', 1 ] ) to equal Map( [ 'b', 1 ] ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("does not report mismatches between Maps with keys with same object identity", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    var  key = {x: 1};
+    var actual = new Map();
+    actual.set(key,2);
+    var expected = new Map();
+    expected.set(key,2);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("reports mismatches between Maps with identical keys with different object identity", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = new Map();
+    actual.set({x:1},2);
+    var expected = new Map();
+    expected.set({x:1},2);
+    var message = "Expected Map( [ Object({ x: 1 }), 2 ] ) to equal Map( [ Object({ x: 1 }), 2 ] ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("does not report mismatches when comparing Map key to jasmine.anything()", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var actual = new Map();
+    actual.set('a',1);
+    var expected = new Map();
+    expected.set(jasmineUnderTest.anything(),1);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("does not report mismatches when comparing Maps with the same symbol keys", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var key = Symbol();
+    var actual = new Map();
+    actual.set(key,1);
+    var expected = new Map();
+    expected.set(key,1);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  it("reports mismatches between Maps with different symbol keys", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var actual = new Map();
+    actual.set(Symbol(),1);
+    var expected = new Map();
+    expected.set(Symbol(),1);
+    var message = "Expected Map( [ Symbol(), 1 ] ) to equal Map( [ Symbol(), 1 ] ).";
+
+    expect(compareEquals(actual, expected).message).toBe(message);
+  });
+
+  it("does not report mismatches when comparing Map symbol key to jasmine.anything()", function() {
+    jasmine.getEnv().requireFunctioningMaps();
+    jasmine.getEnv().requireFunctioningSymbols();
+
+    var actual = new Map();
+    actual.set(Symbol(),1);
+    var expected = new Map();
+    expected.set(jasmineUnderTest.anything(),1);
+
+    expect(compareEquals(actual, expected).pass).toBe(true);
+  });
+
+  describe('DOM nodes', function() {
+    function isNotRunningInBrowser() {
+      return typeof document === 'undefined'
+    }
+
+    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);
+    });
+
+    it('reports mismatches between DOM nodes with different content', function() {
+      var nodeA = this.doc.createElement('div'),
+      nodeB = this.doc.createElement('div');
+
+      nodeA.setAttribute('thing', 'foo');
+      nodeB.setAttribute('thing', 'bar');
+
+      expect(nodeA.isEqualNode(nodeB)).toBe(false);
+      var actual = {a: nodeA},
+      expected = {a: nodeB},
+      message = 'Expected $.a = <div thing="foo"> to equal <div thing="bar">.';
+
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    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);
+    });
+  });
+
+  it("reports asymmetric mismatches", function() {
+    var actual = {a: 1},
+      expected = {a: jasmineUnderTest.any(String)},
+      message = 'Expected $.a = 1 to equal <jasmine.any(String)>.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+    expect(compareEquals(actual, expected).pass).toBe(false)
+  });
+
+  it("reports asymmetric mismatches when the asymmetric comparand is the actual value", function() {
+    var actual = {a: jasmineUnderTest.any(String)},
+      expected = {a: 1},
+      message = 'Expected $.a = <jasmine.any(String)> to equal 1.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+    expect(compareEquals(actual, expected).pass).toBe(false)
+  });
+
+  it("does not report a mismatch when asymmetric matchers are satisfied", function() {
+    var actual = {a: 'a'},
+      expected = {a: jasmineUnderTest.any(String)};
+
+    expect(compareEquals(actual, expected).message).toEqual('');
+    expect(compareEquals(actual, expected).pass).toBe(true)
+  });
+
+  it("works on big complex stuff", function() {
+    var actual = {
+      foo: [
+        {bar: 1, things: ['a', 'b']},
+        {bar: 2, things: ['a', 'b']}
+      ],
+      baz: [
+        {a: {b: 1}}
+      ],
+      quux: 1,
+      nan: 0,
+      aRegexp: 'hi',
+      inf: -1/0,
+      boolean: false,
+      notDefined: 0,
+      aNull: void 0
+    };
+
+    var expected = {
+      foo: [
+        {bar: 2, things: ['a', 'b', 'c']},
+        {bar: 2, things: ['a', 'd']}
+      ],
+      baz: [
+        {a: {b: 1, c: 1}}
+      ],
+      quux: [],
+      nan: 0/0,
+      aRegexp: /hi/,
+      inf: 1/0,
+      boolean: true,
+      notDefined: void 0,
+      aNull: null
+    };
+
+    var message =
+      'Expected $.foo[0].bar = 1 to equal 2.\n' +
+      'Expected $.foo[0].things.length = 2 to equal 3.\n' +
+      "Expected $.foo[0].things[2] = undefined to equal 'c'.\n" +
+      "Expected $.foo[1].things[1] = 'b' to equal 'd'.\n" +
+      'Expected $.baz[0].a to have properties\n' +
+      '    c: 1\n' +
+      'Expected $.quux = 1 to equal [  ].\n' +
+      'Expected $.nan = 0 to equal NaN.\n' +
+      "Expected $.aRegexp = 'hi' to equal /hi/.\n" +
+      '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.';
+
+    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' +
+          'Unexpected $[4] = 5 in array.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("expected array is longer", function() {
+      var actual = [1, 1, 2, 3],
+        expected = [1, 1, 2, 3, 5],
+        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).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);
+    });
+
+    it("expected array is longer by 4 elements", function() {
+      var actual = [1, 1, 2],
+        expected = [1, 1, 2, 3, 5, 8, 13],
+        message = 'Expected $.length = 3 to equal 7.\n' +
+          'Expected $[3] = undefined to equal 3.\n' +
+          'Expected $[4] = undefined to equal 5.\n' +
+          'Expected $[5] = undefined to equal 8.\n' +
+          'Expected $[6] = undefined to equal 13.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("different length and different elements", function() {
+      var actual = [1],
+        expected = [2, 3],
+        message = 'Expected $.length = 1 to equal 2.\n' +
+          'Expected $[0] = 1 to equal 2.\n' +
+          'Expected $[1] = undefined to equal 3.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    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' +
+          'Unexpected $.values[3] = 3 in array.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    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' +
+          'Unexpected $[3] = Object({ value: 3 }) in array.';
+
+      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);
+    });
+
+    it("array with nested different length array", function() {
+      var actual = [[1], [1, 2]],
+        expected = [[1, 1], [2]],
+        message = 'Expected $[0].length = 1 to equal 2.\n' +
+          'Expected $[0][1] = undefined to equal 1.\n' +
+          'Expected $[1].length = 2 to equal 1.\n' +
+          'Expected $[1][0] = 1 to equal 2.\n' +
+          'Unexpected $[1][1] = 2 in array.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+
+    it("last element of longer array is undefined", function() {
+      var actual = [1, 2],
+        expected = [1, 2, void 0],
+        message = 'Expected $.length = 2 to equal 3.';
+
+      expect(compareEquals(actual, expected).pass).toBe(false);
+      expect(compareEquals(actual, expected).message).toEqual(message);
+    });
+  })
 });

spec/core/matchers/toHaveBeenCalledBeforeSpec.js

@@ -0,0 +1,99 @@
+describe("toHaveBeenCalledBefore", function() {
+  it("throws an exception when the actual is not a spy", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        fn = function() {},
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy');
+
+    expect(function() { matcher.compare(fn, secondSpy) }).toThrowError(Error, /Expected a spy, but got Function./);
+  });
+
+  it("throws an exception when the expected is not a spy", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        fn = function() {};
+
+    expect(function() { matcher.compare(firstSpy, fn) }).toThrowError(Error, /Expected a spy, but got Function./);
+  });
+
+  it("fails when the actual was not called", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy');
+
+    secondSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toMatch(/Expected spy first spy to have been called./);
+  });
+
+  it("fails when the expected was not called", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy');
+
+    firstSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toMatch(/Expected spy second spy to have been called./);
+  });
+
+  it("fails when the actual is called after the expected", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy'),
+        result;
+
+    secondSpy();
+    firstSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual('Expected spy first spy to have been called before spy second spy');
+  });
+
+	it("fails when the actual is called before and after the expected", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy'),
+        result;
+
+    firstSpy();
+    secondSpy();
+    firstSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual('Expected latest call to spy first spy to have been called before first call to spy second spy (no interleaved calls)');
+  });
+
+	it("fails when the expected is called before and after the actual", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy'),
+        result;
+
+    secondSpy();
+    firstSpy();
+    secondSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual('Expected first call to spy second spy to have been called after latest call to spy first spy (no interleaved calls)');
+  });
+
+  it("passes when the actual is called before the expected", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = new jasmineUnderTest.Env().createSpy('first spy'),
+        secondSpy = new jasmineUnderTest.Env().createSpy('second spy'),
+        result;
+
+    firstSpy();
+    secondSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual('Expected spy first spy to not have been called before spy second spy, but it was');
+  });
+});

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -1,7 +1,7 @@
 describe("toHaveBeenCalled", function() {
   it("passes when the actual was called, with a custom .not fail message", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      calledSpy = jasmineUnderTest.createSpy('called-spy'),
+      calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
       result;
 
     calledSpy();
@@ -13,7 +13,7 @@ describe("toHaveBeenCalled", function() {
 
   it("fails when the actual was not called", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
+      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
       result;
 
     result = matcher.compare(uncalledSpy);
@@ -29,14 +29,14 @@ describe("toHaveBeenCalled", function() {
 
   it("throws an exception when invoked with any arguments", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      spy = jasmineUnderTest.createSpy('sample spy');
+      spy = new jasmineUnderTest.Env().createSpy('sample spy');
 
     expect(function() { matcher.compare(spy, 'foo') }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
   });
 
   it("has a custom message on failure", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      spy = jasmineUnderTest.createSpy('sample-spy'),
+      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
       result;
 
     result = matcher.compare(spy);

spec/core/matchers/toHaveBeenCalledTimesSpec.js

@@ -1,14 +1,14 @@
 describe("toHaveBeenCalledTimes", function() {
   it("passes when the actual 0 matches the expected 0 ", function () {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-        calledSpy = jasmineUnderTest.createSpy('called-spy'),
+        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
         result;
     result = matcher.compare(calledSpy, 0);
     expect(result.pass).toBeTruthy();
   });
   it("passes when the actual matches the expected", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      calledSpy = jasmineUnderTest.createSpy('called-spy'),
+      calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
       result;
     calledSpy();
 
@@ -18,7 +18,7 @@ describe("toHaveBeenCalledTimes", function() {
 
   it("fails when expected numbers is not supplied", function(){
      var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = jasmineUnderTest.createSpy('spy'),
+      spy = new jasmineUnderTest.Env().createSpy('spy'),
       result;
 
     spy();
@@ -29,7 +29,7 @@ describe("toHaveBeenCalledTimes", function() {
 
   it("fails when the actual was called less than the expected", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
+      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
       result;
 
     result = matcher.compare(uncalledSpy, 2);
@@ -38,7 +38,7 @@ describe("toHaveBeenCalledTimes", function() {
 
   it("fails when the actual was called more than expected", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
+      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
       result;
 
     uncalledSpy();
@@ -59,7 +59,7 @@ describe("toHaveBeenCalledTimes", function() {
 
   it("has a custom message on failure that tells it was called only once", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = jasmineUnderTest.createSpy('sample-spy'),
+      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
       result;
     spy();
     spy();
@@ -72,7 +72,7 @@ describe("toHaveBeenCalledTimes", function() {
 
   it("has a custom message on failure that tells how many times it was called", function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = jasmineUnderTest.createSpy('sample-spy'),
+      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
       result;
     spy();
     spy();

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -5,7 +5,7 @@ describe("toHaveBeenCalledWith", function() {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
         },
         matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        calledSpy = jasmineUnderTest.createSpy('called-spy'),
+        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
         result;
 
     calledSpy('a', 'b');
@@ -21,7 +21,7 @@ describe("toHaveBeenCalledWith", function() {
         },
         customEqualityTesters = [function() { return true; }],
         matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util, customEqualityTesters),
-        calledSpy = jasmineUnderTest.createSpy('called-spy');
+        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy');
 
     calledSpy('a', 'b');
     matcher.compare(calledSpy, 'a', 'b');
@@ -34,7 +34,7 @@ describe("toHaveBeenCalledWith", function() {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
         },
         matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        uncalledSpy = jasmineUnderTest.createSpy('uncalled spy'),
+        uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
         result;
 
     result = matcher.compare(uncalledSpy);
@@ -47,7 +47,7 @@ describe("toHaveBeenCalledWith", function() {
           contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
         },
         matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        calledSpy = jasmineUnderTest.createSpy('called spy'),
+        calledSpy = new jasmineUnderTest.Env().createSpy('called spy'),
         result;
 
     calledSpy('a');

spec/core/matchers/toHaveClassSpec.js

@@ -0,0 +1,69 @@
+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(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 = this.createElementWithClassName('foo bar baz');
+
+    expect(matcher.compare(el, 'foo').pass).toBe(true);
+    expect(matcher.compare(el, 'bar').pass).toBe(true);
+    expect(matcher.compare(el, 'bar').pass).toBe(true);
+  });
+
+  it('fails for a DOM element that only has other classes', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveClass(),
+      el = this.createElementWithClassName('foo bar');
+
+    expect(matcher.compare(el, 'fo').pass).toBe(false);
+  });
+
+  it('throws an exception when actual is not a DOM element', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveClass();
+
+    expect(function() {
+      matcher.compare('x', 'foo');
+    }).toThrowError("'x' is not a DOM element");
+
+    expect(function() {
+      matcher.compare(undefined, 'foo');
+    }).toThrowError('undefined is not a DOM element');
+
+    var textNode = this.doc.createTextNode('');
+    expect(function() {
+      matcher.compare(textNode, 'foo')
+    }).toThrowError('HTMLNode is not a DOM element');
+
+    expect(function() {
+      matcher.compare({classList: ''}, 'foo');
+    }).toThrowError("Object({ classList: '' }) is not a DOM element");
+  });
+});

spec/core/matchers/toThrowErrorSpec.js

@@ -65,6 +65,43 @@ describe("toThrowError", function() {
     expect(result.message()).toEqual("Expected function to throw an Error, but it threw 4.");
   });
 
+  describe("when error is from another frame", function() {
+    function isNotRunningInBrowser() {
+      return typeof document === 'undefined'
+    }
+
+    var iframe = null;
+
+    afterEach(function() {
+      if (iframe !== null) {
+        document.body.removeChild(iframe);
+      }
+    });
+
+    it("passes if thrown is an instanceof Error regardless of global that contains its constructor", function() {
+      if (isNotRunningInBrowser()) {
+        return;
+      }
+
+      var matcher = jasmineUnderTest.matchers.toThrowError();
+      iframe = document.body.appendChild(document.createElement("iframe"));
+      iframe.src = "about:blank";
+      var iframeDocument = iframe.contentWindow.document;
+
+      if (iframeDocument.body) {
+        iframeDocument.body.appendChild(iframeDocument.createElement("script"))
+        .textContent = "function method() { throw new Error('foo'); }";
+      } else {
+        // IE 10 and older
+        iframeDocument.write("<html><head><script>function method() { throw new Error('foo'); }</script></head></html>");
+      }
+
+      var result = matcher.compare(iframe.contentWindow.method);
+      expect(result.pass).toBe(true);
+      expect(result.message).toEqual("Expected function not to throw an Error, but it threw Error.");
+    });
+  });
+
   it("fails with the correct message if thrown is a falsy value", function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {

spec/core/matchers/toThrowMatchingSpec.js

@@ -0,0 +1,73 @@
+describe("toThrowMatching", function() {
+  it("throws an error when the actual is not a function", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching();
+
+    expect(function() {
+      matcher.compare({}, function() { return true; });
+    }).toThrowError(/Actual is not a Function/);
+  });
+
+  it("throws an error when the expected is not a function", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+      fn = function() {
+        throw new Error("foo");
+      };
+
+    expect(function() {
+      matcher.compare(fn, 1);
+    }).toThrowError(/Predicate is not a Function/);
+  });
+
+  it("fails if actual does not throw at all", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+      fn = function() {
+        return true;
+      },
+      result;
+
+    result = matcher.compare(fn, function() { return true; });
+
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual("Expected function to throw an exception.");
+  });
+
+  it("fails with the correct message if thrown is a falsy value", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+      fn = function() {
+        throw undefined;
+      },
+      result;
+
+    result = matcher.compare(fn, function() { return false; });
+    expect(result.pass).toBe(false);
+    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw undefined.");
+  });
+
+  it("passes if the argument is a function that returns true when called with the error", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+    predicate = function(e) { return e.message === "nope" },
+      fn = function() {
+        throw new TypeError("nope");
+      },
+      result;
+
+    result = matcher.compare(fn, predicate);
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected function not to throw an exception matching a predicate.");
+  });
+
+  it("fails if the argument is a function that returns false when called with the error", function() {
+    var matcher = jasmineUnderTest.matchers.toThrowMatching(),
+    predicate = function(e) { return e.message === "oh no" },
+      fn = function() {
+        throw new TypeError("nope");
+      },
+      result;
+
+    result = matcher.compare(fn, predicate);
+
+    expect(result.pass).toBe(false);
+    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'.");
+  });
+});

spec/helpers/BrowserFlags.js

@@ -8,14 +8,6 @@
     return match ? parseFloat(match[1]) : void 0;
   }
 
-  env.ieVersion = browserVersion(function(userAgent) {
-    return /MSIE ([0-9]{1,}[\.0-9]{0,})/.exec(userAgent);
-  });
-
-  env.safariVersion = browserVersion(function(userAgent) {
-    return /Safari/.exec(userAgent) && /Version\/([0-9]{0,})/.exec(userAgent);
-  });
-
   env.firefoxVersion = browserVersion(function(userAgent) {
     return /Firefox\/([0-9]{0,})/.exec(userAgent);
   });

spec/helpers/asyncAwait.js

@@ -0,0 +1,27 @@
+(function(env) {
+  function getAsyncCtor() {
+    try {
+      eval("var func = async function(){};");
+    } catch (e) {
+      return null;
+    }
+
+    return Object.getPrototypeOf(func).constructor;
+  }
+
+  function hasAsyncAwaitSupport() {
+    return getAsyncCtor() !== null;
+  }
+
+  env.makeAsyncAwaitFunction = function() {
+    var AsyncFunction = getAsyncCtor();
+    return new AsyncFunction("");
+  };
+
+  env.requireAsyncAwait = function() {
+    if (!hasAsyncAwaitSupport()) {
+      env.pending("Environment does not support async/await functions");
+    }
+  };
+})(jasmine.getEnv());
+

spec/helpers/checkForMap.js

@@ -0,0 +1,37 @@
+(function(env) {
+  function hasFunctioningMaps() {
+    if (typeof Map === 'undefined') { return false; }
+
+    try {
+      var s = new Map();
+      s.set('a',1);
+      s.set('b',2);
+
+      if (s.size !== 2) { return false; }
+      if (s.has('a') !== true) { return false; }
+
+      var iterations = 0;
+      var ifForEachWorking = true;
+      s.forEach(function(value, key, map) {
+        ifForEachWorking = ifForEachWorking && map === s;
+        if (key==='a') {
+          ifForEachWorking = ifForEachWorking && value===1;
+        }
+        iterations++;
+      });
+      if (iterations !== 2) { return false; }
+      if (ifForEachWorking !== true) { return false; }
+
+      return true;
+    } catch(e) {
+      return false;
+    }
+  }
+
+  env.requireFunctioningMaps = function() {
+    if (!hasFunctioningMaps()) {
+      env.pending("Browser has incomplete or missing support for Maps");
+    }
+  };
+
+})(jasmine.getEnv());

spec/helpers/checkForSet.js

@@ -0,0 +1,41 @@
+(function(env) {
+  function hasFunctioningSets() {
+    if (typeof Set === 'undefined') { return false; }
+
+    try {
+      var s = new Set();
+      s.add(1);
+      s.add(2);
+
+      if (s.size !== 2) { return false; }
+      if (s.has(1) !== true) { return false; }
+
+      var iterations = 0;
+      var isForEachWorking = true;
+      s.forEach(function(value, key, set) {
+        isForEachWorking = isForEachWorking && set === s;
+
+        if (iterations===0) {
+          isForEachWorking = isForEachWorking && (key===value) && value===1;
+        } else if (iterations===1) {
+          isForEachWorking = isForEachWorking && (key===value) && value===2;
+        }
+
+        iterations++;
+      });
+      if (iterations !== 2) { return false; }
+      if (isForEachWorking !== true) { return false; }
+
+      return true;
+    } catch(e) {
+      return false;
+    }
+  }
+
+  env.requireFunctioningSets = function() {
+    if (!hasFunctioningSets()) {
+      env.pending("Browser has incomplete or missing support for Sets");
+    }
+  };
+
+})(jasmine.getEnv());