Bump version to 3.7.1

* Fixes #1880

.github/CONTRIBUTING.md

@@ -17,7 +17,7 @@ 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                                             # Fetch changes not present in your local repository
-git merge upstream/master                                      # Sync local master with upstream repository
+git merge upstream/main                                      # Sync local main 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
@@ -101,7 +101,7 @@ Follow these tips and your pull request, patch, or suggestion is much more likel
 
 Jasmine uses some internal tooling to test itself in browser on Travis. This tooling _should_ work locally as well.
 
-    $ node ci.js
+    $ node spec/support/ci.js
 
 You can also set the `JASMINE_BROWSER` environment variable to specify which browser should be used.
 
@@ -121,7 +121,7 @@ The easiest way to run the tests in **Internet Explorer** is to run a VM that ha
 1. Build `jasmine.js` with `npm run build` and run all specs again - this ensures that your changes self-test well
 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
-    * When we accept your pull request, we will generate these files as a separate commit and merge the entire branch into master
+    * When we accept your pull request, we will generate these files as a separate commit and merge the entire branch into main
 
 Note that we use Travis for Continuous Integration. We only accept green pull requests.
 

.travis.yml

@@ -1,8 +1,5 @@
 language: node_js
-node_js:
-  - "10"
-  - "8"
-  - "12"
+node_js: 14
 
 script: $TEST_COMMAND
 
@@ -12,36 +9,15 @@ env:
     - TEST_COMMAND="bash travis-core-script.sh"
     - secure: WSPWhlnC4mWSnSPquX+m1/BCu5ch5NygkaHuM2Nea7lD8oS3XLX8QncZZAsQ4lnNfqoDDuBOizG0AESiqNvE4y6x5qvLLTS6q+ce255ZEMZ71TBdZgDEEvGMEjOPPsVXiXyTQOP1lwOPlrbZvaPgWV7e11KIBab6DfFcQpnvDgo=
     - secure: SW7CJhZnwaNT749Gdnhvqb5rbXlAOsygUAzh9qhtyvbqXKkmJdBIEsO01YF6pbju1X2twE9JvWCOxeZju43NgQChJlPsGbjY2j3k/TdQeTAJesQe2K7ytwghunI30gjEovtRH0T3w1EmcKPH8yj5eBIcB2OYoJHx8KEC7e68q1g=
-  matrix:
-    - TEST_COMMAND="npm test"
-
 
 matrix:
   include:
-    - env: JASMINE_BROWSER="firefox" SAUCE_BROWSER_VERSION='' SAUCE_OS="Linux"
-      if: type != pull_request
-      addons:
-        sauce_connect: true
-    - env: JASMINE_BROWSER="chrome" SAUCE_BROWSER_VERSION='' SAUCE_OS="Linux"
-      if: type != pull_request
-      addons:
-        sauce_connect: true
-    - env: JASMINE_BROWSER="safari" SAUCE_BROWSER_VERSION="10" SAUCE_OS="OS X 10.12"
-      if: type != pull_request
-      addons:
-        sauce_connect: true
-    - env: JASMINE_BROWSER="safari" SAUCE_BROWSER_VERSION="9" SAUCE_OS="OS X 10.11"
-      if: type != pull_request
-      addons:
-        sauce_connect: true
-    - env: JASMINE_BROWSER="safari" SAUCE_BROWSER_VERSION="8" SAUCE_OS="OS X 10.10"
-      if: type != pull_request
-      addons:
-        sauce_connect: true
-    - env: JASMINE_BROWSER="MicrosoftEdge" SAUCE_BROWSER_VERSION="15" SAUCE_OS="Windows 10"
-      if: type != pull_request
-      addons:
-        sauce_connect: true
+    - node_js: "14"
+      env: JASMINE_LONG_PROPERTY_TESTS="y" TEST_COMMAND="npm test"
+    - node_js: "12"
+      env: TEST_COMMAND="npm test"
+    - node_js: "10"
+      env: TEST_COMMAND="npm test"
     - env: JASMINE_BROWSER="internet explorer" SAUCE_BROWSER_VERSION=11 SAUCE_OS="Windows 8.1"
       if: type != pull_request
       addons:
@@ -50,3 +26,27 @@ matrix:
       if: type != pull_request
       addons:
         sauce_connect: true
+    - env: JASMINE_BROWSER="firefox" SAUCE_BROWSER_VERSION='' SAUCE_OS="Windows 10"
+      if: type != pull_request
+      addons:
+        sauce_connect: true
+    - env: JASMINE_BROWSER="firefox" SAUCE_BROWSER_VERSION='68' SAUCE_OS="Windows 10"
+      if: type != pull_request
+      addons:
+        sauce_connect: true
+    - env: JASMINE_BROWSER="chrome" SAUCE_BROWSER_VERSION='' SAUCE_OS="Windows 10"
+      if: type != pull_request
+      addons:
+        sauce_connect: true
+    - env: JASMINE_BROWSER="safari" SAUCE_BROWSER_VERSION="13" SAUCE_OS="OS X 10.13"
+      if: type != pull_request
+      addons:
+        sauce_connect: true
+    - env: JASMINE_BROWSER="safari" SAUCE_BROWSER_VERSION="8" SAUCE_OS="OS X 10.10"
+      if: type != pull_request
+      addons:
+        sauce_connect: true
+    - env: JASMINE_BROWSER="MicrosoftEdge" SAUCE_BROWSER_VERSION="" SAUCE_OS="Windows 10"
+      if: type != pull_request
+      addons:
+        sauce_connect: true

README.md

@@ -1,6 +1,6 @@
-<a name="README">[<img src="https://rawgithub.com/jasmine/jasmine/master/images/jasmine-horizontal.svg" width="400px" />](http://jasmine.github.io)</a>
+<a name="README">[<img src="https://rawgithub.com/jasmine/jasmine/main/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)
+[![Build Status](https://travis-ci.com/jasmine/jasmine.svg?branch=main)](https://travis-ci.com/jasmine/jasmine)
 [![Open Source Helpers](https://www.codetriage.com/jasmine/jasmine/badges/users.svg)](https://www.codetriage.com/jasmine/jasmine)
 [![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fjasmine%2Fjasmine.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fjasmine%2Fjasmine?ref=badge_shield)
 
@@ -9,59 +9,70 @@
 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, see the beginning of [http://jasmine.github.io/edge/introduction.html](http://jasmine.github.io/edge/introduction.html)
+For a quick start guide of Jasmine, see the beginning of [http://jasmine.github.io/edge/introduction.html](http://jasmine.github.io/edge/introduction.html).
 
 Upgrading from Jasmine 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/.github/CONTRIBUTING.md)
+Please read the [contributors' guide](https://github.com/jasmine/jasmine/blob/main/.github/CONTRIBUTING.md).
 
 ## Installation
 
 For the Jasmine NPM module:<br>
-[https://github.com/jasmine/jasmine-npm](https://github.com/jasmine/jasmine-npm)
+[https://github.com/jasmine/jasmine-npm](https://github.com/jasmine/jasmine-npm).
 
 For the Jasmine Ruby Gem:<br>
-[https://github.com/jasmine/jasmine-gem](https://github.com/jasmine/jasmine-gem)
+[https://github.com/jasmine/jasmine-gem](https://github.com/jasmine/jasmine-gem).
 
 For the Jasmine Python Egg:<br>
-[https://github.com/jasmine/jasmine-py](https://github.com/jasmine/jasmine-py)
+[https://github.com/jasmine/jasmine-py](https://github.com/jasmine/jasmine-py).
 
 For the Jasmine headless browser gulp plugin:<br>
-[https://github.com/jasmine/gulp-jasmine-browser](https://github.com/jasmine/gulp-jasmine-browser)
+[https://github.com/jasmine/gulp-jasmine-browser](https://github.com/jasmine/gulp-jasmine-browser).
 
 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-{#.#.#}.zip my-project/jasmine`
-* Change directory - `cd my-project/jasmine`
-* Unzip the dist - `unzip jasmine-standalone-{#.#.#}.zip`
+* 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-{#.#.#}.zip my-project/jasmine`
+* Change directory. - `cd my-project/jasmine`
+* 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-{#.#.#}/jasmine_favicon.png">
-<link rel="stylesheet" type="text/css" href="jasmine/lib/jasmine-{#.#.#}/jasmine.css">
+<link rel="shortcut icon" type="image/png" href="lib/jasmine-{#.#.#}/jasmine_favicon.png">
+<link rel="stylesheet" type="text/css" href="lib/jasmine-{#.#.#}/jasmine.css">
 
-<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>
+<script type="text/javascript" src="lib/jasmine-{#.#.#}/jasmine.js"></script>
+<script type="text/javascript" src="lib/jasmine-{#.#.#}/jasmine-html.js"></script>
+<script type="text/javascript" src="lib/jasmine-{#.#.#}/boot.js"></script>
 ```
 
 ## Supported environments
 
-Jasmine tests itself across many browsers (Safari, Chrome, Firefox, 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)
+Jasmine tests itself across many browsers (Safari, Chrome, Firefox, Microsoft Edge, and Internet Explorer) as well as nodejs.
 
-[![Sauce Test Status](https://saucelabs.com/browser-matrix/jasmine-js.svg)](https://saucelabs.com/u/jasmine-js)
+| Environment       | Supported versions |
+|-------------------|--------------------|
+| Node              | 10, 12, 14         |
+| Safari            | 8-13               |
+| Chrome            | Evergreen          |
+| Firefox           | Evergreen, 68      |
+| Edge              | Evergreen          |
+| Internet Explorer | 10, 11             |
+
+For evergreen browsers, each version of Jasmine is tested against the version of the browser that is available to us
+at the time of release. Other browsers, as well as older & newer versions of some supported browsers, are likely to work.
+However, Jasmine isn't tested against them and they aren't actively supported. 
 
 ## Support
 
-* Search past discussions: [http://groups.google.com/group/jasmine-js](http://groups.google.com/group/jasmine-js)
-* Send an email to the list: [jasmine-js@googlegroups.com](mailto:jasmine-js@googlegroups.com)
-* View the project backlog at Pivotal Tracker: [http://www.pivotaltracker.com/projects/10606](http://www.pivotaltracker.com/projects/10606)
-* Follow us on Twitter: [@JasmineBDD](http://twitter.com/JasmineBDD)
+* Search past discussions: [http://groups.google.com/group/jasmine-js](http://groups.google.com/group/jasmine-js).
+* Send an email to the list: [jasmine-js@googlegroups.com](mailto:jasmine-js@googlegroups.com).
+* View the project backlog at Pivotal Tracker: [http://www.pivotaltracker.com/projects/10606](http://www.pivotaltracker.com/projects/10606).
+* Follow us on Twitter: [@JasmineBDD](http://twitter.com/JasmineBDD).
 
 ## Maintainers
 

RELEASE.md

@@ -7,7 +7,7 @@ Follow the instructions in `CONTRIBUTING.md` during development.
 
 ### Git Rules
 
-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`.
+Please attempt to keep commits to `main` 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 `main`.
 
 ### Version
 
@@ -29,29 +29,34 @@ When jasmine-core revs its major or minor version, the binding libraries should
 When ready to release - specs are all green and the stories are done:
 
 1. Update the release notes in `release_notes` - use the Anchorman gem to generate the markdown file and edit accordingly
-1. Update the version in `package.json` to a release candidate
-1. Update any links or top-level landing page for the Github Pages
+1. Update the version in `package.json`
+1. Run `npm run build`.
+1. Copy version to the Ruby gem with `grunt build:copyVersionToGem`
+
+### Commit and push core changes
+
+1. Commit release notes and version changes (jasmine.js, version.rb, package.json)
+1. Push
+1. Wait for Travis to go green
 
 ### Build standalone distribution
 
 1. Build the standalone distribution with `grunt buildStandaloneDist`
+1. This will generate `dist/jasmine-standalone-<version>.zip`, which you will upload later (see "Finally" below).
 
-### Release the Python egg
+### Release the core Ruby gem
+
+1. __NOTE__: You will likely need to push a new jasmine gem with a dependent version right after this release. See below.
+1. `rake release` - tags the repo with the version, builds the `jasmine-core` gem, pushes the gem to Rubygems.org. In order to release you will have to ensure you have rubygems creds locally.
+
+### Release the core Python 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
-
-1. Copy version to the Ruby gem with `grunt build:copyVersionToGem`
-1. __NOTE__: You will likely need to point to a local jasmine gem in order to run tests locally. _Do not_ push this version of the Gemfile.
-1. __NOTE__: You will likely need to push a new jasmine gem with a dependent version right after this release.
-1. Push these changes to GitHub and verify that this SHA is green
-1. `rake release` - tags the repo with the version, builds the `jasmine-core` gem, pushes the gem to Rubygems.org. In order to release you will have to ensure you have rubygems creds locally.
-
-### Release the NPM
+### Release the core NPM module
 
 1. `npm adduser` to save your credentials locally
 1. `npm publish .` to publish what's in `package.json`
@@ -60,15 +65,34 @@ Install [twine](https://github.com/pypa/twine)
 
 Probably only need to do this when releasing a minor version, and not a patch version.
 
-1. `cp -R edge ${version}` to copy the current edge docs to the new version
-1. Add a link to the new version in `index.html`
+1. `rake update_edge_jasmine`
+1. `npm run jsdoc`
+1. `rake release[${version}]` to copy the current edge docs to the new version
+1. Commit and push.
+
+### Release the binding libraries
+
+#### NPM
+
+1. Create release notes using Anchorman as above
+1. In `package.json`, update both the package version and the jasmine-core dependency version
+1. Commit and push.
+1. Wait for Travis to go green again.
+1. `grunt release `. (Note: This will publish the package by running `npm publish`.)
+
+#### Gem
+
+1. Create release notes using Anchorman as above
+1. Update the version number in `lib/jasmine/version.rb`.
+1. Update the jasmine-core dependency version in `jasmine.gemspec`.
+1. Commit and push.
+1. Wait for Travis to go green again.
+1. `rake release`
 
 ### Finally
 
-1. Visit the [Releases page for Jasmine](https://github.com/jasmine/jasmine/releases), find the tag just pushed.
- 1. Paste in a link to the correct release notes for this release. The link should reference the blob and tag correctly, and the markdown file for the notes.
- 1. If it is a pre-release, mark it as such.
- 1. Attach the standalone zipfile
-
-
-There should be a post to Pivotal Labs blog and a tweet to that link.
+For each of the above GitHub repos:
+1. Visit the releases page and find the tag just published.
+1. Paste in a link to the correct release notes for this release. The link should reference the blob and tag correctly, and the markdown file for the notes.
+1. If it is a pre-release, mark it as such.
+1. For core, attach the standalone zipfile.

lib/jasmine-core/boot.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2021 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -31,13 +31,16 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
 (function() {
+  var jasmineRequire = window.jasmineRequire || require('./jasmine.js');
 
   /**
    * ## Require & Instantiate
    *
    * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
    */
-  window.jasmine = jasmineRequire.core(jasmineRequire);
+  var jasmine = jasmineRequire.core(jasmineRequire),
+    global = jasmine.getGlobal();
+  global.jasmine = jasmine;
 
   /**
    * Since this is being run in a browser and the results should populate to an HTML page, require the HTML-specific Jasmine code, injecting the same reference.
@@ -59,7 +62,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   /**
    * Add all of the Jasmine global/public interface to the global scope, so a project can use the public interface directly. For example, calling `describe` in specs instead of `jasmine.getEnv().describe`.
    */
-  extend(window, jasmineInterface);
+  extend(global, jasmineInterface);
 
   /**
    * ## Runner Parameters

lib/jasmine-core/boot/boot.js

@@ -9,13 +9,16 @@
  */
 
 (function() {
+  var jasmineRequire = window.jasmineRequire || require('./jasmine.js');
 
   /**
    * ## Require & Instantiate
    *
    * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
    */
-  window.jasmine = jasmineRequire.core(jasmineRequire);
+  var jasmine = jasmineRequire.core(jasmineRequire),
+    global = jasmine.getGlobal();
+  global.jasmine = jasmine;
 
   /**
    * Since this is being run in a browser and the results should populate to an HTML page, require the HTML-specific Jasmine code, injecting the same reference.
@@ -37,7 +40,7 @@
   /**
    * Add all of the Jasmine global/public interface to the global scope, so a project can use the public interface directly. For example, calling `describe` in specs instead of `jasmine.getEnv().describe`.
    */
-  extend(window, jasmineInterface);
+  extend(global, jasmineInterface);
 
   /**
    * ## Runner Parameters

lib/jasmine-core/example/src/Player.js

@@ -19,4 +19,4 @@ Player.prototype.resume = function() {
 
 Player.prototype.makeFavorite = function() {
   this.currentlyPlayingSong.persistFavoriteStatus(true);
-};
+};

lib/jasmine-core/example/src/Song.js

@@ -4,4 +4,4 @@ function Song() {
 Song.prototype.persistFavoriteStatus = function(value) {
   // something complicated
   throw new Error("not yet implemented");
-};
+};

lib/jasmine-core/jasmine-html.js

@@ -1,5 +1,5 @@
 /*
-Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2021 Pivotal Labs
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -20,6 +20,8 @@ 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.
 */
+var jasmineRequire = window.jasmineRequire || require('./jasmine.js');
+
 jasmineRequire.html = function(j$) {
   j$.ResultsNode = jasmineRequire.ResultsNode();
   j$.HtmlReporter = jasmineRequire.HtmlReporter(j$);
@@ -130,7 +132,7 @@ jasmineRequire.HtmlReporter = function(j$) {
       if (result.status === 'failed') {
         failures.push(failureDom(result));
       }
-      addDeprecationWarnings(result);
+      addDeprecationWarnings(result, 'suite');
     };
 
     this.specStarted = function(result) {
@@ -166,7 +168,7 @@ jasmineRequire.HtmlReporter = function(j$) {
         failures.push(failureDom(result));
       }
 
-      addDeprecationWarnings(result);
+      addDeprecationWarnings(result, 'spec');
     };
 
     this.displaySpecInCorrectFormat = function(result) {
@@ -305,14 +307,27 @@ jasmineRequire.HtmlReporter = function(j$) {
 
       addDeprecationWarnings(doneResult);
 
-      var warningBarClassName = 'jasmine-bar jasmine-warning';
       for (i = 0; i < deprecationWarnings.length; i++) {
-        var warning = deprecationWarnings[i];
+        var context;
+
+        switch (deprecationWarnings[i].runnableType) {
+          case 'spec':
+            context = '(in spec: ' + deprecationWarnings[i].runnableName + ')';
+            break;
+          case 'suite':
+            context = '(in suite: ' + deprecationWarnings[i].runnableName + ')';
+            break;
+          default:
+            context = '';
+        }
+
         alert.appendChild(
           createDom(
             'span',
-            { className: warningBarClassName },
-            'DEPRECATION: ' + warning
+            { className: 'jasmine-bar jasmine-warning' },
+            'DEPRECATION: ' + deprecationWarnings[i].message,
+            createDom('br'),
+            context
           )
         );
       }
@@ -350,9 +365,11 @@ jasmineRequire.HtmlReporter = function(j$) {
 
         find('.jasmine-failures-menu').onclick = function() {
           setMenuModeTo('jasmine-failure-list');
+          return false;
         };
         find('.jasmine-spec-list-menu').onclick = function() {
           setMenuModeTo('jasmine-spec-list');
+          return false;
         };
 
         setMenuModeTo('jasmine-failure-list');
@@ -621,12 +638,16 @@ jasmineRequire.HtmlReporter = function(j$) {
       return addToExistingQueryString('spec', els.join(' '));
     }
 
-    function addDeprecationWarnings(result) {
+    function addDeprecationWarnings(result, runnableType) {
       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);
+            deprecationWarnings.push({
+              message: warning,
+              runnableName: result.fullName,
+              runnableType: runnableType
+            });
           }
         }
       }

lib/jasmine-core/node_boot.js

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

lib/jasmine-core/version.rb

@@ -4,6 +4,6 @@
 #
 module Jasmine
   module Core
-    VERSION = "3.5.0"
+    VERSION = "3.7.1"
   end
 end

package.json

@@ -1,7 +1,7 @@
 {
   "name": "jasmine-core",
   "license": "MIT",
-  "version": "3.5.0",
+  "version": "3.7.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -13,9 +13,9 @@
     "bdd"
   ],
   "scripts": {
-    "posttest": "eslint src/**/*.js spec/**/*.js && prettier --check src/**/*.js spec/**/*.js",
+    "posttest": "eslint \"src/**/*.js\" \"spec/**/*.js\" && prettier --check \"src/**/*.js\" \"spec/**/*.js\"",
     "test": "grunt --stack execSpecsInNode",
-    "cleanup": "prettier --write src/**/*.js spec/**/*.js",
+    "cleanup": "prettier --write \"src/**/*.js\" \"spec/**/*.js\"",
     "build": "grunt buildDistribution",
     "serve": "node spec/support/localJasmineBrowser.js",
     "serve:performance": "node spec/support/localJasmineBrowser.js jasmine-browser-performance.json",
@@ -28,8 +28,10 @@
   "devDependencies": {
     "acorn": "^6.0.0",
     "ejs": "^2.5.5",
-    "eslint": "^5.16.0",
+    "eslint": "^6.8.0",
+    "eslint-plugin-compat": "^3.8.0",
     "express": "^4.16.4",
+    "fast-check": "^1.21.0",
     "fast-glob": "^2.2.6",
     "grunt": "^1.0.4",
     "grunt-cli": "^1.3.2",
@@ -38,7 +40,7 @@
     "grunt-css-url-embed": "^1.11.1",
     "grunt-sass": "^3.0.2",
     "jasmine": "^3.4.0",
-    "jasmine-browser-runner": "0.3.0",
+    "jasmine-browser-runner": "^0.4.0",
     "jsdom": "^15.0.0",
     "load-grunt-tasks": "^4.0.0",
     "node-sass": "^4.11.0",
@@ -51,6 +53,12 @@
     "singleQuote": true
   },
   "eslintConfig": {
+    "extends": [
+      "plugin:compat/recommended"
+    ],
+    "parserOptions": {
+      "ecmaVersion": 5
+    },
     "rules": {
       "quotes": [
         "error",
@@ -66,10 +74,6 @@
         }
       ],
       "block-spacing": "error",
-      "comma-dangle": [
-        "error",
-        "never"
-      ],
       "func-call-spacing": [
         "error",
         "never"
@@ -84,5 +88,13 @@
       ],
       "space-before-blocks": "error"
     }
-  }
+  },
+  "browserslist": [
+    "Safari >= 8",
+    "last 2 Chrome versions",
+    "last 2 Firefox versions",
+    "Firefox 68",
+    "last 2 Edge versions",
+    "IE >= 10"
+  ]
 }

release_notes/3.6.0.md

@@ -0,0 +1,146 @@
+# Jasmine Core 3.6 Release Notes
+
+## Summary
+
+This is a maintenance release of Jasmine with a number of new features and fixes.
+
+## Highlights
+
+* Added support for custom object formatters
+    * Allows customizing how an object is stringified in matcher failure messages
+    * [Tutorial](https://jasmine.github.io/tutorials/custom_object_formatter)
+    * [API reference](https://jasmine.github.io/api/3.6/jasmine.html#.addCustomObjectFormatter)
+
+* Don't require matchers and asymmetric equality testers to pass custom object formatters back to Jasmine
+    - Supports custom object formatters.
+    - Makes it easier to write high quality matchers and asymmetric equality testers.
+    - The old API will still work until 4.0.
+
+* Properly import jasmineRequire object before using
+    - Improves compatibility with Webpack
+    - Merges [#1766](https://github.com/jasmine/jasmine/pull/1766) from @amilligan
+
+* Added a toHaveBeenCalledOnceWith matcher
+    - Merges [#1801](https://github.com/jasmine/jasmine/pull/1801) from @Maximaximum
+    - Fixes [#1717](https://github.com/jasmine/jasmine/issues/1717)
+    
+* Added a toHaveSize matcher
+    - Merges [#1796](https://github.com/jasmine/jasmine/pull/1796) from @wokier
+
+* Added a toBePending async matcher
+    - Merges [#1808](https://github.com/jasmine/jasmine/pull/1808) from @DCtheTall
+    - Fixes [#1803](https://github.com/jasmine/jasmine/issues/1803)
+    
+* Added support for user-defined spec/suite properties
+    - Allows specs/suites to pass data to custom reporters
+    - Merges [#1763](https://github.com/jasmine/jasmine/pull/1763) from @johnjbarton
+
+* Route unhandled promise rejections to onerror
+    - Merges [#1778](https://github.com/jasmine/jasmine/pull/1778) from @johnjbarton
+    - Fixes [#1777](https://github.com/jasmine/jasmine/issues/1777)
+
+
+## Internal notes
+
+* Use a version of eslint that works on Node 8
+
+* Check for syntax and standard library objects that don't work in IE
+
+* Run eslint against all files
+
+* Add Additional Test for equals Matcher
+    - Merges [#1829](https://github.com/jasmine/jasmine/pull/1829) from @tobiasschweizer
+    - Fixes [#1821](https://github.com/jasmine/jasmine/issues/1821)
+
+* Depend on head of jasmine-browser to fix IE failures in CI
+
+* Fixed test failure in Firefox 74
+
+* Added test for resolveTo/rejectWith with empty parameters
+    - Merges [#1802](https://github.com/jasmine/jasmine/pull/1802) from @chivesrs
+    
+* Removed unnecessary uses of new in tests
+
+* Realigned the browser testing matrix to match current reality
+    - Use Windows instead of Linux so we can get current browsers from Sauce.
+    - Test against the version of Firefox that corresponds to ESR as well as
+  latest.
+    - Test the latest Edge rather than a specific older version.
+    - Test Safari 8 and 13 instead of 8, 9 and 10. What works in those versions
+  is likely to work in the ones in between.
+
+* Don't leak global error handlers between Jasmine's own tests
+
+* Added basic property tests for matchersUtil.equals
+
+* Added integration tests for existing matcher interfaces
+
+* Added integration tests for asymmetric equality testers
+
+* Test IE before other browsers on Travis
+
+
+## Other Changes
+
+* Show diffs involving root-level asymmetric equality testers
+    - Fixes [#1831](https://github.com/jasmine/jasmine/issues/1831)
+
+* Fixed references to master in docs
+
+* Allow spy throwError to throw an Object
+    - Merges [#1822](https://github.com/jasmine/jasmine/pull/1822) from @terencehonles
+
+* Added missing periods to README
+    - Merges [#1828](https://github.com/jasmine/jasmine/pull/1828) from @dirkpuge
+
+
+* Expose setSpec/SuiteProperty on interface
+    - Merges [#1820](https://github.com/jasmine/jasmine/pull/1820) from @johnjbarton
+
+* Prevent undesired reloads when karma-jasmine-html-reporter is used
+    - Merges [#1807](https://github.com/jasmine/jasmine/pull/1807) from @parloti
+    - Fixes [#1775](https://github.com/jasmine/jasmine/issues/1775)
+
+* Correctly report spec and suite duration
+    - Fixes [#1676](https://github.com/jasmine/jasmine/issues/1676).
+
+* Added jsdocs for MatchersUtil
+
+* Allow the .callThrough spy strategy to call constructor functions without errors
+    - Merges [#1782](https://github.com/jasmine/jasmine/pull/1782) from @enelson
+    - Fixes [#1760](https://github.com/jasmine/jasmine/issues/1760)
+    
+* Inject a per-runable pretty printer into MatchersUtil
+    - Supports custom object formatters
+
+* Include stack traces in unhandled promise rejection messages
+
+* Describe the naming for the function it
+    - Merges [#1772](https://github.com/jasmine/jasmine/pull/1772) from @johnlinp
+
+* Correctly extract error messages from stack traces that don't start with `Error`
+    - Merges [#1776](https://github.com/jasmine/jasmine/pull/1776) from @vhermannitk
+    - Fixes [#1771](https://github.com/jasmine/jasmine/issues/1771)
+
+* Fixed objectContaining to not match when the expected is the empty object and the actual is a non-object
+
+* Fixed toEqual(0, Number.MIN_VALUE) to fail instead of passing 
+    - Merges [#1764](https://github.com/jasmine/jasmine/pull/1764) from @dubzzz
+
+* Fixed comparison between ObjectContaining and non-objects on IE
+
+* Provide better diffs for object graphs that include `objectContaining`
+
+* Indent multiline failure messages in the output of `withContext`
+    * This makes it easier to see where each failure message begins and ends.
+
+* Report async expectations that complete after the runable completes
+    - See [#1752](https://github.com/jasmine/jasmine/issues/1752).
+
+* Treat NodeJS assertion failures as expectation failures
+    - Merges [#1678](https://github.com/jasmine/jasmine/pull/1678) from @apla
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/3.7.0.md

@@ -0,0 +1,80 @@
+# Jasmine Core 3.7 Release Notes
+
+## Summary
+
+This is a maintenance release of Jasmine with a number of new features and fixes.
+
+
+## New features and bug fixes
+
+* Allow custom object formatters to be added in beforeAll
+    - Fixes [#1876](http://github.com/jasmine/jasmine/issues/1876)
+
+* Allow specs to disable Jasmine's global error handling by overwriting `onerror`.
+    - Merges [#1860](https://github.com/jasmine/jasmine/pull/1860) from @greghuc
+
+* Fixed comparison between URL objects
+    -  Fixes [#1866](http://github.com/jasmine/jasmine/issues/1866)
+
+* Added support for stack traces created by `node --enable-source-maps`
+  with tools like the Typescript compiler.
+    - Merges [#1862](https://github.com/jasmine/jasmine/pull/1862) from @JannesMeyer
+
+* Made properties added by createSpyObj() enumerable.
+    - Merges [#1859](https://github.com/jasmine/jasmine/pull/1859) from DCtheTall
+    - Fixes [#1837](http://github.com/jasmine/jasmine/issues/1837)
+
+* Show the name of the spec/suite that caused a deprecation
+
+* Warn if a spec or before/after function both takes a callback and returns a promise
+
+* Don't overwrite MatchersUtil methods with ones that were added to 
+  `Array.prototype`, esp. `contains`
+    - Fixes [#1849](http://github.com/jasmine/jasmine/issues/1849)
+
+* Allow generator functions to be passed to `.and.callFake`
+    - Fixes [#1848](http://github.com/jasmine/jasmine/issues/1848)
+
+
+## Documentation updates
+
+* Fixed instructions for contributors to run Jasmine's ci script
+
+* Updated supported Node versions in README
+
+* Fixed script and CSS URLs in standalone example in README
+    - Merges [#1839](https://github.com/jasmine/jasmine/pull/1839) from @snowman
+
+* Fixed typo in asyncMatcher toBePending comment
+    - Merges [#1847](https://github.com/jasmine/jasmine/pull/1847) from @SnailCoil
+
+* Fixed link to custom object formatter tutorial
+
+* Added jasmine.isSpy to the public interface
+    - Fixes [#1880](http://github.com/jasmine/jasmine/issues/1880)
+
+
+
+## Internal notes
+
+* Fixed intermittent test failures
+
+* Added additional assertions to tests for toBeTruthy and toBeFalsy
+    -  Merges [#1875](https://github.com/jasmine/jasmine/pull/1875) from @yasinkocak
+
+* Pointed Travis badge at travis-ci.com, not .org
+
+* Fixed file globs so that Prettier runs on all files
+
+* Check for forgotten console and debugger statements
+
+* Fixed code in Jasmine that will trigger deprecations in 3.99
+    
+* Use jasmine-browser from npm rather than from the main branch
+    - The current released version now works with IE, so we no longer need to
+depend on main.
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/3.7.1.md

@@ -0,0 +1,8 @@
+# Jasmine Core 3.7.1 Release Notes
+
+## Summary
+
+This is a bug fix release of Jasmine. It's identical to 3.7.0 except that it
+correctly reports its version number. Please see the
+[3.7.0 release notes](https://github.com/jasmine/jasmine/blob/main/release_notes/3.7.0.md)
+if you're upgrading directly from 3.6.0 or earlier.

spec/.eslintrc.js

@@ -0,0 +1,20 @@
+module.exports = {
+  ignorePatterns: ['support/ci.js', 'support/jasmine-browser.js'],
+  rules: {
+    // Relax rules for now to allow for the quirks of the test suite
+    // TODO: We should probably remove these & fix the resulting errors
+    quotes: 'off',
+    semi: 'off',
+    'key-spacing': 'off',
+    'space-before-blocks': 'off',
+    'no-unused-vars': 'off',
+    'no-trailing-spaces': 'off',
+    'block-spacing': 'off',
+
+    // Since linting is done at the end of the process and doesn't stop us
+    // from running tests, it makes sense to fail if debugger statements
+    // or console references are present.
+    'no-debugger': 'error',
+    'no-console': 'error'
+  }
+};

spec/core/AsyncExpectationSpec.js

@@ -1,3 +1,4 @@
+/* eslint-disable compat/compat */
 describe('AsyncExpectation', function() {
   beforeEach(function() {
     jasmineUnderTest.Expectation.addAsyncCoreMatchers(
@@ -24,8 +25,9 @@ describe('AsyncExpectation', function() {
 
       var addExpectationResult = jasmine.createSpy('addExpectationResult'),
         actual = Promise.resolve(),
+        pp = jasmineUnderTest.makePrettyPrinter(),
         expectation = jasmineUnderTest.Expectation.asyncFactory({
-          util: jasmineUnderTest.matchersUtil,
+          matchersUtil: new jasmineUnderTest.MatchersUtil({ pp: pp }),
           actual: actual,
           addExpectationResult: addExpectationResult
         });
@@ -47,7 +49,9 @@ describe('AsyncExpectation', function() {
       var addExpectationResult = jasmine.createSpy('addExpectationResult'),
         actual = Promise.reject(),
         expectation = jasmineUnderTest.Expectation.asyncFactory({
-          util: jasmineUnderTest.matchersUtil,
+          matchersUtil: new jasmineUnderTest.MatchersUtil({
+            pp: function() {}
+          }),
           actual: actual,
           addExpectationResult: addExpectationResult
         });
@@ -91,7 +95,7 @@ describe('AsyncExpectation', function() {
     it('prepends the context to the generated failure message', function() {
       jasmine.getEnv().requirePromises();
 
-      var util = {
+      var matchersUtil = {
           buildFailureMessage: function() {
             return 'failure message';
           }
@@ -100,7 +104,7 @@ describe('AsyncExpectation', function() {
         expectation = jasmineUnderTest.Expectation.asyncFactory({
           actual: Promise.reject('rejected'),
           addExpectationResult: addExpectationResult,
-          util: util
+          matchersUtil: matchersUtil
         });
 
       return expectation
@@ -119,16 +123,17 @@ describe('AsyncExpectation', function() {
     it('prepends the context to a custom failure message', function() {
       jasmine.getEnv().requirePromises();
 
-      var util = {
+      var matchersUtil = {
           buildFailureMessage: function() {
             return 'failure message';
-          }
+          },
+          pp: jasmineUnderTest.makePrettyPrinter()
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.asyncFactory({
           actual: Promise.reject('b'),
           addExpectationResult: addExpectationResult,
-          util: util
+          matchersUtil: matchersUtil
         });
 
       return expectation
@@ -149,7 +154,7 @@ describe('AsyncExpectation', function() {
       pending('should actually work, but no custom matchers for async yet');
       jasmine.getEnv().requirePromises();
 
-      var util = {
+      var matchersUtil = {
           buildFailureMessage: function() {
             return 'failure message';
           }
@@ -159,7 +164,7 @@ describe('AsyncExpectation', function() {
         expectation = jasmineUnderTest.Expectation.asyncFactory({
           actual: actual,
           addExpectationResult: addExpectationResult,
-          util: util
+          matchersUtil: matchersUtil
         });
 
       return expectation
@@ -180,10 +185,11 @@ describe('AsyncExpectation', function() {
 
       var addExpectationResult = jasmine.createSpy('addExpectationResult'),
         actual = Promise.resolve(),
+        pp = jasmineUnderTest.makePrettyPrinter(),
         expectation = jasmineUnderTest.Expectation.asyncFactory({
           actual: actual,
           addExpectationResult: addExpectationResult,
-          util: jasmineUnderTest.matchersUtil
+          matchersUtil: new jasmineUnderTest.MatchersUtil({ pp: pp })
         });
 
       return expectation
@@ -208,7 +214,9 @@ describe('AsyncExpectation', function() {
         expectation = jasmineUnderTest.Expectation.asyncFactory({
           actual: actual,
           addExpectationResult: addExpectationResult,
-          util: jasmineUnderTest.matchersUtil
+          matchersUtil: new jasmineUnderTest.MatchersUtil({
+            pp: jasmineUnderTest.makePrettyPrinter()
+          })
         });
 
       return expectation
@@ -256,7 +264,7 @@ describe('AsyncExpectation', function() {
         matchers = {
           toFoo: matcherFactory
         },
-        util = {
+        matchersUtil = {
           buildFailureMessage: jasmine.createSpy('buildFailureMessage')
         },
         customEqualityTesters = ['a'],
@@ -264,7 +272,7 @@ describe('AsyncExpectation', function() {
         expectation;
 
       expectation = jasmineUnderTest.Expectation.asyncFactory({
-        util: util,
+        matchersUtil: matchersUtil,
         customAsyncMatchers: matchers,
         customEqualityTesters: customEqualityTesters,
         actual: 'an actual',
@@ -273,7 +281,7 @@ describe('AsyncExpectation', function() {
 
       return expectation.toFoo('hello').then(function() {
         expect(matcherFactory).toHaveBeenCalledWith(
-          util,
+          matchersUtil,
           customEqualityTesters
         );
       });
@@ -292,14 +300,14 @@ describe('AsyncExpectation', function() {
             };
           }
         },
-        util = {
+        matchersUtil = {
           buildFailureMessage: jasmine.createSpy('buildFailureMessage')
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation;
 
       expectation = jasmineUnderTest.Expectation.asyncFactory({
-        util: util,
+        matchersUtil: matchersUtil,
         customAsyncMatchers: matchers,
         actual: 'an actual',
         addExpectationResult: addExpectationResult
@@ -322,7 +330,7 @@ describe('AsyncExpectation', function() {
             };
           }
         },
-        util = {
+        matchersUtil = {
           buildFailureMessage: jasmine.createSpy('buildFailureMessage')
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
@@ -335,7 +343,7 @@ describe('AsyncExpectation', function() {
 
       expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
-        util: util,
+        matchersUtil: matchersUtil,
         actual: 'an actual',
         addExpectationResult: addExpectationResult
       });
@@ -365,7 +373,7 @@ describe('AsyncExpectation', function() {
             };
           }
         },
-        util = {
+        matchersUtil = {
           buildFailureMessage: function() {
             return '';
           }
@@ -380,7 +388,7 @@ describe('AsyncExpectation', function() {
 
       expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
-        util: util,
+        matchersUtil: matchersUtil,
         actual: 'an actual',
         addExpectationResult: addExpectationResult
       });
@@ -536,7 +544,7 @@ describe('AsyncExpectation', function() {
             };
           }
         },
-        util = {
+        matchersUtil = {
           buildFailureMessage: function() {
             return 'default message';
           }
@@ -553,7 +561,7 @@ describe('AsyncExpectation', function() {
       expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
         actual: 'an actual',
-        util: util,
+        matchersUtil: matchersUtil,
         addExpectationResult: addExpectationResult
       }).not;
 

spec/core/EnvSpec.js

@@ -5,6 +5,10 @@ describe('Env', function() {
     env = new jasmineUnderTest.Env();
   });
 
+  afterEach(function() {
+    env.cleanup_();
+  });
+
   describe('#pending', function() {
     it('throws the Pending Spec exception', function() {
       expect(function() {
@@ -281,11 +285,13 @@ describe('Env', function() {
     it('installs a global error handler on construction', function() {
       var globalErrors = jasmine.createSpyObj('globalErrors', [
         'install',
+        'uninstall',
         'pushListener',
         'popListener'
       ]);
       spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
-      new jasmineUnderTest.Env();
+      env.cleanup_();
+      env = new jasmineUnderTest.Env();
       expect(globalErrors.install).toHaveBeenCalled();
     });
   });
@@ -294,14 +300,82 @@ describe('Env', function() {
     it('does not install a global error handler until execute is called', function() {
       var globalErrors = jasmine.createSpyObj('globalErrors', [
         'install',
+        'uninstall',
         'pushListener',
         'popListener'
       ]);
       spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
+      env.cleanup_();
       env = new jasmineUnderTest.Env({ suppressLoadErrors: true });
       expect(globalErrors.install).not.toHaveBeenCalled();
       env.execute();
       expect(globalErrors.install).toHaveBeenCalled();
     });
   });
+
+  it('creates an expectationFactory that uses the current custom equality testers and object formatters', function(done) {
+    function customEqualityTester() {}
+    function customObjectFormatter() {}
+    function prettyPrinter() {}
+    var RealSpec = jasmineUnderTest.Spec,
+      specInstance,
+      expectationFactory;
+    spyOn(jasmineUnderTest, 'MatchersUtil');
+    spyOn(jasmineUnderTest, 'makePrettyPrinter').and.returnValue(prettyPrinter);
+    spyOn(jasmineUnderTest, 'Spec').and.callFake(function(options) {
+      expectationFactory = options.expectationFactory;
+      specInstance = new RealSpec(options);
+      return specInstance;
+    });
+
+    env.it('spec', function() {
+      env.addCustomEqualityTester(customEqualityTester);
+      env.addCustomObjectFormatter(customObjectFormatter);
+      expectationFactory('actual', specInstance);
+    });
+
+    env.execute(null, function() {
+      expect(jasmineUnderTest.makePrettyPrinter).toHaveBeenCalledWith([
+        customObjectFormatter
+      ]);
+      expect(jasmineUnderTest.MatchersUtil).toHaveBeenCalledWith({
+        customTesters: [customEqualityTester],
+        pp: prettyPrinter
+      });
+      done();
+    });
+  });
+
+  it('creates an asyncExpectationFactory that uses the current custom equality testers and object formatters', function(done) {
+    function customEqualityTester() {}
+    function customObjectFormatter() {}
+    function prettyPrinter() {}
+    var RealSpec = jasmineUnderTest.Spec,
+      specInstance,
+      asyncExpectationFactory;
+    spyOn(jasmineUnderTest, 'MatchersUtil');
+    spyOn(jasmineUnderTest, 'makePrettyPrinter').and.returnValue(prettyPrinter);
+    spyOn(jasmineUnderTest, 'Spec').and.callFake(function(options) {
+      asyncExpectationFactory = options.asyncExpectationFactory;
+      specInstance = new RealSpec(options);
+      return specInstance;
+    });
+
+    env.it('spec', function() {
+      env.addCustomEqualityTester(customEqualityTester);
+      env.addCustomObjectFormatter(customObjectFormatter);
+      asyncExpectationFactory('actual', specInstance);
+    });
+
+    env.execute(null, function() {
+      expect(jasmineUnderTest.makePrettyPrinter).toHaveBeenCalledWith([
+        customObjectFormatter
+      ]);
+      expect(jasmineUnderTest.MatchersUtil).toHaveBeenCalledWith({
+        customTesters: [customEqualityTester],
+        pp: prettyPrinter
+      });
+      done();
+    });
+  });
 });

spec/core/ExceptionFormatterSpec.js

@@ -86,6 +86,37 @@ describe('ExceptionFormatter', function() {
       );
     });
 
+    it('filters Jasmine stack frames from V8-style traces but leaves unmatched lines intact', function() {
+      var error = {
+        message: 'nope',
+        stack:
+          'C:\\__spec__\\core\\UtilSpec.ts:120\n' +
+          "                new Error('nope');\n" +
+          '                ^\n' +
+          '\n' +
+          'Error: nope\n' +
+          '    at fn1 (C:\\__spec__\\core\\UtilSpec.js:115:19)\n' +
+          '        -> C:\\__spec__\\core\\UtilSpec.ts:120:15\n' +
+          '    at fn2 (C:\\__jasmine__\\lib\\jasmine-core\\jasmine.js:7533:40)\n' +
+          '    at fn3 (C:\\__jasmine__\\lib\\jasmine-core\\jasmine.js:7575:25)\n' +
+          '    at fn4 (node:internal/timers:462:21)\n'
+      };
+      var subject = new jasmineUnderTest.ExceptionFormatter({
+        jasmineFile: 'C:\\__jasmine__\\lib\\jasmine-core\\jasmine.js'
+      });
+      var result = subject.stack(error);
+      expect(result).toEqual(
+        'C:\\__spec__\\core\\UtilSpec.ts:120\n' +
+          "                new Error('nope');\n" +
+          '                ^\n' +
+          'Error: nope\n' +
+          '    at fn1 (C:\\__spec__\\core\\UtilSpec.js:115:19)\n' +
+          '        -> C:\\__spec__\\core\\UtilSpec.ts:120:15\n' +
+          '    at <Jasmine>\n' +
+          '    at fn4 (node:internal/timers:462:21)'
+      );
+    });
+
     it('filters Jasmine stack frames from V8 style traces', function() {
       var error = {
         message: 'nope',

spec/core/ExceptionsSpec.js

@@ -5,6 +5,10 @@ describe('Exceptions:', function() {
     env = new jasmineUnderTest.Env();
   });
 
+  afterEach(function() {
+    env.cleanup_();
+  });
+
   it('should handle exceptions thrown, but continue', function(done) {
     var secondTest = jasmine.createSpy('second test');
     env.describe('Suite for handles exceptions', function() {
@@ -25,8 +29,7 @@ describe('Exceptions:', function() {
       done();
     };
 
-    env.addReporter({ jasmineDone: expectations });
-    env.execute();
+    env.execute(null, expectations);
   });
 
   it('should handle exceptions thrown directly in top-level describe blocks and continue', function(done) {
@@ -45,7 +48,6 @@ describe('Exceptions:', function() {
       done();
     };
 
-    env.addReporter({ jasmineDone: expectations });
-    env.execute();
+    env.execute(null, expectations);
   });
 });

spec/core/ExpectationFilterChainSpec.js

@@ -72,21 +72,21 @@ describe('ExpectationFilterChain', function() {
           matcherResult = { pass: false },
           matcherName = 'foo',
           args = [],
-          util = {},
+          matchersUtil = {},
           result;
 
         result = chain.buildFailureMessage(
           matcherResult,
           matcherName,
           args,
-          util
+          matchersUtil
         );
 
         expect(first).toHaveBeenCalledWith(
           matcherResult,
           matcherName,
           args,
-          util
+          matchersUtil
         );
         expect(second).not.toHaveBeenCalled();
         expect(result).toEqual('first');

spec/core/ExpectationResultSpec.js

@@ -90,4 +90,37 @@ describe('buildExpectationResult', function() {
     });
     expect(result.actual).toBe('some-value');
   });
+
+  it('handles nodejs assertions', function() {
+    if (typeof require === 'undefined') {
+      return;
+    }
+    var assert = require('assert');
+    var error;
+    var value = 8421;
+    var expectedValue = 'JasmineExpectationTestValue';
+    try {
+      assert.equal(value, expectedValue);
+    } catch (e) {
+      error = e;
+    }
+
+    expect(error.code).toEqual('ERR_ASSERTION');
+    expect(error.actual).toEqual(value);
+    expect(error.expected).toEqual(expectedValue);
+    expect(error.operator).toEqual('==');
+
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: false,
+      matcherName: '',
+      expected: '',
+      actual: '',
+      error: error
+    });
+
+    expect(result.code).toEqual('ERR_ASSERTION');
+    expect(result.actual).toEqual(value);
+    expect(result.expected).toEqual(expectedValue);
+    expect(result.matcherName).toEqual('assert ==');
+  });
 });

spec/core/ExpectationSpec.js

@@ -37,7 +37,7 @@ describe('Expectation', function() {
       matchers = {
         toFoo: matcherFactory
       },
-      util = {
+      matchersUtil = {
         buildFailureMessage: jasmine.createSpy('buildFailureMessage')
       },
       customEqualityTesters = ['a'],
@@ -45,7 +45,7 @@ describe('Expectation', function() {
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
-      util: util,
+      matchersUtil: matchersUtil,
       customMatchers: matchers,
       customEqualityTesters: customEqualityTesters,
       actual: 'an actual',
@@ -54,7 +54,10 @@ describe('Expectation', function() {
 
     expectation.toFoo('hello');
 
-    expect(matcherFactory).toHaveBeenCalledWith(util, customEqualityTesters);
+    expect(matcherFactory).toHaveBeenCalledWith(
+      matchersUtil,
+      customEqualityTesters
+    );
   });
 
   it("wraps matchers's compare functions, passing the actual and expected", function() {
@@ -68,14 +71,14 @@ describe('Expectation', function() {
           };
         }
       },
-      util = {
+      matchersUtil = {
         buildFailureMessage: jasmine.createSpy('buildFailureMessage')
       },
       addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
-      util: util,
+      matchersUtil: matchersUtil,
       customMatchers: matchers,
       actual: 'an actual',
       addExpectationResult: addExpectationResult
@@ -96,7 +99,7 @@ describe('Expectation', function() {
           };
         }
       },
-      util = {
+      matchersUtil = {
         buildFailureMessage: jasmine.createSpy('buildFailureMessage')
       },
       addExpectationResult = jasmine.createSpy('addExpectationResult'),
@@ -104,7 +107,7 @@ describe('Expectation', function() {
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      util: util,
+      matchersUtil: matchersUtil,
       actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
@@ -132,7 +135,7 @@ describe('Expectation', function() {
           };
         }
       },
-      util = {
+      matchersUtil = {
         buildFailureMessage: function() {
           return '';
         }
@@ -142,7 +145,7 @@ describe('Expectation', function() {
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      util: util,
+      matchersUtil: matchersUtil,
       actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
@@ -275,7 +278,7 @@ describe('Expectation', function() {
           };
         }
       },
-      util = {
+      matchersUtil = {
         buildFailureMessage: function() {
           return 'default message';
         }
@@ -287,7 +290,7 @@ describe('Expectation', function() {
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
       actual: 'an actual',
-      util: util,
+      matchersUtil: matchersUtil,
       addExpectationResult: addExpectationResult
     }).not;
 
@@ -539,7 +542,7 @@ describe('Expectation', function() {
             };
           }
         },
-        util = {
+        matchersUtil = {
           buildFailureMessage: function() {
             return 'failure message';
           }
@@ -547,7 +550,7 @@ describe('Expectation', function() {
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.factory({
           customMatchers: matchers,
-          util: util,
+          matchersUtil: matchersUtil,
           actual: 'an actual',
           addExpectationResult: addExpectationResult
         });
@@ -589,6 +592,32 @@ describe('Expectation', function() {
       );
     });
 
+    it('indents a multiline failure message', function() {
+      var matchers = {
+          toFoo: function() {
+            return {
+              compare: function() {
+                return { pass: false, message: 'a\nmultiline\nmessage' };
+              }
+            };
+          }
+        },
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        expectation = jasmineUnderTest.Expectation.factory({
+          customMatchers: matchers,
+          actual: 'an actual',
+          addExpectationResult: addExpectationResult
+        }),
+        actualMessage;
+
+      expectation.withContext('Some context').toFoo('hello');
+
+      actualMessage = addExpectationResult.calls.argsFor(0)[1].message;
+      expect(actualMessage).toEqual(
+        'Some context:\n    a\n    multiline\n    message'
+      );
+    });
+
     it('prepends the context to a custom failure message from a function', function() {
       var matchers = {
           toFoo: function() {
@@ -632,9 +661,10 @@ describe('Expectation', function() {
           }
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
+        pp = jasmineUnderTest.makePrettyPrinter(),
         expectation = jasmineUnderTest.Expectation.factory({
           customMatchers: matchers,
-          util: jasmineUnderTest.matchersUtil,
+          matchersUtil: new jasmineUnderTest.MatchersUtil({ pp: pp }),
           actual: 'an actual',
           addExpectationResult: addExpectationResult
         });

spec/core/GlobalErrorsSpec.js

@@ -12,6 +12,23 @@ describe('GlobalErrors', function() {
     expect(handler).toHaveBeenCalledWith('foo');
   });
 
+  it('enables external interception of error by overriding global.onerror', function() {
+    var fakeGlobal = { onerror: null },
+      handler = jasmine.createSpy('errorHandler'),
+      hijackHandler = jasmine.createSpy('hijackErrorHandler'),
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+    errors.install();
+    errors.pushListener(handler);
+
+    fakeGlobal.onerror = hijackHandler;
+
+    fakeGlobal.onerror('foo');
+
+    expect(hijackHandler).toHaveBeenCalledWith('foo');
+    expect(handler).not.toHaveBeenCalled();
+  });
+
   it('calls the global error handler with all parameters', function() {
     var fakeGlobal = { onerror: null },
       handler = jasmine.createSpy('errorHandler'),
@@ -58,7 +75,7 @@ describe('GlobalErrors', function() {
     errors.pushListener(handler1);
     errors.pushListener(handler2);
 
-    errors.popListener();
+    errors.popListener(handler2);
 
     fakeGlobal.onerror('foo');
 
@@ -66,6 +83,13 @@ describe('GlobalErrors', function() {
     expect(handler2).not.toHaveBeenCalled();
   });
 
+  it('throws when no listener is passed to #popListener', function() {
+    var errors = new jasmineUnderTest.GlobalErrors({});
+    expect(function() {
+      errors.popListener();
+    }).toThrowError('popListener expects a listener');
+  });
+
   it('uninstalls itself, putting back a previous callback', function() {
     var originalCallback = jasmine.createSpy('error'),
       fakeGlobal = { onerror: originalCallback },
@@ -193,4 +217,139 @@ describe('GlobalErrors', function() {
       'foo'
     );
   });
+
+  describe('Reporting unhandled promise rejections in the browser', function() {
+    it('subscribes and unsubscribes from the unhandledrejection event', function() {
+      var fakeGlobal = jasmine.createSpyObj('globalErrors', [
+          'addEventListener',
+          'removeEventListener',
+          'onerror'
+        ]),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+      errors.install();
+      expect(fakeGlobal.addEventListener).toHaveBeenCalledWith(
+        'unhandledrejection',
+        jasmine.any(Function)
+      );
+
+      var addedListener = fakeGlobal.addEventListener.calls.argsFor(0)[1];
+      errors.uninstall();
+
+      expect(fakeGlobal.removeEventListener).toHaveBeenCalledWith(
+        'unhandledrejection',
+        addedListener
+      );
+    });
+
+    it('reports rejections whose reason is a string', function() {
+      var fakeGlobal = jasmine.createSpyObj('globalErrors', [
+          'addEventListener',
+          'removeEventListener',
+          'onerror'
+        ]),
+        handler = jasmine.createSpy('errorHandler'),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+      errors.install();
+      errors.pushListener(handler);
+
+      var addedListener = fakeGlobal.addEventListener.calls.argsFor(0)[1];
+      addedListener({ reason: 'nope' });
+
+      expect(handler).toHaveBeenCalledWith('Unhandled promise rejection: nope');
+    });
+
+    it('reports rejections whose reason is an Error', function() {
+      var fakeGlobal = jasmine.createSpyObj('globalErrors', [
+          'addEventListener',
+          'removeEventListener',
+          'onerror'
+        ]),
+        handler = jasmine.createSpy('errorHandler'),
+        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+      errors.install();
+      errors.pushListener(handler);
+
+      var addedListener = fakeGlobal.addEventListener.calls.argsFor(0)[1];
+      var reason;
+
+      try {
+        // Throwing ensures that we get a stack property in all browsers
+        throw new Error('bar');
+      } catch (e) {
+        reason = e;
+      }
+
+      addedListener({ reason: reason });
+
+      expect(handler).toHaveBeenCalledWith(
+        jasmine.objectContaining({
+          jasmineMessage: 'Unhandled promise rejection: Error: bar',
+          message: reason.message,
+          stack: reason.stack
+        })
+      );
+    });
+
+    describe('Enabling external interception of reported rejections by overriding global.onerror', function() {
+      it('overriding global.onerror intercepts rejections whose reason is a string', function() {
+        var fakeGlobal = jasmine.createSpyObj('globalErrors', [
+            'addEventListener'
+          ]),
+          handler = jasmine.createSpy('errorHandler'),
+          hijackHandler = jasmine.createSpy('hijackErrorHandler'),
+          errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+        errors.install();
+        errors.pushListener(handler);
+
+        fakeGlobal.onerror = hijackHandler;
+
+        var addedListener = fakeGlobal.addEventListener.calls.argsFor(0)[1];
+        addedListener({ reason: 'nope' });
+
+        expect(hijackHandler).toHaveBeenCalledWith(
+          'Unhandled promise rejection: nope'
+        );
+        expect(handler).not.toHaveBeenCalled();
+      });
+
+      it('overriding global.onerror intercepts rejections whose reason is an Error', function() {
+        var fakeGlobal = jasmine.createSpyObj('globalErrors', [
+            'addEventListener'
+          ]),
+          handler = jasmine.createSpy('errorHandler'),
+          hijackHandler = jasmine.createSpy('hijackErrorHandler'),
+          errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+
+        errors.install();
+        errors.pushListener(handler);
+
+        fakeGlobal.onerror = hijackHandler;
+
+        var addedListener = fakeGlobal.addEventListener.calls.argsFor(0)[1];
+        var reason;
+
+        try {
+          // Throwing ensures that we get a stack property in all browsers
+          throw new Error('bar');
+        } catch (e) {
+          reason = e;
+        }
+
+        addedListener({ reason: reason });
+
+        expect(hijackHandler).toHaveBeenCalledWith(
+          jasmine.objectContaining({
+            jasmineMessage: 'Unhandled promise rejection: Error: bar',
+            message: reason.message,
+            stack: reason.stack
+          })
+        );
+        expect(handler).not.toHaveBeenCalled();
+      });
+    });
+  });
 });

spec/core/PrettyPrintSpec.js

@@ -1,26 +1,29 @@
-describe('jasmineUnderTest.pp', function() {
+describe('PrettyPrinter', function() {
   it('should wrap strings in single quotes', function() {
-    expect(jasmineUnderTest.pp('some string')).toEqual("'some string'");
-    expect(jasmineUnderTest.pp("som' string")).toEqual("'som' string'");
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp('some string')).toEqual("'some string'");
+    expect(pp("som' string")).toEqual("'som' string'");
   });
 
   it('should stringify primitives properly', function() {
-    expect(jasmineUnderTest.pp(true)).toEqual('true');
-    expect(jasmineUnderTest.pp(false)).toEqual('false');
-    expect(jasmineUnderTest.pp(null)).toEqual('null');
-    expect(jasmineUnderTest.pp(jasmine.undefined)).toEqual('undefined');
-    expect(jasmineUnderTest.pp(3)).toEqual('3');
-    expect(jasmineUnderTest.pp(-3.14)).toEqual('-3.14');
-    expect(jasmineUnderTest.pp(-0)).toEqual('-0');
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp(true)).toEqual('true');
+    expect(pp(false)).toEqual('false');
+    expect(pp(null)).toEqual('null');
+    expect(pp(jasmine.undefined)).toEqual('undefined');
+    expect(pp(3)).toEqual('3');
+    expect(pp(-3.14)).toEqual('-3.14');
+    expect(pp(-0)).toEqual('-0');
   });
 
   describe('stringify sets', function() {
     it('should stringify sets properly', function() {
       jasmine.getEnv().requireFunctioningSets();
-      var set = new Set();
+      var set = new Set(); // eslint-disable-line compat/compat
       set.add(1);
       set.add(2);
-      expect(jasmineUnderTest.pp(set)).toEqual('Set( 1, 2 )');
+      var pp = jasmineUnderTest.makePrettyPrinter();
+      expect(pp(set)).toEqual('Set( 1, 2 )');
     });
 
     it('should truncate sets with more elements than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH', function() {
@@ -29,11 +32,12 @@ describe('jasmineUnderTest.pp', function() {
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        var set = new Set();
+        var set = new Set(); // eslint-disable-line compat/compat
         set.add('a');
         set.add('b');
         set.add('c');
-        expect(jasmineUnderTest.pp(set)).toEqual("Set( 'a', 'b', ... )");
+        var pp = jasmineUnderTest.makePrettyPrinter();
+        expect(pp(set)).toEqual("Set( 'a', 'b', ... )");
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
       }
@@ -43,9 +47,10 @@ describe('jasmineUnderTest.pp', function() {
   describe('stringify maps', function() {
     it('should stringify maps properly', function() {
       jasmine.getEnv().requireFunctioningMaps();
-      var map = new Map();
+      var map = new Map(); // eslint-disable-line compat/compat
       map.set(1, 2);
-      expect(jasmineUnderTest.pp(map)).toEqual('Map( [ 1, 2 ] )');
+      var pp = jasmineUnderTest.makePrettyPrinter();
+      expect(pp(map)).toEqual('Map( [ 1, 2 ] )');
     });
 
     it('should truncate maps with more elements than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH', function() {
@@ -54,13 +59,12 @@ describe('jasmineUnderTest.pp', function() {
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        var map = new Map();
+        var map = new Map(); // eslint-disable-line compat/compat
         map.set('a', 1);
         map.set('b', 2);
         map.set('c', 3);
-        expect(jasmineUnderTest.pp(map)).toEqual(
-          "Map( [ 'a', 1 ], [ 'b', 2 ], ... )"
-        );
+        var pp = jasmineUnderTest.makePrettyPrinter();
+        expect(pp(map)).toEqual("Map( [ 'a', 1 ], [ 'b', 2 ], ... )");
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
       }
@@ -69,43 +73,44 @@ describe('jasmineUnderTest.pp', function() {
 
   describe('stringify arrays', function() {
     it('should stringify arrays properly', function() {
-      expect(jasmineUnderTest.pp([1, 2])).toEqual('[ 1, 2 ]');
-      expect(
-        jasmineUnderTest.pp([1, 'foo', {}, jasmine.undefined, null])
-      ).toEqual("[ 1, 'foo', Object({  }), undefined, null ]");
+      var pp = jasmineUnderTest.makePrettyPrinter();
+      expect(pp([1, 2])).toEqual('[ 1, 2 ]');
+      expect(pp([1, 'foo', {}, jasmine.undefined, null])).toEqual(
+        "[ 1, 'foo', Object({  }), undefined, null ]"
+      );
     });
 
     it('should truncate arrays that are longer than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH', function() {
       var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
       var array = [1, 2, 3];
+      var pp = jasmineUnderTest.makePrettyPrinter();
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(array)).toEqual('[ 1, 2, ... ]');
+        expect(pp(array)).toEqual('[ 1, 2, ... ]');
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
       }
     });
 
     it('should stringify arrays with properties properly', function() {
+      var pp = jasmineUnderTest.makePrettyPrinter();
       var arr = [1, 2];
       arr.foo = 'bar';
       arr.baz = {};
-      expect(jasmineUnderTest.pp(arr)).toEqual(
-        "[ 1, 2, foo: 'bar', baz: Object({  }) ]"
-      );
+      expect(pp(arr)).toEqual("[ 1, 2, foo: 'bar', baz: Object({  }) ]");
     });
 
     it('should stringify empty arrays with properties properly', function() {
+      var pp = jasmineUnderTest.makePrettyPrinter();
       var empty = [];
       empty.foo = 'bar';
       empty.baz = {};
-      expect(jasmineUnderTest.pp(empty)).toEqual(
-        "[ foo: 'bar', baz: Object({  }) ]"
-      );
+      expect(pp(empty)).toEqual("[ foo: 'bar', baz: Object({  }) ]");
     });
 
     it('should stringify long arrays with properties properly', function() {
+      var pp = jasmineUnderTest.makePrettyPrinter();
       var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
       var long = [1, 2, 3];
       long.foo = 'bar';
@@ -113,7 +118,7 @@ describe('jasmineUnderTest.pp', function() {
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(long)).toEqual(
+        expect(pp(long)).toEqual(
           "[ 1, 2, ..., foo: 'bar', baz: Object({  }) ]"
         );
       } finally {
@@ -122,26 +127,25 @@ describe('jasmineUnderTest.pp', function() {
     });
 
     it('should indicate circular array references', function() {
+      var pp = jasmineUnderTest.makePrettyPrinter();
       var array1 = [1, 2];
       var array2 = [array1];
       array1.push(array2);
-      expect(jasmineUnderTest.pp(array1)).toEqual(
-        '[ 1, 2, [ <circular reference: Array> ] ]'
-      );
+      expect(pp(array1)).toEqual('[ 1, 2, [ <circular reference: Array> ] ]');
     });
 
     it('should not indicate circular references incorrectly', function() {
+      var pp = jasmineUnderTest.makePrettyPrinter();
       var array = [[1]];
-      expect(jasmineUnderTest.pp(array)).toEqual('[ [ 1 ] ]');
+      expect(pp(array)).toEqual('[ [ 1 ] ]');
     });
   });
 
   it('should stringify objects properly', function() {
-    expect(jasmineUnderTest.pp({ foo: 'bar' })).toEqual(
-      "Object({ foo: 'bar' })"
-    );
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp({ foo: 'bar' })).toEqual("Object({ foo: 'bar' })");
     expect(
-      jasmineUnderTest.pp({
+      pp({
         foo: 'bar',
         baz: 3,
         nullValue: null,
@@ -150,24 +154,24 @@ describe('jasmineUnderTest.pp', function() {
     ).toEqual(
       "Object({ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined })"
     );
-    expect(jasmineUnderTest.pp({ foo: function() {}, bar: [1, 2, 3] })).toEqual(
+    expect(pp({ foo: function() {}, bar: [1, 2, 3] })).toEqual(
       'Object({ foo: Function, bar: [ 1, 2, 3 ] })'
     );
   });
 
   it('should stringify objects that almost look like DOM nodes', function() {
-    expect(jasmineUnderTest.pp({ nodeType: 1 })).toEqual(
-      'Object({ nodeType: 1 })'
-    );
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp({ nodeType: 1 })).toEqual('Object({ nodeType: 1 })');
   });
 
   it('should truncate objects with too many keys', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     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, ... })');
+      expect(pp(long)).toEqual('Object({ a: 1, b: 2, ... })');
     } finally {
       jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
     }
@@ -185,12 +189,11 @@ describe('jasmineUnderTest.pp', function() {
   }
 
   it('should truncate outputs that are too long', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var big = [{ a: 1, b: 'a long string' }, {}];
 
     withMaxChars(34, function() {
-      expect(jasmineUnderTest.pp(big)).toEqual(
-        "[ Object({ a: 1, b: 'a long st ..."
-      );
+      expect(pp(big)).toEqual("[ Object({ a: 1, b: 'a long st ...");
     });
   });
 
@@ -214,59 +217,55 @@ describe('jasmineUnderTest.pp', function() {
         jasmineToString: jasmine
           .createSpy('d jasmineToString')
           .and.returnValue('')
-      };
+      },
+      pp = jasmineUnderTest.makePrettyPrinter();
 
     withMaxChars(30, function() {
-      jasmineUnderTest.pp([{ a: a, b: b, c: c }, d]);
+      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({');
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp({ constructor: function() {} })).toContain('null({');
+    expect(pp({ constructor: 'foo' })).toContain('null({');
   });
 
   it('should not include inherited properties when stringifying an object', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var SomeClass = function SomeClass() {};
     SomeClass.prototype.foo = 'inherited foo';
     var instance = new SomeClass();
     instance.bar = 'my own bar';
-    expect(jasmineUnderTest.pp(instance)).toEqual(
-      "SomeClass({ bar: 'my own bar' })"
-    );
+    expect(pp(instance)).toEqual("SomeClass({ bar: 'my own bar' })");
   });
 
   it('should not recurse objects and arrays more deeply than jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var originalMaxDepth = jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH;
     var nestedObject = { level1: { level2: { level3: { level4: 'leaf' } } } };
     var nestedArray = [1, [2, [3, [4, 'leaf']]]];
 
     try {
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 2;
-      expect(jasmineUnderTest.pp(nestedObject)).toEqual(
+      expect(pp(nestedObject)).toEqual(
         'Object({ level1: Object({ level2: Object }) })'
       );
-      expect(jasmineUnderTest.pp(nestedArray)).toEqual('[ 1, [ 2, Array ] ]');
+      expect(pp(nestedArray)).toEqual('[ 1, [ 2, Array ] ]');
 
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 3;
-      expect(jasmineUnderTest.pp(nestedObject)).toEqual(
+      expect(pp(nestedObject)).toEqual(
         'Object({ level1: Object({ level2: Object({ level3: Object }) }) })'
       );
-      expect(jasmineUnderTest.pp(nestedArray)).toEqual(
-        '[ 1, [ 2, [ 3, Array ] ] ]'
-      );
+      expect(pp(nestedArray)).toEqual('[ 1, [ 2, [ 3, Array ] ] ]');
 
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 4;
-      expect(jasmineUnderTest.pp(nestedObject)).toEqual(
+      expect(pp(nestedObject)).toEqual(
         "Object({ level1: Object({ level2: Object({ level3: Object({ level4: 'leaf' }) }) }) })"
       );
-      expect(jasmineUnderTest.pp(nestedArray)).toEqual(
-        "[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]"
-      );
+      expect(pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
     } finally {
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
     }
@@ -274,28 +273,32 @@ describe('jasmineUnderTest.pp', function() {
 
   it('should stringify immutable circular objects', function() {
     if (Object.freeze) {
+      var pp = jasmineUnderTest.makePrettyPrinter();
       var frozenObject = { foo: { bar: 'baz' } };
       frozenObject.circular = frozenObject;
       frozenObject = Object.freeze(frozenObject);
-      expect(jasmineUnderTest.pp(frozenObject)).toEqual(
+      expect(pp(frozenObject)).toEqual(
         "Object({ foo: Object({ bar: 'baz' }), circular: <circular reference: Object> })"
       );
     }
   });
 
   it('should stringify RegExp objects properly', function() {
-    expect(jasmineUnderTest.pp(/x|y|z/)).toEqual('/x|y|z/');
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp(/x|y|z/)).toEqual('/x|y|z/');
   });
 
   it('should indicate circular object references', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var sampleValue = { foo: 'hello' };
     sampleValue.nested = sampleValue;
-    expect(jasmineUnderTest.pp(sampleValue)).toEqual(
+    expect(pp(sampleValue)).toEqual(
       "Object({ foo: 'hello', nested: <circular reference: Object> })"
     );
   });
 
   it('should indicate getters on objects as such', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var sampleValue = { id: 1 };
     if (sampleValue.__defineGetter__) {
       //not supported in IE!
@@ -304,95 +307,117 @@ describe('jasmineUnderTest.pp', function() {
       });
     }
     if (sampleValue.__defineGetter__) {
-      expect(jasmineUnderTest.pp(sampleValue)).toEqual(
+      expect(pp(sampleValue)).toEqual(
         'Object({ id: 1, calculatedValue: <getter> })'
       );
     } else {
-      expect(jasmineUnderTest.pp(sampleValue)).toEqual('Object({ id: 1 })');
+      expect(pp(sampleValue)).toEqual('Object({ id: 1 })');
     }
   });
 
   it('should not do HTML escaping of strings', function() {
-    expect(jasmineUnderTest.pp('some <b>html string</b> &', false)).toEqual(
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp('some <b>html string</b> &', false)).toEqual(
       "'some <b>html string</b> &'"
     );
   });
 
   it('should abbreviate the global (usually window) object', function() {
-    expect(jasmineUnderTest.pp(jasmine.getGlobal())).toEqual('<global>');
+    var pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp(jasmine.getGlobal())).toEqual('<global>');
   });
 
   it('should stringify Date objects properly', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var now = new Date();
-    expect(jasmineUnderTest.pp(now)).toEqual('Date(' + now.toString() + ')');
+    expect(pp(now)).toEqual('Date(' + now.toString() + ')');
   });
 
-  it('should stringify spy objects properly', function() {
-    var TestObject = {
-        someFunction: function() {}
-      },
-      env = new jasmineUnderTest.Env();
+  describe('with a spy object', function() {
+    var env, pp;
 
-    var spyRegistry = new jasmineUnderTest.SpyRegistry({
-      currentSpies: function() {
-        return [];
-      },
-      createSpy: function(name, originalFn) {
-        return jasmineUnderTest.Spy(name, originalFn);
-      }
+    beforeEach(function() {
+      env = new jasmineUnderTest.Env();
+      pp = jasmineUnderTest.makePrettyPrinter();
     });
 
-    spyRegistry.spyOn(TestObject, 'someFunction');
-    expect(jasmineUnderTest.pp(TestObject.someFunction)).toEqual(
-      'spy on someFunction'
-    );
-
-    expect(jasmineUnderTest.pp(env.createSpy('something'))).toEqual(
-      'spy on something'
-    );
-  });
-
-  it('should stringify spyOn toString properly', function() {
-    var TestObject = {
-        someFunction: function() {}
-      },
-      env = new jasmineUnderTest.Env();
-
-    var spyRegistry = new jasmineUnderTest.SpyRegistry({
-      currentSpies: function() {
-        return [];
-      },
-      createSpy: function(name, originalFn) {
-        return jasmineUnderTest.Spy(name, originalFn);
-      }
+    afterEach(function() {
+      env.cleanup_();
     });
 
-    spyRegistry.spyOn(TestObject, 'toString');
-    var testSpyObj = env.createSpyObj('TheClassName', ['toString']);
+    it('should stringify spy objects properly', function() {
+      var TestObject = {
+        someFunction: function() {}
+      };
 
-    expect(jasmineUnderTest.pp(testSpyObj)).toEqual(
-      'spy on TheClassName.toString'
-    );
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+        currentSpies: function() {
+          return [];
+        },
+        createSpy: function(name, originalFn) {
+          return jasmineUnderTest.Spy(name, originalFn);
+        }
+      });
+
+      spyRegistry.spyOn(TestObject, 'someFunction');
+      expect(pp(TestObject.someFunction)).toEqual('spy on someFunction');
+
+      expect(pp(env.createSpy('something'))).toEqual('spy on something');
+    });
+
+    it('should stringify spyOn toString properly', function() {
+      var TestObject = {
+          someFunction: function() {}
+        },
+        env = new jasmineUnderTest.Env(),
+        pp = jasmineUnderTest.makePrettyPrinter();
+
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+        currentSpies: function() {
+          return [];
+        },
+        createSpy: function(name, originalFn) {
+          return jasmineUnderTest.Spy(name, originalFn);
+        }
+      });
+
+      spyRegistry.spyOn(TestObject, 'toString');
+      var testSpyObj = env.createSpyObj('TheClassName', ['toString']);
+
+      expect(pp(testSpyObj)).toEqual('spy on TheClassName.toString');
+    });
   });
 
   it('should stringify objects that implement jasmineToString', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var obj = {
       jasmineToString: function() {
         return 'strung';
       }
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual('strung');
+    expect(pp(obj)).toEqual('strung');
+  });
+
+  it('should pass itself to jasmineToString', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter([]);
+    var obj = {
+      jasmineToString: jasmine.createSpy('jasmineToString').and.returnValue('')
+    };
+
+    pp(obj);
+    expect(obj.jasmineToString).toHaveBeenCalledWith(pp);
   });
 
   it('should stringify objects that implement custom toString', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var obj = {
       toString: function() {
         return 'my toString';
       }
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual('my toString');
+    expect(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
@@ -403,20 +428,22 @@ describe('jasmineUnderTest.pp', function() {
       }
     };
 
-    expect(jasmineUnderTest.pp(objFromOtherContext)).toEqual(
+    expect(pp(objFromOtherContext)).toEqual(
       "Object({ foo: 'bar', toString: Function })"
     );
   });
 
   it("should stringify objects have have a toString that isn't a function", function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var obj = {
       toString: 'foo'
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual("Object({ toString: 'foo' })");
+    expect(pp(obj)).toEqual("Object({ toString: 'foo' })");
   });
 
   it('should stringify objects from anonymous constructors with custom toString', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var MyAnonymousConstructor = (function() {
       return function() {};
     })();
@@ -426,17 +453,19 @@ describe('jasmineUnderTest.pp', function() {
 
     var a = new MyAnonymousConstructor();
 
-    expect(jasmineUnderTest.pp(a)).toEqual('<anonymous>({  })');
+    expect(pp(a)).toEqual('<anonymous>({  })');
   });
 
   it('should handle objects with null prototype', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var obj = Object.create(null);
     obj.foo = 'bar';
 
-    expect(jasmineUnderTest.pp(obj)).toEqual("null({ foo: 'bar' })");
+    expect(pp(obj)).toEqual("null({ foo: 'bar' })");
   });
 
   it('should gracefully handle objects with invalid toString implementations', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter();
     var obj = {
       foo: {
         toString: function() {
@@ -466,8 +495,72 @@ describe('jasmineUnderTest.pp', function() {
       }
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual(
+    expect(pp(obj)).toEqual(
       'Object({ foo: [object Number], bar: [object Object], baz: 3, qux: Error: bar, baddy: has-invalid-toString-method })'
     );
   });
+
+  describe('Custom object formatters', function() {
+    it('should use the first custom object formatter that does not return undefined', function() {
+      var customObjectFormatters = [
+          function(obj) {
+            return undefined;
+          },
+          function(obj) {
+            return '2nd: ' + obj.foo;
+          },
+          function(obj) {
+            return '3rd: ' + obj.foo;
+          }
+        ],
+        pp = jasmineUnderTest.makePrettyPrinter(customObjectFormatters),
+        obj = { foo: 'bar' };
+
+      expect(pp(obj)).toEqual('2nd: bar');
+    });
+
+    it('should fall back to built in logic if all custom object formatters return undefined', function() {
+      var customObjectFormatters = [
+          function(obj) {
+            return undefined;
+          }
+        ],
+        pp = jasmineUnderTest.makePrettyPrinter(customObjectFormatters),
+        obj = { foo: 'bar' };
+
+      expect(pp(obj)).toEqual("Object({ foo: 'bar' })");
+    });
+  });
+
+  describe('#customFormat_', function() {
+    it('should use the first custom object formatter that does not return undefined', function() {
+      var customObjectFormatters = [
+          function(obj) {
+            return undefined;
+          },
+          function(obj) {
+            return '2nd: ' + obj.foo;
+          },
+          function(obj) {
+            return '3rd: ' + obj.foo;
+          }
+        ],
+        pp = jasmineUnderTest.makePrettyPrinter(customObjectFormatters),
+        obj = { foo: 'bar' };
+
+      expect(pp.customFormat_(obj)).toEqual('2nd: bar');
+    });
+
+    it('should return undefined if all custom object formatters return undefined', function() {
+      var customObjectFormatters = [
+          function(obj) {
+            return undefined;
+          }
+        ],
+        pp = jasmineUnderTest.makePrettyPrinter(customObjectFormatters),
+        obj = { foo: 'bar' };
+
+      expect(pp.customFormat_(obj)).toBeUndefined();
+    });
+  });
 });

spec/core/QueueRunnerSpec.js

@@ -512,6 +512,50 @@ describe('QueueRunner', function() {
       expect(onExceptionCallback).toHaveBeenCalledWith('foo');
       expect(queueableFn2.fn).toHaveBeenCalled();
     });
+
+    it('issues a deprecation if the function also takes a parameter', function() {
+      var queueableFn = {
+          fn: function(done) {
+            return new StubPromise();
+          }
+        },
+        deprecated = jasmine.createSpy('deprecated'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn],
+          deprecated: deprecated
+        }),
+        env = jasmineUnderTest.getEnv();
+
+      queueRunner.execute();
+
+      expect(deprecated).toHaveBeenCalledWith(
+        'An asynchronous ' +
+          'before/it/after function took a done callback but also returned a ' +
+          'promise. This is not supported and will stop working in the future. ' +
+          'Either remove the done callback (recommended) or change the function ' +
+          'to not return a promise.'
+      );
+    });
+
+    it('issues a more specific deprecation if the function is `async`', function() {
+      jasmine.getEnv().requireAsyncAwait();
+      eval('var fn = async function(done){};');
+      var deprecated = jasmine.createSpy('deprecated'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [{ fn: fn }],
+          deprecated: deprecated
+        });
+
+      queueRunner.execute();
+
+      expect(deprecated).toHaveBeenCalledWith(
+        'An asynchronous ' +
+          'before/it/after function was defined with the async keyword but ' +
+          'also took a done callback. This is not supported and will stop ' +
+          'working in the future. Either remove the done callback ' +
+          '(recommended) or remove the async keyword.'
+      );
+    });
   });
 
   it('passes the error instance to exception handlers in HTML browsers', function() {

spec/core/SpecSpec.js

@@ -227,7 +227,8 @@ describe('Spec', function() {
         passedExpectations: [],
         deprecationWarnings: [],
         pendingReason: '',
-        duration: null
+        duration: jasmine.any(Number),
+        properties: null
       },
       'things'
     );
@@ -273,8 +274,34 @@ describe('Spec', function() {
   });
 
   it('should report the duration of the test', function() {
+    var timer = jasmine.createSpyObj('timer', { start: null, elapsed: 77000 }),
+      spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: jasmine.createSpy('spec body') },
+        catchExceptions: function() {
+          return false;
+        },
+        resultCallback: function(result) {
+          duration = result.duration;
+        },
+        queueRunnerFactory: function(config) {
+          config.queueableFns.forEach(function(qf) {
+            qf.fn();
+          });
+          config.cleanupFns.forEach(function(qf) {
+            qf.fn();
+          });
+          config.onComplete();
+        },
+        timer: timer
+      }),
+      duration = undefined;
+
+    spec.execute(function() {});
+    expect(duration).toBe(77000);
+  });
+
+  it('should report properties set during the test', function() {
     var done = jasmine.createSpy('done callback'),
-      timer = jasmine.createSpyObj('timer', { start: null, elapsed: 77000 }),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: jasmine.createSpy('spec body') },
         catchExceptions: function() {
@@ -283,11 +310,11 @@ describe('Spec', function() {
         resultCallback: function() {},
         queueRunnerFactory: function(attrs) {
           attrs.onComplete();
-        },
-        timer: timer
+        }
       });
+    spec.setSpecProperty('a', 4);
     spec.execute(done);
-    expect(spec.result.duration).toBe(77000);
+    expect(spec.result.properties).toEqual({ a: 4 });
   });
 
   it('#status returns passing by default', function() {

spec/core/SpySpec.js

@@ -5,6 +5,10 @@ describe('Spies', function() {
     env = new jasmineUnderTest.Env();
   });
 
+  afterEach(function() {
+    env.cleanup_();
+  });
+
   describe('createSpy', function() {
     var TestClass;
 
@@ -179,14 +183,13 @@ describe('Spies', function() {
       var spyObj = env.createSpyObj('base', ['method1'], ['prop1']);
 
       expect(spyObj).toEqual({
-        method1: jasmine.any(Function)
+        method1: jasmine.any(Function),
+        prop1: undefined
       });
 
       var descriptor = Object.getOwnPropertyDescriptor(spyObj, 'prop1');
       expect(descriptor.get.and.identity).toEqual('base.prop1.get');
       expect(descriptor.set.and.identity).toEqual('base.prop1.set');
-
-      expect(spyObj.prop1).toBeUndefined();
     });
 
     it('creates an object with property names and return values if second object is passed', function() {
@@ -196,7 +199,9 @@ describe('Spies', function() {
       });
 
       expect(spyObj).toEqual({
-        method1: jasmine.any(Function)
+        method1: jasmine.any(Function),
+        prop1: 'foo',
+        prop2: 37
       });
 
       expect(spyObj.prop1).toEqual('foo');

spec/core/SpyStrategySpec.js

@@ -70,7 +70,7 @@ describe('SpyStrategy', function() {
     expect(originalFn).not.toHaveBeenCalled();
   });
 
-  it('allows a non-Error to be thrown, wrapping it into an exception when executed', function() {
+  it('allows a string to be thrown, wrapping it into an exception when executed', function() {
     var originalFn = jasmine.createSpy('original'),
       spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
@@ -82,6 +82,18 @@ describe('SpyStrategy', function() {
     expect(originalFn).not.toHaveBeenCalled();
   });
 
+  it('allows a non-Error to be thrown when executed', function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
+
+    spyStrategy.throwError({ code: 'ESRCH' });
+
+    expect(function() {
+      spyStrategy.exec();
+    }).toThrow({ code: 'ESRCH' });
+    expect(originalFn).not.toHaveBeenCalled();
+  });
+
   it('allows a fake function to be called instead', function() {
     var originalFn = jasmine.createSpy('original'),
       fakeFn = jasmine.createSpy('fake').and.returnValue(67),
@@ -140,6 +152,28 @@ describe('SpyStrategy', function() {
         .catch(done.fail);
     });
 
+    it('allows an empty resolved promise to be returned', function(done) {
+      jasmine.getEnv().requirePromises();
+
+      var originalFn = jasmine.createSpy('original'),
+        getPromise = function() {
+          return Promise;
+        },
+        spyStrategy = new jasmineUnderTest.SpyStrategy({
+          fn: originalFn,
+          getPromise: getPromise
+        });
+
+      spyStrategy.resolveTo();
+      spyStrategy
+        .exec()
+        .then(function(returnValue) {
+          expect(returnValue).toBe();
+          done();
+        })
+        .catch(done.fail);
+    });
+
     it('fails if promises are not available', function() {
       var originalFn = jasmine.createSpy('original'),
         spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
@@ -176,6 +210,29 @@ describe('SpyStrategy', function() {
         .catch(done.fail);
     });
 
+    it('allows an empty rejected promise to be returned', function(done) {
+      jasmine.getEnv().requirePromises();
+
+      var originalFn = jasmine.createSpy('original'),
+        getPromise = function() {
+          return Promise;
+        },
+        spyStrategy = new jasmineUnderTest.SpyStrategy({
+          fn: originalFn,
+          getPromise: getPromise
+        });
+
+      spyStrategy.rejectWith();
+      spyStrategy
+        .exec()
+        .then(done.fail)
+        .catch(function(error) {
+          expect(error).toBe();
+          done();
+        })
+        .catch(done.fail);
+    });
+
     it('allows a non-Error to be rejected', function(done) {
       jasmine.getEnv().requirePromises();
 
@@ -277,6 +334,17 @@ describe('SpyStrategy', function() {
     }).toThrowError(/^Argument passed to callFake should be a function, got/);
   });
 
+  it('allows generator functions to be passed to callFake strategy', function() {
+    jasmine.getEnv().requireGeneratorFunctions();
+
+    var generator = jasmine.getEnv().makeGeneratorFunction('yield "ok";'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: function() {} });
+
+    spyStrategy.callFake(generator);
+
+    expect(spyStrategy.exec().next().value).toEqual('ok');
+  });
+
   it('allows a return to plan stubbing after another strategy', function() {
     var originalFn = jasmine.createSpy('original'),
       fakeFn = jasmine.createSpy('fake').and.returnValue(67),

spec/core/StackTraceSpec.js

@@ -213,4 +213,46 @@ describe('StackTrace', function() {
       }
     ]);
   });
+
+  it('consideres different types of errors', function() {
+    var error = {
+      message: 'nope',
+      stack:
+        'TypeError: 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('TypeError: nope');
+    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
+      }
+    ]);
+
+    var no_error = {
+      message: 'nope',
+      stack:
+        'Type 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_no_error = new jasmineUnderTest.StackTrace(no_error);
+
+    expect(result_no_error.message).not.toEqual(jasmine.anything());
+  });
 });

spec/core/SuiteSpec.js

@@ -1,28 +1,35 @@
 describe('Suite', function() {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+  });
+
+  afterEach(function() {
+    env.cleanup_();
+  });
+
   it('keeps its id', function() {
-    var env = new jasmineUnderTest.Env(),
-      suite = new jasmineUnderTest.Suite({
-        env: env,
-        id: 456,
-        description: 'I am a suite'
-      });
+    var suite = new jasmineUnderTest.Suite({
+      env: env,
+      id: 456,
+      description: 'I am a suite'
+    });
 
     expect(suite.id).toEqual(456);
   });
 
   it('returns blank full name for top level suite', function() {
-    var env = new jasmineUnderTest.Env(),
-      suite = new jasmineUnderTest.Suite({
-        env: env,
-        description: 'I am a suite'
-      });
+    var suite = new jasmineUnderTest.Suite({
+      env: env,
+      description: 'I am a suite'
+    });
 
     expect(suite.getFullName()).toEqual('');
   });
 
   it('returns its full name when it has parent suites', function() {
-    var env = new jasmineUnderTest.Env(),
-      parentSuite = new jasmineUnderTest.Suite({
+    var parentSuite = new jasmineUnderTest.Suite({
         env: env,
         description: 'I am a parent suite',
         parentSuite: jasmine.createSpy('pretend top level suite')
@@ -37,8 +44,7 @@ describe('Suite', function() {
   });
 
   it('adds before functions in order of needed execution', function() {
-    var env = new jasmineUnderTest.Env(),
-      suite = new jasmineUnderTest.Suite({
+    var suite = new jasmineUnderTest.Suite({
         env: env,
         description: 'I am a suite'
       }),
@@ -52,8 +58,7 @@ describe('Suite', function() {
   });
 
   it('adds after functions in order of needed execution', function() {
-    var env = new jasmineUnderTest.Env(),
-      suite = new jasmineUnderTest.Suite({
+    var suite = new jasmineUnderTest.Suite({
         env: env,
         description: 'I am a suite'
       }),
@@ -115,13 +120,12 @@ describe('Suite', function() {
   });
 
   it('calls timer to compute duration', function() {
-    var env = new jasmineUnderTest.Env(),
-      suite = new jasmineUnderTest.Suite({
-        env: env,
-        id: 456,
-        description: 'I am a suite',
-        timer: jasmine.createSpyObj('timer', { start: null, elapsed: 77000 })
-      });
+    var suite = new jasmineUnderTest.Suite({
+      env: env,
+      id: 456,
+      description: 'I am a suite',
+      timer: jasmine.createSpyObj('timer', { start: null, elapsed: 77000 })
+    });
     suite.startTimer();
     suite.endTimer();
     expect(suite.getResult().duration).toEqual(77000);

spec/core/UtilSpec.js

@@ -40,7 +40,7 @@ describe('jasmineUnderTest.util', function() {
 
     beforeEach(function() {
       jasmine.getEnv().requirePromises();
-      mockNativePromise = new Promise(function(res, rej) {});
+      mockNativePromise = new Promise(function(res, rej) {}); // eslint-disable-line compat/compat
       mockPromiseLikeObject = new mockPromiseLike();
     });
 

spec/core/asymmetricEqualityTesterArgCompatShimSpec.js

@@ -0,0 +1,140 @@
+describe('asymmetricEqualityTesterArgCompatShim', function() {
+  it('provides all the properties of the MatchersUtil', function() {
+    var matchersUtil = {
+        foo: function() {},
+        bar: function() {}
+      },
+      shim = jasmineUnderTest.asymmetricEqualityTesterArgCompatShim(
+        matchersUtil,
+        []
+      );
+
+    expect(shim.foo).toBe(matchersUtil.foo);
+    expect(shim.bar).toBe(matchersUtil.bar);
+  });
+
+  it('provides all the properties of the customEqualityTesters', function() {
+    var customEqualityTesters = [function() {}, function() {}],
+      shim = jasmineUnderTest.asymmetricEqualityTesterArgCompatShim(
+        {},
+        customEqualityTesters
+      );
+
+    expect(shim.length).toBe(2);
+    expect(shim[0]).toBe(customEqualityTesters[0]);
+    expect(shim[1]).toBe(customEqualityTesters[1]);
+  });
+
+  it('provides all the properties of Array.prototype', function() {
+    var shim = jasmineUnderTest.asymmetricEqualityTesterArgCompatShim({}, []);
+
+    expect(shim.filter).toBe(Array.prototype.filter);
+    expect(shim.forEach).toBe(Array.prototype.forEach);
+    expect(shim.map).toBe(Array.prototype.map);
+  });
+
+  it('provides properties of Array.prototype', function() {
+    var keys = [
+        'concat',
+        'every',
+        'filter',
+        'forEach',
+        'indexOf',
+        'join',
+        'lastIndexOf',
+        'length',
+        'map',
+        'pop',
+        'push',
+        'reduce',
+        'reduceRight',
+        'reverse',
+        'shift',
+        'slice',
+        'some',
+        'sort',
+        'splice',
+        'unshift'
+      ],
+      optionalKeys = [
+        'copyWithin',
+        'entries',
+        'fill',
+        'find',
+        'findIndex',
+        'flat',
+        'flatMap',
+        'includes',
+        'keys',
+        'toSource',
+        'values'
+      ],
+      shim = jasmineUnderTest.asymmetricEqualityTesterArgCompatShim({}, []),
+      i,
+      k;
+
+    // Properties that are present on all supported runtimes
+    for (i = 0; i < keys.length; i++) {
+      k = keys[i];
+      expect(shim[k])
+        .withContext(k)
+        .not.toBeUndefined();
+      expect(shim[k])
+        .withContext(k)
+        .toBe(Array.prototype[k]);
+    }
+
+    // Properties that are present on only some supported runtimes
+    for (i = 0; i < optionalKeys.length; i++) {
+      k = optionalKeys[i];
+
+      if (shim[k] !== undefined) {
+        expect(shim[k])
+          .withContext(k)
+          .toBe(Array.prototype[k]);
+      }
+    }
+  });
+
+  describe('When Array.prototype additions collide with MatchersUtil methods', function() {
+    function keys() {
+      return [
+        'contains',
+        'buildFailureMessage',
+        'asymmetricDiff_',
+        'asymmetricMatch_',
+        'equals',
+        'eq_'
+      ];
+    }
+
+    beforeEach(function() {
+      keys().forEach(function(k) {
+        expect(Array.prototype[k])
+          .withContext('Array.prototype already had ' + k)
+          .toBeUndefined();
+        Array.prototype[k] = function() {};
+      });
+    });
+
+    afterEach(function() {
+      keys().forEach(function(k) {
+        delete Array.prototype[k];
+      });
+    });
+
+    it('uses the MatchersUtil methods', function() {
+      var matchersUtil = new jasmineUnderTest.MatchersUtil({}),
+        shim = jasmineUnderTest.asymmetricEqualityTesterArgCompatShim(
+          matchersUtil,
+          []
+        );
+
+      keys().forEach(function(k) {
+        expect(shim[k])
+          .withContext(k + ' was overwritten')
+          .toBe(jasmineUnderTest.MatchersUtil.prototype[k]);
+      });
+    });
+  });
+});

spec/core/asymmetric_equality/AnySpec.js

@@ -1,74 +1,74 @@
-describe("Any", function() {
-  it("matches a string", function() {
+describe('Any', function() {
+  it('matches a string', function() {
     var any = new jasmineUnderTest.Any(String);
 
-    expect(any.asymmetricMatch("foo")).toBe(true);
+    expect(any.asymmetricMatch('foo')).toBe(true);
   });
 
-  it("matches a number", function() {
+  it('matches a number', function() {
     var any = new jasmineUnderTest.Any(Number);
 
     expect(any.asymmetricMatch(1)).toBe(true);
   });
 
-  it("matches a function", function() {
+  it('matches a function', function() {
     var any = new jasmineUnderTest.Any(Function);
 
-    expect(any.asymmetricMatch(function(){})).toBe(true);
+    expect(any.asymmetricMatch(function() {})).toBe(true);
   });
 
-  it("matches an Object", function() {
+  it('matches an Object', function() {
     var any = new jasmineUnderTest.Any(Object);
 
     expect(any.asymmetricMatch({})).toBe(true);
   });
 
-  it("matches a Boolean", function() {
+  it('matches a Boolean', function() {
     var any = new jasmineUnderTest.Any(Boolean);
 
     expect(any.asymmetricMatch(true)).toBe(true);
   });
 
-  it("matches a Map", function() {
+  it('matches a Map', function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var any = new jasmineUnderTest.Any(Map);
 
-    expect(any.asymmetricMatch(new Map())).toBe(true);
+    expect(any.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Set", function() {
+  it('matches a Set', function() {
     jasmine.getEnv().requireFunctioningSets();
 
     var any = new jasmineUnderTest.Any(Set);
 
-    expect(any.asymmetricMatch(new Set())).toBe(true);
+    expect(any.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a TypedArray", function() {
+  it('matches a TypedArray', function() {
     jasmine.getEnv().requireFunctioningTypedArrays();
 
-    var any = new jasmineUnderTest.Any(Uint32Array);
+    var any = new jasmineUnderTest.Any(Uint32Array); // eslint-disable-line compat/compat
 
-    expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true);
+    expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Symbol", function() {
+  it('matches a Symbol', function() {
     jasmine.getEnv().requireFunctioningSymbols();
 
-    var any = new jasmineUnderTest.Any(Symbol);
+    var any = new jasmineUnderTest.Any(Symbol); // eslint-disable-line compat/compat
 
-    expect(any.asymmetricMatch(Symbol())).toBe(true);
+    expect(any.asymmetricMatch(Symbol())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches another constructed object", function() {
+  it('matches another constructed object', function() {
     var Thing = function() {},
       any = new jasmineUnderTest.Any(Thing);
 
     expect(any.asymmetricMatch(new Thing())).toBe(true);
   });
 
-  it("does not treat null as an Object", function() {
+  it('does not treat null as an Object', function() {
     var any = new jasmineUnderTest.Any(Object);
 
     expect(any.asymmetricMatch(null)).toBe(false);
@@ -81,8 +81,8 @@ describe("Any", function() {
     expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
   });
 
-  describe("when called without an argument", function() {
-    it("tells the user to pass a constructor or use jasmine.anything()", function() {
+  describe('when called without an argument', function() {
+    it('tells the user to pass a constructor or use jasmine.anything()', function() {
       expect(function() {
         new jasmineUnderTest.Any();
       }).toThrowError(TypeError, /constructor.*anything/);

spec/core/asymmetric_equality/AnythingSpec.js

@@ -1,58 +1,58 @@
-describe("Anything", function() {
-  it("matches a string", function() {
+describe('Anything', function() {
+  it('matches a string', function() {
     var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch('foo')).toBe(true);
   });
 
-  it("matches a number", function() {
+  it('matches a number', function() {
     var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch(42)).toBe(true);
   });
 
-  it("matches an object", function() {
+  it('matches an object', function() {
     var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch({ foo: 'bar' })).toBe(true);
   });
 
-  it("matches an array", function() {
+  it('matches an array', function() {
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.asymmetricMatch([1,2,3])).toBe(true);
+    expect(anything.asymmetricMatch([1, 2, 3])).toBe(true);
   });
 
-  it("matches a Map", function() {
+  it('matches a Map', function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.asymmetricMatch(new Map())).toBe(true);
+    expect(anything.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Set", function() {
+  it('matches a Set', function() {
     jasmine.getEnv().requireFunctioningSets();
 
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.asymmetricMatch(new Set())).toBe(true);
+    expect(anything.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a TypedArray", function() {
+  it('matches a TypedArray', function() {
     jasmine.getEnv().requireFunctioningTypedArrays();
 
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true);
+    expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Symbol", function() {
+  it('matches a Symbol', function() {
     jasmine.getEnv().requireFunctioningSymbols();
 
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.asymmetricMatch(Symbol())).toBe(true);
+    expect(anything.asymmetricMatch(Symbol())).toBe(true); // eslint-disable-line compat/compat
   });
 
   it("doesn't match undefined", function() {
@@ -71,6 +71,6 @@ describe("Anything", function() {
   it("jasmineToString's itself", function() {
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.jasmineToString()).toEqual("<jasmine.anything>");
+    expect(anything.jasmineToString()).toEqual('<jasmine.anything>');
   });
 });

spec/core/asymmetric_equality/ArrayContainingSpec.js

@@ -1,58 +1,74 @@
-describe("ArrayContaining", function() {
-  it("matches any actual to an empty array", function() {
+describe('ArrayContaining', function() {
+  it('matches any actual to an empty array', function() {
     var containing = new jasmineUnderTest.ArrayContaining([]);
 
-    expect(containing.asymmetricMatch("foo")).toBe(true);
+    expect(containing.asymmetricMatch('foo')).toBe(true);
   });
 
-  it("does not work when not passed an array", function() {
-    var containing = new jasmineUnderTest.ArrayContaining("foo");
+  it('does not work when not passed an array', function() {
+    var containing = new jasmineUnderTest.ArrayContaining('foo');
 
     expect(function() {
       containing.asymmetricMatch([]);
     }).toThrowError(/not 'foo'/);
   });
 
-  it("matches when the item is in the actual", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+  it('matches when the item is in the actual', function() {
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(["foo"])).toBe(true);
+    expect(containing.asymmetricMatch(['foo'], matchersUtil)).toBe(true);
   });
 
-  it("matches when additional items are in the actual", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+  it('matches when additional items are in the actual', function() {
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(["foo", "bar"])).toBe(true);
+    expect(containing.asymmetricMatch(['foo', 'bar'], matchersUtil)).toBe(true);
   });
 
-  it("does not match when the item is not in the actual", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+  it('does not match when the item is not in the actual', function() {
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(["bar"])).toBe(false);
+    expect(containing.asymmetricMatch(['bar'], matchersUtil)).toBe(false);
   });
 
-  it("does not match when the actual is not an array", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+  it('does not match when the actual is not an array', function() {
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch("foo")).toBe(false);
+    expect(containing.asymmetricMatch('foo', matchersUtil)).toBe(false);
   });
 
-  it("jasmineToStrings itself", function() {
-    var containing = new jasmineUnderTest.ArrayContaining([]);
+  it('jasmineToStrings itself', function() {
+    var sample = [],
+      matcher = new jasmineUnderTest.ArrayContaining(sample),
+      pp = jasmine.createSpy('pp').and.returnValue('sample');
 
-    expect(containing.jasmineToString()).toMatch("<jasmine.arrayContaining");
+    expect(matcher.jasmineToString(pp)).toEqual(
+      '<jasmine.arrayContaining(sample)>'
+    );
+    expect(pp).toHaveBeenCalledWith(sample);
   });
 
-  it("uses custom equality testers", function() {
+  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") {
+      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"]);
+    var containing = new jasmineUnderTest.ArrayContaining(['fooVal']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(containing.asymmetricMatch(["fooBar"], [tester])).toBe(true);
+    expect(containing.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
   });
 });

spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js

@@ -1,47 +1,64 @@
-describe("ArrayWithExactContents", function() {
-  it("matches an array with the same items in a different order", function() {
+describe('ArrayWithExactContents', function() {
+  it('matches an array with the same items in a different order', function() {
     var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(matcher.asymmetricMatch([2, 'a', /a/])).toBe(true);
+    expect(matcher.asymmetricMatch([2, 'a', /a/], matchersUtil)).toBe(true);
   });
 
-  it("does not work when not passed an array", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents("foo");
+  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() {
+  it('does not match when an item is missing', function() {
     var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(matcher.asymmetricMatch(['a', 2])).toBe(false);
-    expect(matcher.asymmetricMatch(['a', 2, undefined])).toBe(false);
+    expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
+    expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(
+      false
+    );
   });
 
-  it("does not match when there is an extra item", function() {
+  it('does not match when there is an extra item', function() {
     var matcher = new jasmineUnderTest.ArrayWithExactContents(['a']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(matcher.asymmetricMatch(['a', 2])).toBe(false);
+    expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
   });
 
-  it("jasmineToStrings itself", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents([]);
+  it('jasmineToStrings itself', function() {
+    var sample = [],
+      matcher = new jasmineUnderTest.ArrayWithExactContents(sample),
+      pp = jasmine.createSpy('pp').and.returnValue('sample');
 
-    expect(matcher.jasmineToString()).toMatch("<jasmine.arrayWithExactContents");
+    expect(matcher.jasmineToString(pp)).toEqual(
+      '<jasmine.arrayWithExactContents(sample)>'
+    );
+    expect(pp).toHaveBeenCalledWith(sample);
   });
 
-  it("uses custom equality testers", function() {
+  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") {
+      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"]);
+    var matcher = new jasmineUnderTest.ArrayWithExactContents(['fooVal']);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(matcher.asymmetricMatch(["fooBar"], [tester])).toBe(true);
+    expect(matcher.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
   });
 });

spec/core/asymmetric_equality/EmptySpec.js

@@ -1,51 +1,51 @@
-describe("Empty", function () {
-  it("matches an empty object", function () {
+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);
+    expect(empty.asymmetricMatch({ undefined: false })).toBe(false);
   });
 
-  it("matches an empty array", function () {
+  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 () {
+  it('matches an empty string', function() {
     var empty = new jasmineUnderTest.Empty();
 
-    expect(empty.asymmetricMatch("")).toBe(true);
+    expect(empty.asymmetricMatch('')).toBe(true);
     expect(empty.asymmetricMatch('')).toBe(true);
     expect(empty.asymmetricMatch('12312')).toBe(false);
   });
 
-  it("matches an empty map", function () {
+  it('matches an empty map', function() {
     jasmine.getEnv().requireFunctioningMaps();
     var empty = new jasmineUnderTest.Empty();
-    var fullMap = new Map();
+    var fullMap = new Map(); // eslint-disable-line compat/compat
     fullMap.set('thing', 2);
 
-    expect(empty.asymmetricMatch(new Map())).toBe(true);
+    expect(empty.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
     expect(empty.asymmetricMatch(fullMap)).toBe(false);
   });
 
-  it("matches an empty set", function () {
+  it('matches an empty set', function() {
     jasmine.getEnv().requireFunctioningSets();
     var empty = new jasmineUnderTest.Empty();
-    var fullSet = new Set();
+    var fullSet = new Set(); // eslint-disable-line compat/compat
     fullSet.add(3);
 
-    expect(empty.asymmetricMatch(new Set())).toBe(true);
+    expect(empty.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
     expect(empty.asymmetricMatch(fullSet)).toBe(false);
   });
 
-  it("matches an empty typed array", function() {
+  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);
+    expect(empty.asymmetricMatch(new Int16Array())).toBe(true); // eslint-disable-line compat/compat
+    expect(empty.asymmetricMatch(new Int16Array([1, 2]))).toBe(false); // eslint-disable-line compat/compat
   });
 });

spec/core/asymmetric_equality/FalsySpec.js

@@ -1,38 +1,38 @@
-describe("Falsy", function() {
-    it("is true for an empty string", function() {
-        var falsy = new jasmineUnderTest.Falsy();
+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);
-    });
+    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);
+  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);
-    });
+    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);
+  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);
-    });
+    expect(falsy.asymmetricMatch(null)).toBe(true);
+    expect(falsy.asymmetricMatch(undefined)).toBe(true);
+  });
 
-    it("is true for NaN", function() {
-        var falsy = new jasmineUnderTest.Falsy(Object);
+  it('is true for NaN', function() {
+    var falsy = new jasmineUnderTest.Falsy(Object);
 
-        expect(falsy.asymmetricMatch(NaN)).toBe(true);
-    });
+    expect(falsy.asymmetricMatch(NaN)).toBe(true);
+  });
 
-    it("is true for a false Boolean", function() {
-        var falsy = new jasmineUnderTest.Falsy(Boolean);
+  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);
-    });
+    expect(falsy.asymmetricMatch(false)).toBe(true);
+    expect(falsy.asymmetricMatch(true)).toBe(false);
+  });
 });

spec/core/asymmetric_equality/MapContainingSpec.js

@@ -1,5 +1,7 @@
+/* eslint-disable compat/compat */
 describe('MapContaining', function() {
-  function MapI(iterable) {    // for IE11
+  function MapI(iterable) {
+    // for IE11
     var map = new Map();
     iterable.forEach(function(kv) {
       map.set(kv[0], kv[1]);
@@ -11,7 +13,6 @@ describe('MapContaining', function() {
     jasmine.getEnv().requireFunctioningMaps();
   });
 
-
   it('matches any actual map to an empty map', function() {
     var actualMap = new MapI([['foo', 'bar']]);
     var containing = new jasmineUnderTest.MapContaining(new Map());
@@ -22,162 +23,149 @@ describe('MapContaining', function() {
   it('matches when all the key/value pairs in sample have matches in actual', function() {
     var actualMap = new MapI([
       ['foo', [1, 2, 3]],
-      [{'foo': 'bar'}, 'baz'],
-      ['other', 'any'],
+      [{ foo: 'bar' }, 'baz'],
+      ['other', 'any']
     ]);
 
-    var containingMap = new MapI([
-      [{'foo': 'bar'}, 'baz'],
-      ['foo', [1, 2, 3]],
-    ]);
+    var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(true);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
   });
 
   it('does not match when a key is not in actual', function() {
     var actualMap = new MapI([
       ['foo', [1, 2, 3]],
-      [{'foo': 'not a bar'}, 'baz'],
+      [{ foo: 'not a bar' }, 'baz']
     ]);
 
-    var containingMap = new MapI([
-      [{'foo': 'bar'}, 'baz'],
-      ['foo', [1, 2, 3]],
-    ]);
+    var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(false);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(false);
   });
 
   it('does not match when a value is not in actual', function() {
-    var actualMap = new MapI([
-      ['foo', [1, 2, 3]],
-      [{'foo': 'bar'}, 'baz'],
-    ]);
+    var actualMap = new MapI([['foo', [1, 2, 3]], [{ foo: 'bar' }, 'baz']]);
 
-    var containingMap = new MapI([
-      [{'foo': 'bar'}, 'baz'],
-      ['foo', [1, 2]],
-    ]);
+    var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2]]]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(false);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(false);
   });
 
   it('matches when all the key/value pairs in sample have asymmetric matches in actual', function() {
     var actualMap = new MapI([
       ['foo1', 'not a bar'],
       ['foo2', 'bar'],
-      ['baz', [1, 2, 3, 4]],
+      ['baz', [1, 2, 3, 4]]
     ]);
 
     var containingMap = new MapI([
-      [
-        jasmine.stringMatching(/^foo\d/),
-        'bar'
-      ],
-      [
-        'baz',
-        jasmine.arrayContaining([2, 3])
-      ],
+      [jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
+      ['baz', jasmineUnderTest.arrayContaining([2, 3])]
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(true);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
   });
 
   it('does not match when a key in sample has no asymmetric matches in actual', function() {
-    var actualMap = new MapI([
-      ['a-foo1', 'bar'],
-      ['baz', [1, 2, 3, 4]],
-    ]);
+    var actualMap = new MapI([['a-foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
 
     var containingMap = new MapI([
-      [
-        jasmine.stringMatching(/^foo\d/),
-        'bar'
-      ],
-      [
-        'baz',
-        jasmine.arrayContaining([2, 3])
-      ],
+      [jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
+      ['baz', jasmineUnderTest.arrayContaining([2, 3])]
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(false);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(false);
   });
 
   it('does not match when a value in sample has no asymmetric matches in actual', function() {
-    var actualMap = new MapI([
-      ['foo1', 'bar'],
-      ['baz', [1, 2, 3, 4]],
-    ]);
+    var actualMap = new MapI([['foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
 
     var containingMap = new MapI([
-      [
-        jasmine.stringMatching(/^foo\d/),
-        'bar'
-      ],
-      [
-        'baz',
-        jasmine.arrayContaining([4, 5])
-      ],
+      [jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
+      ['baz', jasmineUnderTest.arrayContaining([4, 5])]
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(false);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(false);
   });
 
   it('matches recursively', function() {
     var actualMap = new MapI([
       ['foo', new MapI([['foo1', 1], ['foo2', 2]])],
       [new MapI([[1, 'bar1'], [2, 'bar2']]), 'bar'],
-      ['other', 'any'],
+      ['other', 'any']
     ]);
 
     var containingMap = new MapI([
-      [
-        'foo',
-        new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))
-      ],
-      [
-        new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])),
-        'bar'
-      ],
+      ['foo', new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))],
+      [new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])), 'bar']
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualMap)).toBe(true);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
   });
 
   it('uses custom equality testers', function() {
     function tester(a, b) {
       // treat all negative numbers as equal
-      return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
+      return typeof a == 'number' && typeof b == 'number'
+        ? a < 0 && b < 0
+        : a === b;
     }
     var actualMap = new MapI([['foo', -1]]);
-    var containing = new jasmineUnderTest.MapContaining(new MapI([['foo', -2]]));
+    var containing = new jasmineUnderTest.MapContaining(
+      new MapI([['foo', -2]])
+    );
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(containing.asymmetricMatch(actualMap, [tester])).toBe(true);
+    expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
   });
 
   it('does not match when actual is not a map', function() {
     var containingMap = new MapI([['foo', 'bar']]);
-    expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')).toBe(false);
-    expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)).toBe(false);
-    expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({'foo': 'bar'})).toBe(false);
+    expect(
+      new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({
+        foo: 'bar'
+      })
+    ).toBe(false);
   });
 
   it('throws an error when sample is not a map', function() {
     expect(function() {
-      new jasmineUnderTest.MapContaining({'foo': 'bar'}).asymmetricMatch(new Map());
+      new jasmineUnderTest.MapContaining({ foo: 'bar' }).asymmetricMatch(
+        new Map()
+      );
     }).toThrowError(/You must provide a map/);
   });
 
   it('defines a `jasmineToString` method', function() {
-    var containing = new jasmineUnderTest.MapContaining(new Map());
+    var sample = new Map(),
+      containing = new jasmineUnderTest.MapContaining(sample),
+      pp = jasmine.createSpy('pp').and.returnValue('sample');
 
-    expect(containing.jasmineToString()).toMatch(/^<jasmine\.mapContaining/);
+    expect(containing.jasmineToString(pp)).toEqual(
+      '<jasmine.mapContaining(sample)>'
+    );
+    expect(pp).toHaveBeenCalledWith(sample);
   });
 });

spec/core/asymmetric_equality/NotEmptySpec.js

@@ -1,53 +1,53 @@
-describe("NotEmpty", function () {
-  it("matches a non empty object", function () {
+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({ undefined: false })).toBe(true);
     expect(notEmpty.asymmetricMatch({})).toBe(false);
   });
 
-  it("matches a non empty array", function () {
+  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 () {
+  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);
     expect(notEmpty.asymmetricMatch('')).toBe(false);
   });
 
-  it("matches a non empty map", function () {
+  it('matches a non empty map', function() {
     jasmine.getEnv().requireFunctioningMaps();
     var notEmpty = new jasmineUnderTest.NotEmpty();
-    var fullMap = new Map();
+    var fullMap = new Map(); // eslint-disable-line compat/compat
     fullMap.set('one', 1);
-    var emptyMap = new Map();
+    var emptyMap = new Map(); // eslint-disable-line compat/compat
 
     expect(notEmpty.asymmetricMatch(fullMap)).toBe(true);
     expect(notEmpty.asymmetricMatch(emptyMap)).toBe(false);
   });
 
-  it("matches a non empty set", function () {
+  it('matches a non empty set', function() {
     jasmine.getEnv().requireFunctioningSets();
     var notEmpty = new jasmineUnderTest.NotEmpty();
-    var filledSet = new Set();
+    var filledSet = new Set(); // eslint-disable-line compat/compat
     filledSet.add(1);
-    var emptySet = new Set();
+    var emptySet = new Set(); // eslint-disable-line compat/compat
 
     expect(notEmpty.asymmetricMatch(filledSet)).toBe(true);
     expect(notEmpty.asymmetricMatch(emptySet)).toBe(false);
   });
 
-  it("matches a non empty typed array", function() {
+  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);
+    expect(notEmpty.asymmetricMatch(new Int16Array([1, 2, 3]))).toBe(true); // eslint-disable-line compat/compat
+    expect(notEmpty.asymmetricMatch(new Int16Array())).toBe(false); // eslint-disable-line compat/compat
   });
 });

spec/core/asymmetric_equality/ObjectContainingSpec.js

@@ -1,75 +1,115 @@
-describe("ObjectContaining", function() {
+describe('ObjectContaining', function() {
+  it('matches any object actual to an empty object', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-  it("matches any actual to an empty object", function() {
+    expect(containing.asymmetricMatch({ foo: 1 }, matchersUtil)).toBe(true);
+  });
+
+  it('does not match when the actual is not an object', function() {
     var containing = new jasmineUnderTest.ObjectContaining({});
 
-    expect(containing.asymmetricMatch("foo")).toBe(true);
+    [1, true, undefined, 'a string'].forEach(function(actual) {
+      expect(containing.asymmetricMatch(actual)).toBe(false);
+    });
   });
 
-  it("does not match an empty object actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining("foo");
+  it('does not match an empty object actual', function() {
+    var containing = new jasmineUnderTest.ObjectContaining('foo');
 
     expect(function() {
-      containing.asymmetricMatch({})
-    }).toThrowError(/not 'foo'/)
+      containing.asymmetricMatch({});
+    }).toThrowError(/not 'foo'/);
   });
 
-  it("matches when the key/value pair is present in the actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+  it('matches when the key/value pair is present in the actual', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"})).toBe(true);
+    expect(
+      containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
+    ).toBe(true);
   });
 
-  it("does not match when the key/value pair is not present in the actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+  it('does not match when the key/value pair is not present in the actual', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({bar: "barVal", quux: "quuxVal"})).toBe(false);
+    expect(
+      containing.asymmetricMatch(
+        { bar: 'barVal', quux: 'quuxVal' },
+        matchersUtil
+      )
+    ).toBe(false);
   });
 
-  it("does not match when the key is present but the value is different in the actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "other"});
+  it('does not match when the key is present but the value is different in the actual', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'other' });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"})).toBe(false);
+    expect(
+      containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
+    ).toBe(false);
   });
 
   it("jasmineToString's itself", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({});
+    var sample = {},
+      matcher = new jasmineUnderTest.ObjectContaining(sample),
+      pp = jasmine.createSpy('pp').and.returnValue('sample');
 
-    expect(containing.jasmineToString()).toMatch("<jasmine.objectContaining");
+    expect(matcher.jasmineToString(pp)).toEqual(
+      '<jasmine.objectContaining(sample)>'
+    );
+    expect(pp).toHaveBeenCalledWith(sample);
   });
 
-  it("matches recursively", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({one: new jasmineUnderTest.ObjectContaining({two: {}})});
+  it('matches recursively', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({
+      one: new jasmineUnderTest.ObjectContaining({ two: {} })
+    });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({one: {two: {}}})).toBe(true);
+    expect(containing.asymmetricMatch({ one: { two: {} } }, matchersUtil)).toBe(
+      true
+    );
   });
 
-  it("matches when key is present with undefined value", function() {
+  it('matches when key is present with undefined value', function() {
     var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({ one: undefined })).toBe(true);
+    expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(
+      true
+    );
   });
 
-  it("does not match when key with undefined value is not present", function() {
+  it('does not match when key with undefined value is not present', function() {
     var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({})).toBe(false);
+    expect(containing.asymmetricMatch({}, matchersUtil)).toBe(false);
   });
 
-  it("matches defined properties", function(){
-    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
+  it('matches defined properties', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
     var definedPropertyObject = {};
-    Object.defineProperty(definedPropertyObject, "foo", {
-      get: function() { return "fooVal" }
+    Object.defineProperty(definedPropertyObject, 'foo', {
+      get: function() {
+        return 'fooVal';
+      }
     });
-    expect(containing.asymmetricMatch(definedPropertyObject)).toBe(true);
+    expect(
+      containing.asymmetricMatch(definedPropertyObject, matchersUtil)
+    ).toBe(true);
   });
 
-  it("matches prototype properties", function(){
-    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
+  it('matches prototype properties', function() {
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    var prototypeObject = {foo: "fooVal"};
+    var prototypeObject = { foo: 'fooVal' };
     var obj;
 
     if (Object.create) {
@@ -81,19 +121,96 @@ describe("ObjectContaining", function() {
       obj = new Foo();
     }
 
-    expect(containing.asymmetricMatch(obj)).toBe(true);
+    expect(containing.asymmetricMatch(obj, matchersUtil)).toBe(true);
   });
 
-  it("uses custom equality testers", function() {
+  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") {
+      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"});
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(containing.asymmetricMatch({foo: "fooBar"}, [tester])).toBe(true);
+    expect(containing.asymmetricMatch({ foo: 'fooBar' }, matchersUtil)).toBe(
+      true
+    );
+  });
+
+  describe('valuesForDiff_', function() {
+    describe('when other is not an object', function() {
+      it('sets self to jasmineToString()', function() {
+        var containing = new jasmineUnderTest.ObjectContaining({}),
+          pp = jasmineUnderTest.makePrettyPrinter(),
+          result = containing.valuesForDiff_('a', pp);
+
+        expect(result).toEqual({
+          self: '<jasmine.objectContaining(Object({  }))>',
+          other: 'a'
+        });
+      });
+    });
+
+    describe('when other is an object', function() {
+      it('includes keys that are present in both other and sample', function() {
+        var sample = { a: 1, b: 2 },
+          other = { a: 3, b: 4 },
+          containing = new jasmineUnderTest.ObjectContaining(sample),
+          result = containing.valuesForDiff_(other);
+
+        expect(result.self).not.toBeInstanceOf(
+          jasmineUnderTest.ObjectContaining
+        );
+        expect(result).toEqual({
+          self: sample,
+          other: other
+        });
+      });
+
+      it('includes keys that are present only in sample', function() {
+        var sample = { a: 1, b: 2 },
+          other = { a: 3 },
+          containing = new jasmineUnderTest.ObjectContaining(sample),
+          result = containing.valuesForDiff_(other);
+
+        expect(result.self).not.toBeInstanceOf(
+          jasmineUnderTest.ObjectContaining
+        );
+        expect(containing.valuesForDiff_(other)).toEqual({
+          self: sample,
+          other: {
+            a: 3,
+            b: undefined
+          }
+        });
+      });
+
+      it('omits keys that are present only in other', function() {
+        var sample = { a: 1, b: 2 },
+          other = { a: 3, b: 4, c: 5 },
+          containing = new jasmineUnderTest.ObjectContaining(sample),
+          result = containing.valuesForDiff_(other);
+
+        expect(result.self).not.toBeInstanceOf(
+          jasmineUnderTest.ObjectContaining
+        );
+        expect(result).toEqual({
+          self: sample,
+          other: {
+            a: 3,
+            b: 4
+          }
+        });
+      });
+    });
   });
 });

spec/core/asymmetric_equality/SetContainingSpec.js

@@ -1,5 +1,7 @@
+/* eslint-disable compat/compat */
 describe('SetContaining', function() {
-  function SetI(iterable) {    // for IE11
+  function SetI(iterable) {
+    // for IE11
     var set = new Set();
     iterable.forEach(function(v) {
       set.add(v);
@@ -11,7 +13,6 @@ describe('SetContaining', function() {
     jasmine.getEnv().requireFunctioningSets();
   });
 
-
   it('matches any actual set to an empty set', function() {
     var actualSet = new SetI(['foo', 'bar']);
     var containing = new jasmineUnderTest.SetContaining(new Set());
@@ -20,99 +21,109 @@ describe('SetContaining', function() {
   });
 
   it('matches when all the values in sample have matches in actual', function() {
-    var actualSet = new SetI([
-      {'foo': 'bar'}, 'baz', [1, 2, 3]
-    ]);
+    var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
 
-    var containingSet = new SetI([
-      [1, 2, 3], {'foo': 'bar'}
-    ]);
+    var containingSet = new SetI([[1, 2, 3], { foo: 'bar' }]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualSet)).toBe(true);
+    expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
   });
 
   it('does not match when a value is not in actual', function() {
-    var actualSet = new SetI([
-      {'foo': 'bar'}, 'baz', [1, 2, 3]
-    ]);
+    var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
 
-    var containingSet = new SetI([
-      [1, 2], {'foo': 'bar'}
-    ]);
+    var containingSet = new SetI([[1, 2], { foo: 'bar' }]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualSet)).toBe(false);
+    expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(false);
   });
 
   it('matches when all the values in sample have asymmetric matches in actual', function() {
-    var actualSet = new SetI([
-      [1, 2, 3, 4], 'other', 'foo1'
-    ]);
+    var actualSet = new SetI([[1, 2, 3, 4], 'other', 'foo1']);
 
     var containingSet = new SetI([
-      jasmine.stringMatching(/^foo\d/),
-      jasmine.arrayContaining([2, 3]),
+      jasmineUnderTest.stringMatching(/^foo\d/),
+      jasmineUnderTest.arrayContaining([2, 3])
     ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualSet)).toBe(true);
+    expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
   });
 
   it('does not match when a value in sample has no asymmetric matches in actual', function() {
-    var actualSet = new SetI([
-      'a-foo1', [1, 2, 3, 4], 'other'
-    ]);
+    var actualSet = new SetI(['a-foo1', [1, 2, 3, 4], 'other']);
 
     var containingSet = new SetI([
       jasmine.stringMatching(/^foo\d/),
-      jasmine.arrayContaining([2, 3]),
+      jasmine.arrayContaining([2, 3])
     ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualSet)).toBe(false);
+    expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(false);
   });
 
   it('matches recursively', function() {
-    var actualSet = new SetI([
-      'foo', new SetI([1, 'bar', 2]), 'other'
-    ]);
+    var actualSet = new SetI(['foo', new SetI([1, 'bar', 2]), 'other']);
 
     var containingSet = new SetI([
-      new jasmineUnderTest.SetContaining(new SetI(['bar'])), 'foo'
+      new jasmineUnderTest.SetContaining(new SetI(['bar'])),
+      'foo'
     ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
+    var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(actualSet)).toBe(true);
+    expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
   });
 
   it('uses custom equality testers', function() {
     function tester(a, b) {
       // treat all negative numbers as equal
-      return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
+      return typeof a == 'number' && typeof b == 'number'
+        ? a < 0 && b < 0
+        : a === b;
     }
     var actualSet = new SetI(['foo', -1]);
     var containing = new jasmineUnderTest.SetContaining(new SetI([-2, 'foo']));
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(containing.asymmetricMatch(actualSet, [tester])).toBe(true);
+    expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
   });
 
   it('does not match when actual is not a set', function() {
     var containingSet = new SetI(['foo']);
-    expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')).toBe(false);
-    expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)).toBe(false);
-    expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])).toBe(false);
+    expect(
+      new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])
+    ).toBe(false);
   });
 
   it('throws an error when sample is not a set', function() {
     expect(function() {
-      new jasmineUnderTest.SetContaining({'foo': 'bar'}).asymmetricMatch(new Set());
+      new jasmineUnderTest.SetContaining({ foo: 'bar' }).asymmetricMatch(
+        new Set()
+      );
     }).toThrowError(/You must provide a set/);
   });
 
   it('defines a `jasmineToString` method', function() {
-    var containing = new jasmineUnderTest.SetContaining(new Set());
+    var sample = new Set(),
+      containing = new jasmineUnderTest.SetContaining(sample),
+      pp = jasmine.createSpy('pp').and.returnValue('sample');
 
-    expect(containing.jasmineToString()).toMatch(/^<jasmine\.setContaining/);
+    expect(containing.jasmineToString(pp)).toEqual(
+      '<jasmine.setContaining(sample)>'
+    );
+    expect(pp).toHaveBeenCalledWith(sample);
   });
 });

spec/core/asymmetric_equality/StringMatchingSpec.js

@@ -1,19 +1,19 @@
-describe("StringMatching", function() {
-  it("matches a string against a provided regexp", function() {
+describe('StringMatching', function() {
+  it('matches a string against a provided regexp', function() {
     var matcher = new jasmineUnderTest.StringMatching(/foo/);
 
     expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
     expect(matcher.asymmetricMatch('barbaz')).toBe(false);
   });
 
-  it("matches a string against provided string", function() {
+  it('matches a string against provided string', function() {
     var matcher = new jasmineUnderTest.StringMatching('foo');
 
     expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
     expect(matcher.asymmetricMatch('barbaz')).toBe(false);
   });
 
-  it("raises an Error when the expected is not a String or RegExp", function() {
+  it('raises an Error when the expected is not a String or RegExp', function() {
     expect(function() {
       new jasmineUnderTest.StringMatching({});
     }).toThrowError(/not a String or a RegExp/);
@@ -22,6 +22,8 @@ describe("StringMatching", function() {
   it("jasmineToString's itself", function() {
     var matching = new jasmineUnderTest.StringMatching(/^foo/);
 
-    expect(matching.jasmineToString()).toEqual("<jasmine.stringMatching(/^foo/)>");
+    expect(matching.jasmineToString()).toEqual(
+      '<jasmine.stringMatching(/^foo/)>'
+    );
   });
 });

spec/core/asymmetric_equality/TruthySpec.js

@@ -1,12 +1,12 @@
-describe("Truthy", function () {
-  it("is true for a non empty string", function () {
+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);
+    expect(truthy.asymmetricMatch('foo')).toBe(true);
+    expect(truthy.asymmetricMatch('')).toBe(false);
   });
 
-  it("is true for a number that is not 0", function () {
+  it('is true for a number that is not 0', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch(1)).toBe(true);
@@ -15,49 +15,47 @@ describe("Truthy", function () {
     expect(truthy.asymmetricMatch(-3.1)).toBe(true);
   });
 
-  it("is true for a function", function () {
+  it('is true for a function', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
-    expect(truthy.asymmetricMatch(function () {
-    })).toBe(true);
+    expect(truthy.asymmetricMatch(function() {})).toBe(true);
   });
 
-  it("is true for an Object", function () {
+  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 () {
+  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 () {
+  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 () {
+  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 () {
+  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 () {
+  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/baseSpec.js

@@ -30,4 +30,49 @@ describe('base helpers', function() {
       }, 100);
     });
   });
+
+  describe('isAsymmetricEqualityTester_', function() {
+    it('returns false when the argument is falsy', function() {
+      expect(jasmineUnderTest.isAsymmetricEqualityTester_(null)).toBe(false);
+    });
+
+    it('returns false when the argument does not have a asymmetricMatch property', function() {
+      var obj = {};
+      expect(jasmineUnderTest.isAsymmetricEqualityTester_(obj)).toBe(false);
+    });
+
+    it("returns false when the argument's asymmetricMatch is not a function", function() {
+      var obj = { asymmetricMatch: 'yes' };
+      expect(jasmineUnderTest.isAsymmetricEqualityTester_(obj)).toBe(false);
+    });
+
+    it("returns true when the argument's asymmetricMatch is a function", function() {
+      var obj = { asymmetricMatch: function() {} };
+      expect(jasmineUnderTest.isAsymmetricEqualityTester_(obj)).toBe(true);
+    });
+  });
+
+  describe('isSet', function() {
+    it('returns true when the object is a Set', function() {
+      jasmine.getEnv().requireFunctioningSets();
+      expect(jasmineUnderTest.isSet(new Set())).toBe(true); // eslint-disable-line compat/compat
+    });
+
+    it('returns false when the object is not a Set', function() {
+      expect(jasmineUnderTest.isSet({})).toBe(false);
+    });
+  });
+
+  describe('isURL', function() {
+    it('returns true when the object is a URL', function() {
+      jasmine.getEnv().requireUrls();
+      // eslint-disable-next-line compat/compat
+      expect(jasmineUnderTest.isURL(new URL('http://localhost/'))).toBe(true);
+    });
+
+    it('returns false when the object is not a URL', function() {
+      jasmine.getEnv().requireUrls();
+      expect(jasmineUnderTest.isURL({})).toBe(false);
+    });
+  });
 });

spec/core/integration/AsymmetricEqualityTestersSpec.js

@@ -0,0 +1,243 @@
+describe('Asymmetric equality testers (Integration)', function() {
+  function verifyPasses(expectations, setup) {
+    it('passes', function(done) {
+      var env = new jasmineUnderTest.Env();
+      env.it('a spec', function() {
+        expectations(env);
+      });
+
+      var specExpectations = function(result) {
+        expect(result.status).toEqual('passed');
+        expect(result.passedExpectations.length)
+          .withContext('Number of passed expectations')
+          .toEqual(1);
+        expect(result.failedExpectations.length)
+          .withContext('Number of failed expectations')
+          .toEqual(0);
+        expect(
+          result.failedExpectations[0] && result.failedExpectations[0].message
+        )
+          .withContext('Failure message')
+          .toBeUndefined();
+      };
+
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
+    });
+  }
+
+  function verifyFails(expectations) {
+    it('fails', function(done) {
+      var env = new jasmineUnderTest.Env();
+      env.it('a spec', function() {
+        expectations(env);
+      });
+
+      var specExpectations = function(result) {
+        expect(result.status).toEqual('failed');
+        expect(result.failedExpectations.length)
+          .withContext('Number of failed expectations')
+          .toEqual(1);
+        expect(result.failedExpectations[0].message)
+          .withContext(
+            'Failed with a thrown error rather than a matcher failure'
+          )
+          .not.toMatch(/^Error: /);
+        expect(result.failedExpectations[0].matcherName)
+          .withContext('Matcher name')
+          .not.toEqual('');
+      };
+
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
+    });
+  }
+
+  describe('any', function() {
+    verifyPasses(function(env) {
+      env.expect(5).toEqual(jasmineUnderTest.any(Number));
+    });
+
+    verifyFails(function(env) {
+      env.expect('five').toEqual(jasmineUnderTest.any(Number));
+    });
+  });
+
+  describe('anything', function() {
+    verifyPasses(function(env) {
+      env.expect('').toEqual(jasmineUnderTest.anything());
+    });
+
+    verifyFails(function(env) {
+      env.expect(null).toEqual(jasmineUnderTest.anything());
+    });
+  });
+
+  describe('arrayContaining', function() {
+    verifyPasses(function(env) {
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env.expect([1, 2, 3]).toEqual(jasmineUnderTest.arrayContaining(['2']));
+    });
+
+    verifyFails(function(env) {
+      env.expect(null).toEqual(jasmineUnderTest.arrayContaining([2]));
+    });
+  });
+
+  describe('arrayWithExactContents', function() {
+    verifyPasses(function(env) {
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env
+        .expect([1, 2])
+        .toEqual(jasmineUnderTest.arrayWithExactContents(['2', '1']));
+    });
+
+    verifyFails(function(env) {
+      env.expect([]).toEqual(jasmineUnderTest.arrayWithExactContents([2]));
+    });
+  });
+
+  describe('empty', function() {
+    verifyPasses(function(env) {
+      env.expect([]).toEqual(jasmineUnderTest.empty());
+    });
+
+    verifyFails(function(env) {
+      env.expect([1]).toEqual(jasmineUnderTest.empty());
+    });
+  });
+
+  describe('falsy', function() {
+    verifyPasses(function(env) {
+      env.expect(false).toEqual(jasmineUnderTest.falsy());
+    });
+
+    verifyFails(function(env) {
+      env.expect(true).toEqual(jasmineUnderTest.falsy());
+    });
+  });
+
+  describe('mapContaining', function() {
+    if (jasmine.getEnv().hasFunctioningMaps()) {
+      verifyPasses(function(env) {
+        var actual = new Map();
+        actual.set('a', '2');
+        var expected = new Map();
+        expected.set('a', 2);
+
+        env.addCustomEqualityTester(function(a, b) {
+          return a.toString() === b.toString();
+        });
+
+        env.expect(actual).toEqual(jasmineUnderTest.mapContaining(expected));
+      });
+    } else {
+      it('passes', function() {
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Maps');
+      });
+    }
+
+    if (jasmine.getEnv().hasFunctioningMaps()) {
+      verifyFails(function(env) {
+        env
+          .expect('something')
+          .toEqual(jasmineUnderTest.mapContaining(new Map()));
+      });
+    } else {
+      it('fails', function() {
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Maps');
+      });
+    }
+  });
+
+  describe('notEmpty', function() {
+    verifyPasses(function(env) {
+      env.expect([1]).toEqual(jasmineUnderTest.notEmpty());
+    });
+
+    verifyFails(function(env) {
+      env.expect([]).toEqual(jasmineUnderTest.notEmpty());
+    });
+  });
+
+  describe('objectContaining', function() {
+    verifyPasses(function(env) {
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+
+      env
+        .expect({ a: 1, b: 2 })
+        .toEqual(jasmineUnderTest.objectContaining({ a: '1' }));
+    });
+
+    verifyFails(function(env) {
+      env.expect({}).toEqual(jasmineUnderTest.objectContaining({ a: '1' }));
+    });
+  });
+
+  describe('setContaining', function() {
+    if (jasmine.getEnv().hasFunctioningSets()) {
+      verifyPasses(function(env) {
+        var actual = new Set();
+        actual.add('1');
+        var expected = new Set();
+        actual.add(1);
+
+        env.addCustomEqualityTester(function(a, b) {
+          return a.toString() === b.toString();
+        });
+
+        env.expect(actual).toEqual(jasmineUnderTest.setContaining(expected));
+      });
+    } else {
+      it('pases', function() {
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Sets');
+      });
+    }
+
+    if (jasmine.getEnv().hasFunctioningSets()) {
+      verifyFails(function(env) {
+        env
+          .expect('something')
+          .toEqual(jasmineUnderTest.setContaining(new Set()));
+      });
+    } else {
+      it('fails', function() {
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Sets');
+      });
+    }
+  });
+
+  describe('stringMatching', function() {
+    verifyPasses(function(env) {
+      env.expect('foo').toEqual(jasmineUnderTest.stringMatching(/o/));
+    });
+
+    verifyFails(function(env) {
+      env.expect('bar').toEqual(jasmineUnderTest.stringMatching(/o/));
+    });
+  });
+
+  describe('truthy', function() {
+    verifyPasses(function(env) {
+      env.expect(true).toEqual(jasmineUnderTest.truthy());
+    });
+
+    verifyFails(function(env) {
+      env.expect(false).toEqual(jasmineUnderTest.truthy());
+    });
+  });
+});

spec/core/integration/CustomAsyncMatchersSpec.js

@@ -1,9 +1,14 @@
+/* eslint-disable compat/compat */
 describe('Custom Async Matchers (Integration)', function() {
   var env;
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
+  });
+
+  afterEach(function() {
+    env.cleanup_();
   });
 
   it('passes the spec if the custom async matcher passes', function(done) {
@@ -12,7 +17,11 @@ describe('Custom Async Matchers (Integration)', function() {
     env.it('spec using custom async matcher', function() {
       env.addAsyncMatchers({
         toBeReal: function() {
-          return { compare: function() { return Promise.resolve({ pass: true }); } };
+          return {
+            compare: function() {
+              return Promise.resolve({ pass: true });
+            }
+          };
         }
       });
 
@@ -23,8 +32,8 @@ describe('Custom Async Matchers (Integration)', function() {
       expect(result.status).toEqual('passed');
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
   it('uses the negative compare function for a negative comparison, if provided', function(done) {
@@ -34,8 +43,12 @@ describe('Custom Async Matchers (Integration)', function() {
       env.addAsyncMatchers({
         toBeReal: function() {
           return {
-            compare: function() { return Promise.resolve({ pass: true }); },
-            negativeCompare: function() { return Promise.resolve({ pass: true }); }
+            compare: function() {
+              return Promise.resolve({ pass: true });
+            },
+            negativeCompare: function() {
+              return Promise.resolve({ pass: true });
+            }
           };
         }
       });
@@ -47,8 +60,8 @@ describe('Custom Async Matchers (Integration)', function() {
       expect(result.status).toEqual('passed');
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
   it('generates messages with the same rules as built in matchers absent a custom message', function(done) {
@@ -69,10 +82,86 @@ describe('Custom Async Matchers (Integration)', function() {
     });
 
     var specExpectations = function(result) {
-      expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
+      expect(result.failedExpectations[0].message).toEqual(
+        "Expected 'a' to be real."
+      );
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
+  });
+
+  // TODO: remove this in the next major release.
+  it('passes the jasmine utility and current equality testers to the matcher factory', function(done) {
+    jasmine.getEnv().requirePromises();
+
+    var matcherFactory = function() {
+        return {
+          compare: function() {
+            return Promise.resolve({ pass: true });
+          }
+        };
+      },
+      matcherFactorySpy = jasmine
+        .createSpy('matcherFactorySpy')
+        .and.callFake(matcherFactory),
+      customEqualityFn = function() {
+        return true;
+      };
+
+    env.it('spec with expectation', function() {
+      env.addCustomEqualityTester(customEqualityFn);
+      env.addAsyncMatchers({
+        toBeReal: matcherFactorySpy
+      });
+
+      return env.expectAsync(true).toBeReal();
+    });
+
+    var specExpectations = function() {
+      expect(matcherFactorySpy).toHaveBeenCalledWith(
+        jasmine.any(jasmineUnderTest.MatchersUtil),
+        [customEqualityFn]
+      );
+    };
+
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
+  });
+
+  it('provides custom equality testers to the matcher factory via matchersUtil', function(done) {
+    jasmine.getEnv().requirePromises();
+
+    var matcherFactory = function(matchersUtil) {
+        return {
+          compare: function(actual, expected) {
+            return Promise.resolve({
+              pass: matchersUtil.equals(actual[0], expected)
+            });
+          }
+        };
+      },
+      customEqualityFn = jasmine
+        .createSpy('customEqualityFn')
+        .and.callFake(function(a, b) {
+          return a.toString() === b;
+        });
+
+    env.it('spec with expectation', function() {
+      env.addCustomEqualityTester(customEqualityFn);
+      env.addAsyncMatchers({
+        toBeArrayWithFirstElement: matcherFactory
+      });
+
+      return env.expectAsync([1, 2]).toBeArrayWithFirstElement('1');
+    });
+
+    var specExpectations = function(result) {
+      expect(customEqualityFn).toHaveBeenCalledWith(1, '1');
+      expect(result.failedExpectations).toEqual([]);
+    };
+
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 });

spec/core/integration/CustomMatchersSpec.js

@@ -1,48 +1,65 @@
-describe("Custom Matchers (Integration)", function() {
+describe('Custom Matchers (Integration)', function() {
   var env;
   var fakeTimer;
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
-  it("allows adding more matchers local to a spec", function(done) {
+  afterEach(function() {
+    env.cleanup_();
+  });
+
+  it('allows adding more matchers local to a spec', function(done) {
     env.it('spec defining a custom matcher', function() {
       env.addMatchers({
         matcherForSpec: function() {
           return {
             compare: function(actual, expected) {
-              return { pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected };
+              return {
+                pass: false,
+                message:
+                  'matcherForSpec: actual: ' +
+                  actual +
+                  '; expected: ' +
+                  expected
+              };
             }
-          }
+          };
         }
       });
 
-      env.expect("zzz").matcherForSpec("yyy");
+      env.expect('zzz').matcherForSpec('yyy');
     });
 
-    env.it("spec without custom matcher defined", function() {
-      expect(env.expect("zzz").matcherForSpec).toBeUndefined();
+    env.it('spec without custom matcher defined', function() {
+      expect(env.expect('zzz').matcherForSpec).toBeUndefined();
     });
 
-    var specDoneSpy = jasmine.createSpy("specDoneSpy");
+    var specDoneSpy = jasmine.createSpy('specDoneSpy');
     var expectations = function() {
       var firstSpecResult = specDoneSpy.calls.first().args[0];
-      expect(firstSpecResult.status).toEqual("failed");
-      expect(firstSpecResult.failedExpectations[0].message).toEqual("matcherForSpec: actual: zzz; expected: yyy");
+      expect(firstSpecResult.status).toEqual('failed');
+      expect(firstSpecResult.failedExpectations[0].message).toEqual(
+        'matcherForSpec: actual: zzz; expected: yyy'
+      );
       done();
     };
-    env.addReporter({ specDone:specDoneSpy, jasmineDone: expectations});
+    env.addReporter({ specDone: specDoneSpy });
 
-    env.execute();
+    env.execute(null, expectations);
   });
 
-  it("passes the spec if the custom matcher passes", function(done) {
-    env.it("spec using custom matcher", function() {
+  it('passes the spec if the custom matcher passes', function(done) {
+    env.it('spec using custom matcher', function() {
       env.addMatchers({
         toBeReal: function() {
-          return { compare: function() { return { pass: true }; } };
+          return {
+            compare: function() {
+              return { pass: true };
+            }
+          };
         }
       });
 
@@ -53,36 +70,80 @@ describe("Custom Matchers (Integration)", function() {
       expect(result.status).toEqual('passed');
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
-  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() {
+  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") {
+        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']));
+      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();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
-  it("displays an appropriate failure message if a custom equality matcher fails", function(done) {
-    env.it("spec using custom equality matcher", function() {
+  it('supports asymmetric equality testers that take a list of custom equality testers', function(done) {
+    // TODO: remove this in the next major release.
+    spyOn(jasmineUnderTest, 'getEnv').and.returnValue(env);
+
+    env.it('spec using custom asymmetric equality tester', function() {
+      var customEqualityFn = function(a, b) {
+        if (a === 2 && b === 'two') {
+          return true;
+        }
+      };
+      var arrayWithFirstElement = function(sample) {
+        return {
+          asymmetricMatch: function(actual, customEqualityTesters) {
+            return jasmineUnderTest.matchersUtil.equals(
+              sample,
+              actual[0],
+              customEqualityTesters
+            );
+          }
+        };
+      };
+
+      env.addCustomEqualityTester(customEqualityFn);
+      env.expect(['two']).toEqual(arrayWithFirstElement(2));
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('passed');
+    };
+
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
+  });
+
+  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') {
@@ -91,7 +152,7 @@ describe("Custom Matchers (Integration)", function() {
       };
 
       env.addCustomEqualityTester(customEqualityFn);
-      env.expect({foo: 'foo'}).toEqual({foo: 'foo'});
+      env.expect({ foo: 'foo' }).toEqual({ foo: 'foo' });
     });
 
     var specExpectations = function(result) {
@@ -101,17 +162,21 @@ describe("Custom Matchers (Integration)", function() {
       );
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
-  it("uses the negative compare function for a negative comparison, if provided", function(done) {
-    env.it("spec with custom negative comparison matcher", function() {
+  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({
         toBeReal: function() {
           return {
-            compare: function() { return { pass: true }; },
-            negativeCompare: function() { return { pass: true }; }
+            compare: function() {
+              return { pass: true };
+            },
+            negativeCompare: function() {
+              return { pass: true };
+            }
           };
         }
       });
@@ -123,11 +188,11 @@ describe("Custom Matchers (Integration)", function() {
       expect(result.status).toEqual('passed');
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
-  it("generates messages with the same rules as built in matchers absent a custom message", function(done) {
+  it('generates messages with the same rules as built in matchers absent a custom message', function(done) {
     env.it('spec with an expectation', function() {
       env.addMatchers({
         toBeReal: function() {
@@ -135,25 +200,29 @@ describe("Custom Matchers (Integration)", function() {
             compare: function() {
               return { pass: false };
             }
-          }
+          };
         }
       });
 
-      env.expect("a").toBeReal();
+      env.expect('a').toBeReal();
     });
 
     var specExpectations = function(result) {
-      expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
+      expect(result.failedExpectations[0].message).toEqual(
+        "Expected 'a' to be real."
+      );
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
-  it("passes the expected and actual arguments to the comparison function", function(done) {
-    var argumentSpy = jasmine.createSpy("argument spy").and.returnValue({ pass: true });
+  it('passes the expected and actual arguments to the comparison function', function(done) {
+    var argumentSpy = jasmine
+      .createSpy('argument spy')
+      .and.returnValue({ pass: true });
 
-    env.it('spec with an expectation', function () {
+    env.it('spec with an expectation', function() {
       env.addMatchers({
         toBeReal: function() {
           return { compare: argumentSpy };
@@ -161,40 +230,85 @@ describe("Custom Matchers (Integration)", function() {
       });
 
       env.expect(true).toBeReal();
-      env.expect(true).toBeReal("arg");
-      env.expect(true).toBeReal("arg1", "arg2");
+      env.expect(true).toBeReal('arg');
+      env.expect(true).toBeReal('arg1', 'arg2');
     });
 
     var specExpectations = function() {
       expect(argumentSpy).toHaveBeenCalledWith(true);
-      expect(argumentSpy).toHaveBeenCalledWith(true, "arg");
-      expect(argumentSpy).toHaveBeenCalledWith(true, "arg1", "arg2");
+      expect(argumentSpy).toHaveBeenCalledWith(true, 'arg');
+      expect(argumentSpy).toHaveBeenCalledWith(true, 'arg1', 'arg2');
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 
-  it("passes the jasmine utility and current equality matchers to the expectation factory", function(done) {
-    var matcherFactory = function() { return { compare: function() { return {pass: true}; }}; },
-        argumentSpy = jasmine.createSpy("argument spy").and.returnValue(matcherFactory),
-        customEqualityFn = function() { return true; };
+  // TODO: remove this in the next major release.
+  it('passes the jasmine utility and current equality testers to the matcher factory', function(done) {
+    var matcherFactory = function() {
+        return {
+          compare: function() {
+            return { pass: true };
+          }
+        };
+      },
+      matcherFactorySpy = jasmine
+        .createSpy('matcherFactorySpy')
+        .and.callFake(matcherFactory),
+      customEqualityFn = function() {
+        return true;
+      };
 
-
-    env.it("spec with expectation", function() {
+    env.it('spec with expectation', function() {
       env.addCustomEqualityTester(customEqualityFn);
       env.addMatchers({
-        toBeReal: argumentSpy
+        toBeReal: matcherFactorySpy
       });
 
       env.expect(true).toBeReal();
     });
 
     var specExpectations = function() {
-      expect(argumentSpy).toHaveBeenCalledWith(jasmineUnderTest.matchersUtil, [customEqualityFn]);
+      expect(matcherFactorySpy).toHaveBeenCalledWith(
+        jasmine.any(jasmineUnderTest.MatchersUtil),
+        [customEqualityFn]
+      );
     };
 
-    env.addReporter({ specDone: specExpectations, jasmineDone: done });
-    env.execute();
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
+  });
+
+  it('provides custom equality testers to the matcher factory via matchersUtil', function(done) {
+    var matcherFactory = function(matchersUtil) {
+        return {
+          compare: function(actual, expected) {
+            return { pass: matchersUtil.equals(actual[0], expected) };
+          }
+        };
+      },
+      customEqualityFn = jasmine
+        .createSpy('customEqualityFn')
+        .and.callFake(function(a, b) {
+          return a.toString() === b;
+        });
+
+    env.it('spec with expectation', function() {
+      env.addCustomEqualityTester(customEqualityFn);
+      env.addMatchers({
+        toBeArrayWithFirstElement: matcherFactory
+      });
+
+      env.expect([1, 2]).toBeArrayWithFirstElement('1');
+    });
+
+    var specExpectations = function(result) {
+      expect(customEqualityFn).toHaveBeenCalledWith(1, '1');
+      expect(result.failedExpectations).toEqual([]);
+    };
+
+    env.addReporter({ specDone: specExpectations });
+    env.execute(null, done);
   });
 });

spec/core/integration/CustomObjectFormatterSpec.js

@@ -0,0 +1,81 @@
+describe('Custom object formatters', function() {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+    env.configure({ random: false });
+  });
+
+  it('scopes custom object formatters to a spec', function(done) {
+    env.it('a spec with custom pretty-printer', function() {
+      env.addCustomObjectFormatter(function(obj) {
+        return 'custom(' + obj + ')';
+      });
+      env.expect(42).toBeUndefined();
+    });
+
+    env.it('a spec without custom pretty-printer', function() {
+      env.expect(42).toBeUndefined();
+    });
+
+    var specResults = [];
+    var specDone = function(result) {
+      specResults.push(result);
+    };
+    var expectations = function() {
+      expect(specResults[0].failedExpectations[0].message).toEqual(
+        'Expected custom(42) to be undefined.'
+      );
+      expect(specResults[1].failedExpectations[0].message).toEqual(
+        'Expected 42 to be undefined.'
+      );
+      done();
+    };
+    env.addReporter({ specDone: specDone });
+
+    env.execute(null, expectations);
+  });
+
+  it('scopes custom object formatters to a suite', function(done) {
+    env.it('a spec without custom pretty-printer', function() {
+      env.expect(42).toBeUndefined();
+    });
+
+    env.describe('with custom pretty-printer', function() {
+      env.beforeAll(function() {
+        env.addCustomObjectFormatter(function(obj) {
+          return 'custom(' + obj + ')';
+        });
+      });
+
+      env.it('a spec', function() {
+        env.expect(42).toBeUndefined();
+      });
+    });
+
+    var specResults = [];
+    var specDone = function(result) {
+      specResults.push(result);
+    };
+    var expectations = function() {
+      expect(specResults[0].failedExpectations[0].message).toEqual(
+        'Expected 42 to be undefined.'
+      );
+      expect(specResults[1].failedExpectations[0].message).toEqual(
+        'Expected custom(42) to be undefined.'
+      );
+      done();
+    };
+    env.addReporter({ specDone: specDone });
+
+    env.execute(null, expectations);
+  });
+
+  it('throws an exception if you try to add a custom object formatter outside a runable', function() {
+    expect(function() {
+      env.addCustomObjectFormatter(function() {});
+    }).toThrowError(
+      'Custom object formatters must be added in a before function or a spec'
+    );
+  });
+});

spec/core/integration/CustomSpyStrategiesSpec.js

@@ -3,14 +3,17 @@ describe('Custom Spy Strategies (Integration)', function() {
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
+  });
+
+  afterEach(function() {
+    env.cleanup_();
   });
 
   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);
+    var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
+    var jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.describe('suite defining a custom spy strategy', function() {
       env.beforeEach(function() {
@@ -29,20 +32,20 @@ describe('Custom Spy Strategies (Integration)', function() {
       expect(env.createSpy('something').and.frobnicate).toBeUndefined();
     });
 
-    function jasmineDone(result) {
+    function expectations() {
+      var result = jasmineDone.calls.argsFor(0)[0];
       expect(result.overallStatus).toEqual('passed');
       done();
     }
 
     env.addReporter({ jasmineDone: jasmineDone });
-    env.execute();
+    env.execute(null, expectations);
   });
 
   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);
+    var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
+    var jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.it('spec defining a custom spy strategy', function() {
       env.addSpyStrategy('frobnicate', strategy);
@@ -56,26 +59,28 @@ describe('Custom Spy Strategies (Integration)', function() {
       expect(env.createSpy('something').and.frobnicate).toBeUndefined();
     });
 
-    function jasmineDone(result) {
+    function expectations() {
+      var result = jasmineDone.calls.argsFor(0)[0];
       expect(result.overallStatus).toEqual('passed');
       done();
     }
 
     env.addReporter({ jasmineDone: jasmineDone });
-    env.execute();
+    env.execute(null, expectations);
   });
 
   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);
+    var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
+    var jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.it('spec defining a custom spy strategy', function() {
       env.addSpyStrategy('frobnicate', strategy);
-      var spy = env.createSpy('something')
+      var spy = env
+        .createSpy('something')
         .and.returnValue('no args return')
-        .withArgs(1, 2, 3).and.frobnicate(17);
+        .withArgs(1, 2, 3)
+        .and.frobnicate(17);
 
       expect(spy()).toEqual('no args return');
       expect(plan).not.toHaveBeenCalled();
@@ -87,13 +92,14 @@ describe('Custom Spy Strategies (Integration)', function() {
       expect(env.createSpy('something').and.frobnicate).toBeUndefined();
     });
 
-    function jasmineDone(result) {
+    function expectations() {
+      var result = jasmineDone.calls.argsFor(0)[0];
       expect(result.overallStatus).toEqual('passed');
       done();
     }
 
     env.addReporter({ jasmineDone: jasmineDone });
-    env.execute();
+    env.execute(null, expectations);
   });
 
   it('allows multiple custom strategies to be used', function(done) {
@@ -101,7 +107,8 @@ describe('Custom Spy Strategies (Integration)', function() {
       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');
+      specDone = jasmine.createSpy('specDone'),
+      jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.beforeEach(function() {
       env.addSpyStrategy('frobnicate', strategy1);
@@ -126,13 +133,14 @@ describe('Custom Spy Strategies (Integration)', function() {
       expect(plan2).toHaveBeenCalled();
     });
 
-    function jasmineDone(result) {
+    function expectations() {
+      var result = jasmineDone.calls.argsFor(0)[0];
       expect(result.overallStatus).toEqual('passed');
       expect(specDone.calls.count()).toBe(2);
       done();
     }
 
     env.addReporter({ jasmineDone: jasmineDone, specDone: specDone });
-    env.execute();
+    env.execute(null, expectations);
   });
 });

spec/core/integration/DefaultSpyStrategySpec.js

@@ -3,13 +3,17 @@ describe('Default Spy Strategy (Integration)', function() {
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
+  });
+
+  afterEach(function() {
+    env.cleanup_();
   });
 
   it('allows defining a default spy strategy', function(done) {
     env.describe('suite with default strategy', function() {
       env.beforeEach(function() {
-        env.setDefaultSpyStrategy(function (and) {
+        env.setDefaultSpyStrategy(function(and) {
           and.returnValue(42);
         });
       });
@@ -25,21 +29,27 @@ describe('Default Spy Strategy (Integration)', function() {
       expect(spy()).toBeUndefined();
     });
 
-    function jasmineDone(result) {
+    function expectations() {
+      var result = jasmineDone.calls.argsFor(0)[0];
       expect(result.overallStatus).toEqual('passed');
       done();
     }
 
+    var jasmineDone = jasmine.createSpy('jasmineDone');
     env.addReporter({ jasmineDone: jasmineDone });
-    env.execute();
+    env.execute(null, expectations);
   });
 
-  it('uses the default spy strategy defined when the spy is created', function (done) {
+  it('uses the default spy strategy defined when the spy is created', function(done) {
     env.it('spec', function() {
       var a = env.createSpy('a');
-      env.setDefaultSpyStrategy(function (and) { and.returnValue(42); });
+      env.setDefaultSpyStrategy(function(and) {
+        and.returnValue(42);
+      });
       var b = env.createSpy('b');
-      env.setDefaultSpyStrategy(function (and) { and.stub(); });
+      env.setDefaultSpyStrategy(function(and) {
+        and.stub();
+      });
       var c = env.createSpy('c');
       env.setDefaultSpyStrategy();
       var d = env.createSpy('d');
@@ -57,12 +67,14 @@ describe('Default Spy Strategy (Integration)', function() {
       expect(d.and.isConfigured()).toBe(false);
     });
 
-    function jasmineDone(result) {
+    function expectations() {
+      var result = jasmineDone.calls.argsFor(0)[0];
       expect(result.overallStatus).toEqual('passed');
       done();
     }
 
+    var jasmineDone = jasmine.createSpy('jasmineDone');
     env.addReporter({ jasmineDone: jasmineDone });
-    env.execute();
+    env.execute(null, expectations);
   });
 });

spec/core/integration/MatchersSpec.js

@@ -1,7 +1,16 @@
 describe('Matchers (Integration)', function() {
+  var env;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+  });
+
+  afterEach(function() {
+    env.cleanup_();
+  });
+
   function verifyPasses(expectations) {
     it('passes', function(done) {
-      var env = new jasmineUnderTest.Env();
       env.it('a spec', function() {
         expectations(env);
       });
@@ -14,19 +23,20 @@ describe('Matchers (Integration)', function() {
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(0);
-        expect(result.failedExpectations[0] && result.failedExpectations[0].message)
+        expect(
+          result.failedExpectations[0] && result.failedExpectations[0].message
+        )
           .withContext('Failure message')
           .toBeUndefined();
       };
 
-      env.addReporter({ specDone: specExpectations, jasmineDone: done });
-      env.execute();
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
     });
   }
 
   function verifyFails(expectations) {
     it('fails', function(done) {
-      var env = new jasmineUnderTest.Env();
       env.it('a spec', function() {
         expectations(env);
       });
@@ -37,21 +47,50 @@ describe('Matchers (Integration)', function() {
           .withContext('Number of failed expectations')
           .toEqual(1);
         expect(result.failedExpectations[0].message)
-          .withContext('Failed with a thrown error rather than a matcher failure')
+          .withContext(
+            'Failed with a thrown error rather than a matcher failure'
+          )
           .not.toMatch(/^Error: /);
-        expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
+        expect(result.failedExpectations[0].message)
+          .withContext(
+            'Failed with a thrown type error rather than a matcher failure'
+          )
+          .not.toMatch(/^TypeError: /);
+        expect(result.failedExpectations[0].matcherName)
+          .withContext('Matcher name')
           .not.toEqual('');
       };
 
-      env.addReporter({ specDone: specExpectations, jasmineDone: done });
-      env.execute();
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
+    });
+  }
+
+  function verifyFailsWithCustomObjectFormatters(config) {
+    it('uses custom object formatters', function(done) {
+      env.it('a spec', function() {
+        env.addCustomObjectFormatter(config.formatter);
+        config.expectations(env);
+      });
+
+      var specExpectations = function(result) {
+        expect(result.status).toEqual('failed');
+        expect(result.failedExpectations.length)
+          .withContext('Number of failed expectations')
+          .toEqual(1);
+        expect(result.failedExpectations[0].message).toEqual(
+          config.expectedMessage
+        );
+      };
+
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
     });
   }
 
   function verifyPassesAsync(expectations) {
     it('passes', function(done) {
       jasmine.getEnv().requirePromises();
-      var env = new jasmineUnderTest.Env();
 
       env.it('a spec', function() {
         return expectations(env);
@@ -65,19 +104,20 @@ describe('Matchers (Integration)', function() {
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(0);
-        expect(result.failedExpectations[0] && result.failedExpectations[0].message)
+        expect(
+          result.failedExpectations[0] && result.failedExpectations[0].message
+        )
           .withContext('Failure message')
           .toBeUndefined();
       };
 
-      env.addReporter({ specDone: specExpectations, jasmineDone: done });
-      env.execute();
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
     });
   }
 
   function verifyFailsAsync(expectations) {
     it('fails', function(done) {
-      var env = new jasmineUnderTest.Env();
       jasmine.getEnv().requirePromises();
 
       env.it('a spec', function() {
@@ -90,14 +130,41 @@ describe('Matchers (Integration)', function() {
           .withContext('Number of failed expectations')
           .toEqual(1);
         expect(result.failedExpectations[0].message)
-          .withContext('Failed with a thrown error rather than a matcher failure')
+          .withContext(
+            'Failed with a thrown error rather than a matcher failure'
+          )
           .not.toMatch(/^Error: /);
-        expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
+        expect(result.failedExpectations[0].matcherName)
+          .withContext('Matcher name')
           .not.toEqual('');
       };
 
-      env.addReporter({ specDone: specExpectations, jasmineDone: done });
-      env.execute();
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
+    });
+  }
+
+  function verifyFailsWithCustomObjectFormattersAsync(config) {
+    it('uses custom object formatters', function(done) {
+      var env = new jasmineUnderTest.Env();
+      jasmine.getEnv().requirePromises();
+      env.it('a spec', function() {
+        env.addCustomObjectFormatter(config.formatter);
+        return config.expectations(env);
+      });
+
+      var specExpectations = function(result) {
+        expect(result.status).toEqual('failed');
+        expect(result.failedExpectations.length)
+          .withContext('Number of failed expectations')
+          .toEqual(1);
+        expect(result.failedExpectations[0].message).toEqual(
+          config.expectedMessage
+        );
+      };
+
+      env.addReporter({ specDone: specExpectations });
+      env.execute(null, done);
     });
   }
 
@@ -217,6 +284,16 @@ describe('Matchers (Integration)', function() {
     verifyFails(function(env) {
       env.expect(2).toBeNaN();
     });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        env.expect(1).toBeNaN();
+      },
+      expectedMessage: 'Expected |1| to be NaN.'
+    });
   });
 
   describe('toBeNegativeInfinity', function() {
@@ -227,6 +304,16 @@ describe('Matchers (Integration)', function() {
     verifyFails(function(env) {
       env.expect(2).toBeNegativeInfinity();
     });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        env.expect(1).toBeNegativeInfinity();
+      },
+      expectedMessage: 'Expected |1| to be -Infinity.'
+    });
   });
 
   describe('toBeNull', function() {
@@ -247,56 +334,129 @@ describe('Matchers (Integration)', function() {
     verifyFails(function(env) {
       env.expect(2).toBePositiveInfinity();
     });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        env.expect(1).toBePositiveInfinity();
+      },
+      expectedMessage: 'Expected |1| to be Infinity.'
+    });
   });
 
   describe('toBeResolved', function() {
     verifyPassesAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.resolve()).toBeResolved();
     });
 
     verifyFailsAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.reject()).toBeResolved();
     });
   });
 
   describe('toBeResolvedTo', function() {
     verifyPassesAsync(function(env) {
-      return env.expectAsync(Promise.resolve('foo')).toBeResolvedTo('foo');
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve('5')).toBeResolvedTo(5);
     });
 
     verifyFailsAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.resolve('foo')).toBeResolvedTo('bar');
     });
+
+    verifyFailsWithCustomObjectFormattersAsync({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        // eslint-disable-next-line compat/compat
+        return env.expectAsync(Promise.resolve('x')).toBeResolvedTo('y');
+      },
+      expectedMessage:
+        'Expected a promise to be resolved to |y| ' +
+        'but it was resolved to |x|.'
+    });
   });
 
   describe('toBeRejected', function() {
     verifyPassesAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.reject('nope')).toBeRejected();
     });
 
     verifyFailsAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.resolve()).toBeRejected();
     });
   });
 
   describe('toBeRejectedWith', function() {
     verifyPassesAsync(function(env) {
-      return env.expectAsync(Promise.reject('nope')).toBeRejectedWith('nope');
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.reject('5')).toBeRejectedWith(5);
     });
 
     verifyFailsAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.resolve()).toBeRejectedWith('nope');
     });
+
+    verifyFailsWithCustomObjectFormattersAsync({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        // eslint-disable-next-line compat/compat
+        return env.expectAsync(Promise.reject('x')).toBeRejectedWith('y');
+      },
+      expectedMessage:
+        'Expected a promise to be rejected with |y| ' +
+        'but it was rejected with |x|.'
+    });
   });
 
   describe('toBeRejectedWithError', function() {
     verifyPassesAsync(function(env) {
-      return env.expectAsync(Promise.reject(new Error())).toBeRejectedWithError(Error);
+      return (
+        env
+          // eslint-disable-next-line compat/compat
+          .expectAsync(Promise.reject(new Error()))
+          .toBeRejectedWithError(Error)
+      );
     });
 
     verifyFailsAsync(function(env) {
+      // eslint-disable-next-line compat/compat
       return env.expectAsync(Promise.resolve()).toBeRejectedWithError(Error);
     });
+
+    verifyFailsWithCustomObjectFormattersAsync({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        return (
+          env
+            // eslint-disable-next-line compat/compat
+            .expectAsync(Promise.reject('foo'))
+            .toBeRejectedWithError('foo')
+        );
+      },
+      expectedMessage:
+        'Expected a promise to be rejected with Error: |foo| ' +
+        'but it was rejected with |foo|.'
+    });
   });
 
   describe('toBeTrue', function() {
@@ -331,7 +491,10 @@ describe('Matchers (Integration)', function() {
 
   describe('toContain', function() {
     verifyPasses(function(env) {
-      env.expect('foobar').toContain('oo');
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env.expect(['1', '2', '3']).toContain(2);
     });
 
     verifyFails(function(env) {
@@ -341,12 +504,39 @@ describe('Matchers (Integration)', function() {
 
   describe('toEqual', function() {
     verifyPasses(function(env) {
-      env.expect('a').toEqual('a');
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env.expect(5).toEqual('5');
     });
 
     verifyFails(function(env) {
       env.expect('a').toEqual('b');
     });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        if (val === 5) {
+          return 'five';
+        } else if (val === 4) {
+          return 'four';
+        }
+      },
+      expectations: function(env) {
+        env.expect([{ foo: 4 }]).toEqual([{ foo: 5 }]);
+      },
+      expectedMessage: 'Expected $[0].foo = four to equal five.'
+    });
+  });
+
+  describe('toHaveSize', function() {
+    verifyPasses(function(env) {
+      env.expect(['a', 'b']).toHaveSize(2);
+    });
+
+    verifyFails(function(env) {
+      env.expect(['a', 'b']).toHaveSize(1);
+    });
   });
 
   describe('toHaveBeenCalled', function() {
@@ -364,14 +554,16 @@ describe('Matchers (Integration)', function() {
 
   describe('toHaveBeenCalledBefore', function() {
     verifyPasses(function(env) {
-      var a = env.createSpy('a'), b = env.createSpy('b');
+      var a = env.createSpy('a'),
+        b = env.createSpy('b');
       a();
       b();
       env.expect(a).toHaveBeenCalledBefore(b);
     });
 
     verifyFails(function(env) {
-      var a = env.createSpy('a'), b = env.createSpy('b');
+      var a = env.createSpy('a'),
+        b = env.createSpy('b');
       b();
       a();
       env.expect(a).toHaveBeenCalledBefore(b);
@@ -394,14 +586,47 @@ describe('Matchers (Integration)', function() {
   describe('toHaveBeenCalledWith', function() {
     verifyPasses(function(env) {
       var spy = env.createSpy();
-      spy('foo');
-      env.expect(spy).toHaveBeenCalledWith('foo');
+      spy('5');
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env.expect(spy).toHaveBeenCalledWith(5);
     });
 
     verifyFails(function(env) {
       var spy = env.createSpy();
       env.expect(spy).toHaveBeenCalledWith('foo');
     });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        var spy = env.createSpy('foo');
+        env.expect(spy).toHaveBeenCalledWith('x');
+      },
+      expectedMessage:
+        'Expected spy foo to have been called with:\n' +
+        '  |x|\n' +
+        'but it was never called.'
+    });
+  });
+
+  describe('toHaveBeenCalledOnceWith', function() {
+    verifyPasses(function(env) {
+      var spy = env.createSpy();
+      spy('5', 3);
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env.expect(spy).toHaveBeenCalledOnceWith(5, 3);
+    });
+
+    verifyFails(function(env) {
+      var spy = env.createSpy();
+      env.expect(spy).toHaveBeenCalledOnceWith(5, 3);
+    });
   });
 
   describe('toHaveClass', function() {
@@ -434,21 +659,62 @@ describe('Matchers (Integration)', function() {
 
   describe('toThrow', function() {
     verifyPasses(function(env) {
-      env.expect(function() { throw new Error(); }).toThrow();
+      env.addCustomEqualityTester(function(a, b) {
+        return a.toString() === b.toString();
+      });
+      env
+        .expect(function() {
+          throw '5';
+        })
+        .toThrow(5);
     });
 
     verifyFails(function(env) {
       env.expect(function() {}).toThrow();
     });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        var spy = env.createSpy('foo');
+        env
+          .expect(function() {
+            throw 'x';
+          })
+          .not.toThrow();
+      },
+      expectedMessage: 'Expected function not to throw, but it threw |x|.'
+    });
   });
 
   describe('toThrowError', function() {
     verifyPasses(function(env) {
-      env.expect(function() { throw new Error(); }).toThrowError();
+      env
+        .expect(function() {
+          throw new Error();
+        })
+        .toThrowError();
     });
 
     verifyFails(function(env) {
-      env.expect(function() { }).toThrowError();
+      env.expect(function() {}).toThrowError();
+    });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        var spy = env.createSpy('foo');
+        env
+          .expect(function() {
+            throw 'x';
+          })
+          .toThrowError();
+      },
+      expectedMessage: 'Expected function to throw an Error, but it threw |x|.'
     });
   });
 
@@ -458,11 +724,34 @@ describe('Matchers (Integration)', function() {
     }
 
     verifyPasses(function(env) {
-      env.expect(throws).toThrowMatching(function() { return true; });
+      env.expect(throws).toThrowMatching(function() {
+        return true;
+      });
     });
 
     verifyFails(function(env) {
-      env.expect(throws).toThrowMatching(function() { return false; });
+      env.expect(throws).toThrowMatching(function() {
+        return false;
+      });
+    });
+
+    verifyFailsWithCustomObjectFormatters({
+      formatter: function(val) {
+        return '|' + val + '|';
+      },
+      expectations: function(env) {
+        var spy = env.createSpy('foo');
+        env
+          .expect(function() {
+            throw new Error('nope');
+          })
+          .toThrowMatching(function() {
+            return false;
+          });
+      },
+      expectedMessage:
+        'Expected function to throw an exception matching ' +
+        'a predicate, but it threw Error with message |nope|.'
     });
   });
 });

spec/core/matchers/DiffBuilderSpec.js

@@ -1,47 +1,213 @@
-describe("DiffBuilder", function() {
-  it("records the actual and expected objects", function() {
+describe('DiffBuilder', function() {
+  it('records the actual and expected objects', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
-    diffBuilder.record({x: 'actual'}, {x: 'expected'});
+    diffBuilder.setRoots({ x: 'actual' }, { x: 'expected' });
+    diffBuilder.recordMismatch();
 
-    expect(diffBuilder.getMessage()).toEqual("Expected Object({ x: 'actual' }) to equal Object({ 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() {
+  it('prints the path at which the difference was found', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
+    diffBuilder.setRoots({ foo: { x: 'actual' } }, { foo: { x: 'expected' } });
 
     diffBuilder.withPath('foo', function() {
-      diffBuilder.record({x: 'actual'}, {x: 'expected'});
+      diffBuilder.recordMismatch();
     });
 
-    expect(diffBuilder.getMessage()).toEqual("Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
+    expect(diffBuilder.getMessage()).toEqual(
+      "Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' })."
+    );
   });
 
-  it("prints multiple messages, separated by newlines", function() {
+  it('prints multiple messages, separated by newlines', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
+    diffBuilder.setRoots({ foo: 1, bar: 3 }, { foo: 2, bar: 4 });
 
     diffBuilder.withPath('foo', function() {
-      diffBuilder.record(1, 2);
+      diffBuilder.recordMismatch();
+    });
+    diffBuilder.withPath('bar', function() {
+      diffBuilder.recordMismatch();
     });
 
     var message =
-      "Expected $.foo = 1 to equal 2.\n" +
-      "Expected 3 to equal 4.";
+      'Expected $.foo = 1 to equal 2.\n' + 'Expected $.bar = 3 to equal 4.';
 
-    diffBuilder.record(3, 4);
     expect(diffBuilder.getMessage()).toEqual(message);
   });
 
-  it("allows customization of the message", function() {
+  it('allows customization of the message', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
+    diffBuilder.setRoots({ x: 'bar' }, { x: 'foo' });
 
     function darthVaderFormatter(actual, expected, path) {
-      return "I find your lack of " + expected + " disturbing. (was " + actual + ", at " + path + ")"
+      return (
+        'I find your lack of ' +
+        expected +
+        ' disturbing. (was ' +
+        actual +
+        ', at ' +
+        path +
+        ')'
+      );
     }
 
     diffBuilder.withPath('x', function() {
-      diffBuilder.record('bar', 'foo', darthVaderFormatter);
+      diffBuilder.recordMismatch(darthVaderFormatter);
     });
 
-    expect(diffBuilder.getMessage()).toEqual("I find your lack of foo disturbing. (was bar, at $.x)");
+    expect(diffBuilder.getMessage()).toEqual(
+      'I find your lack of foo disturbing. (was bar, at $.x)'
+    );
+  });
+
+  it('uses the injected pretty-printer', function() {
+    var prettyPrinter = function(val) {
+        return '|' + val + '|';
+      },
+      diffBuilder = jasmineUnderTest.DiffBuilder({
+        prettyPrinter: prettyPrinter
+      });
+    prettyPrinter.customFormat_ = function() {};
+
+    diffBuilder.setRoots({ foo: 'actual' }, { foo: 'expected' });
+    diffBuilder.withPath('foo', function() {
+      diffBuilder.recordMismatch();
+    });
+
+    expect(diffBuilder.getMessage()).toEqual(
+      'Expected $.foo = |actual| to equal |expected|.'
+    );
+  });
+
+  it('passes the injected pretty-printer to the diff formatter', function() {
+    var diffFormatter = jasmine.createSpy('diffFormatter'),
+      prettyPrinter = function() {},
+      diffBuilder = jasmineUnderTest.DiffBuilder({
+        prettyPrinter: prettyPrinter
+      });
+    prettyPrinter.customFormat_ = function() {};
+
+    diffBuilder.setRoots({ x: 'bar' }, { x: 'foo' });
+    diffBuilder.withPath('x', function() {
+      diffBuilder.recordMismatch(diffFormatter);
+    });
+
+    diffBuilder.getMessage();
+
+    expect(diffFormatter).toHaveBeenCalledWith(
+      'bar',
+      'foo',
+      jasmine.anything(),
+      prettyPrinter
+    );
+  });
+
+  it('uses custom object formatters on leaf nodes', function() {
+    var formatter = function(x) {
+      if (typeof x === 'number') {
+        return '[number:' + x + ']';
+      }
+    };
+    prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
+    var diffBuilder = new jasmineUnderTest.DiffBuilder({
+      prettyPrinter: prettyPrinter
+    });
+
+    diffBuilder.setRoots(5, 4);
+    diffBuilder.recordMismatch();
+
+    expect(diffBuilder.getMessage()).toEqual(
+      'Expected [number:5] to equal [number:4].'
+    );
+  });
+
+  it('uses custom object formatters on non leaf nodes', function() {
+    var formatter = function(x) {
+      if (x.hasOwnProperty('a')) {
+        return '[thing with a=' + x.a + ', b=' + JSON.stringify(x.b) + ']';
+      }
+    };
+    prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
+    var diffBuilder = new jasmineUnderTest.DiffBuilder({
+      prettyPrinter: prettyPrinter
+    });
+    var expectedMsg =
+      'Expected $[0].foo = [thing with a=1, b={"x":42}] to equal [thing with a=1, b={"x":43}].\n' +
+      "Expected $[0].bar = 'yes' to equal 'no'.";
+
+    diffBuilder.setRoots(
+      [{ foo: { a: 1, b: { x: 42 } }, bar: 'yes' }],
+      [{ foo: { a: 1, b: { x: 43 } }, bar: 'no' }]
+    );
+
+    diffBuilder.withPath(0, function() {
+      diffBuilder.withPath('foo', function() {
+        diffBuilder.withPath('b', function() {
+          diffBuilder.withPath('x', function() {
+            diffBuilder.recordMismatch();
+          });
+        });
+      });
+
+      diffBuilder.withPath('bar', function() {
+        diffBuilder.recordMismatch();
+      });
+    });
+
+    expect(diffBuilder.getMessage()).toEqual(expectedMsg);
+  });
+
+  it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ at the root', function() {
+    var prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
+      diffBuilder = new jasmineUnderTest.DiffBuilder({
+        prettyPrinter: prettyPrinter
+      }),
+      expectedMsg =
+        'Expected $.foo = 1 to equal 2.\n' +
+        'Expected $.baz = undefined to equal 3.';
+
+    diffBuilder.setRoots(
+      { foo: 1, bar: 2 },
+      jasmine.objectContaining({ foo: 2, baz: 3 })
+    );
+
+    diffBuilder.withPath('foo', function() {
+      diffBuilder.recordMismatch();
+    });
+    diffBuilder.withPath('baz', function() {
+      diffBuilder.recordMismatch();
+    });
+
+    expect(diffBuilder.getMessage()).toEqual(expectedMsg);
+  });
+
+  it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ below the root', function() {
+    var prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
+      diffBuilder = new jasmineUnderTest.DiffBuilder({
+        prettyPrinter: prettyPrinter
+      }),
+      expectedMsg =
+        'Expected $.x.foo = 1 to equal 2.\n' +
+        'Expected $.x.baz = undefined to equal 3.';
+
+    diffBuilder.setRoots(
+      { x: { foo: 1, bar: 2 } },
+      { x: jasmine.objectContaining({ foo: 2, baz: 3 }) }
+    );
+
+    diffBuilder.withPath('x', function() {
+      diffBuilder.withPath('foo', function() {
+        diffBuilder.recordMismatch();
+      });
+      diffBuilder.withPath('baz', function() {
+        diffBuilder.recordMismatch();
+      });
+    });
+
+    expect(diffBuilder.getMessage()).toEqual(expectedMsg);
   });
 });

spec/core/matchers/MismatchTreeSpec.js

@@ -0,0 +1,142 @@
+describe('MismatchTree', function() {
+  describe('#add', function() {
+    describe('When the path is empty', function() {
+      it('flags the root node as mismatched', function() {
+        var tree = new jasmineUnderTest.MismatchTree();
+        tree.add(new jasmineUnderTest.ObjectPath([]));
+        expect(tree.isMismatch).toBe(true);
+      });
+    });
+
+    describe('When the path is not empty', function() {
+      it('flags the node as mismatched', function() {
+        var tree = new jasmineUnderTest.MismatchTree();
+
+        tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
+
+        expect(tree.child('a').child('b').isMismatch).toBe(true);
+      });
+
+      it('does not flag ancestors as mismatched', function() {
+        var tree = new jasmineUnderTest.MismatchTree();
+
+        tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
+
+        expect(tree.isMismatch).toBe(false);
+        expect(tree.child('a').isMismatch).toBe(false);
+      });
+    });
+
+    it('stores the formatter on only the target node', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+
+      tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
+
+      expect(tree.formatter).toBeFalsy();
+      expect(tree.child('a').formatter).toBeFalsy();
+      expect(tree.child('a').child('b').formatter).toBe(formatter);
+    });
+
+    it('stores the path to the node', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+
+      tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
+
+      expect(tree.child('a').child('b').path.components).toEqual(['a', 'b']);
+    });
+  });
+
+  describe('#traverse', function() {
+    it('calls the callback for all nodes that are or contain mismatches', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+      tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
+      tree.add(new jasmineUnderTest.ObjectPath(['c']));
+      var visit = jasmine.createSpy('visit').and.returnValue(true);
+
+      tree.traverse(visit);
+
+      expect(visit).toHaveBeenCalledWith(
+        new jasmineUnderTest.ObjectPath([]),
+        false,
+        undefined
+      );
+      expect(visit).toHaveBeenCalledWith(
+        new jasmineUnderTest.ObjectPath(['a']),
+        false,
+        undefined
+      );
+      expect(visit).toHaveBeenCalledWith(
+        new jasmineUnderTest.ObjectPath(['a', 'b']),
+        true,
+        formatter
+      );
+      expect(visit).toHaveBeenCalledWith(
+        new jasmineUnderTest.ObjectPath(['c']),
+        true,
+        undefined
+      );
+    });
+
+    it('does not call the callback if there are no mismatches', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+      var visit = jasmine.createSpy('visit');
+
+      tree.traverse(visit);
+
+      expect(visit).not.toHaveBeenCalled();
+    });
+
+    it('visits parents before children', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+      tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
+      var visited = [];
+
+      tree.traverse(function(path) {
+        visited.push(path);
+        return true;
+      });
+
+      expect(visited).toEqual([
+        new jasmineUnderTest.ObjectPath([]),
+        new jasmineUnderTest.ObjectPath(['a']),
+        new jasmineUnderTest.ObjectPath(['a', 'b'])
+      ]);
+    });
+
+    it('visits children in the order they were recorded', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+      tree.add(new jasmineUnderTest.ObjectPath(['length']));
+      tree.add(new jasmineUnderTest.ObjectPath([1]));
+      var visited = [];
+
+      tree.traverse(function(path) {
+        visited.push(path);
+        return true;
+      });
+
+      expect(visited).toEqual([
+        new jasmineUnderTest.ObjectPath([]),
+        new jasmineUnderTest.ObjectPath(['length']),
+        new jasmineUnderTest.ObjectPath([1])
+      ]);
+    });
+
+    it('does not visit children if the callback returns falsy', function() {
+      var tree = new jasmineUnderTest.MismatchTree();
+      tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
+      var visited = [];
+
+      tree.traverse(function(path) {
+        visited.push(path);
+        return path.depth() === 0;
+      });
+
+      expect(visited).toEqual([
+        new jasmineUnderTest.ObjectPath([]),
+        new jasmineUnderTest.ObjectPath(['a'])
+      ]);
+    });
+  });
+
+  function formatter() {}
+});

spec/core/matchers/NullDiffBuilderSpec.js

@@ -4,10 +4,4 @@ describe('NullDiffBuilder', function() {
     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

@@ -39,5 +39,5 @@ describe('ObjectPath', function() {
 
     expect(path.toString()).toEqual('$.foo');
     expect(root.toString()).toEqual('');
-  })
+  });
 });

spec/core/matchers/async/toBePendingSpec.js

@@ -0,0 +1,50 @@
+/* eslint-disable compat/compat */
+describe('toBePending', function() {
+  it('passes if the actual promise is pending', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
+      actual = new Promise(function() {});
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
+    });
+  });
+
+  it('fails if the actual promise is resolved', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
+      actual = Promise.resolve();
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
+    });
+  });
+
+  it('fails if the actual promise is rejected', function() {
+    jasmine.getEnv().requirePromises();
+
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
+      actual = Promise.reject(new Error('promise was rejected'));
+
+    return matcher.compare(actual).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
+    });
+  });
+
+  it('fails if actual is not a promise', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
+      actual = 'not a promise';
+
+    function f() {
+      return matcher.compare(actual);
+    }
+
+    expect(f).toThrowError('Expected toBePending to be called on a promise.');
+  });
+});

spec/core/matchers/async/toBeRejectedSpec.js

@@ -1,36 +1,38 @@
+/* eslint-disable compat/compat */
 describe('toBeRejected', function() {
   it('passes if the actual is rejected', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejected(matchersUtil),
       actual = Promise.reject('AsyncExpectationSpec rejection');
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if the actual is resolved', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejected(matchersUtil),
       actual = Promise.resolve();
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejected(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejected(matchersUtil),
       actual = 'not a promise';
 
     function f() {
       return matcher.compare(actual);
     }
 
-    expect(f).toThrowError(
-      'Expected toBeRejected to be called on a promise.'
-    );
+    expect(f).toThrowError('Expected toBeRejected to be called on a promise.');
   });
 });

spec/core/matchers/async/toBeRejectedWithErrorSpec.js

@@ -1,161 +1,253 @@
-describe('#toBeRejectedWithError', function () {
-  it('passes when Error type matches', function () {
+/* eslint-disable compat/compat */
+describe('#toBeRejectedWithError', function() {
+  it('passes when Error type matches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new TypeError('foo'));
 
-    return matcher.compare(actual, TypeError).then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with TypeError, but it was.'
-      }));
+    return matcher.compare(actual, TypeError).then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            'Expected a promise not to be rejected with TypeError, but it was.'
+        })
+      );
     });
   });
 
-  it('passes when Error type and message matches', function () {
+  it('passes when Error type and message matches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new TypeError('foo'));
 
-    return matcher.compare(actual, TypeError, 'foo').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with TypeError: \'foo\', but it was.'
-      }));
+    return matcher.compare(actual, TypeError, 'foo').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            "Expected a promise not to be rejected with TypeError: 'foo', but it was."
+        })
+      );
     });
   });
 
   it('passes when Error matches and is exactly Error', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error());
 
-    return matcher.compare(actual, Error).then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with Error, but it was.'
-      }));
+    return matcher.compare(actual, Error).then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            'Expected a promise not to be rejected with Error, but it was.'
+        })
+      );
     });
-
   });
 
-  it('passes when Error message matches a string', function () {
+  it('passes when Error message matches a string', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, 'foo').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with Error: \'foo\', but it was.'
-      }));
+    return matcher.compare(actual, 'foo').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            "Expected a promise not to be rejected with Error: 'foo', but it was."
+        })
+      );
     });
   });
 
-  it('passes when Error message matches a RegExp', function () {
+  it('passes when Error message matches a RegExp', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, /foo/).then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with Error: /foo/, but it was.'
-      }));
+    return matcher.compare(actual, /foo/).then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            'Expected a promise not to be rejected with Error: /foo/, but it was.'
+        })
+      );
     });
   });
 
-  it('passes when Error message is empty', function () {
+  it('passes when Error message is empty', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error());
 
-    return matcher.compare(actual, '').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with Error: \'\', but it was.'
-      }));
+    return matcher.compare(actual, '').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            "Expected a promise not to be rejected with Error: '', but it was."
+        })
+      );
     });
   });
 
-  it('passes when no arguments', function () {
+  it('passes when no arguments', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error());
 
-    return matcher.compare(actual, void 0).then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with Error, but it was.'
-      }));
+    return matcher.compare(actual, void 0).then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message:
+            'Expected a promise not to be rejected with Error, but it was.'
+        })
+      );
     });
   });
 
-  it('fails when resolved', function () {
+  it('fails when resolved', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.resolve(new Error('foo'));
 
-    return matcher.compare(actual, 'foo').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: 'Expected a promise to be rejected but it was resolved.'
-      }));
+    return matcher.compare(actual, 'foo').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message: 'Expected a promise to be rejected but it was resolved.'
+        })
+      );
     });
   });
 
-  it('fails when rejected with non Error type', function () {
+  it('fails when rejected with non Error type', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject('foo');
 
-    return matcher.compare(actual, 'foo').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: 'Expected a promise to be rejected with Error: \'foo\' but it was rejected with \'foo\'.'
-      }));
+    return matcher.compare(actual, 'foo').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message:
+            "Expected a promise to be rejected with Error: 'foo' but it was rejected with 'foo'."
+        })
+      );
     });
   });
 
-  it('fails when Error type mismatches', function () {
+  it('fails when Error type mismatches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, TypeError, 'foo').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: 'Expected a promise to be rejected with TypeError: \'foo\' but it was rejected with type Error.'
-      }));
+    return matcher.compare(actual, TypeError, 'foo').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message:
+            "Expected a promise to be rejected with TypeError: 'foo' but it was rejected with type Error."
+        })
+      );
     });
   });
 
-  it('fails when Error message mismatches', function () {
+  it('fails when Error message mismatches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, 'bar').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: 'Expected a promise to be rejected with Error: \'bar\' but it was rejected with Error: foo.'
-      }));
+    return matcher.compare(actual, 'bar').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message:
+            "Expected a promise to be rejected with Error: 'bar' but it was rejected with Error: foo."
+        })
+      );
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = 'not a promise';
 
     function f() {

spec/core/matchers/async/toBeRejectedWithSpec.js

@@ -1,68 +1,92 @@
-describe('#toBeRejectedWith', function () {
-  it('should return true if the promise is rejected with the expected value', function () {
+/* eslint-disable compat/compat */
+describe('#toBeRejectedWith', function() {
+  it('should return true if the promise is rejected with the expected value', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
-      actual = Promise.reject({error: 'PEBCAK'});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
+      actual = Promise.reject({ error: 'PEBCAK' });
 
-    return matcher.compare(actual, {error: 'PEBCAK'}).then(function (result) {
+    return matcher.compare(actual, { error: 'PEBCAK' }).then(function(result) {
       expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
-  it('should fail if the promise resolves', function () {
+  it('should fail if the promise resolves', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.resolve();
 
-    return matcher.compare(actual, '').then(function (result) {
+    return matcher.compare(actual, '').then(function(result) {
       expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
-  it('should fail if the promise is rejected with a different value', function () {
+  it('should fail if the promise is rejected with a different value', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.reject('A Bad Apple');
 
-    return matcher.compare(actual, 'Some Cool Thing').then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'.",
-      }));
+    return matcher.compare(actual, 'Some Cool Thing').then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message:
+            "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'."
+        })
+      );
     });
   });
 
-  it('should build its error correctly when negated', function () {
+  it('should build its error correctly when negated', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.reject(true);
 
-    return matcher.compare(actual, true).then(function (result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be rejected with true.'
-      }));
+    return matcher.compare(actual, true).then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message: 'Expected a promise not to be rejected with true.'
+        })
+      );
     });
   });
 
-  it('should support custom equality testers', function () {
+  it('should support custom equality testers', function() {
     jasmine.getEnv().requirePromises();
 
-    var customEqualityTesters = [function() { return true; }],
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil, customEqualityTesters),
+    var customEqualityTesters = [
+        function() {
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.reject('actual');
 
     return matcher.compare(actual, 'expected').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = 'not a promise';
 
     function f() {

spec/core/matchers/async/toBeResolvedSpec.js

@@ -1,36 +1,38 @@
+/* eslint-disable compat/compat */
 describe('toBeResolved', function() {
   it('passes if the actual is resolved', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolved(matchersUtil),
       actual = Promise.resolve();
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if the actual is rejected', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolved(matchersUtil),
       actual = Promise.reject('AsyncExpectationSpec rejection');
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolved(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolved(matchersUtil),
       actual = 'not a promise';
 
     function f() {
       return matcher.compare(actual);
     }
 
-    expect(f).toThrowError(
-      'Expected toBeResolved to be called on a promise.'
-    );
+    expect(f).toThrowError('Expected toBeResolved to be called on a promise.');
   });
 });

spec/core/matchers/async/toBeResolvedToSpec.js

@@ -1,71 +1,101 @@
+/* eslint-disable compat/compat */
 describe('#toBeResolvedTo', function() {
   it('passes if the promise is resolved to the expected value', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
-      actual = Promise.resolve({foo: 42});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
+      actual = Promise.resolve({ foo: 42 });
 
-    return matcher.compare(actual, {foo: 42}).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+    return matcher.compare(actual, { foo: 42 }).then(function(result) {
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if the promise is rejected', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = Promise.reject('AsyncExpectationSpec error');
 
     return matcher.compare(actual, '').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: "Expected a promise to be resolved to '' but it was rejected.",
-      }));
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message:
+            "Expected a promise to be resolved to '' but it was rejected."
+        })
+      );
     });
   });
 
   it('fails if the promise is resolved to a different value', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
-      actual = Promise.resolve({foo: 17});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
+      actual = Promise.resolve({ foo: 17 });
 
-    return matcher.compare(actual, {foo: 42}).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: false,
-        message: 'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).',
-      }));
+    return matcher.compare(actual, { foo: 42 }).then(function(result) {
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: false,
+          message:
+            'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).'
+        })
+      );
     });
   });
 
   it('builds its message correctly when negated', function() {
     jasmine.getEnv().requirePromises();
 
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = Promise.resolve(true);
 
     return matcher.compare(actual, true).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
-        pass: true,
-        message: 'Expected a promise not to be resolved to true.'
-      }));
+      expect(result).toEqual(
+        jasmine.objectContaining({
+          pass: true,
+          message: 'Expected a promise not to be resolved to true.'
+        })
+      );
     });
   });
 
   it('supports custom equality testers', function() {
     jasmine.getEnv().requirePromises();
 
-    var customEqualityTesters = [function() { return true; }],
-      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil, customEqualityTesters),
+    var customEqualityTesters = [
+        function() {
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters,
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = Promise.resolve('actual');
 
     return matcher.compare(actual, 'expected').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(jasmineUnderTest.matchersUtil),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = 'not a promise';
 
     function f() {

spec/core/matchers/toBeCloseToSpec.js

@@ -1,5 +1,5 @@
-describe("toBeCloseTo", function() {
-  it("passes when within two decimal places by default", function() {
+describe('toBeCloseTo', function() {
+  it('passes when within two decimal places by default', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -13,7 +13,7 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when not within two decimal places by default", function() {
+  it('fails when not within two decimal places by default', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -24,7 +24,7 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("accepts an optional precision argument", function() {
+  it('accepts an optional precision argument', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -47,23 +47,29 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when one of the arguments is null", function() {
+  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).');
+    }).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).');
+    }).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).');
+    }).toThrowError(
+      'Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).'
+    );
   });
 
-  it("rounds expected values", function() {
+  it('rounds expected values', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -91,15 +97,15 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("handles edge cases with rounding", function () {
+  it('handles edge cases with rounding', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
-    // these cases resulted in false negatives in version of V8 
+    // these cases resulted in false negatives in version of V8
     // included in Node.js 12 and Chrome 74 (and Edge Chromium)
     result = matcher.compare(4.030904708957288, 4.0309, 5);
     expect(result.pass).toBe(true);
-    result = matcher.compare(4.82665525779431,4.82666, 5);
+    result = matcher.compare(4.82665525779431, 4.82666, 5);
     expect(result.pass).toBe(true);
     result = matcher.compare(-2.82665525779431, -2.82666, 5);
     expect(result.pass).toBe(true);

spec/core/matchers/toBeDefinedSpec.js

@@ -1,18 +1,17 @@
-describe("toBeDefined", function() {
-  it("matches for defined values", function() {
+describe('toBeDefined', function() {
+  it('matches for defined values', function() {
     var matcher = jasmineUnderTest.matchers.toBeDefined(),
       result;
 
-
     result = matcher.compare('foo');
     expect(result.pass).toBe(true);
   });
 
-  it("fails when matching undefined values", function() {
+  it('fails when matching undefined values', function() {
     var matcher = jasmineUnderTest.matchers.toBeDefined(),
       result;
 
     result = matcher.compare(void 0);
     expect(result.pass).toBe(false);
-  })
+  });
 });

spec/core/matchers/toBeFalseSpec.js

@@ -1,5 +1,5 @@
-describe("toBeFalse", function() {
-  it("passes for false", function() {
+describe('toBeFalse', function() {
+  it('passes for false', function() {
     var matcher = jasmineUnderTest.matchers.toBeFalse(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeFalse", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails for non-false", function() {
+  it('fails for non-false', function() {
     var matcher = jasmineUnderTest.matchers.toBeFalse(),
       result;
 
@@ -15,7 +15,7 @@ describe("toBeFalse", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("fails for falsy", function() {
+  it('fails for falsy', function() {
     var matcher = jasmineUnderTest.matchers.toBeFalse(),
       result;
 

spec/core/matchers/toBeFalsySpec.js

@@ -1,4 +1,4 @@
-describe("toBeFalsy", function() {
+describe('toBeFalsy', function() {
   it("passes for 'falsy' values", function() {
     var matcher = jasmineUnderTest.matchers.toBeFalsy(),
       result;
@@ -15,6 +15,9 @@ describe("toBeFalsy", function() {
     result = matcher.compare(null);
     expect(result.pass).toBe(true);
 
+    result = matcher.compare(undefined);
+    expect(result.pass).toBe(true);
+
     result = matcher.compare(void 0);
     expect(result.pass).toBe(true);
   });
@@ -29,10 +32,16 @@ describe("toBeFalsy", function() {
     result = matcher.compare(1);
     expect(result.pass).toBe(false);
 
-    result = matcher.compare("foo");
+    result = matcher.compare('foo');
     expect(result.pass).toBe(false);
 
     result = matcher.compare({});
     expect(result.pass).toBe(false);
+
+    result = matcher.compare([]);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(function() {});
+    expect(result.pass).toBe(false);
   });
 });

spec/core/matchers/toBeGreaterThanOrEqualSpec.js

@@ -1,5 +1,5 @@
-describe("toBeGreaterThanOrEqual", function() {
-  it("passes when actual >= expected", function() {
+describe('toBeGreaterThanOrEqual', function() {
+  it('passes when actual >= expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
       result;
 
@@ -16,7 +16,7 @@ describe("toBeGreaterThanOrEqual", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when actual < expected", function() {
+  it('fails when actual < expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
       result;
 
@@ -25,5 +25,5 @@ describe("toBeGreaterThanOrEqual", function() {
 
     result = matcher.compare(1, 1.0000001);
     expect(result.pass).toBe(false);
-  })
+  });
 });

spec/core/matchers/toBeGreaterThanSpec.js

@@ -1,5 +1,5 @@
-describe("toBeGreaterThan", function() {
-  it("passes when actual > expected", function() {
+describe('toBeGreaterThan', function() {
+  it('passes when actual > expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeGreaterThan", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when actual <= expected", function() {
+  it('fails when actual <= expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
       result;
 

spec/core/matchers/toBeInstanceOfSpec.js

@@ -10,7 +10,9 @@ describe('toBeInstanceOf', function() {
     });
 
     it('passes for NaN', function() {
-      var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
+      var matcher = jasmineUnderTest.matchers.toBeInstanceOf({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      });
       var result = matcher.compare(NaN, Number);
       expect(result).toEqual({
         pass: true,
@@ -90,13 +92,14 @@ describe('toBeInstanceOf', function() {
 
   describe('when expecting Function', function() {
     it('passes for a function', function() {
-      var fn = function() { };
+      var fn = function() {};
 
       var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
       var result = matcher.compare(fn, Function);
       expect(result).toEqual({
         pass: true,
-        message: 'Expected instance of Function not to be an instance of Function'
+        message:
+          'Expected instance of Function not to be an instance of Function'
       });
     });
 
@@ -109,13 +112,14 @@ describe('toBeInstanceOf', function() {
       var result = matcher.compare(fn, Function);
       expect(result).toEqual({
         pass: true,
-        message: 'Expected instance of AsyncFunction not to be an instance of Function'
+        message:
+          'Expected instance of AsyncFunction not to be an instance of Function'
       });
     });
   });
 
   describe('when expecting Object', function() {
-    function Animal() { }
+    function Animal() {}
 
     it('passes for any object', function() {
       var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
@@ -156,18 +160,21 @@ describe('toBeInstanceOf', function() {
     it('passes for objects with no constructor', function() {
       var object = Object.create(null);
 
-      var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
+      var matcher = jasmineUnderTest.matchers.toBeInstanceOf({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      });
       var result = matcher.compare(object, Object);
       expect(result).toEqual({
         pass: true,
-        message: 'Expected instance of null({  }) not to be an instance of Object'
+        message:
+          'Expected instance of null({  }) not to be an instance of Object'
       });
     });
   });
 
   describe('when expecting a user-defined class', function() {
     // Base class
-    function Animal() { }
+    function Animal() {}
 
     // Subclasses, defined using syntax that is as old as possible
     function Dog() {
@@ -214,15 +221,21 @@ describe('toBeInstanceOf', function() {
     var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
     expect(function() {
       matcher.compare({}, 'Error');
-    }).toThrowError('<toBeInstanceOf> : Expected value is not a constructor function\n' +
-        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)');
+    }).toThrowError(
+      '<toBeInstanceOf> : Expected value is not a constructor function\n' +
+        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)'
+    );
   });
 
   it('raises an error if missing an expected value', function() {
-    var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
+    var matcher = jasmineUnderTest.matchers.toBeInstanceOf({
+      pp: jasmineUnderTest.makePrettyPrinter()
+    });
     expect(function() {
       matcher.compare({}, undefined);
-    }).toThrowError('<toBeInstanceOf> : Expected value is not a constructor function\n' +
-        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)');
+    }).toThrowError(
+      '<toBeInstanceOf> : Expected value is not a constructor function\n' +
+        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)'
+    );
   });
 });

spec/core/matchers/toBeLessThanOrEqualSpec.js

@@ -1,5 +1,5 @@
-describe("toBeLessThanOrEqual", function() {
-  it("passes when actual <= expected", function() {
+describe('toBeLessThanOrEqual', function() {
+  it('passes when actual <= expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
       result;
 
@@ -11,12 +11,12 @@ describe("toBeLessThanOrEqual", function() {
 
     result = matcher.compare(1, 1.0000001);
     expect(result.pass).toBe(true);
-    
+
     result = matcher.compare(1.0, 1.0);
     expect(result.pass).toBe(true);
   });
 
-  it("fails when actual < expected", function() {
+  it('fails when actual < expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
       result;
 

spec/core/matchers/toBeLessThanSpec.js

@@ -1,5 +1,5 @@
-describe("toBeLessThan", function() {
-  it("passes when actual < expected", function() {
+describe('toBeLessThan', function() {
+  it('passes when actual < expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeLessThan(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeLessThan", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when actual <= expected", function() {
+  it('fails when actual <= expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeLessThan(),
       result;
 

spec/core/matchers/toBeNaNSpec.js

@@ -1,14 +1,14 @@
-describe("toBeNaN", function() {
-  it("passes for NaN with a custom .not fail", function() {
+describe('toBeNaN', function() {
+  it('passes for NaN with a custom .not fail', function() {
     var matcher = jasmineUnderTest.matchers.toBeNaN(),
       result;
 
     result = matcher.compare(Number.NaN);
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected actual not to be NaN.");
+    expect(result.message).toEqual('Expected actual not to be NaN.');
   });
 
-  it("fails for anything not a NaN", function() {
+  it('fails for anything not a NaN', function() {
     var matcher = jasmineUnderTest.matchers.toBeNaN(),
       result;
 
@@ -28,10 +28,12 @@ describe("toBeNaN", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("has a custom message on failure", function() {
-    var matcher = jasmineUnderTest.matchers.toBeNaN(),
+  it('has a custom message on failure', function() {
+    var matcher = jasmineUnderTest.matchers.toBeNaN({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       result = matcher.compare(0);
 
-    expect(result.message()).toEqual("Expected 0 to be NaN.");
+    expect(result.message()).toEqual('Expected 0 to be NaN.');
   });
 });

spec/core/matchers/toBeNegativeInfinitySpec.js

@@ -1,4 +1,4 @@
-describe("toBeNegativeInfinity", function() {
+describe('toBeNegativeInfinity', function() {
   it("fails for anything that isn't -Infinity", function() {
     var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
       result;
@@ -13,19 +13,20 @@ describe("toBeNegativeInfinity", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("has a custom message on failure", function() {
-    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+  it('has a custom message on failure', function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       result = matcher.compare(0);
 
-    expect(result.message()).toEqual("Expected 0 to be -Infinity.")
+    expect(result.message()).toEqual('Expected 0 to be -Infinity.');
   });
 
-  it("succeeds for -Infinity", function() {
+  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 not to be -Infinity.")
+    expect(result.message).toEqual('Expected actual not to be -Infinity.');
   });
-
 });

spec/core/matchers/toBeNullSpec.js

@@ -1,5 +1,5 @@
-describe("toBeNull", function() {
-  it("passes for null", function() {
+describe('toBeNull', function() {
+  it('passes for null', function() {
     var matcher = jasmineUnderTest.matchers.toBeNull(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeNull", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails for non-null", function() {
+  it('fails for non-null', function() {
     var matcher = jasmineUnderTest.matchers.toBeNull(),
       result;
 

spec/core/matchers/toBePositiveInfinitySpec.js

@@ -1,4 +1,4 @@
-describe("toBePositiveInfinity", function() {
+describe('toBePositiveInfinity', function() {
   it("fails for anything that isn't Infinity", function() {
     var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
       result;
@@ -13,19 +13,20 @@ describe("toBePositiveInfinity", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("has a custom message on failure", function() {
-    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+  it('has a custom message on failure', function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       result = matcher.compare(0);
 
-    expect(result.message()).toEqual("Expected 0 to be Infinity.")
+    expect(result.message()).toEqual('Expected 0 to be Infinity.');
   });
 
-  it("succeeds for Infinity", function() {
+  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 not to be Infinity.")
+    expect(result.message).toEqual('Expected actual not to be Infinity.');
   });
-
 });

spec/core/matchers/toBeSpec.js

@@ -1,34 +1,46 @@
-describe("toBe", function() {
-  it("passes with no message when actual === expected", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+describe('toBe', function() {
+  it('passes with no message when actual === expected', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
     result = matcher.compare(1, 1);
     expect(result.pass).toBe(true);
   });
 
-  it("passes with a custom message when expected is an array", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+  it('passes with a custom message when expected is an array', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result,
       array = [1];
 
     result = matcher.compare(array, array);
     expect(result.pass).toBe(true);
-    expect(result.message).toBe("Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      'Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
+    );
   });
 
-  it("passes with a custom message when expected is an object", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+  it('passes with a custom message when expected is an object', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result,
-      obj = {foo: "bar"};
+      obj = { foo: 'bar' };
 
     result = matcher.compare(obj, obj);
     expect(result.pass).toBe(true);
-    expect(result.message).toBe("Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      "Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe()."
+    );
   });
 
-  it("fails with no message when actual !== expected", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+  it('fails with no message when actual !== expected', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil(),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
     result = matcher.compare(1, 2);
@@ -36,21 +48,47 @@ describe("toBe", function() {
     expect(result.message).toBeUndefined();
   });
 
-  it("fails with a custom message when expected is an array", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+  it('fails with a custom message when expected is an array', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
     result = matcher.compare([1], [1]);
     expect(result.pass).toBe(false);
-    expect(result.message).toBe("Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      'Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
+    );
   });
 
-  it("fails with a custom message when expected is an object", function() {
-    var matcher = jasmineUnderTest.matchers.toBe(jasmineUnderTest.matchersUtil),
+  it('fails with a custom message when expected is an object', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
-    result = matcher.compare({foo: "bar"}, {foo: "bar"});
+    result = matcher.compare({ foo: 'bar' }, { foo: 'bar' });
     expect(result.pass).toBe(false);
-    expect(result.message).toBe("Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      "Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe()."
+    );
+  });
+
+  it('works with custom object formatters when expected is an object', function() {
+    var formatter = function(x) {
+        return '<' + x.foo + '>';
+      },
+      prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]),
+      matchersUtil = new jasmineUnderTest.MatchersUtil({ pp: prettyPrinter }),
+      matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
+      result;
+
+    result = matcher.compare({ foo: 'bar' }, { foo: 'bar' });
+    expect(result.pass).toBe(false);
+    expect(result.message).toBe(
+      'Expected <bar> to be <bar>. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
+    );
   });
 });

spec/core/matchers/toBeTrueSpec.js

@@ -1,5 +1,5 @@
-describe("toBeTrue", function() {
-  it("passes for true", function() {
+describe('toBeTrue', function() {
+  it('passes for true', function() {
     var matcher = jasmineUnderTest.matchers.toBeTrue(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeTrue", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails for non-true", function() {
+  it('fails for non-true', function() {
     var matcher = jasmineUnderTest.matchers.toBeTrue(),
       result;
 

spec/core/matchers/toBeTruthySpec.js

@@ -1,4 +1,4 @@
-describe("toBeTruthy", function() {
+describe('toBeTruthy', function() {
   it("passes for 'truthy' values", function() {
     var matcher = jasmineUnderTest.matchers.toBeTruthy(),
       result;
@@ -9,11 +9,17 @@ describe("toBeTruthy", function() {
     result = matcher.compare(1);
     expect(result.pass).toBe(true);
 
-    result = matcher.compare("foo");
+    result = matcher.compare('foo');
     expect(result.pass).toBe(true);
 
     result = matcher.compare({});
     expect(result.pass).toBe(true);
+
+    result = matcher.compare([]);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(function() {});
+    expect(result.pass).toBe(true);
   });
 
   it("fails for 'falsy' values", function() {
@@ -32,6 +38,9 @@ describe("toBeTruthy", function() {
     result = matcher.compare(null);
     expect(result.pass).toBe(false);
 
+    result = matcher.compare(undefined);
+    expect(result.pass).toBe(false);
+
     result = matcher.compare(void 0);
     expect(result.pass).toBe(false);
   });

spec/core/matchers/toBeUndefinedSpec.js

@@ -1,18 +1,17 @@
-describe("toBeUndefined", function() {
-  it("passes for undefined values", function() {
+describe('toBeUndefined', function() {
+  it('passes for undefined values', function() {
     var matcher = jasmineUnderTest.matchers.toBeUndefined(),
       result;
 
     result = matcher.compare(void 0);
     expect(result.pass).toBe(true);
-
   });
 
-  it("fails when matching defined values", function() {
+  it('fails when matching defined values', function() {
     var matcher = jasmineUnderTest.matchers.toBeUndefined(),
       result;
 
     result = matcher.compare('foo');
     expect(result.pass).toBe(false);
-  })
+  });
 });

spec/core/matchers/toContainSpec.js

@@ -1,26 +1,27 @@
-describe("toContain", function() {
-  it("delegates to jasmineUnderTest.matchersUtil.contains", function() {
-    var util = {
+describe('toContain', function() {
+  it('delegates to jasmineUnderTest.matchersUtil.contains', function() {
+    var matchersUtil = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
-      matcher = jasmineUnderTest.matchers.toContain(util),
+      matcher = jasmineUnderTest.matchers.toContain(matchersUtil),
       result;
 
-    result = matcher.compare("ABC", "B");
-    expect(util.contains).toHaveBeenCalledWith("ABC", "B", []);
+    result = matcher.compare('ABC', 'B');
+    expect(matchersUtil.contains).toHaveBeenCalledWith('ABC', 'B');
     expect(result.pass).toBe(true);
   });
 
-  it("delegates to jasmineUnderTest.matchersUtil.contains, passing in equality testers if present", function() {
-    var util = {
-        contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
+  it('works with custom equality testers', function() {
+    var tester = function(a, b) {
+        return a.toString() === b.toString();
       },
-      customEqualityTesters = ['a', 'b'],
-      matcher = jasmineUnderTest.matchers.toContain(util, customEqualityTesters),
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: [tester]
+      }),
+      matcher = jasmineUnderTest.matchers.toContain(matchersUtil),
       result;
 
-    result = matcher.compare("ABC", "B");
-    expect(util.contains).toHaveBeenCalledWith("ABC", "B", ['a', 'b']);
+    result = matcher.compare(['1', '2'], 2);
     expect(result.pass).toBe(true);
   });
 });

spec/core/matchers/toHaveBeenCalledBeforeSpec.js

@@ -1,63 +1,77 @@
-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');
+describe('toHaveBeenCalledBefore', function() {
+  it('throws an exception when the actual is not a spy', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      fn = function() {},
+      spy = new jasmineUnderTest.Env().createSpy('a spy');
 
-    expect(function() { matcher.compare(fn, secondSpy) }).toThrowError(Error, /Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(fn, spy);
+    }).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() {};
+  it('throws an exception when the expected is not a spy', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      spy = new jasmineUnderTest.Env().createSpy('a spy'),
+      fn = function() {};
 
-    expect(function() { matcher.compare(firstSpy, fn) }).toThrowError(Error, /Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(spy, fn);
+    }).toThrowError(Error, /Expected a spy, but got Function./);
   });
 
-  it("fails when the actual was not called", 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');
+      firstSpy = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('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./);
+    expect(result.message).toMatch(
+      /Expected spy first spy to have been called./
+    );
   });
 
-  it("fails when the expected was not called", function() {
+  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 = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('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./);
+    expect(result.message).toMatch(
+      /Expected spy second spy to have been called./
+    );
   });
 
-  it("fails when the actual is called after the expected", function() {
+  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;
+      firstSpy = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('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');
+    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() {
+  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 = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('second spy'),
+      result;
 
     firstSpy();
     secondSpy();
@@ -65,14 +79,16 @@ describe("toHaveBeenCalledBefore", function() {
 
     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)');
+    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() {
+  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;
+      firstSpy = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('second spy'),
+      result;
 
     secondSpy();
     firstSpy();
@@ -80,20 +96,24 @@ describe("toHaveBeenCalledBefore", function() {
 
     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)');
+    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() {
+  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 = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('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');
+    expect(result.message).toEqual(
+      'Expected spy first spy to not have been called before spy second spy, but it was'
+    );
   });
 });

spec/core/matchers/toHaveBeenCalledOnceWithSpec.js

@@ -0,0 +1,114 @@
+describe('toHaveBeenCalledOnceWith', function() {
+  it('passes when the actual was called only once and with matching parameters', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
+
+    calledSpy('a', 'b');
+    result = matcher.compare(calledSpy, 'a', 'b');
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called 0 times, multiple times, or once, but with arguments different from:\n  [ 'a', 'b' ]\nBut the actual call was:\n  [ 'a', 'b' ].\n\n"
+    );
+  });
+
+  it('supports custom equality testers', function() {
+    var customEqualityTesters = [
+        function() {
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters
+      }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(
+        matchersUtil
+      ),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
+
+    calledSpy('a', 'b');
+    result = matcher.compare(calledSpy, 'a', 'a');
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails when the actual was never called', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
+
+    result = matcher.compare(calledSpy, 'a', 'b');
+
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut it was never called.\n\n"
+    );
+  });
+
+  it('fails when the actual was called once with different parameters', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
+
+    calledSpy('a', 'c');
+    result = matcher.compare(calledSpy, 'a', 'b');
+
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual call was:\n  [ 'a', 'c' ].\nExpected $[1] = 'c' to equal 'b'.\n\n"
+    );
+  });
+
+  it('fails when the actual was called multiple times with expected parameters', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
+
+    calledSpy('a', 'b');
+    calledSpy('a', 'b');
+    result = matcher.compare(calledSpy, 'a', 'b');
+
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual calls were:\n  [ 'a', 'b' ],\n  [ 'a', 'b' ].\n\n"
+    );
+  });
+
+  it('fails when the actual was called multiple times (one of them - with expected parameters)', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
+
+    calledSpy('a', 'b');
+    calledSpy('a', 'c');
+    result = matcher.compare(calledSpy, 'a', 'b');
+
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual calls were:\n  [ 'a', 'b' ],\n  [ 'a', 'c' ].\n\n"
+    );
+  });
+
+  it('throws an exception when the actual is not a spy', function() {
+    var pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      fn = function() {};
+
+    expect(function() {
+      matcher.compare(fn);
+    }).toThrowError(/Expected a spy, but got Function./);
+  });
+});

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -1,47 +1,56 @@
-describe("toHaveBeenCalled", function() {
-  it("passes when the actual was called, with a custom .not fail message", function() {
+describe('toHaveBeenCalled', function() {
+  it('passes when the actual was called, with a custom .not fail message', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
       result;
 
     calledSpy();
 
     result = matcher.compare(calledSpy);
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected spy called-spy not to have been called.");
+    expect(result.message).toEqual(
+      'Expected spy called-spy not to have been called.'
+    );
   });
 
-  it("fails when the actual was not called", function() {
+  it('fails when the actual was not called', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
+      uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
       result;
 
     result = matcher.compare(uncalledSpy);
     expect(result.pass).toBe(false);
   });
 
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+  it('throws an exception when the actual is not a spy', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {};
 
-    expect(function() { matcher.compare(fn) }).toThrowError(Error, /Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(fn);
+    }).toThrowError(Error, /Expected a spy, but got Function./);
   });
 
-  it("throws an exception when invoked with any arguments", function() {
+  it('throws an exception when invoked with any arguments', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      spy = new jasmineUnderTest.Env().createSpy('sample spy');
+      spy = new jasmineUnderTest.Spy('sample spy');
 
-    expect(function() { matcher.compare(spy, 'foo') }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
+    expect(function() {
+      matcher.compare(spy, 'foo');
+    }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
   });
 
-  it("has a custom message on failure", function() {
+  it('has a custom message on failure', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
+      spy = new jasmineUnderTest.Spy('sample-spy'),
       result;
 
     result = matcher.compare(spy);
 
-    expect(result.message).toEqual("Expected spy sample-spy to have been called.");
+    expect(result.message).toEqual(
+      'Expected spy sample-spy to have been called.'
+    );
   });
 });
-

spec/core/matchers/toHaveBeenCalledTimesSpec.js

@@ -1,14 +1,14 @@
-describe("toHaveBeenCalledTimes", function() {
-  it("passes when the actual 0 matches the expected 0 ", function () {
+describe('toHaveBeenCalledTimes', function() {
+  it('passes when the actual 0 matches the expected 0 ', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
-        result;
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
     result = matcher.compare(calledSpy, 0);
     expect(result.pass).toBeTruthy();
   });
-  it("passes when the actual matches the expected", function() {
+  it('passes when the actual matches the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
       result;
     calledSpy();
 
@@ -16,29 +16,31 @@ describe("toHaveBeenCalledTimes", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when expected numbers is not supplied", function(){
-     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = new jasmineUnderTest.Env().createSpy('spy'),
+  it('fails when expected numbers is not supplied', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      spy = new jasmineUnderTest.Spy('spy'),
       result;
 
     spy();
-     expect(function() {
-       matcher.compare(spy);
-     }).toThrowError(/The expected times failed is a required argument and must be a number./);
+    expect(function() {
+      matcher.compare(spy);
+    }).toThrowError(
+      /The expected times failed is a required argument and must be a number./
+    );
   });
 
-  it("fails when the actual was called less than the expected", function() {
+  it('fails when the actual was called less than the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
+      uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
       result;
 
     result = matcher.compare(uncalledSpy, 2);
     expect(result.pass).toBe(false);
   });
 
-  it("fails when the actual was called more than expected", function() {
+  it('fails when the actual was called more than expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
+      uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
       result;
 
     uncalledSpy();
@@ -48,8 +50,10 @@ describe("toHaveBeenCalledTimes", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+  it('throws an exception when the actual is not a spy', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {};
 
     expect(function() {
@@ -57,9 +61,9 @@ describe("toHaveBeenCalledTimes", function() {
     }).toThrowError(/Expected a spy, but got Function./);
   });
 
-  it("has a custom message on failure that tells it was called only once", function() {
+  it('has a custom message on failure that tells it was called only once', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
+      spy = new jasmineUnderTest.Spy('sample-spy'),
       result;
     spy();
     spy();
@@ -67,12 +71,16 @@ describe("toHaveBeenCalledTimes", function() {
     spy();
 
     result = matcher.compare(spy, 1);
-    expect(result.message).toEqual('Expected spy sample-spy to have been called once. It was called ' +  4 + ' times.');
+    expect(result.message).toEqual(
+      'Expected spy sample-spy to have been called once. It was called ' +
+        4 +
+        ' times.'
+    );
   });
 
-  it("has a custom message on failure that tells how many times it was called", function() {
+  it('has a custom message on failure that tells how many times it was called', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
+      spy = new jasmineUnderTest.Spy('sample-spy'),
       result;
     spy();
     spy();
@@ -80,7 +88,10 @@ describe("toHaveBeenCalledTimes", function() {
     spy();
 
     result = matcher.compare(spy, 2);
-    expect(result.message).toEqual('Expected spy sample-spy to have been called 2 times. It was called ' +  4 + ' times.');
+    expect(result.message).toEqual(
+      'Expected spy sample-spy to have been called 2 times. It was called ' +
+        4 +
+        ' times.'
+    );
   });
 });
-

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -1,52 +1,65 @@
-describe("toHaveBeenCalledWith", function() {
-
-  it("passes when the actual was called with matching parameters", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
-        },
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
-        result;
+describe('toHaveBeenCalledWith', function() {
+  it('passes when the actual was called with matching parameters', function() {
+    var matchersUtil = {
+        contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      },
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
 
     calledSpy('a', 'b');
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected spy called-spy not to have been called with:\n  [ 'a', 'b' ]\nbut it was.");
+    expect(result.message()).toEqual(
+      "Expected spy called-spy not to have been called with:\n  [ 'a', 'b' ]\nbut it was."
+    );
   });
 
-  it("passes through the custom equality testers", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
-        },
-        customEqualityTesters = [function() { return true; }],
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util, customEqualityTesters),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy');
+  it('supports custom equality testers', function() {
+    var customEqualityTesters = [
+        function() {
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters
+      }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      result;
 
     calledSpy('a', 'b');
-    matcher.compare(calledSpy, 'a', 'b');
-
-    expect(util.contains).toHaveBeenCalledWith([['a', 'b']], ['a', 'b'], customEqualityTesters);
+    result = matcher.compare(calledSpy, 'a', 'b');
+    expect(result.pass).toBe(true);
   });
 
-  it("fails when the actual was not called", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
-        },
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
-        result;
+  it('fails when the actual was not called', function() {
+    var matchersUtil = {
+        contains: jasmine
+          .createSpy('delegated-contains')
+          .and.returnValue(false),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      },
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
+      result;
 
     result = matcher.compare(uncalledSpy);
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected spy uncalled spy to have been called with:\n  [  ]\nbut it was never called.");
+    expect(result.message()).toEqual(
+      'Expected spy uncalled spy to have been called with:\n  [  ]\nbut it was never called.'
+    );
   });
 
-  it("fails when the actual was called with different parameters", function() {
-    var util = jasmineUnderTest.matchersUtil,
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called spy'),
-        result;
+  it('fails when the actual was called with different parameters', function() {
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      calledSpy = new jasmineUnderTest.Spy('called spy'),
+      result;
 
     calledSpy('a');
     calledSpy('c', 'd');
@@ -55,27 +68,32 @@ describe("toHaveBeenCalledWith", function() {
 
     expect(result.pass).toBe(false);
     expect(result.message()).toEqual(
-      "Expected spy called spy to have been called with:\n" +
-      "  [ 'a', 'b' ]\n" +
-      "but actual calls were:\n" +
-      "  [ 'a' ],\n" +
-      "  [ 'c', 'd' ],\n" +
-      "  [ 'a', 'b', 'c' ].\n\n" +
-      "Call 0:\n" +
-      "  Expected $.length = 1 to equal 2.\n" +
-      "  Expected $[1] = undefined to equal 'b'.\n" +
-      "Call 1:\n" +
-      "  Expected $[0] = 'c' to equal 'a'.\n" +
-      "  Expected $[1] = 'd' to equal 'b'.\n" +
-      "Call 2:\n" +
-      "  Expected $.length = 3 to equal 2.\n" +
-      "  Unexpected $[2] = 'c' in array.");
+      'Expected spy called spy to have been called with:\n' +
+        "  [ 'a', 'b' ]\n" +
+        'but actual calls were:\n' +
+        "  [ 'a' ],\n" +
+        "  [ 'c', 'd' ],\n" +
+        "  [ 'a', 'b', 'c' ].\n\n" +
+        'Call 0:\n' +
+        '  Expected $.length = 1 to equal 2.\n' +
+        "  Expected $[1] = undefined to equal 'b'.\n" +
+        'Call 1:\n' +
+        "  Expected $[0] = 'c' to equal 'a'.\n" +
+        "  Expected $[1] = 'd' to equal 'b'.\n" +
+        'Call 2:\n' +
+        '  Expected $.length = 3 to equal 2.\n' +
+        "  Unexpected $[2] = 'c' in array."
+    );
   });
 
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(),
-        fn = function() {};
+  it('throws an exception when the actual is not a spy', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      fn = function() {};
 
-    expect(function() { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(fn);
+    }).toThrowError(/Expected a spy, but got Function./);
   });
 });

spec/core/matchers/toHaveClassSpec.js

@@ -5,7 +5,10 @@ describe('toHaveClass', function() {
 
   it('fails for a DOM element that lacks the expected class', function() {
     var matcher = jasmineUnderTest.matchers.toHaveClass(),
-      result = matcher.compare(this.domHelpers.createElementWithClassName(''), 'foo');
+      result = matcher.compare(
+        this.domHelpers.createElementWithClassName(''),
+        'foo'
+      );
 
     expect(result.pass).toBe(false);
   });
@@ -27,7 +30,9 @@ describe('toHaveClass', function() {
   });
 
   it('throws an exception when actual is not a DOM element', function() {
-    var matcher = jasmineUnderTest.matchers.toHaveClass();
+    var matcher = jasmineUnderTest.matchers.toHaveClass({
+      pp: jasmineUnderTest.makePrettyPrinter()
+    });
 
     expect(function() {
       matcher.compare('x', 'foo');
@@ -39,11 +44,11 @@ describe('toHaveClass', function() {
 
     var textNode = this.domHelpers.document.createTextNode('');
     expect(function() {
-      matcher.compare(textNode, 'foo')
+      matcher.compare(textNode, 'foo');
     }).toThrowError('HTMLNode is not a DOM element');
 
     expect(function() {
-      matcher.compare({classList: ''}, 'foo');
+      matcher.compare({ classList: '' }, 'foo');
     }).toThrowError("Object({ classList: '' }) is not a DOM element");
   });
 });

spec/core/matchers/toHaveSizeSpec.js

@@ -0,0 +1,138 @@
+/* eslint-disable compat/compat */
+describe('toHaveSize', function() {
+  'use strict';
+
+  it('passes for an array whose length matches', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare([1, 2], 2);
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails for an array whose length does not match', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare([1, 2, 3], 2);
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for an object with the proper number of keys', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare({ a: 1, b: 2 }, 2);
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails for an object with a different number of keys', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare({ a: 1, b: 2 }, 1);
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for an object with an explicit `length` property that matches', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare({ a: 1, b: 2, length: 5 }, 5);
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails for an object with an explicit `length` property that does not match', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare({ a: 1, b: 2, length: 5 }, 1);
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for a string whose length matches', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare('ab', 2);
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails for a string whose length does not match', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare('abc', 2);
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for a Map whose length matches', function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var map = new Map();
+    map.set('a', 1);
+    map.set('b', 2);
+
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare(map, 2);
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails for a Map whose length does not match', function() {
+    jasmine.getEnv().requireFunctioningMaps();
+
+    var map = new Map();
+    map.set('a', 1);
+    map.set('b', 2);
+
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare(map, 1);
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for a Set whose length matches', function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var set = new Set();
+    set.add('a');
+    set.add('b');
+
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare(set, 2);
+
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails for a Set whose length does not match', function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var set = new Set();
+    set.add('a');
+    set.add('b');
+
+    var matcher = jasmineUnderTest.matchers.toHaveSize(),
+      result = matcher.compare(set, 1);
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('throws an error for WeakSet', function() {
+    jasmine.getEnv().requireWeakSets();
+    var matcher = jasmineUnderTest.matchers.toHaveSize();
+
+    expect(function() {
+      matcher.compare(new WeakSet(), 2);
+    }).toThrowError('Cannot get size of [object WeakSet].');
+  });
+
+  it('throws an error for WeakMap', function() {
+    jasmine.getEnv().requireWeakMaps();
+    var matcher = jasmineUnderTest.matchers.toHaveSize();
+
+    expect(function() {
+      matcher.compare(new WeakMap(), 2);
+    }).toThrowError(/Cannot get size of \[object (WeakMap|Object)\]\./);
+  });
+
+  it('throws an error for DataView', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveSize();
+
+    expect(function() {
+      matcher.compare(new DataView(new ArrayBuffer(128)), 2);
+    }).toThrowError(/Cannot get size of \[object (DataView|Object)\]\./);
+  });
+});

spec/core/matchers/toMatchSpec.js

@@ -1,6 +1,5 @@
-describe("toMatch", function() {
-
-  it("passes when RegExps are equivalent", function() {
+describe('toMatch', function() {
+  it('passes when RegExps are equivalent', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -8,7 +7,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when RegExps are not equivalent", function() {
+  it('fails when RegExps are not equivalent', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -16,7 +15,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("passes when the actual matches the expected string as a pattern", function() {
+  it('passes when the actual matches the expected string as a pattern', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -24,7 +23,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when the actual matches the expected string as a pattern", function() {
+  it('fails when the actual matches the expected string as a pattern', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -32,7 +31,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("throws an Error when the expected is not a String or RegExp", function() {
+  it('throws an Error when the expected is not a String or RegExp', function() {
     var matcher = jasmineUnderTest.matchers.toMatch();
 
     expect(function() {
@@ -40,4 +39,3 @@ describe("toMatch", function() {
     }).toThrowError(/Expected is not a String or a RegExp/);
   });
 });
-

spec/core/matchers/toThrowErrorSpec.js

@@ -1,5 +1,5 @@
-describe("toThrowError", function() {
-  it("throws an error when the actual is not a function", function() {
+describe('toThrowError', function() {
+  it('throws an error when the actual is not a function', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError();
 
     expect(function() {
@@ -7,10 +7,10 @@ describe("toThrowError", function() {
     }).toThrowError(/Actual is not a Function/);
   });
 
-  it("throws an error when the expected is not an Error, string, or RegExp", function() {
+  it('throws an error when the expected is not an Error, string, or RegExp', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
@@ -18,21 +18,21 @@ describe("toThrowError", function() {
     }).toThrowError(/Expected is not an Error, string, or RegExp./);
   });
 
-  it("throws an error when the expected error type is not an Error", function() {
+  it('throws an error when the expected error type is not an Error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
-      matcher.compare(fn, void 0, "foo");
+      matcher.compare(fn, void 0, 'foo');
     }).toThrowError(/Expected error type is not an Error./);
   });
 
-  it("throws an error when the expected error message is not a string or RegExp", function() {
+  it('throws an error when the expected error message is not a string or RegExp', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
@@ -40,7 +40,7 @@ describe("toThrowError", function() {
     }).toThrowError(/Expected error message is not a string or RegExp./);
   });
 
-  it("fails if actual does not throw at all", function() {
+  it('fails if actual does not throw at all', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         return true;
@@ -50,11 +50,13 @@ describe("toThrowError", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an Error.");
+    expect(result.message).toEqual('Expected function to throw an Error.');
   });
 
-  it("fails if thrown is not an instanceof Error", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('fails if thrown is not an instanceof Error', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
         throw 4;
       },
@@ -62,12 +64,14 @@ describe("toThrowError", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an Error, but it threw 4.");
+    expect(result.message()).toEqual(
+      'Expected function to throw an Error, but it threw 4.'
+    );
   });
 
-  describe("when error is from another frame", function() {
+  describe('when error is from another frame', function() {
     function isNotRunningInBrowser() {
-      return typeof document === 'undefined'
+      return typeof document === 'undefined';
     }
 
     var iframe = null;
@@ -78,32 +82,39 @@ describe("toThrowError", function() {
       }
     });
 
-    it("passes if thrown is an instanceof Error regardless of global that contains its constructor", function() {
+    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";
+      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'); }";
+        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>");
+        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.");
+      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(),
+  it('fails with the correct message if thrown is a falsy value', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
         throw undefined;
       },
@@ -111,10 +122,12 @@ describe("toThrowError", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an Error, but it threw undefined.");
+    expect(result.message()).toEqual(
+      'Expected function to throw an Error, but it threw undefined.'
+    );
   });
 
-  it("passes if thrown is a type of Error, but there is no expected error", function() {
+  it('passes if thrown is a type of Error, but there is no expected error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError();
@@ -124,66 +137,81 @@ describe("toThrowError", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw an Error, but it threw TypeError.");
+    expect(result.message).toEqual(
+      'Expected function not to throw an Error, but it threw TypeError.'
+    );
   });
 
-  it("passes if thrown is an Error and the expected is the same message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('passes if thrown is an Error and the expected is the same message', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       },
       result;
 
-    result = matcher.compare(fn, "foo");
+    result = matcher.compare(fn, 'foo');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function not to throw an exception with message 'foo'."
+    );
   });
 
-  it("fails if thrown is an Error and the expected is not the same message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('fails if thrown is an Error and the expected is not the same message', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       },
       result;
 
-    result = matcher.compare(fn, "bar");
+    result = matcher.compare(fn, 'bar');
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'."
+    );
   });
 
-  it("passes if thrown is an Error and the expected is a RegExp that matches the message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('passes if thrown is an Error and the expected is a RegExp that matches the message', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
-        throw new Error("a long message");
+        throw new Error('a long message');
       },
       result;
 
     result = matcher.compare(fn, /long/);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception with a message matching /long/.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw an exception with a message matching /long/.'
+    );
   });
 
-  it("fails if thrown is an Error and the expected is a RegExp that does not match the message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('fails if thrown is an Error and the expected is a RegExp that does not match the message', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
-        throw new Error("a long message");
+        throw new Error('a long message');
       },
       result;
 
     result = matcher.compare(fn, /foo/);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'."
+    );
   });
 
-  it("passes if thrown is an Error and the expected the same Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('passes if thrown is an Error and the expected the same Error', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error();
       },
@@ -192,15 +220,14 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, Error);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw Error.");
+    expect(result.message()).toEqual('Expected function not to throw Error.');
   });
 
-  it("passes if thrown is a custom error that takes arguments and the expected is the same error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
+  it('passes if thrown is a custom error that takes arguments and the expected is the same error', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
+      CustomError = function CustomError(arg) {
+        arg.x;
       },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      CustomError = function CustomError(arg) { arg.x },
       fn = function() {
         throw new CustomError({ x: 1 });
       },
@@ -211,14 +238,13 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, CustomError);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw CustomError.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw CustomError.'
+    );
   });
 
-  it("fails if thrown is an Error and the expected is a different Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
+  it('fails if thrown is an Error and the expected is a different Error', function() {
+    var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error();
       },
@@ -227,89 +253,108 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, TypeError);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError, but it threw Error.");
+    expect(result.message()).toEqual(
+      'Expected function to throw TypeError, but it threw Error.'
+    );
   });
 
-  it("passes if thrown is a type of Error and it is equal to the expected Error and message", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
+  it('passes if thrown is a type of Error and it is equal to the expected Error and message', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
-    result = matcher.compare(fn, TypeError, "foo");
+    result = matcher.compare(fn, TypeError, 'foo');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw TypeError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function not to throw TypeError with message 'foo'."
+    );
   });
 
-  it("passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
+  it('passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      },
+      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
+      CustomError = function CustomError(arg) {
+        this.message = arg.message;
       },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      CustomError = function CustomError(arg) { this.message = arg.message },
       fn = function() {
-        throw new CustomError({message: "foo"});
+        throw new CustomError({ message: 'foo' });
       },
       result;
 
     CustomError.prototype = new Error();
 
-    result = matcher.compare(fn, CustomError, "foo");
+    result = matcher.compare(fn, CustomError, 'foo');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw CustomError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function not to throw CustomError with message 'foo'."
+    );
   });
 
-  it("fails if thrown is a type of Error and the expected is a different Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
+  it('fails if thrown is a type of Error and the expected is a different Error', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
-    result = matcher.compare(fn, TypeError, "bar");
+    result = matcher.compare(fn, TypeError, 'bar');
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'."
+    );
   });
 
-  it("passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
+  it('passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
     result = matcher.compare(fn, TypeError, /foo/);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw TypeError with a message matching /foo/.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw TypeError with a message matching /foo/.'
+    );
   });
 
-  it("fails if thrown is a type of Error and the expected is a different Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
+  it('fails if thrown is a type of Error and the expected is a different Error', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
+      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
     result = matcher.compare(fn, TypeError, /bar/);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'."
+    );
   });
 });

spec/core/matchers/toThrowMatchingSpec.js

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

spec/core/matchers/toThrowSpec.js

@@ -1,6 +1,5 @@
-describe("toThrow", function() {
-
-  it("throws an error when the actual is not a function", function() {
+describe('toThrow', function() {
+  it('throws an error when the actual is not a function', function() {
     var matcher = jasmineUnderTest.matchers.toThrow();
 
     expect(function() {
@@ -9,7 +8,7 @@ describe("toThrow", function() {
     }).toThrowError(/Actual is not a Function/);
   });
 
-  it("fails if actual does not throw", function() {
+  it('fails if actual does not throw', function() {
     var matcher = jasmineUnderTest.matchers.toThrow(),
       fn = function() {
         return true;
@@ -19,14 +18,15 @@ describe("toThrow", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an exception.");
+    expect(result.message).toEqual('Expected function to throw an exception.');
   });
 
-  it("passes if it throws but there is no expected", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
+  it('passes if it throws but there is no expected', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(matchersUtil),
       fn = function() {
         throw 5;
       },
@@ -35,11 +35,15 @@ describe("toThrow", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw, but it threw 5.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw, but it threw 5.'
+    );
   });
 
-  it("passes even if what is thrown is falsy", function() {
-    var matcher = jasmineUnderTest.matchers.toThrow(),
+  it('passes even if what is thrown is falsy', function() {
+    var matcher = jasmineUnderTest.matchers.toThrow({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       fn = function() {
         throw undefined;
       },
@@ -47,14 +51,17 @@ describe("toThrow", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw, but it threw undefined.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw, but it threw undefined.'
+    );
   });
 
-  it("passes if what is thrown is equivalent to what is expected", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
+  it('passes if what is thrown is equivalent to what is expected', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(matchersUtil),
       fn = function() {
         throw 5;
       },
@@ -63,30 +70,34 @@ describe("toThrow", function() {
     result = matcher.compare(fn, 5);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw 5.");
+    expect(result.message()).toEqual('Expected function not to throw 5.');
   });
 
-  it("fails if what is thrown is not equivalent to what is expected", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
+  it('fails if what is thrown is not equivalent to what is expected', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(matchersUtil),
       fn = function() {
         throw 5;
       },
       result;
 
-    result = matcher.compare(fn, "foo");
+    result = matcher.compare(fn, 'foo');
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw 'foo', but it threw 5.");
+    expect(result.message()).toEqual(
+      "Expected function to throw 'foo', but it threw 5."
+    );
   });
 
-  it("fails if what is thrown is not equivalent to undefined", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
+  it('fails if what is thrown is not equivalent to undefined', function() {
+    var matchersUtil = {
+        equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
+        pp: jasmineUnderTest.makePrettyPrinter()
       },
-      matcher = jasmineUnderTest.matchers.toThrow(util),
+      matcher = jasmineUnderTest.matchers.toThrow(matchersUtil),
       fn = function() {
         throw 5;
       },
@@ -95,6 +106,8 @@ describe("toThrow", function() {
     result = matcher.compare(fn, void 0);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw undefined, but it threw 5.");
+    expect(result.message()).toEqual(
+      'Expected function to throw undefined, but it threw 5.'
+    );
   });
 });

spec/helpers/checkForMap.js

@@ -1,5 +1,6 @@
+/* eslint-disable compat/compat */
 (function(env) {
-  function hasFunctioningMaps() {
+  env.hasFunctioningMaps = function() {
     if (typeof Map === 'undefined') {
       return false;
     }
@@ -36,11 +37,17 @@
     } catch (e) {
       return false;
     }
-  }
+  };
 
   env.requireFunctioningMaps = function() {
-    if (!hasFunctioningMaps()) {
+    if (!env.hasFunctioningMaps()) {
       env.pending('Browser has incomplete or missing support for Maps');
     }
   };
+
+  env.requireWeakMaps = function() {
+    if (typeof WeakMap === 'undefined') {
+      env.pending('Browser does not have support for WeakMap');
+    }
+  };
 })(jasmine.getEnv());

spec/helpers/checkForSet.js

@@ -1,5 +1,6 @@
+/* eslint-disable compat/compat */
 (function(env) {
-  function hasFunctioningSets() {
+  env.hasFunctioningSets = function() {
     if (typeof Set === 'undefined') {
       return false;
     }
@@ -40,11 +41,17 @@
     } catch (e) {
       return false;
     }
-  }
+  };
 
   env.requireFunctioningSets = function() {
-    if (!hasFunctioningSets()) {
+    if (!env.hasFunctioningSets()) {
       env.pending('Browser has incomplete or missing support for Sets');
     }
   };
+
+  env.requireWeakSets = function() {
+    if (typeof WeakSet === 'undefined') {
+      env.pending('Browser does not have support for WeakSet');
+    }
+  };
 })(jasmine.getEnv());

spec/helpers/checkForSymbol.js

@@ -1,3 +1,4 @@
+/* eslint-disable compat/compat */
 (function(env) {
   function hasFunctioningSymbols() {
     if (typeof Symbol === 'undefined') {