Bump version to 5.11.0

This feature requires an update to boot1.js, as shown in this commit.
Users with an older boot1.js will get the older inexact filtering.

.circleci/config.yml

@@ -4,13 +4,21 @@
 version: 2.1
 
 executors:
+  node24:
+    docker:
+      - image: cimg/node:24.0.0
+    working_directory: ~/workspace
+  node22:
+    docker:
+      - image: cimg/node:22.0.0
+    working_directory: ~/workspace
   node20:
     docker:
       - image: cimg/node:20.0.0
     working_directory: ~/workspace
   node18:
     docker:
-      - image: cimg/node:18.0.0
+      - image: cimg/node:18.20.5
     working_directory: ~/workspace
 
 jobs:
@@ -57,7 +65,7 @@ jobs:
           at: .
       - run:
           name: Run tests in parallel
-          command: npx grunt execSpecsInParallel
+          command: npm run test:parallel
 
   test_browsers: &test_browsers
     executor: node18
@@ -67,12 +75,14 @@ jobs:
       - run:
           name: Install Sauce Connect
           command: |
-            cd /tmp
-            curl https://saucelabs.com/downloads/sc-4.7.1-linux.tar.gz | tar zxf -
-            chmod +x sc-4.7.1-linux/bin/sc
+            tmpdir=$(mktemp -d)
+            cd "$tmpdir"
+            curl https://saucelabs.com/downloads/sauce-connect/5.2.2/sauce-connect-5.2.2_linux.x86_64.tar.gz | tar zxf -
+            chmod +x sc
             mkdir ~/workspace/bin
-            cp sc-4.7.1-linux/bin/sc ~/workspace/bin
-            ~/workspace/bin/sc --version
+            cp sc ~/workspace/bin
+            echo "Sauce Connect version info:"
+            ~/workspace/bin/sc version
       - run:
           name: Run tests
           command: |
@@ -80,13 +90,13 @@ jobs:
             # cleanly if we kill it from a different step than it started in.
 
             export PATH=$PATH:$HOME/workspace/bin
-            export SAUCE_TUNNEL_IDENTIFIER=$CIRCLE_WORKFLOW_JOB_ID
-            scripts/start-sauce-connect sauce-pidfile
+            export SAUCE_TUNNEL_NAME=$CIRCLE_WORKFLOW_JOB_ID
+            scripts/start-sauce-connect
             set +o errexit
             scripts/run-all-browsers
             exitcode=$?
             set -o errexit
-            scripts/stop-sauce-connect $(cat sauce-pidfile)
+            scripts/stop-sauce-connect
             exit $exitcode
 
 workflows:
@@ -94,12 +104,23 @@ workflows:
 
   push:
     jobs:
+      - build:
+          executor: node24
+          name: build_node_24
+      - build:
+          executor: node22
+          name: build_node_22
       - build:
           executor: node20
           name: build_node_20
       - build:
           executor: node18
           name: build_node_18
+      - test_node:
+          executor: node22
+          name: test_node_22
+          requires:
+            - build_node_22
       - test_node:
           executor: node20
           name: test_node_20
@@ -111,15 +132,25 @@ workflows:
           requires:
             - build_node_18
       - test_parallel:
-          executor: node18
-          name: test_parallel_node_18
+          executor: node24
+          name: test_parallel_node_24
           requires:
-            - build_node_18
+            - build_node_24
+      - test_parallel:
+          executor: node22
+          name: test_parallel_node_22
+          requires:
+            - build_node_22
       - test_parallel:
           executor: node20
           name: test_parallel_node_20
           requires:
             - build_node_20
+      - test_parallel:
+          executor: node18
+          name: test_parallel_node_18
+          requires:
+            - build_node_18
       - test_browsers:
           requires:
              - build_node_18

.editorconfig

@@ -3,6 +3,6 @@ charset = utf-8
 end_of_line = lf
 insert_final_newline = true
 
-[*.{js, json, sh, yml}]
+[*.{js,mjs,json,sh,yml}]
 indent_style = space
 indent_size = 2

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -13,7 +13,7 @@ body:
         Check the [FAQ](https://jasmine.github.io/pages/faq.html) and any other relevant [documentation](https://jasmine.github.io/pages/docs_home.html) to see if your issue has already been addressed.
 
         ## Special troubleshooting steps for asynchronous scenarios
-        If the issue has to do with testing asynchronous code, please read the [async tutorial](https://jasmine.github.io/tutorials/async) and the async section of the FAQ. In particular, check for the following common errors:
+        If the issue has to do with testing asynchronous code, please read the [async tutorial](https://jasmine.github.io/tutorials/async) and the [async section of the FAQ](https://jasmine.github.io/pages/faq.html#async). In particular, check for the following common errors:
 
         * Are you trying to write a synchronous test for asynchronous code?
         * Does the test signal completion before the code under test finishes?
@@ -22,19 +22,22 @@ body:
         ## Try the latest version of Jasmine
         If at all possible, upgrade to the latest versions of `jasmine-core` and any other relevant packages (e.g. `jasmine`, `jasmine-browser-runner`). If you can't do that, please check the [release notes](https://github.com/jasmine/jasmine/tree/main/release_notes) for all newer versions to make sure that the bug hasn't already been fixed.
 
-        ## Put together a [minimal, reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
-        Please help us help you by creating a minimal but complete setup that demonstrates the problem. Remove any code and libraries that aren't absolutely necessary, but make sure it doesn't depend on any code you haven't included. In many cases a simple code snippet is enough. In cases involving external libraries, *especially* Karma or Angular, we're likely to need a runable Git repository or jsbin/stackblitz/etc.
-
-        **If we can't reproduce it, we can't fix it. Bug reports without a minimal, reproducible example are very likely to be closed.**
+        ## Explain how to reproduce the bug
+        
+        **Working steps to reproduce are required for all bug reports.** Please help us help you by creating complete but minimal instructions for reproducing the bug.
+        
+        The steps to reproduce could be:
+        
+        * A code snippet that reproduces the problem when run by itself in a newly generated empty `jasmine` or `jasmine-browser-runner` project, or in the standalone distribution.
+        * A set of steps that reproduce the problem when followed exactly as they're written in an empty directory.
+        * A link to a Git repository or zip/tar file containing a [minimal, reproducible example](https://stackoverflow.com/help/minimal-reproducible-example). This option is required for all bugs that can only be reproduced with third-party libraries, including Angular and Karma.
 
+        Please **test your steps** by starting with an empty directory and following them exactly as they're written. Bug reports with steps to reproduce that are unclear, don't work, or include an unreasonable amount of extraneous code will likely be closed.
+        
   - type: textarea
     id: steps-to-reproduce
     attributes:
       label: Steps to Reproduce
-      placeholder: |
-        Example steps:
-        1. Paste the example code below into `mySpec.js`.
-        2. Run `npx jasmine@<some version> mySpec.js`
     validations:
       required: true
   - type: textarea
@@ -51,14 +54,6 @@ body:
       description: What happened instead?
     validations:
       required: true
-  - type: textarea
-    id: code-sample
-    attributes:
-      label: Example code that reproduces the problem
-      description: Please include either a code snippet that reproduces the problem or a link to a repository or jsbin/stackblitz/etc containing a minimal, reproducible example as described above.
-      render: JavaScript
-    validations:
-      required: true
   - type: textarea
     id: possible-solution
     attributes:
@@ -82,10 +77,11 @@ body:
       placeholder: |
         jasmine-browser-runner 1.2.0
         fancy-reporter 132.4.8
+
   - type: input
     id: browser-or-node-version
     attributes:
-      label: Node.js or browser version
+      label: Node.js and/or browser version
       placeholder: E.g. "node 16.2.0" or "Safari 15"
     validations:
       required: true
@@ -96,3 +92,4 @@ body:
       placeholder: E.g. "Windows 10", "MacOS 12.5", "MCC Interim Linux 0.99.p8"
     validations:
       required: true
+

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +1,8 @@
 blank_issues_enabled: false
 contact_links:
+  - name: Questions, requests for help, etc
+    url: https://github.com/jasmine/jasmine/discussions/new/choose
+    about: Please start a discussion.
   - name: Issues with the `jasmine` CLI
     url: https://github.com/jasmine/jasmine-npm/issues
     about: Please create issues related to the `jasmine` package in its repository.

.github/ISSUE_TEMPLATE/support_request.yml

@@ -1,73 +0,0 @@
-name: Question or Support Request
-description: I need help using Jasmine
-labels: ["question"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Jasmine is supported by volunteers working in their free time. Although we're generally willing to help, we're going to ask you to put in some effort first to help us help you.
-
-        ## Troubleshooting
-        Please take the time to rule out problems with your code or third party libraries before opening an issue. If you're running into an error, try to determine whether the error is coming from Jasmine, another library, or your own code.
-
-        Check the [FAQ](https://jasmine.github.io/pages/faq.html) and any other relevant [documentation](https://jasmine.github.io/pages/docs_home.html) to see if your question has already been answered. Consider searching [Stack Overflow](https://stackoverflow.com/questions/tagged/jasmine) and past issues in this repository for related questions as well.
-
-        ## Special troubleshooting steps for asynchronous scenarios
-        If the issue has to do with testing asynchronous code, please read the [async tutorial](https://jasmine.github.io/tutorials/async) and the async section of the FAQ. In particular, check for the following common errors:
-
-        * Are you trying to write a synchronous test for asynchronous code?
-        * Does the test signal completion before the code under test finishes?
-        * Do expectations run before the code that they're trying to verify?
-
-        ## Consider asking Angular questions in an Angular forum
-
-        Questions like "how do I test this Angular service" are mostly about Angular, not Jasmine. You'll likely get better responses in an Angular forum. Here's a rule of thumb: If you can't demonstrate the problem without Angular, you probably have an Angular question.
-
-        ## Try the latest version of Jasmine
-        If at all possible, upgrade to the latest versions of `jasmine-core` and any other relevant packages (e.g. `jasmine`, `jasmine-browser-runner`).
-
-        ## Put together a [minimal, reproducible example](https://stackoverflow.com/help/minimal-reproducible-example)
-        Please help us help you by creating a minimal but complete setup that demonstrates the problem. Remove any code and libraries that aren't absolutely necessary, but make sure it doesn't depend on any code you haven't included. In many cases a simple code snippet is enough. In cases involving external libraries, *especially* Karma or Angular, we're likely to need a runable Git repository or jsbin/stackblitz/etc.
-
-  - type: textarea
-    id: question
-    attributes:
-      label: Your question
-      description: Clearly describe what you'd like help with.
-    validations:
-      required: true
-  - type: textarea
-    id: code-sample
-    attributes:
-      label: Example code that demonstrates the problem
-      description: Please include either a code snippet that demonstrates the problem or a link to a repository or jsbin/stackblitz/etc containing a minimal, reproducible example as described above.
-      render: JavaScript
-    validations:
-      required: true
-  - type: input
-    id: jasmine-core-version
-    attributes:
-      label: jasmine-core version
-    validations:
-      required: true
-  - type: textarea
-    id: other-versions
-    attributes:
-      label: Versions of other relevant packages
-      placeholder: |
-        jasmine-browser-runner 1.2.0
-        fancy-reporter 132.4.8
-  - type: input
-    id: browser-or-node-version
-    attributes:
-      label: Node.js or browser version
-      placeholder: E.g. "node 16.2.0" or "Safari 15"
-    validations:
-      required: true
-  - type: input
-    id: os
-    attributes:
-      label: Operating System
-      placeholder: E.g. "Windows 10", "MacOS 12.5", "MCC Interim Linux 0.99.p8"
-    validations:
-      required: true

.prettierrc

@@ -0,0 +1,3 @@
+{
+  "singleQuote": true
+}

Gruntfile.js

@@ -1,104 +0,0 @@
-module.exports = function(grunt) {
-  var pkg = require("./package.json");
-  global.jasmineVersion = pkg.version;
-
-  grunt.initConfig({
-    pkg: pkg,
-    concat: require('./grunt/config/concat.js'),
-    sass: require('./grunt/config/sass.js'),
-    compress: require('./grunt/config/compress.js'),
-    cssUrlEmbed: require('./grunt/config/cssUrlEmbed.js')
-  });
-
-  require('load-grunt-tasks')(grunt);
-
-  grunt.loadTasks('grunt/tasks');
-
-  grunt.registerTask('default', ['sass:dist', "cssUrlEmbed"]);
-
-  grunt.registerTask('buildDistribution',
-    'Builds and lints jasmine.js, jasmine-html.js, jasmine.css',
-    [
-      'sass:dist',
-      "cssUrlEmbed",
-      'concat'
-    ]
-  );
-
-  grunt.registerTask("execSpecsInNode",
-    "Run Jasmine core specs in Node.js",
-    function() {
-      verifyNoGlobals(() => require('./lib/jasmine-core.js').noGlobals());
-      const done = this.async(),
-        Jasmine = require('jasmine'),
-        jasmineCore = require('./lib/jasmine-core.js'),
-        jasmine = new Jasmine({jasmineCore: jasmineCore});
-
-      jasmine.loadConfigFile('./spec/support/jasmine.json');
-      jasmine.exitOnCompletion = false;
-      jasmine.execute().then(
-        result => done(result.overallStatus === 'passed'),
-        err => {
-          console.error(err);
-          done(false);
-        }
-      );
-    }
-  );
-
-  grunt.registerTask("execSpecsInParallel",
-    "Run Jasmine core specs in parallel in Node.js",
-    function() {
-      // Need to require this here rather than at the top of the file
-      // so that we don't break verifyNoGlobals above by loading jasmine-core
-      // too early
-      const ParallelRunner = require('jasmine/parallel');
-      let numWorkers = require('os').cpus().length;
-
-      if (process.env['CIRCLECI']) {
-        // On Circle CI, the above gives the number of CPU cores on the host
-        // computer, which is unrelated to the resources actually available
-        // to the container. 2 workers gives peak performance with our current
-        // configuration, but 4 might increase the odds of discovering any
-        // parallel-specific bugs.
-        numWorkers = 4;
-      }
-
-      const done = this.async();
-      const runner = new ParallelRunner({
-        jasmineCore: require('./lib/jasmine-core.js'),
-        numWorkers
-      });
-
-      runner.loadConfigFile('./spec/support/jasmine.json')
-        .then(() => {
-          runner.exitOnCompletion = false;
-          return runner.execute();
-        }).then(
-          jasmineDoneInfo => done(jasmineDoneInfo.overallStatus === 'passed'),
-          err => {
-            console.error(err);
-            done(false);
-          }
-        );
-    }
-  );
-
-  grunt.registerTask("execSpecsInNode:performance",
-    "Run Jasmine performance specs in Node.js",
-    function() {
-      require("shelljs").exec("node_modules/.bin/jasmine JASMINE_CONFIG_PATH=spec/support/jasmine-performance.json");
-    }
-  );
-};
-
-function verifyNoGlobals(fn) {
-  const initialGlobals = Object.keys(global);
-  fn();
-
-  const extras = Object.keys(global).filter(k => !initialGlobals.includes(k));
-
-  if (extras.length !== 0) {
-    throw new Error('Globals were unexpectedly created: ' + extras.join(', '));
-  }
-}

LICENSE

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

README.md

@@ -1,7 +1,4 @@
-<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://circleci.com/gh/jasmine/jasmine.svg?style=shield)](https://circleci.com/gh/jasmine/jasmine)
-[![Open Source Helpers](https://www.codetriage.com/jasmine/jasmine/badges/users.svg)](https://www.codetriage.com/jasmine/jasmine)
+<a name="README"><img src="https://raw.githubusercontent.com/jasmine/jasmine/main/images/jasmine-horizontal.svg" width="400px" alt="Jasmine"></a>
 
 # A JavaScript Testing Framework
 
@@ -30,18 +27,22 @@ for information on writing specs, and [the FAQ](https://jasmine.github.io/pages/
 Jasmine tests itself across popular browsers (Safari, Chrome, Firefox, and
 Microsoft Edge) as well as Node.
 
-| Environment       | Supported versions  |
-|-------------------|---------------------|
-| Node              | 18, 20              |
-| Safari            | 15-16               |
-| Chrome            | Evergreen           |
-| Firefox           | Evergreen, 102      |
-| Edge              | Evergreen           |
+| Environment       | Supported versions               |
+|-------------------|----------------------------------|
+| Node              | 18.20.5+*, 20, 22, 24            |
+| Safari            | 16*, 17*                         |
+| Chrome            | Evergreen                        |
+| Firefox           | Evergreen, 102*, 115*, 128*, 140 |
+| Edge              | Evergreen                        |
 
 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. 
 
+\* Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
 To find out what environments work with a particular Jasmine release, see the [release notes](https://github.com/jasmine/jasmine/tree/main/release_notes).
 
 ## Maintainers
@@ -58,4 +59,6 @@ To find out what environments work with a particular Jasmine release, see the [r
 * [Christian Williams](mailto:antixian666@gmail.com)
 * Sheel Choksi
 
-Copyright (c) 2008-2022 Jasmine Maintainers. This software is licensed under the [MIT License](https://github.com/jasmine/jasmine/blob/main/MIT.LICENSE).
+Copyright (c) 2008-2019 Pivotal Labs<br>
+Copyright (c) 2008-2025 The Jasmine developers<br>
+This software is licensed under the [MIT License](https://github.com/jasmine/jasmine/blob/main/LICENSE).

RELEASE.md

@@ -41,13 +41,13 @@ When ready to release - specs are all green and the stories are done:
 
 ### Build standalone distribution
 
-1. Build the standalone distribution with `grunt buildStandaloneDist`
+1. Build the standalone distribution with `npm run buildStandaloneDist`
 1. This will generate `dist/jasmine-standalone-<version>.zip`, which you will upload later (see "Finally" below).
 
 ### Release the core NPM module
 
-1. `npm adduser` to save your credentials locally
-1. `npm publish .` to publish what's in `package.json`
+1. `npm login` to save your credentials locally
+2. `npm publish .` to publish what's in `package.json`
 
 ### Release the docs
 
@@ -55,11 +55,6 @@ Probably only need to do this when releasing a minor version, and not a patch
 version. See [the README file in the docs repo](https://github.com/jasmine/jasmine.github.io/blob/master/README.md)
 for instructions.
 
-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 `jasmine` NPM package
 
 See <https://github.com/jasmine/jasmine-npm/blob/main/RELEASE.md>.

eslint.config.mjs

@@ -0,0 +1,56 @@
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import js from "@eslint/js";
+import { FlatCompat } from "@eslint/eslintrc";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const compat = new FlatCompat({
+  baseDirectory: __dirname,
+  recommendedConfig: js.configs.recommended,
+  allConfig: js.configs.all
+});
+
+export default defineConfig([{
+  extends: compat.extends("plugin:compat/recommended"),
+
+  languageOptions: {
+    globals: {
+      ...globals.browser,
+      ...globals.node,
+    },
+
+    // 2022 isn't exactly right, but it's the earliest version that allows
+    // private properties.
+    ecmaVersion: 2022,
+    sourceType: "commonjs",
+  },
+
+  rules: {
+    curly: "error",
+
+    quotes: ["error", "single", {
+      avoidEscape: true,
+    }],
+
+    "no-unused-vars": ["error", {
+      args: "none",
+    }],
+
+    "no-implicit-globals": "error",
+    "block-spacing": "error",
+    "func-call-spacing": ["error", "never"],
+    "key-spacing": "error",
+    "no-tabs": "error",
+    "no-trailing-spaces": "error",
+    "no-whitespace-before-property": "error",
+    semi: ["error", "always"],
+    "space-before-blocks": "error",
+    "no-eval": "error",
+    "no-var": "error",
+    "no-debugger": "error",
+    "no-console": "error",
+  },
+}]);

grunt/config/compress.js

@@ -1,57 +0,0 @@
-var standaloneLibDir = "lib/jasmine-" + jasmineVersion;
-
-function root(path) { return "./" + path; }
-function libJasmineCore(path) { return root("lib/jasmine-core/" + path); }
-function dist(path) { return root("dist/" + path); }
-
-module.exports = {
-  standalone: {
-    options: {
-      archive: root("dist/jasmine-standalone-" + global.jasmineVersion + ".zip")
-    },
-
-    files: [
-      { src: [ root("MIT.LICENSE") ] },
-      {
-        src: [ "jasmine_favicon.png"],
-        dest: standaloneLibDir,
-        expand: true,
-        cwd: root("images")
-      },
-      {
-        src: [
-          "jasmine.js",
-          "jasmine-html.js",
-          "jasmine.css"
-        ],
-        dest: standaloneLibDir,
-        expand: true,
-        cwd: libJasmineCore("")
-      },
-      {
-        src: [ "boot0.js", "boot1.js" ],
-        dest: standaloneLibDir,
-        expand: true,
-        cwd: libJasmineCore("")
-      },
-      {
-        src: [ "SpecRunner.html" ],
-        dest: root(""),
-        expand: true,
-        cwd: dist("tmp")
-      },
-      {
-        src: [ "*.js" ],
-        dest: "src",
-        expand: true,
-        cwd: libJasmineCore("example/src/")
-      },
-      {
-        src: [ "*.js" ],
-        dest: "spec",
-        expand: true,
-        cwd: libJasmineCore("example/spec/")
-      }
-    ]
-  }
-};

grunt/config/concat.js

@@ -1,56 +0,0 @@
-var grunt = require('grunt');
-
-function license() {
-  var currentYear = "" + new Date(Date.now()).getFullYear();
-
-  return grunt.template.process(
-      grunt.file.read("grunt/templates/licenseBanner.js.jst"),
-      { data: { currentYear: currentYear}});
-}
-
-module.exports = {
-  'jasmine-html': {
-    src: [
-      'src/html/requireHtml.js',
-      'src/html/HtmlReporter.js',
-      'src/html/HtmlSpecFilter.js',
-      'src/html/ResultsNode.js',
-      'src/html/QueryString.js',
-      'src/html/**/*.js'
-    ],
-    dest: 'lib/jasmine-core/jasmine-html.js'
-  },
-  jasmine: {
-    src: [
-      'src/core/requireCore.js',
-      'src/core/matchers/requireMatchers.js',
-      'src/core/base.js',
-      'src/core/util.js',
-      'src/core/Spec.js',
-      'src/core/Order.js',
-      'src/core/Env.js',
-      'src/core/JsApiReporter.js',
-      'src/core/PrettyPrinter',
-      'src/core/Suite',
-      'src/core/**/*.js',
-      'src/version.js'
-    ],
-    dest: 'lib/jasmine-core/jasmine.js'
-  },
-  boot0: {
-    src: ['src/boot/boot0.js'],
-    dest: 'lib/jasmine-core/boot0.js'
-  },
-  boot1: {
-    src: ['src/boot/boot1.js'],
-    dest: 'lib/jasmine-core/boot1.js'
-  },
-  options: {
-    banner: license(),
-    process: {
-      data: {
-        version: global.jasmineVersion
-      }
-    }
-  }
-};

grunt/config/cssUrlEmbed.js

@@ -1,7 +0,0 @@
-module.exports = {
-  encodeWithBaseDir: {
-    files: {
-      "lib/jasmine-core/jasmine.css": ["lib/jasmine-core/jasmine.css"]
-    }
-  }
-};

grunt/config/sass.js

@@ -1,13 +0,0 @@
-const sass = require('sass');
-
-module.exports = {
-  options: {
-    implementation: sass,
-    sourceComments: false
-  },
-  dist: {
-    files: {
-      "lib/jasmine-core/jasmine.css": "src/html/jasmine.scss"
-    }
-  }
-};

grunt/tasks/build_standalone.js

@@ -1,31 +0,0 @@
-var grunt = require("grunt");
-
-function standaloneTmpDir(path) {  return "dist/tmp/" + path; }
-
-grunt.registerTask("build:compileSpecRunner",
-    "Processes the spec runner template and writes to a tmp file",
-    function() {
-        var runnerHtml = grunt.template.process(
-            grunt.file.read("grunt/templates/SpecRunner.html.jst"),
-            { data: { jasmineVersion: global.jasmineVersion }});
-
-        grunt.file.write(standaloneTmpDir("SpecRunner.html"), runnerHtml);
-    }
-);
-
-grunt.registerTask("build:cleanSpecRunner",
-    "Deletes the tmp spec runner file",
-    function() {
-        grunt.file.delete(standaloneTmpDir(""));
-    }
-);
-
-grunt.registerTask("buildStandaloneDist",
-    "Builds a standalone distribution",
-    [
-      "buildDistribution",
-      "build:compileSpecRunner",
-      "compress:standalone",
-      "build:cleanSpecRunner"
-    ]
-);

lib/jasmine-core/boot0.js

@@ -1,5 +1,6 @@
 /*
-Copyright (c) 2008-2023 Pivotal Labs
+Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2025 The Jasmine developers
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -20,6 +21,7 @@ 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.
 */
+
 /**
  This file starts the process of "booting" Jasmine. It initializes Jasmine,
  makes its globals available, and creates the env. This file should be loaded

lib/jasmine-core/boot1.js

@@ -1,5 +1,6 @@
 /*
-Copyright (c) 2008-2023 Pivotal Labs
+Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2025 The Jasmine developers
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -20,6 +21,7 @@ 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.
 */
+
 /**
  This file finishes 'booting' Jasmine, performing all of the necessary
  initialization before executing the loaded environment and all of a project's
@@ -36,20 +38,12 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 (function() {
   const env = jasmine.getEnv();
 
-  /**
-   * ## Runner Parameters
-   *
-   * More browser specific code - wrap the query string in an object and to allow for getting/setting parameters from the runner user interface.
-   */
-
   const queryString = new jasmine.QueryString({
     getWindowLocation: function() {
       return window.location;
     }
   });
 
-  const filterSpecs = !!queryString.getParam('spec');
-
   const config = {
     stopOnSpecFailure: queryString.getParam('stopOnSpecFailure'),
     stopSpecOnExpectationFailure: queryString.getParam(
@@ -91,7 +85,7 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
       return document.createTextNode.apply(document, arguments);
     },
     timer: new jasmine.Timer(),
-    filterSpecs: filterSpecs
+    queryString
   });
 
   /**
@@ -103,14 +97,9 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
   /**
    * Filter which specs will be run by matching the start of the full name against the `spec` query param.
    */
-  const specFilter = new jasmine.HtmlSpecFilter({
-    filterString: function() {
-      return queryString.getParam('spec');
-    }
-  });
-
+  const specFilter = new jasmine.HtmlExactSpecFilter({ queryString });
   config.specFilter = function(spec) {
-    return specFilter.matches(spec.getFullName());
+    return specFilter.matches(spec);
   };
 
   env.configure(config);

lib/jasmine-core/jasmine-html.js

@@ -1,5 +1,6 @@
 /*
-Copyright (c) 2008-2023 Pivotal Labs
+Copyright (c) 2008-2019 Pivotal Labs
+Copyright (c) 2008-2025 The Jasmine developers
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
@@ -20,6 +21,7 @@ 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.
 */
+
 // eslint-disable-next-line no-var
 var jasmineRequire = window.jasmineRequire || require('./jasmine.js');
 
@@ -28,6 +30,7 @@ jasmineRequire.html = function(j$) {
   j$.HtmlReporter = jasmineRequire.HtmlReporter(j$);
   j$.QueryString = jasmineRequire.QueryString();
   j$.HtmlSpecFilter = jasmineRequire.HtmlSpecFilter();
+  j$.HtmlExactSpecFilter = jasmineRequire.HtmlExactSpecFilter();
 };
 
 jasmineRequire.HtmlReporter = function(j$) {
@@ -37,11 +40,13 @@ jasmineRequire.HtmlReporter = function(j$) {
     this.specsExecuted = 0;
     this.failureCount = 0;
     this.pendingSpecCount = 0;
+    this.suitesById = [];
   }
 
   ResultsStateBuilder.prototype.suiteStarted = function(result) {
     this.currentParent.addChild(result, 'suite');
     this.currentParent = this.currentParent.last();
+    this.suitesById[result.id] = this.currentParent;
   };
 
   ResultsStateBuilder.prototype.suiteDone = function(result) {
@@ -79,6 +84,13 @@ jasmineRequire.HtmlReporter = function(j$) {
     }
   };
 
+  /**
+   * @class HtmlReporter
+   * @classdesc Displays results and allows re-running individual specs and suites.
+   * @implements {Reporter}
+   * @param options Options object. See lib/jasmine-core/boot1.js for details.
+   * @since 1.2.0
+   */
   function HtmlReporter(options) {
     function config() {
       return (options.env && options.env.configuration()) || {};
@@ -87,15 +99,24 @@ jasmineRequire.HtmlReporter = function(j$) {
     const getContainer = options.getContainer;
     const createElement = options.createElement;
     const createTextNode = options.createTextNode;
+    // TODO: in the next major release, replace navigateWithNewParam and
+    // addToExistingQueryString with direct usage of options.queryString
     const navigateWithNewParam = options.navigateWithNewParam || function() {};
     const addToExistingQueryString =
       options.addToExistingQueryString || defaultQueryString;
-    const filterSpecs = options.filterSpecs;
+    const filterSpecs = options.queryString
+      ? !!options.queryString.getParam('spec')
+      : options.filterSpecs; // For compatibility with pre-5.11 boot files
     let htmlReporterMain;
     let symbols;
     const deprecationWarnings = [];
     const failures = [];
 
+    /**
+     * Initializes the reporter. Should be called before {@link Env#execute}.
+     * @function
+     * @name HtmlReporter#initialize
+     */
     this.initialize = function() {
       clearPrior();
       htmlReporterMain = createDom(
@@ -154,8 +175,10 @@ jasmineRequire.HtmlReporter = function(j$) {
       if (noExpectations(result)) {
         const noSpecMsg = "Spec '" + result.fullName + "' has no expectations.";
         if (result.status === 'failed') {
+          // eslint-disable-next-line no-console
           console.error(noSpecMsg);
         } else {
+          // eslint-disable-next-line no-console
           console.warn(noSpecMsg);
         }
       }
@@ -462,7 +485,11 @@ jasmineRequire.HtmlReporter = function(j$) {
             'tr',
             {},
             createDom('td', {}, entry.timestamp.toString()),
-            createDom('td', {}, entry.message)
+            createDom(
+              'td',
+              { className: 'jasmine-debug-log-msg' },
+              entry.message
+            )
           )
         );
       });
@@ -549,6 +576,11 @@ jasmineRequire.HtmlReporter = function(j$) {
                 'a',
                 { href: specHref(resultNode.result) },
                 specDescription
+              ),
+              createDom(
+                'span',
+                { className: 'jasmine-spec-duration' },
+                '(' + resultNode.result.duration + 'ms)'
               )
             )
           );
@@ -703,21 +735,6 @@ jasmineRequire.HtmlReporter = function(j$) {
       return wrapper;
     }
 
-    function suiteHref(suite) {
-      const els = [];
-
-      while (suite && suite.parent) {
-        els.unshift(suite.result.description);
-        suite = suite.parent;
-      }
-
-      // include window.location.pathname to fix issue with karma-jasmine-html-reporter in angular: see https://github.com/jasmine/jasmine/issues/1906
-      return (
-        (window.location.pathname || '') +
-        addToExistingQueryString('spec', els.join(' '))
-      );
-    }
-
     function addDeprecationWarnings(result, runnableType) {
       if (result && result.deprecationWarnings) {
         for (let i = 0; i < result.deprecationWarnings.length; i++) {
@@ -815,11 +832,33 @@ jasmineRequire.HtmlReporter = function(j$) {
       return '' + count + ' ' + word;
     }
 
+    function suitePath(suite) {
+      const els = [];
+
+      while (suite && suite.parent) {
+        els.unshift(suite.result.description);
+        suite = suite.parent;
+      }
+
+      return els;
+    }
+
+    function suiteHref(suite) {
+      return pathHref(suitePath(suite));
+    }
+
     function specHref(result) {
+      const suite = stateBuilder.suitesById[result.parentSuiteId];
+      const path = suitePath(suite);
+      path.push(result.description);
+      return pathHref(path);
+    }
+
+    function pathHref(path) {
       // include window.location.pathname to fix issue with karma-jasmine-html-reporter in angular: see https://github.com/jasmine/jasmine/issues/1906
       return (
         (window.location.pathname || '') +
-        addToExistingQueryString('spec', result.fullName)
+        addToExistingQueryString('spec', JSON.stringify(path))
       );
     }
 
@@ -868,13 +907,36 @@ jasmineRequire.HtmlReporter = function(j$) {
 };
 
 jasmineRequire.HtmlSpecFilter = function() {
+  /**
+   * @name HtmlSpecFilter
+   * @classdesc Legacy HTML spec filter, for backward compatibility
+   * with boot files that predate {@link HtmlExactSpecFilter}.
+   * @param options Object with a filterString method
+   * @constructor
+   * @deprecated
+   * @since 1.2.0
+   */
+  // Legacy HTML spec filter, preserved for backward compatibility with
+  // boot files that predate HtmlExactSpecFilterV2
   function HtmlSpecFilter(options) {
-    const filterString =
-      options &&
-      options.filterString() &&
-      options.filterString().replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+    let filterString = (options && options.filterString()) || '';
+
+    if (filterString.startsWith('[')) {
+      // Convert an HtmlExactSpecFilterV2 string into something we can use
+      filterString = JSON.parse(filterString).join(' ');
+    }
+
+    filterString = filterString.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+
     const filterPattern = new RegExp(filterString);
 
+    /**
+     * Determines whether the spec with the specified name should be executed.
+     * @name HtmlSpecFilter#matches
+     * @function
+     * @param {string} specName The full name of the spec
+     * @returns {boolean}
+     */
     this.matches = function(specName) {
       return filterPattern.test(specName);
     };
@@ -908,38 +970,57 @@ jasmineRequire.ResultsNode = function() {
 };
 
 jasmineRequire.QueryString = function() {
-  function QueryString(options) {
-    this.navigateWithNewParam = function(key, value) {
-      options.getWindowLocation().search = this.fullStringWithNewParam(
+  /**
+   * Reads and manipulates the query string.
+   * @since 2.0.0
+   */
+  class QueryString {
+    #getWindowLocation;
+
+    /**
+     * @param options Object with a getWindowLocation property, which should be
+     * a function returning the current value of window.location.
+     */
+    constructor(options) {
+      this.#getWindowLocation = options.getWindowLocation;
+    }
+
+    /**
+     * Sets the specified query parameter and navigates to the resulting URL.
+     * @param {string} key
+     * @param {string} value
+     */
+    navigateWithNewParam(key, value) {
+      this.#getWindowLocation().search = this.fullStringWithNewParam(
         key,
         value
       );
-    };
-
-    this.fullStringWithNewParam = function(key, value) {
-      const paramMap = queryStringToParamMap();
-      paramMap[key] = value;
-      return toQueryString(paramMap);
-    };
-
-    this.getParam = function(key) {
-      return queryStringToParamMap()[key];
-    };
-
-    return this;
-
-    function toQueryString(paramMap) {
-      const qStrPairs = [];
-      for (const prop in paramMap) {
-        qStrPairs.push(
-          encodeURIComponent(prop) + '=' + encodeURIComponent(paramMap[prop])
-        );
-      }
-      return '?' + qStrPairs.join('&');
     }
 
-    function queryStringToParamMap() {
-      const paramStr = options.getWindowLocation().search.substring(1);
+    /**
+     * Returns a new URL based on the current location, with the specified
+     * query parameter set.
+     * @param {string} key
+     * @param {string} value
+     * @return {string}
+     */
+    fullStringWithNewParam(key, value) {
+      const paramMap = this.#queryStringToParamMap();
+      paramMap[key] = value;
+      return toQueryString(paramMap);
+    }
+
+    /**
+     * Gets the value of the specified query parameter.
+     * @param {string} key
+     * @return {string}
+     */
+    getParam(key) {
+      return this.#queryStringToParamMap()[key];
+    }
+
+    #queryStringToParamMap() {
+      const paramStr = this.#getWindowLocation().search.substring(1);
       let params = [];
       const paramMap = {};
 
@@ -959,5 +1040,68 @@ jasmineRequire.QueryString = function() {
     }
   }
 
+  function toQueryString(paramMap) {
+    const qStrPairs = [];
+    for (const prop in paramMap) {
+      qStrPairs.push(
+        encodeURIComponent(prop) + '=' + encodeURIComponent(paramMap[prop])
+      );
+    }
+    return '?' + qStrPairs.join('&');
+  }
+
   return QueryString;
 };
+
+jasmineRequire.HtmlExactSpecFilter = function() {
+  /**
+   * Spec filter for use with {@link HtmlReporter}
+   *
+   * See lib/jasmine-core/boot1.js for usage.
+   * @since 5.11.0
+   */
+  class HtmlExactSpecFilter {
+    #getFilterString;
+
+    /**
+     * Create a filter instance.
+     * @param options Object with a queryString property, which should be an
+     * instance of {@link QueryString}.
+     */
+    constructor(options) {
+      this.#getFilterString = function() {
+        return options.queryString.getParam('spec');
+      };
+    }
+
+    /**
+     * Determines whether the specified spec should be executed.
+     * @param {Spec} spec
+     * @returns {boolean}
+     */
+    matches(spec) {
+      const filterString = this.#getFilterString();
+
+      if (!filterString) {
+        return true;
+      }
+
+      const filterPath = JSON.parse(this.#getFilterString());
+      const specPath = spec.getPath();
+
+      if (filterPath.length > specPath.length) {
+        return false;
+      }
+
+      for (let i = 0; i < filterPath.length; i++) {
+        if (specPath[i] !== filterPath[i]) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+  }
+
+  return HtmlExactSpecFilter;
+};

lib/jasmine-core/jasmine.css

@@ -229,6 +229,9 @@ body {
 .jasmine_html-reporter .jasmine-specs li.jasmine-excluded a:before {
   content: "• ";
 }
+.jasmine_html-reporter .jasmine-specs li .jasmine-spec-duration {
+  margin-left: 1em;
+}
 .jasmine_html-reporter .jasmine-description + .jasmine-suite {
   margin-top: 0;
 }
@@ -295,4 +298,7 @@ body {
 }
 .jasmine_html-reporter .jasmine-debug-log table, .jasmine_html-reporter .jasmine-debug-log th, .jasmine_html-reporter .jasmine-debug-log td {
   border: 1px solid #ddd;
+}
+.jasmine_html-reporter .jasmine-debug-log .jasmine-debug-log-msg {
+  white-space: pre;
 }

package.json

@@ -1,7 +1,7 @@
 {
   "name": "jasmine-core",
   "license": "MIT",
-  "version": "5.1.1",
+  "version": "5.11.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/jasmine/jasmine.git"
@@ -15,9 +15,11 @@
   ],
   "scripts": {
     "posttest": "eslint \"src/**/*.js\" \"spec/**/*.js\" && prettier --check \"src/**/*.js\" \"spec/**/*.js\"",
-    "test": "grunt --stack execSpecsInNode",
+    "test": "node scripts/runSpecsInNode.js",
+    "test:parallel": "node scripts/runSpecsInParallel.js",
     "cleanup": "prettier --write \"src/**/*.js\" \"spec/**/*.js\"",
-    "build": "grunt buildDistribution",
+    "build": "node scripts/buildDistribution.js",
+    "buildStandaloneDist": "node scripts/buildStandaloneDist.js",
     "serve": "node spec/support/localJasmineBrowser.js",
     "serve:performance": "node spec/support/localJasmineBrowser.js jasmine-browser-performance.json",
     "ci": "node spec/support/ci.js",
@@ -27,82 +29,30 @@
   "homepage": "https://jasmine.github.io",
   "main": "./lib/jasmine-core.js",
   "files": [
-    "MIT.LICENSE",
+    "LICENSE",
     "README.md",
     "images/*.{png,svg}",
     "lib/**/*.{js,css}",
     "package.json"
   ],
   "devDependencies": {
-    "eslint": "^8.36.0",
-    "eslint-plugin-compat": "^4.0.0",
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.24.0",
+    "archiver": "^7.0.1",
+    "css-url-embed": "^0.1.0",
+    "ejs": "^3.1.10",
+    "eslint": "^9.24.0",
+    "eslint-plugin-compat": "^6.0.2",
     "glob": "^10.2.3",
-    "grunt": "^1.0.4",
-    "grunt-cli": "^1.3.2",
-    "grunt-contrib-compress": "^2.0.0",
-    "grunt-contrib-concat": "^2.0.0",
-    "grunt-css-url-embed": "^1.11.1",
-    "grunt-sass": "^3.0.2",
+    "globals": "^16.0.0",
     "jasmine": "^5.0.0",
     "jasmine-browser-runner": "github:jasmine/jasmine-browser-runner",
-    "jsdom": "^22.0.0",
-    "load-grunt-tasks": "^5.1.0",
+    "jsdom": "^26.0.0",
     "prettier": "1.17.1",
-    "sass": "^1.58.3",
-    "shelljs": "^0.8.3",
-    "temp": "^0.9.0"
-  },
-  "prettier": {
-    "singleQuote": true
-  },
-  "eslintConfig": {
-    "extends": [
-      "plugin:compat/recommended"
-    ],
-    "env": {
-      "browser": true,
-      "node": true,
-      "es2017": true
-    },
-    "parserOptions": {
-      "ecmaVersion": 2018
-    },
-    "rules": {
-      "quotes": [
-        "error",
-        "single",
-        {
-          "avoidEscape": true
-        }
-      ],
-      "no-unused-vars": [
-        "error",
-        {
-          "args": "none"
-        }
-      ],
-      "no-implicit-globals": "error",
-      "block-spacing": "error",
-      "func-call-spacing": [
-        "error",
-        "never"
-      ],
-      "key-spacing": "error",
-      "no-tabs": "error",
-      "no-trailing-spaces": "error",
-      "no-whitespace-before-property": "error",
-      "semi": [
-        "error",
-        "always"
-      ],
-      "space-before-blocks": "error",
-      "no-eval": "error",
-      "no-var": "error",
-      "no-debugger": "error"
-    }
+    "sass": "^1.58.3"
   },
   "browserslist": [
-    "Safari >= 15",
+    "Safari >= 16",
     "Firefox >= 102",
     "last 2 Chrome versions",
     "last 2 Edge versions"

release_notes/4.6.1.md

@@ -0,0 +1,51 @@
+# Jasmine Core 4.6.1 Release Notes
+
+## Summary
+
+This is a one-time backport of bug fixes from 5.x, for the benefit of Karma
+users who may not be aware that they're still using 4.x.
+
+No further 4.x releases are planned. If possible, you should upgrade to the
+latest 5.x instead of 4.6.1. If you're using Karma, you can do this by 
+installing jasmine-core 5.x and adding an override to package.json:
+
+```
+{
+    // ...
+    "overrides": {
+        "karma-jasmine": {
+            "jasmine-core": "^5.0.0"
+        }
+    }
+}
+```
+
+## Bug Fixes
+
+* Removed unnecessary throw when building stack trace
+
+* Fixed error when formatting Error object with non-Error cause property
+
+  Merges [#2013](https://github.com/jasmine/jasmine/pull/2013) from @angrycat9000.
+
+  Fixes [#2011](https://github.com/jasmine/jasmine/issues/2011).
+
+* Accessibility: Always provide a non-color indication that a spec is pending
+
+* Accessibility: Improved contrast of version number and inactive tab links
+
+## Supported environments
+
+jasmine-core 4.6.1 has been tested in the following environments.
+
+| Environment       | Supported versions |
+|-------------------|--------------------|
+| Node              | 12.17+, 14, 16, 18 |
+| Safari            | 14-16              |
+| Chrome            | 125                |
+| Firefox           | 91, 102, 126       |
+| Edge              | 124                |
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.1.2.md

@@ -0,0 +1,27 @@
+# Jasmine Core 5.1.2 Release Notes
+
+## Bug Fixes
+
+* Fixed `throwUnlessAsync`
+  * Fixes [#2026](https://github.com/jasmine/jasmine/issues/2026)
+
+# Documentation improvements 
+
+* Added Safari 17 to supported browsers
+* Added Firefox 115 (current ESR) to supported browsers
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions |
+|-------------------|--------------------|
+| Node              | 18, 20             |
+| Safari            | 15-17              |
+| Chrome            | 121                |
+| Firefox           | 102, 115, 122      |
+| Edge              | 121                |
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.10.0.md

@@ -0,0 +1,54 @@
+# Jasmine Core 5.10.0 Release Notes
+
+## New Features
+
+* Optionally detect promise rejections that are handled after an initial
+  unhandled promise rejection event and don't report them as errors.
+  This is off by default because it comes with a performance cost. It can be
+  enabled by setting the `detectLateRejectionHandling` config property to true.
+* Add `getSpecProperty` to retrieve data that was set with `setSpecProperty`.
+    * Merges [#2072](https://github.com/jasmine/jasmine/pull/2072) from @bonkevin
+* Show spec duration in the HTML reporter.
+    * Merges [#2073](https://github.com/jasmine/jasmine/pull/2073) from @bonkevin
+* Protect `GlobalErrors` against monkey patching.
+  
+  All currently shipped versions of zone.js contain a monkey patch that fails
+  to pass constructor arguments on to `GlobalErrors`. This patch normally has
+  no effect because zone.js is normally installed after `GlobalErrors` is
+  instantiated, but it would crash Jasmine if it was applied early enough.
+
+## Deprecations
+
+* Issue a deprecation warning if the suite/spec order passed as a parameter to
+  `Env#execute` causes a suite to be re-entered.
+
+## Changes to supported environments
+
+* Added Firefox 140 (current ESR) to supported environments
+* Demoted Firefox 128 (previous ESR) to best-effort support
+
+## Internal improvements
+
+* Core suite/spec execution flow has been significantly simplified.
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions             |
+|-------------------|--------------------------------|
+| Node              | 18.20.5**, 20, 22, 24          |
+| Safari            | 15**, 16**, 17**               |
+| Chrome            | 139*                           |
+| Firefox           | 102**, 115**, 128**, 140, 142* |
+| Edge              | 139*                           |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.11.0.md

@@ -0,0 +1,66 @@
+# Jasmine Core 5.11.0 Release Notes
+
+## New features
+
+* `detectLateRejectionHandling` works in `beforeAll` and `afterAll` as well as 
+  in specs.
+* Clicking a link in the HTML reporter does exact filtering rather than a 
+  substring match.
+
+  If you use jasmine-browser-runner or load boot1.js directly from jasmine-core,
+  you'll get the new filtering behavior automatically. Otherwise, it requires 
+  several changes to boot1.js:
+  
+  1. Add `queryString` to the options object passed to `HtmlReporter`, and 
+     remove `filterSpecs`.
+  2. Instantiate a `jasmine.HtmlExactSpecFilter` instead of a
+     `jasmine.HtmlSpecFilter`.
+  2. Change the body of `config.specFilter` from
+     `return specFilter.matches(spec.getFullName());` to
+     `return specFilter.matches(spec)`
+
+  For a working example, see lib/jasmine-core/boot1.js in this package.
+  Old boot1.js files will still work, but you'll get the old filtering behavior.
+
+## Bug fixes
+
+* Fixed global error handling when the env is executed repeatedly
+
+## Changes to supported environments
+
+* Safari 15 is no longer supported.
+
+## Documentation improvements
+
+* Added API reference docs for classes used in browser boot files
+* Documented the order properties of `jasmineStarted` and `jasmineDone` events
+
+## Internal improvements
+
+* Unified top suite and regular suite execution
+* Converted `Spec`, `Suite`, and `QueryString` to ES6 classes
+* Extracted configuration out of `Env`
+* Updated tests to characterize suite/spec reporting more completely
+* Adopted `forbidDuplicateNames: true` in jasmine-core's own tests
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions             |
+|-------------------|--------------------------------|
+| Node              | 18.20.5**, 20, 22, 24          |
+| Safari            | 16**, 17**                     |
+| Chrome            | 140*                           |
+| Firefox           | 102**, 115**, 128**, 140, 143* |
+| Edge              | 140*                           |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.2.0.md

@@ -0,0 +1,35 @@
+# Jasmine Core 5.2.0 Release Notes
+
+## Bug Fixes
+
+* Fixed stack trace filtering in FF when the developer tools are open
+* Fixed handling of browser `error` events with message but no error
+
+## New Features
+
+* Improved the error message of the toHaveSize matcher.
+  * Merges [#2033](https://github.com/jasmine/jasmine/pull/2033) from @stephanreiter
+* HTML reporter: show debug logs with white-space: pre
+
+## Documentation improvements
+
+* Improved discoverability of asymmetric equality testers
+* Added an example for withContext()
+* Clarified spyOnGlobalErrorsAsync API docs
+* Added Node 22 to supported environments
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions |
+|-------------------|--------------------|
+| Node              | 18, 20, 22         |
+| Safari            | 15-17              |
+| Chrome            | 126                |
+| Firefox           | 102, 115, 128      |
+| Edge              | 126                |
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.3.0.md

@@ -0,0 +1,35 @@
+# Jasmine Core 5.3.0 Release Notes
+
+## Changes
+
+* Improved performance in Safari
+  * Merges [#2040](https://github.com/jasmine/jasmine/pull/2040) from @dcsaszar
+  * Fixes [#2008](https://github.com/jasmine/jasmine/issues/2008)
+
+* Improved performance in Playwright Webkit on Windows
+  * Merges [#2034](https://github.com/jasmine/jasmine/pull/2034) from @m-akinc
+
+* Throw if spying has no effect, as when spying on localStorage methods in Firefox and Safari 17
+    * See [#2036](https://github.com/jasmine/jasmine/issues/2036) and [#2007](https://github.com/jasmine/jasmine/issues/2007)
+
+
+## Documentation improvements
+
+* Added API reference for reporter capabilities
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions |
+|-------------------|--------------------|
+| Node              | 18, 20, 22         |
+| Safari            | 15-17              |
+| Chrome            | 128                |
+| Firefox           | 102, 115, 130      |
+| Edge              | 128                |
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.4.0.md

@@ -0,0 +1,39 @@
+# Jasmine Core 5.4.0 Release Notes
+
+## Changes
+
+* Fixed de-duplication of exception messages containing blank lines on Node and Chrome
+
+  This is particularly helpful when reporting testing-library errors, which
+  have messages that contain blank lines and can be hundreds or even thousands
+  of lines long.
+
+* Document that the expected and actual properties of expectation results are deprecated
+
+  The values of these properties are not reliable in configurations where 
+  reporter messages are JSON serialized. They appear to have been seldom if ever 
+  used. They will be removed in the next major release. 
+
+* Added Firefox 128 (current ESR) to supported browsers
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18, 20, 22              |
+| Safari            | 15-17                   |
+| Chrome            | 129*                    |
+| Firefox           | 102**, 115**, 128, 131* |
+| Edge              | 129*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Environments that are past end of life are supported on a best-effort basis.
+They may be dropped in a future minor release of Jasmine if continued support
+becomes impractical.
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.5.0.md

@@ -0,0 +1,34 @@
+# Jasmine Core 5.5.0 Release Notes
+
+## Changes
+
+* Optionally enforce uniqueness of spec and suite names
+
+  This is off by default for backwards compatibility but can be enabled
+  by setting the `forbidDuplicateNames` env config property to true.
+  Fixes [#1633](https://github.com/jasmine/jasmine/issues/1633).
+
+* Include property value mismatches in diffs even when there are missing or 
+  extra properties
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18, 20, 22              |
+| Safari            | 15-17                   |
+| Chrome            | 131*                    |
+| Firefox           | 102**, 115**, 128, 132* |
+| Edge              | 131*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Environments that are past end of life are supported on a best-effort basis.
+They may be dropped in a future minor release of Jasmine if continued support
+becomes impractical.
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.6.0.md

@@ -0,0 +1,51 @@
+# Jasmine Core 5.6.0 Release Notes
+
+## Changes
+
+* Added [toHaveNoOtherSpyInteractions](https://jasmine.github.io/api/5.6/matchers.html#toHaveNoOtherSpyInteractions) matcher
+  * Merges [#2051](https://github.com/jasmine/jasmine/pull/2051) from @Eradev
+  * Fixes [#1991](https://github.com/jasmine/jasmine/issues/1991)
+
+* Added [toBeNullish](https://jasmine.github.io/api/5.6/matchers.html#toBeNullish) matcher
+  * Merges [#2045](https://github.com/jasmine/jasmine/pull/2045) from @MattMcCherry
+
+* Improved error messages when non-promises are passed to built-in async matchers
+  * Merges [#2049](https://github.com/jasmine/jasmine/pull/2049) from @andiz2
+  * Fixes [#2037](https://github.com/jasmine/jasmine/issues/2037)
+
+* Added [toHaveClasses](https://jasmine.github.io/api/5.6/matchers.html#toHaveClasses) matcher
+  * Merges [#2046](https://github.com/jasmine/jasmine/pull/2046) from @aYorky 
+
+## Documentation updates
+
+* Demoted Safari to best-effort support
+  
+  Due to limited availability of Safari versions for contributors and maintainers
+  as well as in CI, Safari will be supported on the same best-effort basis as
+  environments that are past end of life, such as previous Firefox ESR versions. 
+  See [this discussion](https://github.com/jasmine/jasmine/discussions/2050) for
+  more information about why this change was made and what to expect.
+
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18, 20, 22              |
+| Safari            | 15**, 16**, 17**        |
+| Chrome            | 133*                    |
+| Firefox           | 102**, 115**, 128, 135* |
+| Edge              | 132*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.7.0.md

@@ -0,0 +1,62 @@
+# Jasmine Core 5.7.0 Release Notes
+
+## New features
+
+* Added [Clock#autoTick](https://jasmine.github.io/api/5.7/Clock.html#autoTick)
+  to automatically tick the clock asynchronously
+  * Merges #2042 from @atscott and @stephenfarrar
+  * Fixes #1725
+
+* Expose [spec path](https://jasmine.github.io/api/5.7/Spec.html#getPath) as an
+  array of names in addition to the existing concatenated name
+
+  This is meant to support tools like IDE integrations that need to filter a run
+  to an exact set of suites/specs.
+
+
+## Documentation improvements
+
+* Documented that [SpecResult#filename](https://jasmine.github.io/api/5.7/global.html#SpecResult)
+  and [SuiteResult#filename](https://jasmine.github.io/api/5.7/global.html#SuiteResult)
+  are wrong when zone.js is present and in some cases where it/describe/etc are
+  replaced
+* Updated docs for expected and actual properties of 
+[expectation results](https://jasmine.github.io/api/5.7/global.html#ExpectationResult)
+
+
+## Internal improvements
+
+* Rewrote the build system to not use Grunt
+
+  Although Grunt has served Jasmine well over the years, it was keeping us tied
+  to an aging and increasingly questionable set of dev dependencies.
+
+* Updated to eslint 9
+* Removed mostly-unmaintained dev dependency 'temp'
+* Updated most other dev dependencies to latest versions
+* Fixed sass deprecation warning
+* Updated to Sauce Connect 5
+* Made stop-sauce-connect script more robust
+
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18**, 20, 22            |
+| Safari            | 15**, 16**, 17**        |
+| Chrome            | 135*                    |
+| Firefox           | 102**, 115**, 128, 137* |
+| Edge              | 135*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.7.1.md

@@ -0,0 +1,28 @@
+# Jasmine Core 5.7.1 Release Notes
+
+## Bug fixes
+
+* Ensure that uninstalling the clock also stops auto tick
+    * Merges #2057 from @atscott
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18**, 20, 22            |
+| Safari            | 15**, 16**, 17**        |
+| Chrome            | 136*                    |
+| Firefox           | 102**, 115**, 128, 138* |
+| Edge              | 135*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.8.0.md

@@ -0,0 +1,44 @@
+# Jasmine Core 5.8.0 Release Notes
+
+## New Features
+
+* Allow passing a function to `saveArgumentsByValue` to customize how arguments
+  are saved
+  * Merges [#2062](https://github.com/jasmine/jasmine/pull/2062) from @evanwaslh
+  * Fixes [#1886](https://github.com/jasmine/jasmine/issues/1886)
+* Use custom object formatters in spy strategy mismatch errors
+* Include function names in pretty printer output
+* Improve performance of autoTick in Node
+  * Merges [#2058](https://github.com/jasmine/jasmine/pull/2058) from @atscott
+
+## Bug Fixes
+
+* Fix diff building when only one side has a custom object formatter
+    * Fixes [#2061](https://github.com/jasmine/jasmine/issues/2061)
+
+## Documentation improvements
+
+* Added Node 24 to supported environments
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18**, 20, 22, 24        |
+| Safari            | 15**, 16**, 17**        |
+| Chrome            | 137*                    |
+| Firefox           | 102**, 115**, 128, 139* |
+| Edge              | 137*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

release_notes/5.9.0.md

@@ -0,0 +1,56 @@
+# Jasmine Core 5.9.0 Release Notes
+
+## Bug fixes
+
+* Avoid generating mock clock timer IDs that conflict with native ones 
+  * Fixes [#2068](https://github.com/jasmine/jasmine/issues/2068)
+  * Merges [#2069](https://github.com/jasmine/jasmine/pull/2069) from @atscott
+
+## Deprecations and changes to platform support
+
+* Node versions before 18.20.5 are no longer supported
+
+  Older 18.x versions might still work, but Jasmine is no longer tested in them
+  prior to release.
+* Document that the filename properties of suite and spec results are deprecated
+
+  These properties are incorrect in many configurations. They'll be removed in 
+  the next major release unless there is enough user interest in fixing them. 
+  See <https://github.com/jasmine/jasmine/issues/2065>.
+
+## Internal improvements
+
+* Extensive GlobalErrors refactoring
+  * Removed many of the error dispatching differences between browsers and Node
+  * Split into portable and platform-specific parts
+  * Converted to ES6 classes
+* Removed unnecessary errorWithStack helper
+
+  Jasmine no longer runs on platforms that create errors without stack traces.
+* Removed protections against user code redefining undefined
+
+  Jasmine no longer runs on platforms that allow redefining undefined.
+* Removed rimraf and shelljs dev dependencies
+
+## Supported environments
+
+This version has been tested in the following environments.
+
+| Environment       | Supported versions      |
+|-------------------|-------------------------|
+| Node              | 18.20.5**, 20, 22, 24   |
+| Safari            | 15**, 16**, 17**        |
+| Chrome            | 138*                    |
+| Firefox           | 102**, 115**, 128, 140* |
+| Edge              | 138*                    |
+
+\* Evergreen browser. Each version of Jasmine is tested against the latest
+version available at release time.<br>
+\** Supported on a best-effort basis. Support for these versions may be dropped
+if it becomes impractical, and bugs affecting only these versions may not be
+treated as release blockers.
+
+
+------
+
+_Release Notes generated with _[Anchorman](http://github.com/infews/anchorman)_

scripts/buildDistribution.js

@@ -0,0 +1,3 @@
+const buildDistribution = require('./lib/buildDistribution');
+
+buildDistribution();

scripts/buildStandaloneDist.js

@@ -0,0 +1,86 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const glob = require('glob');
+const ejs = require('ejs');
+const archiver = require('archiver');
+const buildDistribution = require('./lib/buildDistribution');
+
+const prefix = path.join(os.tmpdir(), 'jasmine-build-standalone');
+const tmpDir = fs.mkdtempSync(prefix);
+
+buildStandaloneDist().finally(function() {
+  fs.rmSync(tmpDir, { recursive: true });
+});
+
+async function buildStandaloneDist() {
+  buildDistribution();
+  const pkg = JSON.parse(fs.readFileSync('package.json'));
+  compileSpecRunner(pkg.version);
+  await zipStandaloneDist(pkg.version);
+}
+
+function compileSpecRunner(jasmineVersion) {
+  const template = fs.readFileSync('src/SpecRunner.html.ejs',
+    {encoding: 'utf8'});
+  const runnerHtml = ejs.render(template, { jasmineVersion });
+  fs.writeFileSync(path.join(tmpDir, 'SpecRunner.html'), runnerHtml,
+    {encoding: 'utf8'});
+}
+
+async function zipStandaloneDist(jasmineVersion) {
+  const fileGroups = [
+    {
+      src: [
+        'LICENSE',
+        path.join(tmpDir, 'SpecRunner.html'),
+      ]
+    },
+    {
+      src: [
+        'images/jasmine_favicon.png',
+        'lib/jasmine-core/jasmine.js',
+        'lib/jasmine-core/jasmine-html.js',
+        'lib/jasmine-core/jasmine.css',
+        'lib/jasmine-core/boot0.js',
+        'lib/jasmine-core/boot1.js',
+      ],
+      destDir: 'lib/jasmine-' + jasmineVersion
+    },
+    {
+      src: glob.sync('lib/jasmine-core/example/src/*.js'),
+      destDir: 'src'
+    },
+    {
+      src: glob.sync('lib/jasmine-core/example/spec/*.js'),
+      destDir: 'spec'
+    }
+  ];
+
+  const destPath = `./dist/jasmine-standalone-${jasmineVersion}.zip`;
+  const output = fs.createWriteStream(destPath);
+  const archive = archiver('zip');
+
+  const done = new Promise(function(resolve, reject) {
+    output.on('close', resolve);
+    archive.on('warning', reject);
+    archive.on('error', reject);
+  });
+
+  archive.pipe(output);
+
+  for (const group of fileGroups) {
+    for (const srcPath of group.src) {
+      let destPath = path.basename(srcPath);
+
+      if (group.destDir) {
+        destPath = `${group.destDir}/${destPath}`;
+      }
+
+      archive.file(srcPath, {name: destPath});
+    }
+  }
+
+  archive.finalize();
+  await done;
+}

scripts/lib/buildDistribution.js

@@ -0,0 +1,129 @@
+const fs = require('fs');
+const sass = require('sass');
+const glob = require('glob');
+const ejs = require('ejs');
+const cssUrlEmbed = require('css-url-embed');
+
+function buildDistribution() {
+  compileSass();
+  embedCssAssets();
+  concatFiles();
+}
+
+function embedCssAssets() {
+  const cssPath = 'lib/jasmine-core/jasmine.css';
+  cssUrlEmbed.processFile(cssPath, cssPath, function(filePath) {
+    if (filePath.endsWith('.png')) {
+      return 'image/png';
+    } else if (filePath.endsWith('.svg')) {
+      return 'image/svg+xml';
+    } else {
+      throw new Error(`Don't know MIME type for file: ${filePath}`);
+    }
+  });
+}
+
+function compileSass() {
+  const output = sass.compile('src/html/jasmine.scss');
+  fs.writeFileSync('lib/jasmine-core/jasmine.css', output.css,
+    {encoding: 'utf8'});
+}
+
+function concatFiles() {
+  const pkg = JSON.parse(fs.readFileSync('package.json'));
+  const configs = [
+    {
+      src: [
+        'src/html/requireHtml.js',
+        'src/html/HtmlReporter.js',
+        'src/html/HtmlSpecFilter.js',
+        'src/html/ResultsNode.js',
+        'src/html/QueryString.js',
+        'src/html/**/*.js'
+      ],
+      dest: 'lib/jasmine-core/jasmine-html.js',
+    },
+    {
+      dest: 'lib/jasmine-core/jasmine.js',
+      src: [
+        'src/core/requireCore.js',
+        'src/core/matchers/requireMatchers.js',
+        'src/core/base.js',
+        'src/core/util.js',
+        'src/core/Spec.js',
+        'src/core/Order.js',
+        'src/core/Env.js',
+        'src/core/JsApiReporter.js',
+        'src/core/PrettyPrinter',
+        'src/core/Suite',
+        'src/core/**/*.js',
+        {
+          template: 'src/version.js',
+          data: {version: pkg.version}
+        },
+      ],
+    },
+    {
+      dest: 'lib/jasmine-core/boot0.js',
+      src: ['src/boot/boot0.js'],
+    },
+    {
+      dest: 'lib/jasmine-core/boot1.js',
+      src: ['src/boot/boot1.js'],
+    }
+  ];
+  const licenseBanner = {
+    template: 'src/licenseBanner.js.ejs',
+    data: {currentYear: new Date(Date.now()).getFullYear()}
+  };
+
+  for (const {src, dest} of configs) {
+    src.unshift(licenseBanner);
+
+    function expand(srcListEntry) {
+      if (typeof srcListEntry === 'object') {
+        return srcListEntry;
+      }
+
+      return glob.sync(srcListEntry)
+        .sort(function (a, b) {
+          // Match the sort order of previous build tools, so that the
+          // output is the same.
+          a = a.toLowerCase();
+          b = b.toLowerCase();
+
+          if (a < b) {
+            return -1;
+          } else if (a === b) {
+            return 0;
+          } else {
+            return 1;
+          }
+        });
+    }
+
+    const srcs = src.flatMap(expand);
+    const seen = new Set();
+    const chunks = [];
+
+    for (const s of srcs) {
+      let content;
+
+      if (!seen.has(s)) {
+        if (s.template) {
+          const template = fs.readFileSync(s.template, {encoding: 'utf8'});
+          content = ejs.render(template, s.data);
+        } else {
+          content = fs.readFileSync(s, {encoding: 'utf8'});
+        }
+
+        chunks.push(content);
+        seen.add(s);
+      }
+    }
+
+    fs.writeFileSync(dest, chunks.join('\n'), {encoding: 'utf8'});
+  }
+}
+
+module.exports = buildDistribution;

scripts/run-all-browsers

@@ -3,6 +3,7 @@
 run_browser() {
 	browser=$1
 	version=$2
+	os="$3"
 	description="$browser $version"
 	if [ $version = "latest" ]; then
 		version=""
@@ -12,7 +13,7 @@ run_browser() {
 	echo
 	echo "Running $description"
 	echo
-	USE_SAUCE=true JASMINE_BROWSER=$browser SAUCE_BROWSER_VERSION=$version npm run ci
+	USE_SAUCE=true JASMINE_BROWSER=$browser SAUCE_BROWSER_VERSION=$version SAUCE_OS="$os" npm run ci
 
 	if [ $? -eq 0 ]; then
 		echo "PASS: $description" >> "$passfile"
@@ -23,11 +24,24 @@ run_browser() {
 
 passfile=`mktemp -t jasmine-results.XXXXXX` || exit 1
 failfile=`mktemp -t jasmine-results.XXXXXX` || exit 1
+
 run_browser chrome latest
+
 run_browser firefox latest
+if [ "$1" = "--not-actually-all" ]; then
+  echo "SKIPPED: firefox 140" >> "$passfile"
+  echo "SKIPPED: firefox 128" >> "$passfile"
+  echo "SKIPPED: firefox 115" >> "$passfile"
+else
+  run_browser firefox 140
+  run_browser firefox 128
+  run_browser firefox 115
+fi
 run_browser firefox 102
+
+run_browser safari 17
 run_browser safari 16
-run_browser safari 15
+
 run_browser MicrosoftEdge latest
 
 echo

scripts/runSpecsInNode.js

@@ -0,0 +1,28 @@
+verifyNoGlobals(() => require('../lib/jasmine-core.js').noGlobals());
+
+const Jasmine = require('jasmine');
+const jasmineCore = require('../lib/jasmine-core.js');
+const runner = new Jasmine({jasmineCore: jasmineCore});
+
+runner.loadConfigFile('./spec/support/jasmine.json');
+runner.exitOnCompletion = false;
+runner.execute()
+  .then(
+    result => result.overallStatus === 'passed',
+    err => {
+      console.error(err);
+      return false;
+    }
+  )
+  .then(ok => process.exit(ok ? 0 : 1));
+
+function verifyNoGlobals(fn) {
+  const initialGlobals = Object.keys(global);
+  fn();
+
+  const extras = Object.keys(global).filter(k => !initialGlobals.includes(k));
+
+  if (extras.length !== 0) {
+    throw new Error('Globals were unexpectedly created: ' + extras.join(', '));
+  }
+}

scripts/runSpecsInParallel.js

@@ -0,0 +1,28 @@
+const ParallelRunner = require('jasmine/parallel');
+const jasmineCore = require('../lib/jasmine-core.js');
+let numWorkers = require('os').cpus().length;
+
+if (process.env['CIRCLECI']) {
+  // On Circle CI, the above gives the number of CPU cores on the host
+  // computer, which is unrelated to the resources actually available
+  // to the container. 2 workers gives peak performance with our current
+  // configuration, but 4 might increase the odds of discovering any
+  // parallel-specific bugs.
+  numWorkers = 4;
+}
+
+const runner = new ParallelRunner({jasmineCore, numWorkers});
+
+runner.loadConfigFile('./spec/support/jasmine.json')
+  .then(() => {
+    runner.exitOnCompletion = false;
+    return runner.execute();
+  })
+  .then(
+    jasmineDoneInfo => jasmineDoneInfo.overallStatus === 'passed',
+    err => {
+      console.error(err);
+      return false;
+    }
+  )
+  .then(ok => process.exit(ok ? 0 : 1));

scripts/start-sauce-connect

@@ -2,32 +2,19 @@
 set -o errexit
 set -o pipefail
 
-if [ $# -gt 1 -o "$1" = "--help" ]; then
-	echo "Usage: $0 [pidfile]" 1>&2
-	exit
-fi
-
-if [ -z "$1" ]; then
-	pidfile=`mktemp`
-else
-	pidfile="$1"
+if [ -z "$SAUCE_TUNNEL_NAME" ]; then
+  echo "SAUCE_TUNNEL_NAME must be set" 1>&2
+  exit 1
 fi
 
 outfile=`mktemp`
 echo "Starting Sauce Connect"
-if [ -z "$SAUCE_TUNNEL_IDENTIFIER" ]; then
-	sc -u "$SAUCE_USERNAME" -k "$SAUCE_ACCESS_KEY" -X 4445 --pidfile "$pidfile" 2>&1 | tee "$outfile" &
-else
-	sc -u "$SAUCE_USERNAME" -k "$SAUCE_ACCESS_KEY" -X 4445 --pidfile "$pidfile" -i "$SAUCE_TUNNEL_IDENTIFIER" 2>&1 | tee "$outfile" &
-fi
+sc legacy --proxy-localhost --tunnel-domains localhost --region us-west \
+  -u "$SAUCE_USERNAME" -k "$SAUCE_ACCESS_KEY" \
+  -X 4445 -i "$SAUCE_TUNNEL_NAME" 2>&1 | tee "$outfile" &
 
-while ! fgrep "Sauce Connect is up, you may start your tests." "$outfile" > /dev/null; do
+while ! fgrep "Sauce Connect is up, you may start your tests" "$outfile" > /dev/null; do
     sleep 1
-
-	 if ! ps -p $(cat "$pidfile") > /dev/null; then
-	 	echo "Sauce Connect exited"
-		exit 1
-	 fi
 done
 
 if ! nc -z localhost 4445; then

scripts/stop-sauce-connect

@@ -2,32 +2,38 @@
 set -o errexit
 set -o pipefail
 
-if [ -z "$1" ]; then
-	echo "Usage: $0 sauce-connect-pid" 1>&2
-	exit
-fi
-
-pid="$1"
-echo "PID: $pid"
-
 echo "Stopping Sauce Connect"
-# Sauce Connect docs say that we can just kill -9 it if we don't care about
-# failing any ongoing sessions. In practice, that sometimes works but usually
-# leaks a tunnel so badly that you can't even stop it from the web UI. 
-# Instead of doing that, we give Sauce Connect some time to shut down
-# gracefully and then give up.
-kill -INT $pid
+
+# Sauce Connect 4 docs said that we can just kill -9 it if we don't care about
+# failing any ongoing sessions. In practice, that sometimes worked but usually
+# leaked a tunnel so badly that you couldn't even stop it from the web UI.
+#
+# Sauce Connect 5 appears to be *much* more prone to hung jobs. Hung jobs have
+# a shutdown deadline of *three hours*, however, they appear to usually exit
+# within a minute or so. Unfortunately the only thing the Sauce Connect 5 docs
+# say about shutdown is that "you can stop your tunnel from the terminal where
+# Sauce Connect is running by entering Ctrl+C". Nothing is said about what to
+# do if Sauce Connect doesn't exit on it own or about non-interactive usage.
+#
+# So we do our best to be well-behaved without assuming that Sauce Connect
+# always is: send it the same signal that it would get if an interactive user
+# hit ctrl-c, wait a while for it to exit, then give up so that the CI task
+# doesn't keep running indefinitely.
+
+if ! pkill -INT '^sc$'; then
+  echo "sc does not appear to be running" 1>&2
+  exit 1
+fi
 
 # Wait up to 2 minutes, then give up if it's still running
 n=0
-while [ $n -lt 120 ] && ps -p $pid > /dev/null; do
+while [ $n -lt 120 ] && pgrep '^sc$' > /dev/null; do
 	sleep 1
-	kill -INT $pid 2> /dev/null || true
+	pkill -INT '^sc$' || true
 	n=$(($n + 1))
 done
 
-if ps -p $pid > /dev/null; then
+if pgrep '^sc$' > /dev/null; then
 	echo "Could not shut down Sauce Connect"
+	exit 1
 fi
-
-exit $exitcode

spec/core/AsyncExpectationSpec.js

@@ -129,33 +129,33 @@ describe('AsyncExpectation', function() {
         });
     });
 
-    it('prepends the context to a custom failure message from a function', function() {
-      pending('should actually work, but no custom matchers for async yet');
-
+    it('prepends the context to a custom failure message from a matcher', async function() {
       const matchersUtil = {
-          buildFailureMessage: function() {
-            return 'failure message';
-          }
+        buildFailureMessage() {
+          return 'failure message';
         },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = Promise.reject(new Error('nope')),
-        expectation = jasmineUnderTest.Expectation.asyncFactory({
-          actual: actual,
-          addExpectationResult: addExpectationResult,
-          matchersUtil: matchersUtil
-        });
+        pp(v) {
+          return v.toString();
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
+      const actual = Promise.reject(new Error('nope'));
+      const expectation = jasmineUnderTest.Expectation.asyncFactory({
+        actual: actual,
+        addExpectationResult: addExpectationResult,
+        matchersUtil: matchersUtil
+      });
 
-      return expectation
-        .withContext('Some context')
-        .toBeResolved()
-        .then(function() {
-          expect(addExpectationResult).toHaveBeenCalledWith(
-            false,
-            jasmine.objectContaining({
-              message: 'Some context: msg'
-            })
-          );
-        });
+      await expectation.withContext('Some context').toBeResolved();
+
+      expect(addExpectationResult).toHaveBeenCalledWith(
+        false,
+        jasmine.objectContaining({
+          message:
+            'Some context: Expected a promise to be resolved but it ' +
+            'was rejected with Error: nope.'
+        })
+      );
     });
 
     it('works with #not', function() {
@@ -277,23 +277,18 @@ describe('AsyncExpectation', function() {
 
     it('reports a passing result to the spec when the comparison passes', function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({ pass: true });
-              }
-            };
-          }
-        },
-        matchersUtil = {
-          buildFailureMessage: jasmine.createSpy('buildFailureMessage')
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({ pass: true });
+            }
+          };
+        }
+      };
+      const matchersUtil = {
+        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -310,7 +305,7 @@ describe('AsyncExpectation', function() {
           error: undefined,
           expected: 'hello',
           actual: 'an actual',
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
@@ -329,13 +324,8 @@ describe('AsyncExpectation', function() {
           buildFailureMessage: function() {
             return '';
           }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -352,30 +342,25 @@ describe('AsyncExpectation', function() {
           actual: 'an actual',
           message: '',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it('reports a failing result and a custom fail message to the spec when the comparison fails', function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({
-                  pass: false,
-                  message: 'I am a custom message'
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({
+                pass: false,
+                message: 'I am a custom message'
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         actual: 'an actual',
@@ -391,32 +376,27 @@ describe('AsyncExpectation', function() {
           actual: 'an actual',
           message: 'I am a custom message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it('reports a failing result with a custom fail message function to the spec when the comparison fails', function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({
-                  pass: false,
-                  message: function() {
-                    return 'I am a custom message';
-                  }
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({
+                pass: false,
+                message: function() {
+                  return 'I am a custom message';
+                }
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -432,28 +412,23 @@ describe('AsyncExpectation', function() {
           actual: 'an actual',
           message: 'I am a custom message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it('reports a passing result to the spec when the comparison fails for a negative expectation', function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({ pass: false });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = 'an actual',
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({ pass: false });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
+      const actual = 'an actual';
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -469,7 +444,7 @@ describe('AsyncExpectation', function() {
           error: undefined,
           expected: 'hello',
           actual: actual,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
@@ -488,14 +463,9 @@ describe('AsyncExpectation', function() {
           buildFailureMessage: function() {
             return 'default message';
           }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = 'an actual',
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
+      const actual = 'an actual';
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -512,31 +482,26 @@ describe('AsyncExpectation', function() {
           actual: actual,
           message: 'default message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it('reports a failing result and a custom fail message to the spec when the comparison passes for a negative expectation', function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({
-                  pass: true,
-                  message: 'I am a custom message'
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = 'an actual',
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({
+                pass: true,
+                message: 'I am a custom message'
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
+      const actual = 'an actual';
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -552,31 +517,26 @@ describe('AsyncExpectation', function() {
           actual: actual,
           message: 'I am a custom message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it("reports a passing result to the spec when the 'not' comparison passes, given a negativeCompare", function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({ pass: true });
-              },
-              negativeCompare: function() {
-                return Promise.resolve({ pass: true });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = 'an actual',
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({ pass: true });
+            },
+            negativeCompare: function() {
+              return Promise.resolve({ pass: true });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
+      const actual = 'an actual';
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -592,34 +552,29 @@ describe('AsyncExpectation', function() {
           actual: actual,
           message: '',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it("reports a failing result and a custom fail message to the spec when the 'not' comparison fails, given a negativeCompare", function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({ pass: true });
-              },
-              negativeCompare: function() {
-                return Promise.resolve({
-                  pass: false,
-                  message: "I'm a custom message"
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        actual = 'an actual',
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({ pass: true });
+            },
+            negativeCompare: function() {
+              return Promise.resolve({
+                pass: false,
+                message: "I'm a custom message"
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
+      const actual = 'an actual';
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         customAsyncMatchers: matchers,
@@ -635,7 +590,7 @@ describe('AsyncExpectation', function() {
           actual: actual,
           message: "I'm a custom message",
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
@@ -643,24 +598,19 @@ describe('AsyncExpectation', function() {
     it('reports errorWithStack when a custom error message is returned', function() {
       const customError = new Error('I am a custom error');
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({
-                  pass: false,
-                  message: 'I am a custom message',
-                  error: customError
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({
+                pass: false,
+                message: 'I am a custom message',
+                error: customError
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         actual: 'an actual',
@@ -676,30 +626,25 @@ describe('AsyncExpectation', function() {
           actual: 'an actual',
           message: 'I am a custom message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it("reports a custom message to the spec when a 'not' comparison fails", function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({
-                  pass: true,
-                  message: 'I am a custom message'
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({
+                pass: true,
+                message: 'I am a custom message'
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       const expectation = jasmineUnderTest.Expectation.asyncFactory({
         actual: 'an actual',
@@ -715,32 +660,27 @@ describe('AsyncExpectation', function() {
           actual: 'an actual',
           message: 'I am a custom message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });
 
     it("reports a custom message func to the spec when a 'not' comparison fails", function() {
       const matchers = {
-          toFoo: function() {
-            return {
-              compare: function() {
-                return Promise.resolve({
-                  pass: true,
-                  message: function() {
-                    return 'I am a custom message';
-                  }
-                });
-              }
-            };
-          }
-        },
-        addExpectationResult = jasmine.createSpy('addExpectationResult'),
-        errorWithStack = new Error('errorWithStack');
-
-      spyOn(jasmineUnderTest.util, 'errorWithStack').and.returnValue(
-        errorWithStack
-      );
+        toFoo: function() {
+          return {
+            compare: function() {
+              return Promise.resolve({
+                pass: true,
+                message: function() {
+                  return 'I am a custom message';
+                }
+              });
+            }
+          };
+        }
+      };
+      const addExpectationResult = jasmine.createSpy('addExpectationResult');
 
       let expectation = jasmineUnderTest.Expectation.asyncFactory({
         actual: 'an actual',
@@ -756,7 +696,7 @@ describe('AsyncExpectation', function() {
           actual: 'an actual',
           message: 'I am a custom message',
           error: undefined,
-          errorForStack: errorWithStack
+          errorForStack: jasmine.any(Error)
         });
       });
     });

spec/core/CallTrackerSpec.js

@@ -134,6 +134,42 @@ describe('CallTracker', function() {
     expect(callTracker.mostRecent().args[1]).toEqual(arrayArg);
   });
 
+  it('allows object arguments to be deep cloned', function() {
+    const callTracker = new jasmineUnderTest.CallTracker();
+    callTracker.saveArgumentsByValue(args => JSON.parse(JSON.stringify(args)));
+
+    const objectArg = { foo: { bar: { baz: ['qux'] } } },
+      arrayArg = ['foo', 'bar'];
+
+    callTracker.track({
+      object: {},
+      args: [objectArg, arrayArg, false, undefined, null, NaN, '', 0, 1.0]
+    });
+
+    objectArg.foo.bar.baz.push('quux');
+
+    expect(callTracker.mostRecent().args[0]).not.toBe(objectArg);
+    expect(callTracker.mostRecent().args[0]).not.toEqual(objectArg);
+    expect(callTracker.mostRecent().args[0]).toEqual({
+      foo: { bar: { baz: ['qux'] } }
+    });
+    expect(callTracker.mostRecent().args[1]).not.toBe(arrayArg);
+    expect(callTracker.mostRecent().args[1]).toEqual(arrayArg);
+  });
+
+  it('can take any function to transform arguments when saving by value', function() {
+    const callTracker = new jasmineUnderTest.CallTracker();
+    callTracker.saveArgumentsByValue(JSON.stringify);
+
+    const objectArg = { foo: { bar: { baz: ['qux'] } } },
+      arrayArg = ['foo', 'bar'],
+      args = [objectArg, arrayArg, false, undefined, null, NaN, '', 0, 1.0];
+
+    callTracker.track({ object: {}, args });
+
+    expect(callTracker.mostRecent().args).toEqual(JSON.stringify(args));
+  });
+
   it('saves primitive arguments by value', function() {
     const callTracker = new jasmineUnderTest.CallTracker(),
       args = [undefined, null, false, '', /\s/, 0, 1.2, NaN];

spec/core/ClearStackSpec.js

@@ -20,6 +20,47 @@ describe('ClearStack', function() {
         MessageChannel: fakeMessageChannel
       };
     });
+
+    it('uses MessageChannel to reduce setTimeout clamping', function() {
+      const fakeChannel = fakeMessageChannel();
+      spyOn(fakeChannel.port2, 'postMessage');
+      const queueMicrotask = jasmine.createSpy('queueMicrotask');
+      const global = {
+        navigator: {
+          userAgent:
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.0.8 (KHTML, like Gecko) Version/15.1 Safari/605.0.8'
+        },
+        MessageChannel: function() {
+          return fakeChannel;
+        },
+        queueMicrotask
+      };
+
+      const clearStack = jasmineUnderTest.getClearStack(global);
+
+      for (let i = 0; i < 9; i++) {
+        clearStack(function() {});
+      }
+
+      expect(fakeChannel.port2.postMessage).not.toHaveBeenCalled();
+
+      clearStack(function() {});
+
+      expect(fakeChannel.port2.postMessage).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("in WebKit (Playwright's build for Windows)", function() {
+    usesQueueMicrotaskWithSetTimeout(function() {
+      return {
+        navigator: {
+          userAgent:
+            'Mozilla/5.0 (Windows NT 6.2; Win64; x64) AppleWebKit/605.1.15 (KHTML, like Gecko)'
+        },
+        // queueMicrotask should be used even though MessageChannel is present
+        MessageChannel: fakeMessageChannel
+      };
+    });
   });
 
   describe('in browsers other than Safari', function() {

spec/core/ClockSpec.js

@@ -242,7 +242,7 @@ describe('Clock', function() {
     expect(fakeGlobal.clearInterval).toBe(replacedClearInterval);
   });
 
-  it('replaces the global timer functions on uninstall', function() {
+  it('restores the global timer functions on uninstall', function() {
     const fakeSetTimeout = jasmine.createSpy('global setTimeout'),
       fakeClearTimeout = jasmine.createSpy('global clearTimeout'),
       fakeSetInterval = jasmine.createSpy('global setInterval'),
@@ -408,211 +408,219 @@ describe('Clock', function() {
     expect(delayedFunctionScheduler.scheduleFunction).not.toHaveBeenCalled();
   });
 
-  it('schedules the delayed function (via setTimeout) with the fake timer', function() {
-    const fakeSetTimeout = jasmine.createSpy('setTimeout'),
-      scheduleFunction = jasmine.createSpy('scheduleFunction'),
-      delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
-      fakeGlobal = { setTimeout: fakeSetTimeout },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      mockDate = {
-        install: function() {},
-        tick: function() {},
-        uninstall: function() {}
-      },
-      clock = new jasmineUnderTest.Clock(
-        fakeGlobal,
-        function() {
-          return delayedFunctionScheduler;
+  describe('setTimeout', function() {
+    it('schedules the delayed function with the fake timer', function() {
+      const fakeSetTimeout = jasmine.createSpy('setTimeout'),
+        scheduleFunction = jasmine.createSpy('scheduleFunction'),
+        delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
+        fakeGlobal = { setTimeout: fakeSetTimeout },
+        delayedFn = jasmine.createSpy('delayedFn'),
+        mockDate = {
+          install: function() {},
+          tick: function() {},
+          uninstall: function() {}
         },
-        mockDate
-      ),
-      timeout = new clock.FakeTimeout();
+        clock = new jasmineUnderTest.Clock(
+          fakeGlobal,
+          function() {
+            return delayedFunctionScheduler;
+          },
+          mockDate
+        ),
+        timeout = new clock.FakeTimeout();
 
-    clock.install();
-    clock.setTimeout(delayedFn, 0, 'a', 'b');
+      clock.install();
+      clock.setTimeout(delayedFn, 0, 'a', 'b');
 
-    expect(fakeSetTimeout).not.toHaveBeenCalled();
+      expect(fakeSetTimeout).not.toHaveBeenCalled();
 
-    if (!NODE_JS) {
-      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
-        delayedFn,
-        0,
-        ['a', 'b']
-      );
-    } else {
-      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
-        delayedFn,
-        0,
-        ['a', 'b'],
-        false,
-        timeout
-      );
-    }
+      if (!NODE_JS) {
+        expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
+          delayedFn,
+          0,
+          ['a', 'b']
+        );
+      } else {
+        expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
+          delayedFn,
+          0,
+          ['a', 'b'],
+          false,
+          timeout
+        );
+      }
+    });
+
+    it('returns an id for the delayed function', function() {
+      const fakeSetTimeout = jasmine.createSpy('setTimeout'),
+        scheduleId = 123,
+        scheduleFunction = jasmine
+          .createSpy('scheduleFunction')
+          .and.returnValue(scheduleId),
+        delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
+        fakeGlobal = { setTimeout: fakeSetTimeout },
+        delayedFn = jasmine.createSpy('delayedFn'),
+        mockDate = {
+          install: function() {},
+          tick: function() {},
+          uninstall: function() {}
+        },
+        clock = new jasmineUnderTest.Clock(
+          fakeGlobal,
+          function() {
+            return delayedFunctionScheduler;
+          },
+          mockDate
+        );
+
+      clock.install();
+      const timeout = clock.setTimeout(delayedFn, 0);
+
+      if (!NODE_JS) {
+        expect(timeout).toEqual(123);
+      } else {
+        expect(timeout.constructor.name).toEqual('FakeTimeout');
+      }
+    });
   });
 
-  it('returns an id for the delayed function', function() {
-    const fakeSetTimeout = jasmine.createSpy('setTimeout'),
-      scheduleId = 123,
-      scheduleFunction = jasmine
-        .createSpy('scheduleFunction')
-        .and.returnValue(scheduleId),
-      delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
-      fakeGlobal = { setTimeout: fakeSetTimeout },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      mockDate = {
-        install: function() {},
-        tick: function() {},
-        uninstall: function() {}
-      },
-      clock = new jasmineUnderTest.Clock(
-        fakeGlobal,
-        function() {
-          return delayedFunctionScheduler;
+  describe('clearTimeout', function() {
+    it('clears the scheduled function with the scheduler', function() {
+      const fakeClearTimeout = jasmine.createSpy('clearTimeout'),
+        delayedFunctionScheduler = jasmine.createSpyObj(
+          'delayedFunctionScheduler',
+          ['removeFunctionWithId']
+        ),
+        fakeGlobal = { setTimeout: fakeClearTimeout },
+        mockDate = {
+          install: function() {},
+          tick: function() {},
+          uninstall: function() {}
         },
-        mockDate
-      );
+        clock = new jasmineUnderTest.Clock(
+          fakeGlobal,
+          function() {
+            return delayedFunctionScheduler;
+          },
+          mockDate
+        );
 
-    clock.install();
-    const timeout = clock.setTimeout(delayedFn, 0);
+      clock.install();
+      clock.clearTimeout(123);
 
-    if (!NODE_JS) {
-      expect(timeout).toEqual(123);
-    } else {
-      expect(timeout.constructor.name).toEqual('FakeTimeout');
-    }
+      expect(fakeClearTimeout).not.toHaveBeenCalled();
+      expect(
+        delayedFunctionScheduler.removeFunctionWithId
+      ).toHaveBeenCalledWith(123);
+    });
   });
 
-  it('clears the scheduled function with the scheduler', function() {
-    const fakeClearTimeout = jasmine.createSpy('clearTimeout'),
-      delayedFunctionScheduler = jasmine.createSpyObj(
-        'delayedFunctionScheduler',
-        ['removeFunctionWithId']
-      ),
-      fakeGlobal = { setTimeout: fakeClearTimeout },
-      mockDate = {
-        install: function() {},
-        tick: function() {},
-        uninstall: function() {}
-      },
-      clock = new jasmineUnderTest.Clock(
-        fakeGlobal,
-        function() {
-          return delayedFunctionScheduler;
+  describe('setInterval', function() {
+    it('schedules the delayed function with the fake timer', function() {
+      const fakeSetInterval = jasmine.createSpy('setInterval'),
+        scheduleFunction = jasmine.createSpy('scheduleFunction'),
+        delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
+        fakeGlobal = { setInterval: fakeSetInterval },
+        delayedFn = jasmine.createSpy('delayedFn'),
+        mockDate = {
+          install: function() {},
+          tick: function() {},
+          uninstall: function() {}
         },
-        mockDate
-      );
+        clock = new jasmineUnderTest.Clock(
+          fakeGlobal,
+          function() {
+            return delayedFunctionScheduler;
+          },
+          mockDate
+        ),
+        timeout = new clock.FakeTimeout();
 
-    clock.install();
-    clock.clearTimeout(123);
+      clock.install();
+      clock.setInterval(delayedFn, 0, 'a', 'b');
 
-    expect(fakeClearTimeout).not.toHaveBeenCalled();
-    expect(delayedFunctionScheduler.removeFunctionWithId).toHaveBeenCalledWith(
-      123
-    );
+      expect(fakeSetInterval).not.toHaveBeenCalled();
+
+      if (!NODE_JS) {
+        expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
+          delayedFn,
+          0,
+          ['a', 'b'],
+          true
+        );
+      } else {
+        expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
+          delayedFn,
+          0,
+          ['a', 'b'],
+          true,
+          timeout
+        );
+      }
+    });
+
+    it('returns an id for the delayed function', function() {
+      const fakeSetInterval = jasmine.createSpy('setInterval'),
+        scheduleId = 123,
+        scheduleFunction = jasmine
+          .createSpy('scheduleFunction')
+          .and.returnValue(scheduleId),
+        delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
+        fakeGlobal = { setInterval: fakeSetInterval },
+        delayedFn = jasmine.createSpy('delayedFn'),
+        mockDate = {
+          install: function() {},
+          tick: function() {},
+          uninstall: function() {}
+        },
+        clock = new jasmineUnderTest.Clock(
+          fakeGlobal,
+          function() {
+            return delayedFunctionScheduler;
+          },
+          mockDate
+        );
+
+      clock.install();
+      const interval = clock.setInterval(delayedFn, 0);
+
+      if (!NODE_JS) {
+        expect(interval).toEqual(123);
+      } else {
+        expect(interval.constructor.name).toEqual('FakeTimeout');
+      }
+    });
   });
 
-  it('schedules the delayed function with the fake timer', function() {
-    const fakeSetInterval = jasmine.createSpy('setInterval'),
-      scheduleFunction = jasmine.createSpy('scheduleFunction'),
-      delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
-      fakeGlobal = { setInterval: fakeSetInterval },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      mockDate = {
-        install: function() {},
-        tick: function() {},
-        uninstall: function() {}
-      },
-      clock = new jasmineUnderTest.Clock(
-        fakeGlobal,
-        function() {
-          return delayedFunctionScheduler;
+  describe('clearInterval', function() {
+    it('clears the scheduled function with the scheduler', function() {
+      const clearInterval = jasmine.createSpy('clearInterval'),
+        delayedFunctionScheduler = jasmine.createSpyObj(
+          'delayedFunctionScheduler',
+          ['removeFunctionWithId']
+        ),
+        fakeGlobal = { setInterval: clearInterval },
+        mockDate = {
+          install: function() {},
+          tick: function() {},
+          uninstall: function() {}
         },
-        mockDate
-      ),
-      timeout = new clock.FakeTimeout();
+        clock = new jasmineUnderTest.Clock(
+          fakeGlobal,
+          function() {
+            return delayedFunctionScheduler;
+          },
+          mockDate
+        );
 
-    clock.install();
-    clock.setInterval(delayedFn, 0, 'a', 'b');
+      clock.install();
+      clock.clearInterval(123);
 
-    expect(fakeSetInterval).not.toHaveBeenCalled();
-
-    if (!NODE_JS) {
-      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
-        delayedFn,
-        0,
-        ['a', 'b'],
-        true
-      );
-    } else {
-      expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(
-        delayedFn,
-        0,
-        ['a', 'b'],
-        true,
-        timeout
-      );
-    }
-  });
-
-  it('returns an id for the delayed function', function() {
-    const fakeSetInterval = jasmine.createSpy('setInterval'),
-      scheduleId = 123,
-      scheduleFunction = jasmine
-        .createSpy('scheduleFunction')
-        .and.returnValue(scheduleId),
-      delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
-      fakeGlobal = { setInterval: fakeSetInterval },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      mockDate = {
-        install: function() {},
-        tick: function() {},
-        uninstall: function() {}
-      },
-      clock = new jasmineUnderTest.Clock(
-        fakeGlobal,
-        function() {
-          return delayedFunctionScheduler;
-        },
-        mockDate
-      );
-
-    clock.install();
-    const interval = clock.setInterval(delayedFn, 0);
-
-    if (!NODE_JS) {
-      expect(interval).toEqual(123);
-    } else {
-      expect(interval.constructor.name).toEqual('FakeTimeout');
-    }
-  });
-
-  it('clears the scheduled function with the scheduler', function() {
-    const clearInterval = jasmine.createSpy('clearInterval'),
-      delayedFunctionScheduler = jasmine.createSpyObj(
-        'delayedFunctionScheduler',
-        ['removeFunctionWithId']
-      ),
-      fakeGlobal = { setInterval: clearInterval },
-      mockDate = {
-        install: function() {},
-        tick: function() {},
-        uninstall: function() {}
-      },
-      clock = new jasmineUnderTest.Clock(
-        fakeGlobal,
-        function() {
-          return delayedFunctionScheduler;
-        },
-        mockDate
-      );
-
-    clock.install();
-    clock.clearInterval(123);
-
-    expect(clearInterval).not.toHaveBeenCalled();
-    expect(delayedFunctionScheduler.removeFunctionWithId).toHaveBeenCalledWith(
-      123
-    );
+      expect(clearInterval).not.toHaveBeenCalled();
+      expect(
+        delayedFunctionScheduler.removeFunctionWithId
+      ).toHaveBeenCalledWith(123);
+    });
   });
 
   it('gives you a friendly reminder if the Clock is not installed and you tick', function() {
@@ -687,6 +695,159 @@ describe('Clock (acceptance)', function() {
     expect(recurring1.calls.count()).toBe(4);
   });
 
+  describe('auto tick mode', () => {
+    let delayedFunctionScheduler;
+    let mockDate;
+    let clock;
+
+    beforeEach(() => {
+      delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler();
+      mockDate = {
+        install: function() {},
+        tick: function() {},
+        uninstall: function() {}
+      };
+      // window setTimeout to window to make firefox happy
+      const _setTimeout =
+        typeof window !== 'undefined' ? setTimeout.bind(window) : setTimeout;
+      // passing a fake global allows us to preserve the real timing functions for use in tests
+      const _global = { setTimeout: _setTimeout, setInterval: setInterval };
+      clock = new jasmineUnderTest.Clock(
+        _global,
+        function() {
+          return delayedFunctionScheduler;
+        },
+        mockDate
+      );
+      clock.install().autoTick();
+    });
+
+    afterEach(() => {
+      clock.uninstall();
+    });
+
+    it('flushes microtask queue between macrotasks', async () => {
+      const log = [];
+      await new Promise(r => clock.setTimeout(r, 10)).then(() => {
+        log.push(1);
+        Promise.resolve().then(() => log.push(2));
+        Promise.resolve().then(() => log.push(3));
+      });
+      await new Promise(r => clock.setTimeout(r, 10)).then(() => {
+        log.push(4);
+        Promise.resolve().then(() => log.push(5));
+      });
+      expect(log).toEqual([1, 2, 3, 4, 5]);
+    });
+
+    it('can run setTimeouts/setIntervals asynchronously', function() {
+      const recurring = jasmine.createSpy('recurring'),
+        fn1 = jasmine.createSpy('fn1'),
+        fn2 = jasmine.createSpy('fn2'),
+        fn3 = jasmine.createSpy('fn3');
+
+      const intervalId = clock.setInterval(recurring, 50);
+      // In a microtask, add some timeouts.
+      Promise.resolve()
+        .then(function() {
+          return new Promise(function(resolve) {
+            clock.setTimeout(resolve, 25);
+          });
+        })
+        .then(function() {
+          fn1();
+          return new Promise(function(resolve) {
+            clock.setTimeout(resolve, 200);
+          });
+        })
+        .then(function() {
+          fn2();
+          return new Promise(function(resolve) {
+            clock.setTimeout(resolve, 100);
+          });
+        })
+        .then(function() {
+          fn3();
+        });
+
+      expect(recurring).not.toHaveBeenCalled();
+      expect(fn1).not.toHaveBeenCalled();
+      expect(fn2).not.toHaveBeenCalled();
+      expect(fn3).not.toHaveBeenCalled();
+
+      return new Promise(resolve => clock.setTimeout(resolve, 50))
+        .then(function() {
+          expect(recurring).toHaveBeenCalledTimes(1);
+          expect(fn1).toHaveBeenCalled();
+          expect(fn2).not.toHaveBeenCalled();
+          expect(fn3).not.toHaveBeenCalled();
+
+          return new Promise(resolve => clock.setTimeout(resolve, 175));
+        })
+        .then(function() {
+          expect(recurring).toHaveBeenCalledTimes(4);
+          expect(fn1).toHaveBeenCalled();
+          expect(fn2).toHaveBeenCalled();
+          expect(fn3).not.toHaveBeenCalled();
+
+          clock.clearInterval(intervalId);
+          return new Promise(resolve => clock.setTimeout(resolve, 100));
+        })
+        .then(function() {
+          expect(recurring).toHaveBeenCalledTimes(4);
+          expect(fn1).toHaveBeenCalled();
+          expect(fn2).toHaveBeenCalled();
+          expect(fn3).toHaveBeenCalled();
+        });
+    });
+
+    it('aborts auto ticking when uninstalled, even if installed again synchonrously', async () => {
+      clock.uninstall();
+      clock.install();
+
+      let resolved = false;
+      const promise = new Promise(resolve => {
+        clock.setTimeout(resolve, 1);
+      }).then(() => {
+        resolved = true;
+      });
+
+      // wait some real time and verify that the clock did not flush the timer above automatically
+      await new Promise(resolve => setTimeout(resolve, 2));
+      expect(resolved).toBe(false);
+
+      // enabling auto tick again will flush the timer
+      clock.autoTick();
+      await expectAsync(promise).toBeResolved();
+    });
+
+    it('speeds up the execution of the timers in all browsers', async () => {
+      const startTimeMs = performance.now() / 1000;
+      await new Promise(resolve => clock.setTimeout(resolve, 5000));
+      await new Promise(resolve => clock.setTimeout(resolve, 5000));
+      await new Promise(resolve => clock.setTimeout(resolve, 5000));
+      await new Promise(resolve => clock.setTimeout(resolve, 5000));
+      const endTimeMs = performance.now() / 1000;
+      // Ensure we didn't take 20s to complete the awaits above and, in fact, can do it in a fraction of a second
+      expect(endTimeMs - startTimeMs).toBeLessThan(100);
+    });
+
+    it('is easy to test async functions with interleaved timers and microtasks', async () => {
+      async function blackBoxWithLotsOfAsyncStuff() {
+        await new Promise(r => clock.setTimeout(r, 10));
+        await Promise.resolve();
+        await Promise.resolve();
+        await new Promise(r => clock.setTimeout(r, 20));
+        await Promise.resolve();
+        await Promise.resolve();
+        await Promise.resolve();
+        return 'done';
+      }
+      const result = await blackBoxWithLotsOfAsyncStuff();
+      expect(result).toBe('done');
+    });
+  });
+
   it('can clear a previously set timeout', function() {
     const clearedFn = jasmine.createSpy('clearedFn'),
       delayedFunctionScheduler = new jasmineUnderTest.DelayedFunctionScheduler(),

spec/core/ConfigurationSpec.js

@@ -0,0 +1,134 @@
+describe('Configuration', function() {
+  const standardBooleanKeys = [
+    'random',
+    'stopOnSpecFailure',
+    'stopSpecOnExpectationFailure',
+    'failSpecWithNoExpectations',
+    'hideDisabled',
+    'autoCleanClosures',
+    'forbidDuplicateNames',
+    'detectLateRejectionHandling'
+  ];
+  const allKeys = [
+    ...standardBooleanKeys,
+    'seed',
+    'specFilter',
+    'verboseDeprecations'
+  ];
+  Object.freeze(standardBooleanKeys);
+  Object.freeze(allKeys);
+
+  it('provides defaults', function() {
+    const subject = new jasmineUnderTest.Configuration();
+    expect(subject.random).toEqual(true);
+    expect(subject.seed).toBeNull();
+    expect(subject.stopOnSpecFailure).toEqual(false);
+    expect(subject.stopSpecOnExpectationFailure).toEqual(false);
+    expect(subject.failSpecWithNoExpectations).toEqual(false);
+    expect(subject.specFilter).toEqual(jasmine.any(Function));
+    expect(subject.specFilter()).toEqual(true);
+    expect(subject.hideDisabled).toEqual(false);
+    expect(subject.autoCleanClosures).toEqual(true);
+    expect(subject.forbidDuplicateNames).toEqual(false);
+    expect(subject.verboseDeprecations).toEqual(false);
+    expect(subject.detectLateRejectionHandling).toEqual(false);
+  });
+
+  describe('copy()', function() {
+    it('returns a copy of the configuration as a plain old JS object', function() {
+      const subject = new jasmineUnderTest.Configuration();
+
+      const copy = subject.copy();
+
+      expect(copy.constructor.name).toEqual('Object');
+
+      expect(new Set(Object.keys(copy))).toEqual(new Set(allKeys));
+      for (const k of allKeys) {
+        expect(copy[k]).toEqual(subject[k]);
+      }
+    });
+  });
+
+  describe('update()', function() {
+    it('does not update properties that are absent from the parameter', function() {
+      const subject = new jasmineUnderTest.Configuration();
+      const originalValues = subject.copy();
+
+      subject.update({});
+      expect(subject.copy()).toEqual(originalValues);
+    });
+
+    function booleanPropertyBehavior(key) {
+      it('does not update the property if the specified value is undefined', function() {
+        const subject = new jasmineUnderTest.Configuration();
+        const orig = subject[key];
+
+        subject.update({ [key]: undefined });
+
+        expect(subject[key]).toEqual(orig);
+      });
+
+      it('updates the property if the specified value is not undefined', function() {
+        const subject = new jasmineUnderTest.Configuration();
+        const orig = subject[key];
+
+        subject.update({ [key]: !orig });
+        expect(subject[key]).toEqual(!orig);
+
+        subject.update({ [key]: orig });
+        expect(subject[key]).toEqual(orig);
+      });
+    }
+
+    for (const k of standardBooleanKeys) {
+      describe(k, function() {
+        booleanPropertyBehavior(k);
+      });
+    }
+
+    // TODO: in the next major release, treat verboseDeprecations like other booleans
+    it('sets verboseDeprecations when present', function() {
+      const subject = new jasmineUnderTest.Configuration();
+      const orig = subject.verboseDeprecations;
+
+      subject.update({ verboseDeprecations: !orig });
+      expect(subject.verboseDeprecations).toEqual(!orig);
+
+      subject.update({ verboseDeprecations: orig });
+      expect(subject.verboseDeprecations).toEqual(orig);
+
+      // For backwards compatibility, explicitly setting to undefined should
+      // work. Undefined isn't officially valid but gets treated like false.
+      subject.update({ verboseDeprecations: undefined });
+      expect(subject.verboseDeprecations).toBeUndefined();
+    });
+
+    it('sets specFilter when truthy', function() {
+      const subject = new jasmineUnderTest.Configuration();
+      const orig = subject.specFilter;
+
+      subject.update({ specFilter: undefined });
+      expect(subject.specFilter).toBe(orig);
+
+      subject.update({ specFilter: false });
+      expect(subject.specFilter).toBe(orig);
+
+      function newSpecFilter() {}
+      subject.update({ specFilter: newSpecFilter });
+      expect(subject.specFilter).toBe(newSpecFilter);
+    });
+
+    it('sets seed when not undefined', function() {
+      const subject = new jasmineUnderTest.Configuration();
+
+      subject.update({ seed: undefined });
+      expect(subject.seed).toBeNull();
+
+      subject.update({ seed: 1234 });
+      expect(subject.seed).toEqual(1234);
+
+      subject.update({ seed: null });
+      expect(subject.seed).toBeNull();
+    });
+  });
+});

spec/core/DelayedFunctionSchedulerSpec.js

@@ -86,12 +86,13 @@ describe('DelayedFunctionScheduler', function() {
   it('increments scheduled fns ids unless one is passed', function() {
     const scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
 
-    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(1);
-    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(2);
+    const initial = scheduler.scheduleFunction(function() {}, 0);
+    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(initial + 1);
+    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(initial + 2);
     expect(scheduler.scheduleFunction(function() {}, 0, [], false, 123)).toBe(
       123
     );
-    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(3);
+    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(initial + 3);
   });
 
   it('#removeFunctionWithId removes a previously scheduled function with a given id', function() {
@@ -264,6 +265,42 @@ describe('DelayedFunctionScheduler', function() {
     expect(fn).toHaveBeenCalled();
   });
 
+  it('runs the next scheduled funtion', function() {
+    const scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
+    const fn = jasmine.createSpy('fn');
+    const tickSpy = jasmine.createSpy('tick');
+
+    scheduler.scheduleFunction(fn, 10, [], false, 'foo');
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.runNextQueuedFunction(tickSpy);
+
+    expect(fn).toHaveBeenCalled();
+    expect(tickSpy).toHaveBeenCalledWith(10);
+  });
+
+  it('runs the only a single scheduled funtion in a time slot', function() {
+    const scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
+    const fn1 = jasmine.createSpy('fn');
+    const fn2 = jasmine.createSpy('fn2');
+    const tickSpy = jasmine.createSpy('tick');
+
+    scheduler.scheduleFunction(fn1, 10, [], false, 'foo1');
+    scheduler.scheduleFunction(fn2, 10, [], false, 'foo2');
+
+    scheduler.runNextQueuedFunction(tickSpy);
+
+    expect(fn1).toHaveBeenCalled();
+    expect(fn2).not.toHaveBeenCalled();
+    expect(tickSpy).toHaveBeenCalledWith(10);
+
+    tickSpy.calls.reset();
+    scheduler.runNextQueuedFunction(tickSpy);
+    expect(fn2).toHaveBeenCalled();
+    expect(tickSpy).toHaveBeenCalledWith(0);
+  });
+
   it('updates the mockDate per scheduled time', function() {
     const scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       tickDate = jasmine.createSpy('tickDate');
@@ -277,6 +314,28 @@ describe('DelayedFunctionScheduler', function() {
     expect(tickDate).toHaveBeenCalledWith(1);
   });
 
+  it('does not conflict with native timer IDs', function() {
+    const NODE_JS =
+      typeof process !== 'undefined' &&
+      process.versions &&
+      typeof process.versions.node === 'string';
+    if (NODE_JS) {
+      pending('numeric timer ID conflicts only relevant for browsers.');
+    }
+    const nativeTimeoutId = setTimeout(function() {}, 100);
+
+    const scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
+    const fn = jasmine.createSpy('fn');
+
+    for (let i = 0; i < nativeTimeoutId; i++) {
+      scheduler.scheduleFunction(fn, 0, [], false);
+    }
+    scheduler.removeFunctionWithId(nativeTimeoutId);
+    scheduler.tick(1);
+
+    expect(fn).toHaveBeenCalledTimes(nativeTimeoutId);
+  });
+
   describe('ticking inside a scheduled function', function() {
     let clock;
 

spec/core/EnvSpec.js

@@ -205,7 +205,6 @@ describe('Env', function() {
 
     it('throws an error when given arguments', function() {
       expect(function() {
-        // eslint-disable-next-line no-unused-vars
         env.describe('done method', function(done) {});
       }).toThrowError('describe does not expect any arguments');
     });
@@ -626,9 +625,12 @@ describe('Env', function() {
         'popListener',
         'removeOverrideListener'
       ]);
-      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
       env.cleanup_();
-      env = new jasmineUnderTest.Env();
+      env = new jasmineUnderTest.Env({
+        GlobalErrors: function() {
+          return globalErrors;
+        }
+      });
       expect(globalErrors.install).toHaveBeenCalled();
     });
   });
@@ -642,9 +644,13 @@ describe('Env', function() {
         'popListener',
         'removeOverrideListener'
       ]);
-      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
       env.cleanup_();
-      env = new jasmineUnderTest.Env({ suppressLoadErrors: true });
+      env = new jasmineUnderTest.Env({
+        suppressLoadErrors: true,
+        GlobalErrors: function() {
+          return globalErrors;
+        }
+      });
       expect(globalErrors.install).not.toHaveBeenCalled();
       env.execute();
       expect(globalErrors.install).toHaveBeenCalled();

spec/core/ExceptionFormatterSpec.js

@@ -153,12 +153,33 @@ describe('ExceptionFormatter', function() {
       );
     });
 
+    it('filters Jasmine stack frames with Firefox async annotations', function() {
+      const error = {
+        stack:
+          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+          'promise callback*fn1@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
+          'setTimeout handler*fn2@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
+          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
+      };
+      const subject = new jasmineUnderTest.ExceptionFormatter({
+        jasmineFile: 'http://localhost:8888/__jasmine__/jasmine.js'
+      });
+      const result = subject.stack(error);
+      expect(result).toEqual(
+        'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+          '<Jasmine>\n' +
+          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
+      );
+    });
+
     it('filters Jasmine stack frames in this environment', function() {
       const error = new Error('an error');
       const subject = new jasmineUnderTest.ExceptionFormatter({
         jasmineFile: jasmine.util.jasmineFile()
       });
       const result = subject.stack(error);
+      jasmine.debugLog('Original stack trace: ' + error.stack);
+      jasmine.debugLog('Filtered stack trace: ' + result);
       const lines = result.split('\n');
 
       if (lines[0].match(/an error/)) {

spec/core/GlobalErrorsSpec.js

@@ -1,14 +1,17 @@
 describe('GlobalErrors', function() {
   it('calls the added handler on error', function() {
-    const fakeGlobal = browserGlobal();
+    const globals = browserGlobals();
     const handler = jasmine.createSpy('errorHandler');
-    const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
 
     errors.install();
     errors.pushListener(handler);
 
     const error = new Error('nope');
-    dispatchErrorEvent(fakeGlobal, { error });
+    dispatchEvent(globals.listeners, 'error', { error });
 
     expect(handler).toHaveBeenCalledWith(
       jasmine.is(error),
@@ -17,17 +20,20 @@ describe('GlobalErrors', function() {
   });
 
   it('is not affected by overriding global.onerror', function() {
-    const fakeGlobal = browserGlobal();
+    const globals = browserGlobals();
     const handler = jasmine.createSpy('errorHandler');
-    const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
 
     errors.install();
     errors.pushListener(handler);
 
-    fakeGlobal.onerror = () => {};
+    globals.global.onerror = () => {};
 
     const error = new Error('nope');
-    dispatchErrorEvent(fakeGlobal, { error });
+    dispatchEvent(globals.listeners, 'error', { error });
 
     expect(handler).toHaveBeenCalledWith(
       jasmine.is(error),
@@ -36,17 +42,20 @@ describe('GlobalErrors', function() {
   });
 
   it('only calls the most recent handler', function() {
-    const fakeGlobal = browserGlobal();
+    const globals = browserGlobals();
     const handler1 = jasmine.createSpy('errorHandler1');
     const handler2 = jasmine.createSpy('errorHandler2');
-    const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
 
     errors.install();
     errors.pushListener(handler1);
     errors.pushListener(handler2);
 
     const error = new Error('nope');
-    dispatchErrorEvent(fakeGlobal, { error });
+    dispatchEvent(globals.listeners, 'error', { error });
 
     expect(handler1).not.toHaveBeenCalled();
     expect(handler2).toHaveBeenCalledWith(
@@ -56,10 +65,13 @@ describe('GlobalErrors', function() {
   });
 
   it('calls previous handlers when one is removed', function() {
-    const fakeGlobal = browserGlobal();
+    const globals = browserGlobals();
     const handler1 = jasmine.createSpy('errorHandler1');
     const handler2 = jasmine.createSpy('errorHandler2');
-    const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
 
     errors.install();
     errors.pushListener(handler1);
@@ -68,7 +80,7 @@ describe('GlobalErrors', function() {
     errors.popListener(handler2);
 
     const error = new Error('nope');
-    dispatchErrorEvent(fakeGlobal, { error });
+    dispatchEvent(globals.listeners, 'error', { error });
 
     expect(handler1).toHaveBeenCalledWith(
       jasmine.is(error),
@@ -85,26 +97,32 @@ describe('GlobalErrors', function() {
   });
 
   it('uninstalls itself', function() {
-    const fakeGlobal = browserGlobal();
-    const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const globals = browserGlobals();
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
     function unrelatedListener() {}
 
     errors.install();
-    fakeGlobal.addEventListener('error', unrelatedListener);
+    globals.global.addEventListener('error', unrelatedListener);
     errors.uninstall();
 
-    expect(fakeGlobal.listeners_.error).toEqual([unrelatedListener]);
+    expect(globals.listeners.error).toEqual([unrelatedListener]);
   });
 
   it('rethrows the original error when there is no handler', function() {
-    const fakeGlobal = browserGlobal();
-    const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const globals = browserGlobals();
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
     const originalError = new Error('nope');
 
     errors.install();
 
     try {
-      dispatchErrorEvent(fakeGlobal, { error: originalError });
+      dispatchEvent(globals.listeners, 'error', { error: originalError });
     } catch (e) {
       expect(e).toBe(originalError);
     }
@@ -113,191 +131,281 @@ describe('GlobalErrors', function() {
   });
 
   it('reports uncaught exceptions in node.js', function() {
-    const fakeGlobal = {
-        process: {
-          on: jasmine.createSpy('process.on'),
-          removeListener: jasmine.createSpy('process.removeListener'),
-          listeners: jasmine
-            .createSpy('process.listeners')
-            .and.returnValue(['foo']),
-          removeAllListeners: jasmine.createSpy('process.removeAllListeners')
-        }
-      },
-      handler = jasmine.createSpy('errorHandler'),
-      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+    const globals = nodeGlobals();
+    const errors = new jasmineUnderTest.GlobalErrors(
+      globals.global,
+      () => ({})
+    );
+    const handler = jasmine.createSpy('errorHandler');
+    function originalHandler() {}
+    globals.listeners.uncaughtException = [originalHandler];
 
     errors.install();
-    expect(fakeGlobal.process.on).toHaveBeenCalledWith(
-      'uncaughtException',
+    expect(globals.listeners.uncaughtException).toEqual([
       jasmine.any(Function)
-    );
-    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith(
-      'uncaughtException'
-    );
-    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith(
-      'uncaughtException'
-    );
+    ]);
+    expect(globals.listeners.uncaughtException).not.toEqual([
+      originalHandler()
+    ]);
 
     errors.pushListener(handler);
 
-    const addedListener = fakeGlobal.process.on.calls.argsFor(0)[1];
-    addedListener(new Error('bar'));
+    dispatchEvent(globals.listeners, 'uncaughtException', new Error('bar'));
 
-    expect(handler).toHaveBeenCalledWith(new Error('bar'));
+    expect(handler).toHaveBeenCalledWith(new Error('bar'), undefined);
     expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe(
       'Uncaught exception: Error: bar'
     );
 
     errors.uninstall();
 
-    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith(
-      'uncaughtException',
-      addedListener
-    );
-    expect(fakeGlobal.process.on).toHaveBeenCalledWith(
-      'uncaughtException',
-      'foo'
-    );
+    expect(globals.listeners.uncaughtException).toEqual([originalHandler]);
   });
 
   describe('Reporting unhandled promise rejections in node.js', function() {
     it('reports rejections with `Error` reasons', function() {
-      const fakeGlobal = {
-          process: {
-            on: jasmine.createSpy('process.on'),
-            removeListener: jasmine.createSpy('process.removeListener'),
-            listeners: jasmine
-              .createSpy('process.listeners')
-              .and.returnValue(['foo']),
-            removeAllListeners: jasmine.createSpy('process.removeAllListeners')
-          }
-        },
-        handler = jasmine.createSpy('errorHandler'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const globals = nodeGlobals();
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
+      const handler = jasmine.createSpy('errorHandler');
+      function originalHandler() {}
+      globals.listeners.unhandledRejection = [originalHandler];
 
       errors.install();
-      expect(fakeGlobal.process.on).toHaveBeenCalledWith(
-        'unhandledRejection',
+      expect(globals.listeners.unhandledRejection).toEqual([
         jasmine.any(Function)
-      );
-      expect(fakeGlobal.process.listeners).toHaveBeenCalledWith(
-        'unhandledRejection'
-      );
-      expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith(
-        'unhandledRejection'
-      );
+      ]);
+      expect(globals.listeners.unhandledRejection).not.toEqual([
+        originalHandler()
+      ]);
 
       errors.pushListener(handler);
 
-      const addedListener = fakeGlobal.process.on.calls.argsFor(1)[1];
-      addedListener(new Error('bar'));
+      dispatchEvent(globals.listeners, 'unhandledRejection', new Error('bar'));
 
-      expect(handler).toHaveBeenCalledWith(new Error('bar'));
+      expect(handler).toHaveBeenCalledWith(new Error('bar'), undefined);
       expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe(
         'Unhandled promise rejection: Error: bar'
       );
 
       errors.uninstall();
 
-      expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith(
-        'unhandledRejection',
-        addedListener
-      );
-      expect(fakeGlobal.process.on).toHaveBeenCalledWith(
-        'unhandledRejection',
-        'foo'
-      );
+      expect(globals.listeners.unhandledRejection).toEqual([originalHandler]);
     });
 
     it('reports rejections with non-`Error` reasons', function() {
-      const fakeGlobal = {
-          process: {
-            on: jasmine.createSpy('process.on'),
-            removeListener: function() {},
-            listeners: function() {
-              return [];
-            },
-            removeAllListeners: function() {}
-          }
-        },
-        handler = jasmine.createSpy('errorHandler'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const globals = nodeGlobals();
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
+      const handler = jasmine.createSpy('errorHandler');
 
       errors.install();
       errors.pushListener(handler);
 
-      expect(fakeGlobal.process.on.calls.argsFor(1)[0]).toEqual(
-        'unhandledRejection'
-      );
-      const addedListener = fakeGlobal.process.on.calls.argsFor(1)[1];
-      addedListener(17);
+      dispatchEvent(globals.listeners, 'unhandledRejection', 17);
 
       expect(handler).toHaveBeenCalledWith(
         new Error(
           'Unhandled promise rejection: 17\n' +
             '(Tip: to get a useful stack trace, use ' +
             'Promise.reject(new Error(...)) instead of Promise.reject(...).)'
-        )
+        ),
+        undefined
       );
     });
 
     it('reports rejections with no reason provided', function() {
-      const fakeGlobal = {
-          process: {
-            on: jasmine.createSpy('process.on'),
-            removeListener: function() {},
-            listeners: function() {
-              return [];
-            },
-            removeAllListeners: function() {}
-          }
-        },
-        handler = jasmine.createSpy('errorHandler'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const globals = nodeGlobals();
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
+      const handler = jasmine.createSpy('errorHandler');
 
       errors.install();
       errors.pushListener(handler);
 
-      expect(fakeGlobal.process.on.calls.argsFor(1)[0]).toEqual(
-        'unhandledRejection'
-      );
-      const addedListener = fakeGlobal.process.on.calls.argsFor(1)[1];
-      addedListener(undefined);
+      dispatchEvent(globals.listeners, 'unhandledRejection', undefined);
 
       expect(handler).toHaveBeenCalledWith(
         new Error(
           'Unhandled promise rejection with no error or message\n' +
             '(Tip: to get a useful stack trace, use ' +
             'Promise.reject(new Error(...)) instead of Promise.reject().)'
-        )
+        ),
+        undefined
       );
     });
+
+    describe('When detectLateRejectionHandling is true', function() {
+      let globals, errors;
+
+      beforeEach(function() {
+        globals = nodeGlobals();
+        errors = new jasmineUnderTest.GlobalErrors(globals.global, () => ({
+          detectLateRejectionHandling: true
+        }));
+      });
+
+      it('subscribes and unsubscribes from the rejectionHandled event', function() {
+        function originalHandler() {}
+        globals.global.process.on('rejectionHandled', originalHandler);
+        errors.install();
+
+        expect(globals.listeners.rejectionHandled).toEqual([
+          jasmine.any(Function)
+        ]);
+        expect(globals.listeners.rejectionHandled).not.toEqual([
+          originalHandler
+        ]);
+
+        errors.uninstall();
+        expect(globals.listeners.rejectionHandled).toEqual([originalHandler]);
+      });
+
+      describe("When the unhandledRejection event doesn't have a promise", function() {
+        it('immediately reports the rejection', function() {
+          const handler = jasmine.createSpy('errorHandler');
+
+          errors.install();
+          errors.pushListener(handler);
+
+          dispatchEvent(
+            globals.listeners,
+            'unhandledRejection',
+            new Error('nope'),
+            undefined
+          );
+
+          expect(handler).toHaveBeenCalledWith(new Error('nope'), undefined);
+          expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe(
+            'Unhandled promise rejection: Error: nope'
+          );
+        });
+      });
+
+      describe('When the unhandledRejection event has a promise property', function() {
+        it('does not immediately report the rejection', function() {
+          const handler = jasmine.createSpy('errorHandler');
+
+          errors.install();
+          errors.pushListener(handler);
+
+          const promise = Promise.reject('nope');
+          promise.catch(() => {});
+          dispatchEvent(
+            globals.listeners,
+            'unhandledRejection',
+            'nope',
+            promise
+          );
+
+          expect(handler).not.toHaveBeenCalled();
+        });
+
+        describe('When reportUnhandledRejections is called', function() {
+          it('reports rejections that have not been handled', function() {
+            const handler = jasmine.createSpy('errorHandler');
+            errors.install();
+            errors.pushListener(handler);
+
+            const reason = new Error('nope');
+            const promise = Promise.reject(reason);
+            promise.catch(() => {});
+            dispatchEvent(
+              globals.listeners,
+              'unhandledRejection',
+              reason,
+              promise
+            );
+            errors.reportUnhandledRejections();
+
+            expect(handler).toHaveBeenCalledWith(new Error('nope'), undefined);
+            expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe(
+              'Unhandled promise rejection: Error: nope'
+            );
+          });
+
+          it('does not report rejections that have been handled', function() {
+            const handler = jasmine.createSpy('errorHandler');
+            errors.install();
+            errors.pushListener(handler);
+
+            const reason = new Error('nope');
+            const promise = Promise.reject(reason);
+            promise.catch(() => {});
+            dispatchEvent(
+              globals.listeners,
+              'unhandledRejection',
+              reason,
+              promise
+            );
+            dispatchEvent(globals.listeners, 'rejectionHandled', promise);
+            errors.reportUnhandledRejections();
+
+            expect(handler).not.toHaveBeenCalled();
+          });
+
+          it('does not report the same rejection on subsequent calls', function() {
+            const handler = jasmine.createSpy('errorHandler');
+
+            errors.install();
+            errors.pushListener(handler);
+
+            const promise = Promise.reject('nope');
+            promise.catch(() => {});
+            dispatchEvent(
+              globals.listeners,
+              'unhandledRejection',
+              'nope',
+              promise
+            );
+            errors.reportUnhandledRejections();
+            expect(handler).toHaveBeenCalled();
+            handler.calls.reset();
+
+            errors.reportUnhandledRejections();
+            expect(handler).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
   });
 
   describe('Reporting unhandled promise rejections in the browser', function() {
     it('subscribes and unsubscribes from the unhandledrejection event', function() {
-      const fakeGlobal = browserGlobal();
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const globals = browserGlobals();
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
-      expect(fakeGlobal.listeners_.unhandledrejection).toEqual([
+      expect(globals.listeners.unhandledrejection).toEqual([
         jasmine.any(Function)
       ]);
 
       errors.uninstall();
-      expect(fakeGlobal.listeners_.unhandledrejection).toEqual([]);
+      expect(globals.listeners.unhandledrejection).toEqual([]);
     });
 
     it('reports rejections whose reason is a string', function() {
-      const fakeGlobal = browserGlobal();
+      const globals = browserGlobals();
       const handler = jasmine.createSpy('errorHandler');
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
       errors.pushListener(handler);
 
       const event = { reason: 'nope' };
-      dispatchUnhandledRejectionEvent(fakeGlobal, event);
+      dispatchEvent(globals.listeners, 'unhandledrejection', event);
 
       expect(handler).toHaveBeenCalledWith(
         'Unhandled promise rejection: nope',
@@ -306,16 +414,19 @@ describe('GlobalErrors', function() {
     });
 
     it('reports rejections whose reason is an Error', function() {
-      const fakeGlobal = browserGlobal();
+      const globals = browserGlobals();
       const handler = jasmine.createSpy('errorHandler');
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
       errors.pushListener(handler);
 
       const reason = new Error('bar');
       const event = { reason };
-      dispatchUnhandledRejectionEvent(fakeGlobal, event);
+      dispatchEvent(globals.listeners, 'unhandledrejection', event);
 
       expect(handler).toHaveBeenCalledWith(
         jasmine.objectContaining({
@@ -326,21 +437,178 @@ describe('GlobalErrors', function() {
         event
       );
     });
+
+    describe('When detectLateRejectionHandling is true', function() {
+      let globals, errors;
+
+      beforeEach(function() {
+        globals = browserGlobals();
+        errors = new jasmineUnderTest.GlobalErrors(globals.global, () => ({
+          detectLateRejectionHandling: true
+        }));
+      });
+
+      it('subscribes and unsubscribes from the rejectionhandled event', function() {
+        errors.install();
+        expect(globals.listeners.rejectionhandled).toEqual([
+          jasmine.any(Function)
+        ]);
+
+        errors.uninstall();
+        expect(globals.listeners.rejectionhandled).toEqual([]);
+      });
+
+      describe("When the unhandledrejection event doesn't have a promise property", function() {
+        it('immediately reports the rejection', function() {
+          const handler = jasmine.createSpy('errorHandler');
+
+          errors.install();
+          errors.pushListener(handler);
+
+          const event = { reason: 'nope' };
+          dispatchEvent(globals.listeners, 'unhandledrejection', event);
+
+          expect(handler).toHaveBeenCalledWith(
+            'Unhandled promise rejection: nope',
+            event
+          );
+        });
+      });
+
+      describe('When the unhandledrejection event has a promise property', function() {
+        it('does not immediately report the rejection', function() {
+          const handler = jasmine.createSpy('errorHandler');
+
+          errors.install();
+          errors.pushListener(handler);
+
+          const promise = Promise.reject('nope');
+          promise.catch(() => {});
+          dispatchEvent(globals.listeners, 'unhandledrejection', {
+            reason: 'nope',
+            promise
+          });
+
+          expect(handler).not.toHaveBeenCalled();
+        });
+
+        describe('When reportUnhandledRejections is called', function() {
+          it('reports rejections that have not been handled', function() {
+            const handler = jasmine.createSpy('errorHandler');
+            errors.install();
+            errors.pushListener(handler);
+
+            const promise = Promise.reject('nope');
+            promise.catch(() => {});
+            dispatchEvent(globals.listeners, 'unhandledrejection', {
+              reason: 'nope',
+              promise
+            });
+            errors.reportUnhandledRejections();
+
+            expect(handler).toHaveBeenCalledWith(
+              'Unhandled promise rejection: nope',
+              { reason: 'nope', promise }
+            );
+          });
+
+          it('does not report rejections that have been handled', function() {
+            const handler = jasmine.createSpy('errorHandler');
+            errors.install();
+            errors.pushListener(handler);
+
+            const promise = Promise.reject('nope');
+            promise.catch(() => {});
+            dispatchEvent(globals.listeners, 'unhandledrejection', {
+              reason: 'nope',
+              promise
+            });
+            dispatchEvent(globals.listeners, 'rejectionhandled', { promise });
+            errors.reportUnhandledRejections();
+
+            expect(handler).not.toHaveBeenCalled();
+          });
+
+          it('does not report the same rejection on subsequent calls', function() {
+            const handler = jasmine.createSpy('errorHandler');
+
+            errors.install();
+            errors.pushListener(handler);
+
+            const promise = Promise.reject('nope');
+            promise.catch(() => {});
+            dispatchEvent(globals.listeners, 'unhandledrejection', {
+              reason: 'nope',
+              promise
+            });
+            errors.reportUnhandledRejections();
+            expect(handler).toHaveBeenCalled();
+            handler.calls.reset();
+
+            errors.reportUnhandledRejections();
+            expect(handler).not.toHaveBeenCalled();
+          });
+        });
+      });
+    });
+  });
+
+  describe('Reporting uncaught exceptions in node.js', function() {
+    it('prepends a descriptive message when the error is not an `Error`', function() {
+      const globals = nodeGlobals();
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
+      const handler = jasmine.createSpy('errorHandler');
+
+      errors.install();
+      errors.pushListener(handler);
+
+      dispatchEvent(globals.listeners, 'uncaughtException', 17);
+
+      expect(handler).toHaveBeenCalledWith(
+        new Error('Uncaught exception: 17'),
+        undefined
+      );
+    });
+
+    it('substitutes a descriptive message when the error is falsy', function() {
+      const globals = nodeGlobals();
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
+      const handler = jasmine.createSpy('errorHandler');
+
+      errors.install();
+      errors.pushListener(handler);
+
+      dispatchEvent(globals.listeners, 'uncaughtException', undefined);
+
+      expect(handler).toHaveBeenCalledWith(
+        new Error('Uncaught exception with no error or message'),
+        undefined
+      );
+    });
   });
 
   describe('#setOverrideListener', function() {
     it('overrides the existing handlers in browsers until removed', function() {
-      const fakeGlobal = browserGlobal();
+      const globals = browserGlobals();
       const handler0 = jasmine.createSpy('handler0');
       const handler1 = jasmine.createSpy('handler1');
       const overrideHandler = jasmine.createSpy('overrideHandler');
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
       errors.pushListener(handler0);
       errors.setOverrideListener(overrideHandler, () => {});
       errors.pushListener(handler1);
-      dispatchErrorEvent(fakeGlobal, { error: 'foo' });
+      dispatchEvent(globals.listeners, 'error', { error: 'foo' });
 
       expect(overrideHandler).toHaveBeenCalledWith('foo');
       expect(handler0).not.toHaveBeenCalled();
@@ -349,55 +617,48 @@ describe('GlobalErrors', function() {
       errors.removeOverrideListener();
 
       const event = { error: 'baz' };
-      dispatchErrorEvent(fakeGlobal, event);
+      dispatchEvent(globals.listeners, 'error', event);
       expect(overrideHandler).not.toHaveBeenCalledWith('baz');
       expect(handler1).toHaveBeenCalledWith('baz', event);
     });
 
     it('overrides the existing handlers in Node until removed', function() {
-      const globalEventListeners = {};
-      const fakeGlobal = {
-        process: {
-          on: (name, listener) => (globalEventListeners[name] = listener),
-          removeListener: () => {},
-          listeners: name => globalEventListeners[name],
-          removeAllListeners: name => (globalEventListeners[name] = [])
-        }
-      };
+      const globals = nodeGlobals();
       const handler0 = jasmine.createSpy('handler0');
       const handler1 = jasmine.createSpy('handler1');
       const overrideHandler = jasmine.createSpy('overrideHandler');
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
       errors.pushListener(handler0);
       errors.setOverrideListener(overrideHandler);
       errors.pushListener(handler1);
 
-      globalEventListeners['uncaughtException'](new Error('foo'));
+      dispatchEvent(globals.listeners, 'uncaughtException', new Error('foo'));
 
       expect(overrideHandler).toHaveBeenCalledWith(new Error('foo'));
       expect(handler0).not.toHaveBeenCalled();
       expect(handler1).not.toHaveBeenCalled();
 
+      overrideHandler.calls.reset();
       errors.removeOverrideListener();
 
-      globalEventListeners['uncaughtException'](new Error('bar'));
-      expect(overrideHandler).not.toHaveBeenCalledWith(new Error('bar'));
-      expect(handler1).toHaveBeenCalledWith(new Error('bar'));
+      dispatchEvent(globals.listeners, 'uncaughtException', new Error('bar'));
+      expect(overrideHandler).not.toHaveBeenCalled();
+      expect(handler1).toHaveBeenCalledWith(new Error('bar'), undefined);
     });
 
     it('handles unhandled promise rejections in browsers', function() {
-      const globalEventListeners = {};
-      const fakeGlobal = {
-        addEventListener(name, listener) {
-          globalEventListeners[name] = listener;
-        },
-        removeEventListener() {}
-      };
+      const globals = browserGlobals();
       const handler = jasmine.createSpy('handler');
       const overrideHandler = jasmine.createSpy('overrideHandler');
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
       errors.pushListener(handler);
@@ -405,7 +666,7 @@ describe('GlobalErrors', function() {
 
       const reason = new Error('bar');
 
-      globalEventListeners['unhandledrejection']({ reason: reason });
+      dispatchEvent(globals.listeners, 'unhandledrejection', { reason });
 
       expect(overrideHandler).toHaveBeenCalledWith(
         jasmine.objectContaining({
@@ -418,32 +679,21 @@ describe('GlobalErrors', function() {
     });
 
     it('handles unhandled promise rejections in Node', function() {
-      const globalEventListeners = {};
-      const fakeGlobal = {
-        process: {
-          on(name, listener) {
-            globalEventListeners[name] = listener;
-          },
-          removeListener() {},
-          listeners(name) {
-            return globalEventListeners[name];
-          },
-          removeAllListeners(name) {
-            globalEventListeners[name] = null;
-          }
-        }
-      };
+      const globals = nodeGlobals();
       const handler0 = jasmine.createSpy('handler0');
       const handler1 = jasmine.createSpy('handler1');
       const overrideHandler = jasmine.createSpy('overrideHandler');
-      const errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      const errors = new jasmineUnderTest.GlobalErrors(
+        globals.global,
+        () => ({})
+      );
 
       errors.install();
       errors.pushListener(handler0);
       errors.setOverrideListener(overrideHandler, () => {});
       errors.pushListener(handler1);
 
-      globalEventListeners['unhandledRejection'](new Error('nope'));
+      dispatchEvent(globals.listeners, 'unhandledRejection', new Error('nope'));
 
       expect(overrideHandler).toHaveBeenCalledWith(new Error('nope'));
       expect(handler0).not.toHaveBeenCalled();
@@ -451,7 +701,7 @@ describe('GlobalErrors', function() {
     });
 
     it('throws if there is already an override handler', function() {
-      const errors = new jasmineUnderTest.GlobalErrors(browserGlobal());
+      const errors = new jasmineUnderTest.GlobalErrors(browserGlobals().global);
 
       errors.setOverrideListener(() => {}, () => {});
       expect(function() {
@@ -463,7 +713,7 @@ describe('GlobalErrors', function() {
   describe('#removeOverrideListener', function() {
     it("calls the handler's onRemove callback", function() {
       const onRemove = jasmine.createSpy('onRemove');
-      const errors = new jasmineUnderTest.GlobalErrors(browserGlobal());
+      const errors = new jasmineUnderTest.GlobalErrors(browserGlobals().global);
 
       errors.setOverrideListener(() => {}, onRemove);
       errors.removeOverrideListener();
@@ -472,43 +722,69 @@ describe('GlobalErrors', function() {
     });
 
     it('does not throw if there is no handler', function() {
-      const errors = new jasmineUnderTest.GlobalErrors(browserGlobal());
+      const errors = new jasmineUnderTest.GlobalErrors(browserGlobals().global);
 
       expect(() => errors.removeOverrideListener()).not.toThrow();
     });
   });
 
-  function browserGlobal() {
+  function browserGlobals() {
+    const listeners = {
+      error: [],
+      unhandledrejection: [],
+      rejectionhandled: []
+    };
     return {
-      listeners_: { error: [], unhandledrejection: [] },
-      addEventListener(eventName, listener) {
-        this.listeners_[eventName].push(listener);
-      },
-      removeEventListener(eventName, listener) {
-        this.listeners_[eventName] = this.listeners_[eventName].filter(
-          l => l !== listener
-        );
+      listeners,
+      global: {
+        addEventListener(eventName, listener) {
+          listeners[eventName].push(listener);
+        },
+        removeEventListener(eventName, listener) {
+          listeners[eventName] = listeners[eventName].filter(
+            l => l !== listener
+          );
+        }
       }
     };
   }
 
-  function dispatchErrorEvent(global, event) {
-    expect(global.listeners_.error.length)
-      .withContext('number of error listeners')
-      .toBeGreaterThan(0);
-
-    for (const l of global.listeners_.error) {
-      l(event);
-    }
+  function nodeGlobals() {
+    const listeners = {
+      uncaughtException: [],
+      unhandledRejection: [],
+      rejectionHandled: []
+    };
+    return {
+      listeners,
+      global: {
+        process: {
+          on(eventName, listener) {
+            listeners[eventName].push(listener);
+          },
+          removeListener(eventName, listener) {
+            listeners[eventName] = listeners[eventName].filter(
+              l => l !== listener
+            );
+          },
+          removeAllListeners(eventName) {
+            listeners[eventName] = [];
+          },
+          listeners(eventName) {
+            return listeners[eventName];
+          }
+        }
+      }
+    };
   }
 
-  function dispatchUnhandledRejectionEvent(global, event) {
-    expect(global.listeners_.unhandledrejection.length)
-      .withContext('number of unhandledrejection listeners')
+  function dispatchEvent(listeners, eventName, ...args) {
+    expect(listeners[eventName].length)
+      .withContext(`number of ${eventName} listeners`)
       .toBeGreaterThan(0);
 
-    for (const l of global.listeners_.unhandledrejection) {
-      l(event);
+    for (const l of listeners[eventName]) {
+      l.apply(null, args);
     }
   }
 });

spec/core/PrettyPrintSpec.js

@@ -164,7 +164,7 @@ describe('PrettyPrinter', function() {
       "Object({ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined })"
     );
     expect(pp({ foo: function() {}, bar: [1, 2, 3] })).toEqual(
-      'Object({ foo: Function, bar: [ 1, 2, 3 ] })'
+      "Object({ foo: Function 'foo', bar: [ 1, 2, 3 ] })"
     );
   });
 
@@ -450,7 +450,7 @@ describe('PrettyPrinter', function() {
     };
 
     expect(pp(objFromOtherContext)).toEqual(
-      "Object({ foo: 'bar', toString: Function })"
+      "Object({ foo: 'bar', toString: Function 'toString' })"
     );
   });
 
@@ -477,6 +477,17 @@ describe('PrettyPrinter', function() {
     expect(pp(a)).toEqual('<anonymous>({  })');
   });
 
+  it('stringifies functions with names', function() {
+    const pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp(foo)).toEqual("Function 'foo'");
+    function foo() {}
+  });
+
+  it('stringifies functions without names', function() {
+    const pp = jasmineUnderTest.makePrettyPrinter();
+    expect(pp(function() {})).toEqual('Function');
+  });
+
   it('should handle objects with null prototype', function() {
     const pp = jasmineUnderTest.makePrettyPrinter();
     const obj = Object.create(null);

spec/core/QueueRunnerSpec.js

@@ -1,4 +1,20 @@
 describe('QueueRunner', function() {
+  it('validates that queueableFns are truthy', function() {
+    expect(function() {
+      new jasmineUnderTest.QueueRunner({
+        queueableFns: [undefined]
+      });
+    }).toThrowError('Received a falsy queueableFn');
+  });
+
+  it('validates that queueableFns have fn properties', function() {
+    expect(function() {
+      new jasmineUnderTest.QueueRunner({
+        queueableFns: [{ fn: undefined }]
+      });
+    }).toThrowError('Received a queueableFn with no fn');
+  });
+
   it("runs all the functions it's passed", function() {
     const calls = [],
       queueableFn1 = { fn: jasmine.createSpy('fn1') },
@@ -239,7 +255,6 @@ describe('QueueRunner', function() {
 
     it("sets a timeout if requested for asynchronous functions so they don't go on forever", function() {
       const timeout = 3,
-        // eslint-disable-next-line no-unused-vars
         beforeFn = { fn: function(done) {}, type: 'before', timeout: timeout },
         queueableFn = { fn: jasmine.createSpy('fn'), type: 'queueable' },
         onComplete = jasmine.createSpy('onComplete'),
@@ -287,7 +302,6 @@ describe('QueueRunner', function() {
     });
 
     it('by default does not set a timeout for asynchronous functions', function() {
-      // eslint-disable-next-line no-unused-vars
       const beforeFn = { fn: function(done) {} },
         queueableFn = { fn: jasmine.createSpy('fn') },
         onComplete = jasmine.createSpy('onComplete'),
@@ -310,7 +324,6 @@ describe('QueueRunner', function() {
 
     it('clears the timeout when an async function throws an exception, to prevent additional exception reporting', function() {
       const queueableFn = {
-          // eslint-disable-next-line no-unused-vars
           fn: function(done) {
             throw new Error('error!');
           }
@@ -409,7 +422,6 @@ describe('QueueRunner', function() {
 
     it('continues running functions when an exception is thrown in async code without timing out', function() {
       const queueableFn = {
-          // eslint-disable-next-line no-unused-vars
           fn: function(done) {
             throwAsync();
           },
@@ -459,6 +471,31 @@ describe('QueueRunner', function() {
       expect(nextQueueableFn.fn).toHaveBeenCalled();
     });
 
+    it('handles a global error event with a message but no error', function() {
+      const queueableFn = {
+        fn: function(done) {
+          const currentHandler = globalErrors.pushListener.calls.mostRecent()
+            .args[0];
+          currentHandler(undefined, { message: 'nope' });
+        },
+        timeout: 1
+      };
+      const onException = jasmine.createSpy('onException');
+      const globalErrors = {
+        pushListener: jasmine.createSpy('pushListener'),
+        popListener: jasmine.createSpy('popListener')
+      };
+      const queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [queueableFn],
+        onException: onException,
+        globalErrors: globalErrors
+      });
+
+      queueRunner.execute();
+
+      expect(onException).toHaveBeenCalledWith('nope');
+    });
+
     it('handles exceptions thrown while waiting for the stack to clear', function() {
       const queueableFn = {
           fn: function(done) {
@@ -492,6 +529,40 @@ describe('QueueRunner', function() {
       clearStack.calls.argsFor(0)[0]();
       expect(onException).toHaveBeenCalledWith(error);
     });
+
+    it('handles a global error event with no error while waiting for the stack to clear', function() {
+      const queueableFn = {
+        fn: function(done) {
+          done();
+        }
+      };
+      const errorListeners = [];
+      const globalErrors = {
+        pushListener: function(f) {
+          errorListeners.push(f);
+        },
+        popListener: function() {
+          errorListeners.pop();
+        }
+      };
+      const clearStack = jasmine.createSpy('clearStack');
+      const onException = jasmine.createSpy('onException');
+      const queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [queueableFn],
+        globalErrors: globalErrors,
+        clearStack: clearStack,
+        onException: onException
+      });
+
+      queueRunner.execute();
+      jasmine.clock().tick();
+      expect(clearStack).toHaveBeenCalled();
+      expect(errorListeners.length).toEqual(1);
+      errorListeners[0](undefined, { message: 'nope' });
+
+      clearStack.calls.argsFor(0)[0]();
+      expect(onException).toHaveBeenCalledWith('nope');
+    });
   });
 
   describe('with a function that returns a promise', function() {
@@ -581,7 +652,6 @@ describe('QueueRunner', function() {
 
     it('issues an error if the function also takes a parameter', function() {
       const queueableFn = {
-          // eslint-disable-next-line no-unused-vars
           fn: function(done) {
             return new StubPromise();
           }
@@ -606,7 +676,6 @@ describe('QueueRunner', function() {
     });
 
     it('issues a more specific error if the function is `async`', function() {
-      // eslint-disable-next-line no-unused-vars
       async function fn(done) {}
       const onException = jasmine.createSpy('onException'),
         queueRunner = new jasmineUnderTest.QueueRunner({
@@ -660,7 +729,6 @@ describe('QueueRunner', function() {
 
   it('continues running the functions even after an exception is thrown in an async spec', function() {
     const queueableFn = {
-        // eslint-disable-next-line no-unused-vars
         fn: function(done) {
           throw new Error('error');
         }

spec/core/ReportDispatcherSpec.js

@@ -12,10 +12,10 @@ describe('ReportDispatcher', function() {
   });
 
   it('dispatches requested methods to added reporters', function() {
-    const queueRunnerFactory = jasmine.createSpy('queueRunner'),
+    const runQueue = jasmine.createSpy('runQueue'),
       dispatcher = new jasmineUnderTest.ReportDispatcher(
         ['foo', 'bar'],
-        queueRunnerFactory
+        runQueue
       ),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       anotherReporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
@@ -25,7 +25,7 @@ describe('ReportDispatcher', function() {
 
     dispatcher.foo(123, 456);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: [
           { fn: jasmine.any(Function) },
@@ -35,7 +35,7 @@ describe('ReportDispatcher', function() {
       })
     );
 
-    let fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    let fns = runQueue.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
     expect(reporter.foo.calls.mostRecent().object).toBe(reporter);
@@ -44,11 +44,11 @@ describe('ReportDispatcher', function() {
     expect(anotherReporter.foo).toHaveBeenCalledWith(123, 456);
     expect(anotherReporter.foo.calls.mostRecent().object).toBe(anotherReporter);
 
-    queueRunnerFactory.calls.reset();
+    runQueue.calls.reset();
 
     dispatcher.bar('a', 'b');
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: [
           { fn: jasmine.any(Function) },
@@ -58,7 +58,7 @@ describe('ReportDispatcher', function() {
       })
     );
 
-    fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns = runQueue.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter.bar).toHaveBeenCalledWith('a', 'b');
 
@@ -67,17 +67,14 @@ describe('ReportDispatcher', function() {
   });
 
   it("does not dispatch to a reporter if the reporter doesn't accept the method", function() {
-    const queueRunnerFactory = jasmine.createSpy('queueRunner'),
-      dispatcher = new jasmineUnderTest.ReportDispatcher(
-        ['foo'],
-        queueRunnerFactory
-      ),
+    const runQueue = jasmine.createSpy('runQueue'),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo'], runQueue),
       reporter = jasmine.createSpyObj('reporter', ['baz']);
 
     dispatcher.addReporter(reporter);
 
     dispatcher.foo(123, 456);
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: []
       })
@@ -85,33 +82,33 @@ describe('ReportDispatcher', function() {
   });
 
   it("allows providing a fallback reporter in case there's no other reporter", function() {
-    const queueRunnerFactory = jasmine.createSpy('queueRunner'),
+    const runQueue = jasmine.createSpy('runQueue'),
       dispatcher = new jasmineUnderTest.ReportDispatcher(
         ['foo', 'bar'],
-        queueRunnerFactory
+        runQueue
       ),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']);
 
     dispatcher.provideFallbackReporter(reporter);
     dispatcher.foo(123, 456);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: [{ fn: jasmine.any(Function) }],
         isReporter: true
       })
     );
 
-    const fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    const fns = runQueue.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
   });
 
   it('does not call fallback reporting methods when another reporter is provided', function() {
-    const queueRunnerFactory = jasmine.createSpy('queueRunner'),
+    const runQueue = jasmine.createSpy('runQueue'),
       dispatcher = new jasmineUnderTest.ReportDispatcher(
         ['foo', 'bar'],
-        queueRunnerFactory
+        runQueue
       ),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       fallbackReporter = jasmine.createSpyObj('otherReporter', ['foo', 'bar']);
@@ -120,38 +117,38 @@ describe('ReportDispatcher', function() {
     dispatcher.addReporter(reporter);
     dispatcher.foo(123, 456);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: [{ fn: jasmine.any(Function) }],
         isReporter: true
       })
     );
 
-    const fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    const fns = runQueue.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
     expect(fallbackReporter.foo).not.toHaveBeenCalledWith(123, 456);
   });
 
   it('allows registered reporters to be cleared', function() {
-    const queueRunnerFactory = jasmine.createSpy('queueRunner'),
+    const runQueue = jasmine.createSpy('runQueue'),
       dispatcher = new jasmineUnderTest.ReportDispatcher(
         ['foo', 'bar'],
-        queueRunnerFactory
+        runQueue
       ),
       reporter1 = jasmine.createSpyObj('reporter1', ['foo', 'bar']),
       reporter2 = jasmine.createSpyObj('reporter2', ['foo', 'bar']);
 
     dispatcher.addReporter(reporter1);
     dispatcher.foo(123);
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: [{ fn: jasmine.any(Function) }],
         isReporter: true
       })
     );
 
-    let fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    let fns = runQueue.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter1.foo).toHaveBeenCalledWith(123);
 
@@ -159,14 +156,14 @@ describe('ReportDispatcher', function() {
     dispatcher.addReporter(reporter2);
     dispatcher.bar(456);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(
+    expect(runQueue).toHaveBeenCalledWith(
       jasmine.objectContaining({
         queueableFns: [{ fn: jasmine.any(Function) }],
         isReporter: true
       })
     );
 
-    fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
+    fns = runQueue.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter1.bar).not.toHaveBeenCalled();
     expect(reporter2.bar).toHaveBeenCalledWith(456);

spec/core/RunnerSpec.js

@@ -0,0 +1,630 @@
+describe('Runner', function() {
+  describe('Integration with TreeProcessor and TreeRunner', function() {
+    let suiteNumber,
+      specNumber,
+      runQueue,
+      globalErrors,
+      reportDispatcher,
+      failSpecWithNoExpectations,
+      detectLateRejectionHandling;
+
+    beforeEach(function() {
+      suiteNumber = 0;
+      specNumber = 0;
+      runQueue = jasmine.createSpy('runQueue');
+      globalErrors = 'the global errors instance';
+      reportDispatcher = jasmine.createSpyObj(
+        'reportDispatcher',
+        jasmineUnderTest.reporterEvents
+      );
+
+      for (const k of jasmineUnderTest.reporterEvents) {
+        reportDispatcher[k].and.returnValue(Promise.resolve());
+      }
+
+      // Reasonable defaults, may be overridden in some cases
+      failSpecWithNoExpectations = false;
+      detectLateRejectionHandling = false;
+
+      spyOn(jasmineUnderTest.TreeRunner.prototype, '_executeSpec');
+    });
+
+    function StubSuite(attrs) {
+      attrs = attrs || {};
+      this.id = 'suite' + suiteNumber++;
+      this.children = attrs.children || [];
+      this.canBeReentered = function() {
+        return !attrs.noReenter;
+      };
+      this.markedPending = attrs.markedPending || false;
+      this.sharedUserContext = function() {
+        return attrs.userContext || {};
+      };
+      this.result = {
+        id: this.id,
+        failedExpectations: []
+      };
+      this.getResult = jasmine.createSpy('getResult');
+      this.beforeAllFns = attrs.beforeAllFns || [];
+      this.afterAllFns = attrs.afterAllFns || [];
+      this.cleanupBeforeAfter = function() {};
+      this.startTimer = function() {};
+      this.endTimer = function() {};
+    }
+
+    function StubSpec(attrs) {
+      attrs = attrs || {};
+      this.id = 'spec' + specNumber++;
+      this.markedPending = attrs.markedPending || false;
+      this.execute = jasmine.createSpy(this.id + '#execute');
+      this.beforeAndAfterFns = () => ({ befores: [], afters: [] });
+      this.userContext = () => ({});
+      this.getFullName = () => '';
+      this.queueableFn = () => {};
+    }
+
+    function makeRunner(topSuite) {
+      const defaultOptions = {
+        getConfig: () => ({
+          specFilter: () => true,
+          failSpecWithNoExpectations,
+          detectLateRejectionHandling
+        }),
+        focusedRunables: () => [],
+        totalSpecsDefined: () => 1,
+        TreeProcessor: jasmineUnderTest.TreeProcessor,
+        runableResources: {
+          initForRunable: () => {},
+          clearForRunable: () => {}
+        },
+        reportDispatcher,
+        globalErrors,
+        runQueue
+      };
+      return new jasmineUnderTest.Runner({
+        ...defaultOptions,
+        topSuite
+      });
+    }
+
+    function arrayNotContaining(item) {
+      return {
+        asymmetricMatch(other, matchersUtil) {
+          if (!jasmine.isArray_(other)) {
+            return false;
+          }
+
+          for (const x of other) {
+            if (matchersUtil.equals(x, item)) {
+              return false;
+            }
+          }
+
+          return true;
+        }
+      };
+    }
+
+    // Precondition: jasmineUnderTest.TreeRunner.prototype._executeSpec is a spy
+    function verifyAndFinishSpec(spec, queueableFn, shouldBeExcluded) {
+      const ex = jasmineUnderTest.TreeRunner.prototype._executeSpec;
+      ex.withArgs(spec, 'onComplete').and.callThrough();
+
+      queueableFn.fn('onComplete');
+      expect(ex).toHaveBeenCalledWith(spec, 'onComplete');
+
+      expect(runQueue).toHaveBeenCalledWith(
+        jasmine.objectContaining({
+          isLeaf: true,
+          SkipPolicy: jasmineUnderTest.CompleteOnFirstErrorSkipPolicy,
+          queueableFns: shouldBeExcluded
+            ? arrayNotContaining(spec.queueableFn)
+            : jasmine.arrayContaining([spec.queueableFn])
+        })
+      );
+    }
+
+    it('runs a single spec', async function() {
+      const spec = new StubSpec();
+      const topSuite = new StubSuite({
+        children: [spec],
+        userContext: { root: 'context' }
+      });
+      detectLateRejectionHandling = true;
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+
+      expect(runQueue).toHaveBeenCalledWith({
+        onComplete: jasmine.any(Function),
+        onException: jasmine.any(Function),
+        userContext: { root: 'context' },
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        onMultipleDone: null,
+        SkipPolicy: jasmineUnderTest.SkipAfterBeforeAllErrorPolicy
+      });
+
+      const runQueueArgs = runQueue.calls.mostRecent().args[0];
+      verifyAndFinishSpec(spec, runQueueArgs.queueableFns[0], false);
+      runQueueArgs.onComplete();
+      await promise;
+    });
+
+    it('runs an empty suite', async function() {
+      const suite = new StubSuite({ userContext: { for: 'suite' } });
+      const topSuite = new StubSuite({
+        children: [suite],
+        userContext: { for: 'topSuite' }
+      });
+      suite.parentSuite = topSuite;
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+
+      expect(runQueue).toHaveBeenCalledWith({
+        onComplete: jasmine.any(Function),
+        onException: jasmine.any(Function),
+        userContext: { for: 'topSuite' },
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        onMultipleDone: null,
+        SkipPolicy: jasmineUnderTest.SkipAfterBeforeAllErrorPolicy
+      });
+
+      const runQueueArgs = runQueue.calls.mostRecent().args[0];
+      const nodeDone = jasmine.createSpy('nodeDone');
+      runQueueArgs.queueableFns[0].fn(nodeDone);
+      expect(runQueue).toHaveBeenCalledWith({
+        onComplete: jasmine.any(Function),
+        onMultipleDone: null,
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        userContext: { for: 'suite' },
+        onException: jasmine.any(Function),
+        onMultipleDone: null,
+        SkipPolicy: jasmineUnderTest.SkipAfterBeforeAllErrorPolicy
+      });
+
+      runQueue.calls.mostRecent().args[0].queueableFns[0].fn('foo');
+      expect(reportDispatcher.suiteStarted).toHaveBeenCalledWith(suite.result);
+
+      suite.getResult.and.returnValue({ my: 'result' });
+
+      runQueue.calls.mostRecent().args[0].onComplete();
+      expect(reportDispatcher.suiteDone).toHaveBeenCalledWith({ my: 'result' });
+
+      runQueueArgs.onComplete();
+      await promise;
+    });
+
+    it('runs a non-empty suite', async function() {
+      const spec1 = new StubSpec();
+      const spec2 = new StubSpec();
+      const suite = new StubSuite({ children: [spec1, spec2] });
+      const topSuite = new StubSuite({ children: [suite] });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      let queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn(function() {});
+
+      expect(runQueue).toHaveBeenCalledTimes(2);
+      queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(queueableFns.length).toBe(3);
+
+      verifyAndFinishSpec(spec1, queueableFns[1], false);
+      verifyAndFinishSpec(spec2, queueableFns[2], false);
+      await expectAsync(promise).toBePending();
+    });
+
+    it('"runs" an excluded suite', async function() {
+      const spec = new StubSpec();
+      const parent = new StubSuite({ children: [spec] });
+      const topSuite = new StubSuite({ children: [parent] });
+      parent.parentSuite = topSuite;
+      const subject = makeRunner(topSuite);
+
+      // Empty list of runable IDs excludes everything
+      const promise = subject.execute([]);
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      let queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn(function() {});
+
+      queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(queueableFns.length).toBe(2);
+
+      queueableFns[0].fn();
+      expect(reportDispatcher.suiteStarted).toHaveBeenCalledWith(parent.result);
+
+      verifyAndFinishSpec(spec, queueableFns[1], true);
+
+      parent.getResult.and.returnValue(parent.result);
+      runQueue.calls.argsFor(1)[0].onComplete();
+      expect(reportDispatcher.suiteDone).toHaveBeenCalledWith(parent.result);
+      await expectAsync(promise).toBePending();
+    });
+
+    it('handles the failSpecWithNoExpectations option', async function() {
+      failSpecWithNoExpectations = true;
+      const spec = new StubSpec();
+      const parent = new StubSuite({ children: [spec] });
+      const topSuite = new StubSuite({ children: [parent] });
+      parent.parentSuite = topSuite;
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      let queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn(function() {});
+
+      queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(queueableFns.length).toBe(2);
+
+      queueableFns[1].fn('foo');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec, 'foo');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs beforeAlls and afterAlls for a suite with children', async function() {
+      const spec = new StubSpec();
+      const target = new StubSuite({
+        children: [spec],
+        beforeAllFns: [
+          { fn: 'beforeAll1', timeout: 1 },
+          { fn: 'beforeAll2', timeout: 2 }
+        ],
+        afterAllFns: [
+          { fn: 'afterAll1', timeout: 3 },
+          { fn: 'afterAll2', timeout: 4 }
+        ]
+      });
+      const topSuite = new StubSuite({ children: [target] });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn(function() {});
+
+      expect(runQueue.calls.mostRecent().args[0].queueableFns).toEqual([
+        { fn: jasmine.any(Function) },
+        { fn: 'beforeAll1', timeout: 1 },
+        { fn: 'beforeAll2', timeout: 2 },
+        { fn: jasmine.any(Function) },
+        { fn: 'afterAll1', timeout: 3 },
+        { fn: 'afterAll2', timeout: 4 }
+      ]);
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('does not run beforeAlls or afterAlls for a suite with no children', async function() {
+      const target = new StubSuite({
+        beforeAllFns: [{ fn: 'before' }],
+        afterAllFns: [{ fn: 'after' }]
+      });
+      const topSuite = new StubSuite({ children: [target] });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn(function() {});
+
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toEqual(
+        1
+      );
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('does not run beforeAlls or afterAlls for a suite with only pending children', async function() {
+      const spec = new StubSpec({ markedPending: true });
+      const target = new StubSuite({
+        children: [spec],
+        beforeAllFns: [{ fn: 'before' }],
+        afterAllFns: [{ fn: 'after' }]
+      });
+      const topSuite = new StubSuite({ children: [target] });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn(function() {});
+
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toEqual(
+        2
+      );
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs specs in the order specified', async function() {
+      const specs = [new StubSpec(), new StubSpec()];
+      const topSuite = new StubSuite({ children: specs });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute([specs[1].id, specs[0].id]);
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn('done');
+
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).not.toHaveBeenCalledWith(specs[0], jasmine.anything());
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(specs[1], 'done');
+
+      queueableFns[1].fn('done');
+
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(specs[0], 'done');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs specified specs before non-specified specs within a suite', async function() {
+      const specified = new StubSpec();
+      const nonSpecified = new StubSpec();
+      const topSuite = new StubSuite({ children: [nonSpecified, specified] });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute([specified.id]);
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn('done');
+
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).not.toHaveBeenCalledWith(nonSpecified, jasmine.anything());
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(specified, 'done');
+
+      queueableFns[1].fn('done');
+
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(nonSpecified, 'done');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs suites and specs with a specified order', async function() {
+      const specifiedSpec = new StubSpec();
+      const nonSpecifiedSpec = new StubSpec();
+      const specifiedSuite = new StubSuite({ children: [nonSpecifiedSpec] });
+      const topSuite = new StubSuite({
+        children: [specifiedSpec, specifiedSuite]
+      });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute([specifiedSuite.id, specifiedSpec.id]);
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      queueableFns[0].fn();
+
+      expect(specifiedSpec.execute).not.toHaveBeenCalled();
+      const nodeQueueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      nodeQueueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(nonSpecifiedSpec, 'done');
+
+      queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(specifiedSpec, 'done');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs suites and specs in the order they were declared', async function() {
+      const spec1 = new StubSpec();
+      const spec2 = new StubSpec();
+      const spec3 = new StubSpec();
+      const parent = new StubSuite({ children: [spec2, spec3] });
+      const topSuite = new StubSuite({ children: [spec1, parent] });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(queueableFns.length).toBe(2);
+
+      queueableFns[0].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec1, 'done');
+
+      queueableFns[1].fn();
+      const childFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(childFns.length).toBe(3);
+      childFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec2, 'done');
+
+      childFns[2].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec3, 'done');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs a suite multiple times if the order specified leaves and re-enters it', async function() {
+      const spec1 = new StubSpec();
+      const spec2 = new StubSpec();
+      const spec3 = new StubSpec();
+      const spec4 = new StubSpec();
+      const spec5 = new StubSpec();
+      const reentered = new StubSuite({ children: [spec1, spec2, spec3] });
+      const topSuite = new StubSuite({ children: [reentered, spec4, spec5] });
+      const subject = makeRunner(topSuite);
+
+      spyOn(jasmineUnderTest.getEnv(), 'deprecated');
+      const promise = subject.execute([
+        spec1.id,
+        spec4.id,
+        spec2.id,
+        spec5.id,
+        spec3.id
+      ]);
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+
+      queueableFns[0].fn();
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec1, 'done');
+
+      queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec4, 'done');
+
+      queueableFns[2].fn();
+      expect(runQueue.calls.count()).toBe(3);
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec2, 'done');
+
+      queueableFns[3].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec5, 'done');
+
+      queueableFns[4].fn();
+      expect(runQueue.calls.count()).toBe(4);
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec3, 'done');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs a parent of a suite with multiple segments correctly', async function() {
+      const spec1 = new StubSpec();
+      const spec2 = new StubSpec();
+      const spec3 = new StubSpec();
+      const spec4 = new StubSpec();
+      const spec5 = new StubSpec();
+      const parent = new StubSuite({ children: [spec1, spec2, spec3] });
+      const grandparent = new StubSuite({ children: [parent] });
+      const topSuite = new StubSuite({ children: [grandparent, spec4, spec5] });
+      const subject = makeRunner(topSuite);
+
+      spyOn(jasmineUnderTest.getEnv(), 'deprecated');
+      const promise = subject.execute([
+        spec1.id,
+        spec4.id,
+        spec2.id,
+        spec5.id,
+        spec3.id
+      ]);
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(queueableFns.length).toBe(5);
+
+      queueableFns[0].fn();
+      expect(runQueue.calls.count()).toBe(2);
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn();
+      expect(runQueue.calls.count()).toBe(3);
+
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec1, 'done');
+
+      queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec4, 'done');
+
+      queueableFns[2].fn();
+      expect(runQueue.calls.count()).toBe(4);
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn();
+      expect(runQueue.calls.count()).toBe(5);
+
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec2, 'done');
+
+      queueableFns[3].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec5, 'done');
+
+      queueableFns[4].fn();
+      expect(runQueue.calls.count()).toBe(6);
+      expect(runQueue.calls.mostRecent().args[0].queueableFns.length).toBe(2);
+
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn();
+      expect(runQueue.calls.count()).toBe(7);
+
+      runQueue.calls.mostRecent().args[0].queueableFns[1].fn('done');
+      expect(
+        jasmineUnderTest.TreeRunner.prototype._executeSpec
+      ).toHaveBeenCalledWith(spec3, 'done');
+
+      await expectAsync(promise).toBePending();
+    });
+
+    it('runs large segments of nodes in the order they were declared', async function() {
+      const specs = [];
+
+      for (let i = 0; i < 11; i++) {
+        specs.push(new StubSpec());
+      }
+
+      const topSuite = new StubSuite({ children: specs });
+      const subject = makeRunner(topSuite);
+
+      const promise = subject.execute();
+      await Promise.resolve();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const queueableFns = runQueue.calls.mostRecent().args[0].queueableFns;
+      expect(queueableFns.length).toBe(11);
+
+      for (let i = 0; i < 11; i++) {
+        queueableFns[i].fn('done');
+        expect(
+          jasmineUnderTest.TreeRunner.prototype._executeSpec
+        ).toHaveBeenCalledWith(specs[i], 'done');
+      }
+
+      await expectAsync(promise).toBePending();
+    });
+  });
+});

spec/core/SpecSpec.js

@@ -33,357 +33,167 @@ describe('Spec', function() {
     expect(jasmineUnderTest.Spec.isPendingSpecException(void 0)).toBe(false);
   });
 
-  it('delegates execution to a QueueRunner', function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      spec = new jasmineUnderTest.Spec({
-        description: 'my test',
-        id: 'some-id',
-        queueableFn: { fn: function() {} }
+  describe('#executionFinished', function() {
+    it('removes the fn if autoCleanClosures is true', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} },
+        autoCleanClosures: true
       });
 
-    spec.execute(fakeQueueRunner);
-
-    expect(fakeQueueRunner).toHaveBeenCalled();
-  });
-
-  it('should call the start callback on execution', function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      startCallback = jasmine.createSpy('startCallback'),
-      spec = new jasmineUnderTest.Spec({
-        id: 123,
-        description: 'foo bar',
-        queueableFn: { fn: function() {} },
-        onStart: startCallback
-      });
-
-    spec.execute(fakeQueueRunner);
-
-    fakeQueueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
-    expect(startCallback).toHaveBeenCalled();
-    expect(startCallback.calls.first().object).toEqual(spec);
-  });
-
-  it('should call the start callback on execution but before any befores are called', function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner');
-    let beforesWereCalled = false;
-    const startCallback = jasmine
-      .createSpy('start-callback')
-      .and.callFake(function() {
-        expect(beforesWereCalled).toBe(false);
-      });
-    const spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: function() {} },
-      beforeFns: function() {
-        return [
-          function() {
-            beforesWereCalled = true;
-          }
-        ];
-      },
-      onStart: startCallback
+      spec.executionFinished();
+      expect(spec.queueableFn.fn).toBeFalsy();
     });
 
-    spec.execute(fakeQueueRunner);
-
-    fakeQueueRunner.calls.mostRecent().args[0].queueableFns[0].fn();
-    expect(startCallback).toHaveBeenCalled();
-  });
-
-  it('provides all before fns and after fns to be run', function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      before = jasmine.createSpy('before'),
-      after = jasmine.createSpy('after'),
-      queueableFn = {
-        fn: jasmine.createSpy('test body').and.callFake(function() {
-          expect(before).toHaveBeenCalled();
-          expect(after).not.toHaveBeenCalled();
-        })
-      },
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: queueableFn,
-        beforeAndAfterFns: function() {
-          return { befores: [before], afters: [after] };
-        }
+    it('removes the fn after execution if autoCleanClosures is undefined', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} },
+        autoCleanClosures: undefined
       });
 
-    spec.execute(fakeQueueRunner);
-
-    const options = fakeQueueRunner.calls.mostRecent().args[0];
-    expect(options.queueableFns).toEqual([
-      { fn: jasmine.any(Function) },
-      before,
-      queueableFn,
-      after,
-      {
-        fn: jasmine.any(Function),
-        type: 'specCleanup'
-      }
-    ]);
-  });
-
-  it("tells the queue runner that it's a leaf node", function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: function() {} },
-        beforeAndAfterFns: function() {
-          return { befores: [], afters: [] };
-        }
-      });
-
-    spec.execute(fakeQueueRunner);
-
-    expect(fakeQueueRunner).toHaveBeenCalledWith(
-      jasmine.objectContaining({
-        isLeaf: true
-      })
-    );
-  });
-
-  it('is marked pending if created without a function body', function() {
-    const startCallback = jasmine.createSpy('startCallback'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        onStart: startCallback,
-        queueableFn: { fn: null },
-        resultCallback: resultCallback
-      });
-
-    expect(spec.status()).toBe('pending');
-  });
-
-  it('can be excluded at execution time by a parent', function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      startCallback = jasmine.createSpy('startCallback'),
-      specBody = jasmine.createSpy('specBody'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        onStart: startCallback,
-        queueableFn: { fn: specBody },
-        resultCallback: resultCallback
-      });
-
-    spec.execute(fakeQueueRunner, 'cally-back', true);
-
-    expect(fakeQueueRunner).toHaveBeenCalledWith(
-      jasmine.objectContaining({
-        onComplete: jasmine.any(Function),
-        queueableFns: [
-          { fn: jasmine.any(Function) },
-          {
-            fn: jasmine.any(Function),
-            type: 'specCleanup'
-          }
-        ]
-      })
-    );
-    expect(specBody).not.toHaveBeenCalled();
-
-    const args = fakeQueueRunner.calls.mostRecent().args[0];
-    args.queueableFns[0].fn();
-    expect(startCallback).toHaveBeenCalled();
-    args.queueableFns[args.queueableFns.length - 1].fn();
-    expect(resultCallback).toHaveBeenCalled();
-
-    expect(spec.result.status).toBe('excluded');
-  });
-
-  it('can be marked pending, but still calls callbacks when executed', function() {
-    const fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-      startCallback = jasmine.createSpy('startCallback'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        onStart: startCallback,
-        resultCallback: resultCallback,
-        description: 'with a spec',
-        parentSuiteId: 'suite1',
-        filename: 'someSpecFile.js',
-        getSpecName: function() {
-          return 'a suite with a spec';
-        },
-        queueableFn: { fn: null }
-      });
-
-    spec.pend();
-
-    expect(spec.status()).toBe('pending');
-
-    spec.execute(fakeQueueRunner);
-
-    expect(fakeQueueRunner).toHaveBeenCalled();
-
-    const args = fakeQueueRunner.calls.mostRecent().args[0];
-    args.queueableFns[0].fn();
-    expect(startCallback).toHaveBeenCalled();
-    args.queueableFns[1].fn('things');
-    expect(resultCallback).toHaveBeenCalledWith(
-      {
-        id: spec.id,
-        status: 'pending',
-        description: 'with a spec',
-        fullName: 'a suite with a spec',
-        parentSuiteId: 'suite1',
-        filename: 'someSpecFile.js',
-        failedExpectations: [],
-        passedExpectations: [],
-        deprecationWarnings: [],
-        pendingReason: '',
-        duration: jasmine.any(Number),
-        properties: null,
-        debugLogs: null
-      },
-      'things'
-    );
-  });
-
-  it('should call the done callback on execution complete', function() {
-    const done = jasmine.createSpy('done callback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: function() {} },
-        catchExceptions: function() {
-          return false;
-        },
-        resultCallback: function() {}
-      });
-
-    spec.execute(attrs => attrs.onComplete(), done);
-
-    expect(done).toHaveBeenCalled();
-  });
-
-  it('should call the done callback with an error if the spec is failed', function() {
-    const done = jasmine.createSpy('done callback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: function() {} },
-        catchExceptions: function() {
-          return false;
-        },
-        resultCallback: function() {}
-      });
-
-    function queueRunnerFactory(attrs) {
-      spec.result.status = 'failed';
-      attrs.onComplete();
-    }
-    spec.execute(queueRunnerFactory, done);
-
-    expect(done).toHaveBeenCalledWith(
-      jasmine.any(jasmineUnderTest.StopExecutionError)
-    );
-  });
-
-  it('should report the duration of the test', function() {
-    const timer = jasmine.createSpyObj('timer', {
-      start: null,
-      elapsed: 77000
-    });
-    let duration = undefined;
-    const spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: jasmine.createSpy('spec body') },
-      catchExceptions: function() {
-        return false;
-      },
-      resultCallback: function(result) {
-        duration = result.duration;
-      },
-      timer: timer
+      spec.executionFinished();
+      expect(spec.queueableFn.fn).toBeFalsy();
     });
 
-    function queueRunnerFactory(config) {
-      config.queueableFns.forEach(function(qf) {
-        qf.fn();
+    it('does not remove the fn after execution if autoCleanClosures is false', function() {
+      function originalFn() {}
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: originalFn },
+        autoCleanClosures: false
       });
-      config.onComplete();
-    }
 
-    spec.execute(queueRunnerFactory, function() {});
-    expect(duration).toBe(77000);
-  });
-
-  it('should report properties set during the test', function() {
-    const done = jasmine.createSpy('done callback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: jasmine.createSpy('spec body') },
-        catchExceptions: function() {
-          return false;
-        },
-        resultCallback: function() {}
-      });
-    spec.setSpecProperty('a', 4);
-    spec.execute(attrs => attrs.onComplete(), done);
-    expect(spec.result.properties).toEqual({ a: 4 });
-  });
-
-  it('#status returns passing by default', function() {
-    const spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: jasmine.createSpy('spec body') }
+      spec.executionFinished();
+      expect(spec.queueableFn.fn).toBe(originalFn);
     });
-    expect(spec.status()).toBe('passed');
   });
 
-  it('#status returns passed if all expectations in the spec have passed', function() {
-    const spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: jasmine.createSpy('spec body') }
-    });
-    spec.addExpectationResult(true, {});
-    expect(spec.status()).toBe('passed');
-  });
-
-  it('#status returns failed if any expectations in the spec have failed', function() {
-    const spec = new jasmineUnderTest.Spec({
-      queueableFn: { fn: jasmine.createSpy('spec body') }
-    });
-    spec.addExpectationResult(true, {});
-    spec.addExpectationResult(false, {});
-    expect(spec.status()).toBe('failed');
-  });
-
-  it('keeps track of passed and failed expectations', function() {
-    const fakeQueueRunner = jasmine.createSpy('queueRunner'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: jasmine.createSpy('spec body') },
-        resultCallback: resultCallback
-      });
-    spec.addExpectationResult(true, { message: 'expectation1' });
-    spec.addExpectationResult(false, { message: 'expectation2' });
-
-    spec.execute(fakeQueueRunner);
-
-    const fns = fakeQueueRunner.calls.mostRecent().args[0].queueableFns;
-    fns[fns.length - 1].fn();
-
-    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual([
-      jasmine.objectContaining({ message: 'expectation1' })
-    ]);
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([
-      jasmine.objectContaining({ message: 'expectation2' })
-    ]);
-  });
-
-  it("throws an ExpectationFailed error upon receiving a failed expectation when 'throwOnExpectationFailure' is set", function() {
-    const fakeQueueRunner = jasmine.createSpy('queueRunner'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: function() {} },
-        resultCallback: resultCallback,
-        throwOnExpectationFailure: true
+  describe('#getSpecProperty', function() {
+    it('get the property value', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
       });
 
-    spec.addExpectationResult(true, { message: 'passed' });
-    expect(function() {
-      spec.addExpectationResult(false, { message: 'failed' });
-    }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
+      spec.setSpecProperty('a', 4);
+      expect(spec.getSpecProperty('a')).toBe(4);
+    });
+  });
 
-    spec.execute(fakeQueueRunner);
+  describe('#setSpecProperty', function() {
+    it('adds the property to the result', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
+      });
 
-    const fns = fakeQueueRunner.calls.mostRecent().args[0].queueableFns;
-    fns[fns.length - 1].fn();
-    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual([
-      jasmine.objectContaining({ message: 'passed' })
-    ]);
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([
-      jasmine.objectContaining({ message: 'failed' })
-    ]);
+      spec.setSpecProperty('a', 4);
+
+      expect(spec.result.properties).toEqual({ a: 4 });
+    });
+
+    it('replace the property result when it was previously set', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
+      });
+
+      spec.setSpecProperty('a', 'original-value');
+      spec.setSpecProperty('b', 'original-value');
+      spec.setSpecProperty('a', 'new-value');
+
+      expect(spec.result.properties).toEqual({
+        a: 'new-value',
+        b: 'original-value'
+      });
+    });
+  });
+
+  describe('status', function() {
+    it('is "passed" by default', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
+      });
+      expect(spec.getResult().status).toBe('passed');
+    });
+
+    it('is "passed" if all expectations passed', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
+      });
+
+      spec.addExpectationResult(true, {});
+
+      expect(spec.getResult().status).toBe('passed');
+    });
+
+    it('is "failed" if any expectation failed', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
+      });
+
+      spec.addExpectationResult(true, {});
+      spec.addExpectationResult(false, {});
+
+      expect(spec.getResult().status).toBe('failed');
+    });
+
+    it('is "pending" if created without a function body', function() {
+      const startCallback = jasmine.createSpy('startCallback'),
+        resultCallback = jasmine.createSpy('resultCallback'),
+        spec = new jasmineUnderTest.Spec({
+          onStart: startCallback,
+          queueableFn: { fn: null },
+          resultCallback: resultCallback
+        });
+
+      expect(spec.getResult().status).toBe('pending');
+    });
+  });
+
+  describe('#addExpectationResult', function() {
+    it('keeps track of passed and failed expectations', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} }
+      });
+
+      spec.addExpectationResult(true, { message: 'expectation1' });
+      spec.addExpectationResult(false, { message: 'expectation2' });
+
+      expect(spec.result.passedExpectations).toEqual([
+        jasmine.objectContaining({ message: 'expectation1' })
+      ]);
+      expect(spec.result.failedExpectations).toEqual([
+        jasmine.objectContaining({ message: 'expectation2' })
+      ]);
+    });
+
+    describe("when 'throwOnExpectationFailure' is set", function() {
+      it('throws an ExpectationFailed error', function() {
+        const spec = new jasmineUnderTest.Spec({
+          queueableFn: { fn: () => {} },
+          throwOnExpectationFailure: true
+        });
+
+        spec.addExpectationResult(true, { message: 'passed' });
+        expect(function() {
+          spec.addExpectationResult(false, { message: 'failed' });
+        }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
+
+        expect(spec.result.failedExpectations).toEqual([
+          jasmine.objectContaining({ message: 'failed' })
+        ]);
+      });
+    });
+
+    describe("when 'throwOnExpectationFailure' is not set", function() {
+      it('does not throw', function() {
+        const spec = new jasmineUnderTest.Spec({
+          queueableFn: { fn: () => {} }
+        });
+
+        spec.addExpectationResult(false, { message: 'failed' });
+
+        expect(spec.result.failedExpectations).toEqual([
+          jasmine.objectContaining({ message: 'failed' })
+        ]);
+      });
+    });
   });
 
   it('forwards late expectation failures to onLateError', function() {
@@ -485,138 +295,76 @@ describe('Spec', function() {
   });
 
   it('can return its full name', function() {
-    const specNameSpy = jasmine
-      .createSpy('specNameSpy')
-      .and.returnValue('expected val');
+    const getPath = jasmine
+      .createSpy('getPath')
+      .and.returnValue(['expected', 'val']);
 
     const spec = new jasmineUnderTest.Spec({
-      getSpecName: specNameSpy,
+      getPath,
       queueableFn: { fn: null }
     });
 
     expect(spec.getFullName()).toBe('expected val');
-    expect(specNameSpy.calls.mostRecent().args[0].id).toEqual(spec.id);
+    expect(getPath.calls.mostRecent().args[0]).toBe(spec);
   });
 
-  describe('when a spec is marked pending during execution', function() {
-    it('should mark the spec as pending', function() {
-      const fakeQueueRunner = function(opts) {
-          opts.onException(
-            new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage)
-          );
-        },
-        spec = new jasmineUnderTest.Spec({
-          description: 'my test',
-          id: 'some-id',
-          queueableFn: { fn: function() {} }
-        });
+  it('can return its full path', function() {
+    const getPath = jasmine
+      .createSpy('getPath')
+      .and.returnValue(['expected val']);
 
-      spec.execute(fakeQueueRunner);
-
-      expect(spec.status()).toEqual('pending');
-      expect(spec.result.pendingReason).toEqual('');
+    const spec = new jasmineUnderTest.Spec({
+      getPath,
+      queueableFn: { fn: null }
     });
 
-    it('should set the pendingReason', function() {
-      const fakeQueueRunner = function(opts) {
-          opts.onException(
-            new Error(
-              jasmineUnderTest.Spec.pendingSpecExceptionMessage +
-                'custom message'
-            )
-          );
-        },
-        spec = new jasmineUnderTest.Spec({
-          description: 'my test',
-          id: 'some-id',
-          queueableFn: { fn: function() {} }
-        });
+    expect(spec.getPath()).toEqual(['expected val']);
+    expect(getPath.calls.mostRecent().args[0]).toBe(spec);
 
-      spec.execute(fakeQueueRunner);
-
-      expect(spec.status()).toEqual('pending');
-      expect(spec.result.pendingReason).toEqual('custom message');
-    });
+    expect(spec.metadata.getPath()).toEqual(['expected val']);
   });
 
-  it('should log a failure when handling an exception', function() {
-    const fakeQueueRunner = jasmine.createSpy('queueRunner'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: function() {} },
-        resultCallback: resultCallback
+  describe('#handleException', function() {
+    it('records a failure', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: {}
       });
 
-    spec.handleException('foo');
-    spec.execute(fakeQueueRunner);
+      spec.handleException('foo');
 
-    const args = fakeQueueRunner.calls.mostRecent().args[0];
-    args.queueableFns[args.queueableFns.length - 1].fn();
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([
-      {
-        message: 'foo thrown',
-        matcherName: '',
-        passed: false,
-        expected: '',
-        actual: '',
-        stack: null
-      }
-    ]);
-  });
-
-  it('should not log an additional failure when handling an ExpectationFailed error', function() {
-    const fakeQueueRunner = jasmine.createSpy('queueRunner'),
-      resultCallback = jasmine.createSpy('resultCallback'),
-      spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: function() {} },
-        resultCallback: resultCallback
-      });
-
-    spec.handleException(new jasmineUnderTest.errors.ExpectationFailed());
-    spec.execute(fakeQueueRunner);
-
-    const args = fakeQueueRunner.calls.mostRecent().args[0];
-    args.queueableFns[args.queueableFns.length - 1].fn();
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([]);
-  });
-
-  it('treats multiple done calls as late errors', function() {
-    const queueRunnerFactory = jasmine.createSpy('queueRunnerFactory'),
-      onLateError = jasmine.createSpy('onLateError'),
-      spec = new jasmineUnderTest.Spec({
-        onLateError: onLateError,
-        queueableFn: { fn: function() {} },
-        getSpecName: function() {
-          return 'a spec';
+      expect(spec.result.failedExpectations).toEqual([
+        {
+          message: 'foo thrown',
+          matcherName: '',
+          passed: false,
+          expected: '',
+          actual: '',
+          stack: null
         }
+      ]);
+    });
+
+    it('does not record an additional failure when the error is ExpectationFailed', function() {
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: {}
       });
 
-    spec.execute(queueRunnerFactory);
+      spec.handleException(new jasmineUnderTest.errors.ExpectationFailed());
 
-    expect(queueRunnerFactory).toHaveBeenCalled();
-    queueRunnerFactory.calls.argsFor(0)[0].onMultipleDone();
-
-    expect(onLateError).toHaveBeenCalledTimes(1);
-    expect(onLateError.calls.argsFor(0)[0]).toBeInstanceOf(Error);
-    expect(onLateError.calls.argsFor(0)[0].message).toEqual(
-      'An asynchronous spec, beforeEach, or afterEach function called its ' +
-        "'done' callback more than once.\n(in spec: a spec)"
-    );
+      expect(spec.result.failedExpectations).toEqual([]);
+    });
   });
 
-  describe('#trace', function() {
+  describe('#debugLog', function() {
     it('adds the messages to the result', function() {
-      const timer = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-        spec = new jasmineUnderTest.Spec({
-          queueableFn: {
-            fn: function() {}
-          },
-          timer: timer
-        }),
-        t1 = 123,
-        t2 = 456;
+      const timer = jasmine.createSpyObj('timer', ['start', 'elapsed']);
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn: () => {} },
+        timer: timer
+      });
+      const t1 = 123;
+      const t2 = 456;
 
-      spec.execute(() => {});
       expect(spec.result.debugLogs).toBeNull();
       timer.elapsed.and.returnValue(t1);
       spec.debugLog('msg 1');
@@ -632,84 +380,36 @@ describe('Spec', function() {
     });
 
     describe('When the spec passes', function() {
-      it('omits the messages from the reported result', function() {
-        const resultCallback = jasmine.createSpy('resultCallback'),
-          spec = new jasmineUnderTest.Spec({
-            queueableFn: {
-              fn: function() {}
-            },
-            resultCallback: resultCallback
-          });
+      it('removes the logs from the result', function() {
+        const spec = new jasmineUnderTest.Spec({
+          queueableFn: { fn: () => {} }
+        });
 
-        function queueRunnerFactory(config) {
-          spec.debugLog('msg');
-          for (const fn of config.queueableFns) {
-            fn.fn();
-          }
-          config.onComplete(false);
-        }
+        spec.debugLog('msg');
+        spec.executionFinished();
 
-        spec.execute(queueRunnerFactory, function() {});
-        expect(resultCallback).toHaveBeenCalledWith(
-          jasmine.objectContaining({ debugLogs: null }),
-          undefined
-        );
-      });
-
-      it('removes the messages to save memory', function() {
-        const resultCallback = jasmine.createSpy('resultCallback'),
-          spec = new jasmineUnderTest.Spec({
-            queueableFn: {
-              fn: function() {}
-            },
-            resultCallback: resultCallback
-          });
-
-        function queueRunnerFactory(config) {
-          spec.debugLog('msg');
-          for (const fn of config.queueableFns) {
-            fn.fn();
-          }
-          config.onComplete(false);
-        }
-
-        spec.execute(queueRunnerFactory, function() {});
-        expect(resultCallback).toHaveBeenCalled();
         expect(spec.result.debugLogs).toBeNull();
       });
     });
 
     describe('When the spec fails', function() {
-      it('includes the messages in the reported result', function() {
-        const resultCallback = jasmine.createSpy('resultCallback'),
-          timer = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-          spec = new jasmineUnderTest.Spec({
-            queueableFn: {
-              fn: function() {}
-            },
-            resultCallback: resultCallback,
-            timer: timer
-          }),
-          timestamp = 12345;
+      it('includes the messages in the result', function() {
+        const timer = jasmine.createSpyObj('timer', ['start', 'elapsed']);
+        const spec = new jasmineUnderTest.Spec({
+          queueableFn: { fn: () => {} },
+          timer: timer
+        });
+        const timestamp = 12345;
 
         timer.elapsed.and.returnValue(timestamp);
 
-        function queueRunnerFactory(config) {
-          spec.debugLog('msg');
-          spec.handleException(new Error('nope'));
-          for (const fn of config.queueableFns) {
-            fn.fn();
-          }
-          config.onComplete(true);
-        }
+        spec.debugLog('msg');
+        spec.handleException(new Error('nope'));
+        spec.executionFinished();
 
-        spec.execute(queueRunnerFactory, function() {});
-        expect(resultCallback).toHaveBeenCalledWith(
-          jasmine.objectContaining({
-            debugLogs: [{ message: 'msg', timestamp: timestamp }]
-          }),
-          undefined
-        );
+        expect(spec.result.debugLogs).toEqual([
+          { message: 'msg', timestamp: timestamp }
+        ]);
       });
     });
   });

spec/core/SpyRegistrySpec.js

@@ -94,6 +94,30 @@ describe('SpyRegistry', function() {
       }).not.toThrowError(/is not declared writable or has no setter/);
     });
 
+    it('throws if assigning to the property is a no-op', function() {
+      const scope = {};
+
+      function original() {
+        return 1;
+      }
+
+      Object.defineProperty(scope, 'myFunc', {
+        get() {
+          return original;
+        },
+        set() {}
+      });
+
+      const spyRegistry = new jasmineUnderTest.SpyRegistry({
+        createSpy: createSpy
+      });
+      expect(function() {
+        spyRegistry.spyOn(scope, 'myFunc');
+      }).toThrowError(
+        "<spyOn> : Can't spy on myFunc because assigning to it had no effect"
+      );
+    });
+
     it('overrides the method on the object and returns the spy', function() {
       const originalFunctionWasCalled = false,
         spyRegistry = new jasmineUnderTest.SpyRegistry({

spec/core/SpySpec.js

@@ -97,17 +97,11 @@ describe('Spies', function() {
     it('preserves arity of original function', function() {
       const functions = [
         function nullary() {},
-        // eslint-disable-next-line no-unused-vars
         function unary(arg) {},
-        // eslint-disable-next-line no-unused-vars
         function binary(arg1, arg2) {},
-        // eslint-disable-next-line no-unused-vars
         function ternary(arg1, arg2, arg3) {},
-        // eslint-disable-next-line no-unused-vars
         function quaternary(arg1, arg2, arg3, arg4) {},
-        // eslint-disable-next-line no-unused-vars
         function quinary(arg1, arg2, arg3, arg4, arg5) {},
-        // eslint-disable-next-line no-unused-vars
         function senary(arg1, arg2, arg3, arg4, arg5, arg6) {}
       ];
 
@@ -159,7 +153,7 @@ describe('Spies', function() {
     it('should throw if you do not pass an array or object argument', function() {
       expect(function() {
         env.createSpyObj('BaseName');
-      }).toThrow(
+      }).toThrowError(
         'createSpyObj requires a non-empty array or object of method names to create spies for'
       );
     });
@@ -167,7 +161,7 @@ describe('Spies', function() {
     it('should throw if you pass an empty array argument', function() {
       expect(function() {
         env.createSpyObj('BaseName', []);
-      }).toThrow(
+      }).toThrowError(
         'createSpyObj requires a non-empty array or object of method names to create spies for'
       );
     });
@@ -175,7 +169,7 @@ describe('Spies', function() {
     it('should throw if you pass an empty object argument', function() {
       expect(function() {
         env.createSpyObj('BaseName', {});
-      }).toThrow(
+      }).toThrowError(
         'createSpyObj requires a non-empty array or object of method names to create spies for'
       );
     });

spec/core/StackTraceSpec.js

@@ -51,6 +51,27 @@ describe('StackTrace', function() {
     ]);
   });
 
+  it('understands Chrome/Edge style traces with messages containing blank lines', function() {
+    const error = {
+      message: 'line 1\n\nline 2',
+      stack:
+        'Error: line 1\n\nline 2\n' +
+        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
+        '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
+    };
+
+    const result = new jasmineUnderTest.StackTrace(error);
+
+    expect(result.message).toEqual('Error: line 1\n\nline 2');
+    const rawFrames = result.frames.map(function(f) {
+      return f.raw;
+    });
+    expect(rawFrames).toEqual([
+      '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
+    ]);
+  });
+
   it('understands Node style traces', function() {
     const error = {
       message: 'nope',
@@ -95,7 +116,7 @@ describe('StackTrace', function() {
     ]);
   });
 
-  it('understands Safari <=14/Firefox/Phantom-OS X style traces', function() {
+  it('understands Safari <=14/Firefox style traces', function() {
     const error = {
       message: 'nope',
       stack:
@@ -149,7 +170,7 @@ describe('StackTrace', function() {
     ]);
   });
 
-  it('does not mistake gibberish for Safari/Firefox/Phantom-OS X style traces', function() {
+  it('does not mistake gibberish for Safari/Firefox style traces', function() {
     const error = {
       message: 'nope',
       stack: 'randomcharsnotincludingwhitespace'
@@ -159,36 +180,6 @@ describe('StackTrace', function() {
     expect(result.frames).toEqual([{ raw: error.stack }]);
   });
 
-  it('understands Phantom-Linux style traces', function() {
-    const error = {
-      message: 'nope',
-      stack:
-        '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
-        '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
-    };
-
-    const result = new jasmineUnderTest.StackTrace(error);
-
-    expect(result.message).toBeFalsy();
-    expect(result.style).toEqual('v8');
-    expect(result.frames).toEqual([
-      {
-        raw:
-          '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
-        func: 'UserContext.<anonymous>',
-        file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
-        line: 115
-      },
-      {
-        raw:
-          '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
-        func: 'QueueRunner.run',
-        file: 'http://localhost:8888/__jasmine__/jasmine.js',
-        line: 4320
-      }
-    ]);
-  });
-
   it('ignores blank lines', function() {
     const error = {
       message: 'nope',
@@ -241,7 +232,7 @@ describe('StackTrace', function() {
     ]);
   });
 
-  it('consideres different types of errors', function() {
+  it('considers different types of errors', function() {
     const error = {
       message: 'nope',
       stack:

spec/core/SuiteBuilderSpec.js

@@ -163,6 +163,20 @@ describe('SuiteBuilder', function() {
       expect(spec2.id).toMatch(/^spec[0-9]+$/);
       expect(spec1.id).not.toEqual(spec2.id);
     });
+
+    it('gives each spec a full path', function() {
+      const env = { configuration: () => ({}) };
+      const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+      let spec;
+
+      suiteBuilder.describe('a suite', function() {
+        suiteBuilder.describe('a nested suite', function() {
+          spec = suiteBuilder[fnName]('a spec', function() {});
+        });
+      });
+
+      expect(spec.getPath()).toEqual(['a suite', 'a nested suite', 'a spec']);
+    });
   }
 
   function sameInstanceAs(expected) {
@@ -176,6 +190,117 @@ describe('SuiteBuilder', function() {
     };
   }
 
+  describe('Duplicate name handling', function() {
+    describe('When forbidDuplicateNames is true', function() {
+      let env;
+
+      beforeEach(function() {
+        env = { configuration: () => ({ forbidDuplicateNames: true }) };
+      });
+
+      it('forbids duplicate spec names', function() {
+        const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+        expect(function() {
+          suiteBuilder.describe('a suite', function() {
+            suiteBuilder.describe('a nested suite', function() {
+              suiteBuilder.it('a spec');
+              suiteBuilder.it('a spec');
+            });
+          });
+        }).toThrowError(
+          'Duplicate spec name "a spec" found in "a suite a nested suite"'
+        );
+      });
+
+      it('forbids duplicate spec names in the top suite', function() {
+        const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+        expect(function() {
+          suiteBuilder.it('another spec');
+          suiteBuilder.it('another spec');
+        }).toThrowError(
+          'Duplicate spec name "another spec" found in top suite'
+        );
+      });
+
+      it('forbids duplicate suite names', function() {
+        const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+        expect(function() {
+          suiteBuilder.describe('a suite', function() {
+            suiteBuilder.describe('a nested suite', function() {
+              suiteBuilder.describe('another suite', function() {
+                suiteBuilder.it('a spec');
+              });
+              suiteBuilder.describe('another suite', function() {
+                suiteBuilder.it('a spec');
+              });
+            });
+          });
+        }).toThrowError(
+          'Duplicate suite name "another suite" found in "a suite a nested suite"'
+        );
+      });
+
+      it('forbids duplicate suite names in the top suite', function() {
+        const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+        expect(function() {
+          suiteBuilder.describe('a suite', function() {
+            suiteBuilder.it('a spec');
+          });
+          suiteBuilder.describe('a suite', function() {
+            suiteBuilder.it('a spec');
+          });
+        }).toThrowError('Duplicate suite name "a suite" found in top suite');
+      });
+
+      it('allows spec and suite names to be duplicated in different suites', function() {
+        const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+        expect(function() {
+          suiteBuilder.describe('suite a', function() {
+            suiteBuilder.describe('dupe suite', function() {
+              suiteBuilder.it('dupe spec');
+              suiteBuilder.describe('child suite', function() {
+                suiteBuilder.it('dupe spec');
+              });
+            });
+          });
+          suiteBuilder.describe('suite b', function() {
+            suiteBuilder.describe('dupe suite', function() {
+              suiteBuilder.it('dupe spec');
+            });
+          });
+        }).not.toThrow();
+      });
+    });
+
+    describe('When forbidDuplicateNames is false', function() {
+      let env;
+
+      beforeEach(function() {
+        env = { configuration: () => ({ forbidDuplicateNames: false }) };
+      });
+
+      it('allows duplicate spec and suite names', function() {
+        const suiteBuilder = new jasmineUnderTest.SuiteBuilder({ env });
+
+        expect(function() {
+          suiteBuilder.describe('dupe suite', function() {
+            suiteBuilder.it('dupe spec');
+            suiteBuilder.it('dupe spec');
+          });
+          suiteBuilder.describe('dupe suite', function() {
+            suiteBuilder.it('dupe spec');
+            suiteBuilder.it('dupe spec');
+          });
+        }).not.toThrow();
+      });
+    });
+  });
+
   describe('#parallelReset', function() {
     it('resets the top suite result', function() {
       jasmineUnderTest.Suite.prototype.handleException.and.callThrough();

spec/core/SuiteSpec.js

@@ -115,7 +115,7 @@ describe('Suite', function() {
     const suite = new jasmineUnderTest.Suite({});
 
     suite.addExpectationResult(false, {});
-    expect(suite.status()).toBe('failed');
+    expect(suite.getResult().status).toBe('failed');
   });
 
   it('retrieves a result with updated status', function() {
@@ -140,7 +140,7 @@ describe('Suite', function() {
       suite.addExpectationResult(false, { message: 'failed' });
     }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
 
-    expect(suite.status()).toBe('failed');
+    expect(suite.getResult().status).toBe('failed');
     expect(suite.result.failedExpectations).toEqual([
       jasmine.objectContaining({ message: 'failed' })
     ]);
@@ -378,4 +378,31 @@ describe('Suite', function() {
       );
     });
   });
+
+  describe('#hasChildWithDescription', function() {
+    it('returns true if there is a child with the given description', function() {
+      const subject = new jasmineUnderTest.Suite({});
+      const description = 'a spec';
+      subject.addChild({ description });
+
+      expect(subject.hasChildWithDescription(description)).toBeTrue();
+    });
+
+    it('returns false if there is no child with the given description', function() {
+      const subject = new jasmineUnderTest.Suite({});
+      subject.addChild({ description: 'a different spec' });
+
+      expect(subject.hasChildWithDescription('a spec')).toBeFalse();
+    });
+
+    it('does not recurse into child suites', function() {
+      const subject = new jasmineUnderTest.Suite({});
+      const childSuite = new jasmineUnderTest.Suite({});
+      subject.addChild(childSuite);
+      const description = 'a spec';
+      childSuite.addChild(description);
+
+      expect(subject.hasChildWithDescription('a spec')).toBeFalse();
+    });
+  });
 });

spec/core/TreeRunnerSpec.js

@@ -0,0 +1,717 @@
+describe('TreeRunner', function() {
+  describe('spec execution', function() {
+    it('starts the timer, reports the spec started, and updates run state at the start of the queue', async function() {
+      const timer = jasmine.createSpyObj('timer', ['start']);
+      const spec = new jasmineUnderTest.Spec({
+        id: 'spec1',
+        queueableFn: {},
+        timer
+      });
+      const {
+        runQueue,
+        currentRunableTracker,
+        runableResources,
+        reportDispatcher,
+        suiteRunQueueArgs,
+        executePromise
+      } = runSingleSpecSuite(spec);
+      suiteRunQueueArgs.queueableFns[0].fn();
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueArgs = runQueue.calls.mostRecent().args[0];
+      const next = jasmine.createSpy('next');
+      specRunQueueArgs.queueableFns[0].fn(next);
+
+      expect(timer.start).toHaveBeenCalled();
+      expect(currentRunableTracker.currentRunable()).toBe(spec);
+      expect(runableResources.initForRunable).toHaveBeenCalledWith(
+        spec.id,
+        spec.parentSuiteId
+      );
+      expect(reportDispatcher.specStarted).toHaveBeenCalledWith(spec.result);
+      await Promise.resolve();
+      expect(reportDispatcher.specStarted).toHaveBeenCalledBefore(next);
+      await expectAsync(executePromise).toBePending();
+    });
+
+    it('stops the timer, updates run state, and reports the spec done at the end of the queue', async function() {
+      const timer = jasmine.createSpyObj('timer', ['start', 'elapsed']);
+      const spec = new jasmineUnderTest.Spec({
+        id: 'spec1',
+        queueableFn: {},
+        timer
+      });
+      const {
+        runQueue,
+        currentRunableTracker,
+        runableResources,
+        reportDispatcher,
+        suiteRunQueueArgs,
+        executePromise
+      } = runSingleSpecSuite(spec);
+
+      suiteRunQueueArgs.queueableFns[0].fn();
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueArgs = runQueue.calls.mostRecent().args[0];
+      const next = jasmine.createSpy('next');
+      timer.elapsed.and.returnValue('the elapsed time');
+      currentRunableTracker.setCurrentSpec(spec);
+      specRunQueueArgs.queueableFns[1].fn(next);
+
+      expect(currentRunableTracker.currentSpec()).toBeFalsy();
+      expect(runableResources.clearForRunable).toHaveBeenCalledWith(spec.id);
+      expect(reportDispatcher.specDone).toHaveBeenCalledWith(spec.result);
+      expect(spec.result.duration).toEqual('the elapsed time');
+      expect(spec.reportedDone).toEqual(true);
+      await Promise.resolve();
+      await Promise.resolve();
+      await Promise.resolve();
+      expect(reportDispatcher.specDone).toHaveBeenCalledBefore(next);
+      await expectAsync(executePromise).toBePending();
+    });
+
+    it('runs before and after fns', function() {
+      const before = { fn: jasmine.createSpy('before') };
+      const after = { fn: jasmine.createSpy('after') };
+      const queueableFn = {
+        fn: jasmine.createSpy('test body').and.callFake(function() {
+          expect(before).toHaveBeenCalled();
+          expect(after).not.toHaveBeenCalled();
+        })
+      };
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: queueableFn,
+        beforeAndAfterFns: function() {
+          return { befores: [before], afters: [after] };
+        }
+      });
+
+      const { runQueue, suiteRunQueueArgs } = runSingleSpecSuite(spec);
+      suiteRunQueueArgs.queueableFns[0].fn();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueArgs = runQueue.calls.mostRecent().args[0];
+
+      expect(specRunQueueArgs.queueableFns[1]).toEqual(before);
+      expect(specRunQueueArgs.queueableFns[2]).toEqual(queueableFn);
+      expect(specRunQueueArgs.queueableFns[3]).toEqual(after);
+    });
+
+    it('marks specs pending at runtime', function() {
+      let spec;
+      const queueableFn = {
+        fn() {
+          spec.pend();
+        }
+      };
+      spec = new jasmineUnderTest.Spec({ queueableFn });
+
+      const { runQueue, suiteRunQueueArgs } = runSingleSpecSuite(spec);
+      suiteRunQueueArgs.queueableFns[0].fn();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueArgs = runQueue.calls.mostRecent().args[0];
+
+      expect(specRunQueueArgs.queueableFns[1]).toEqual(queueableFn);
+      queueableFn.fn();
+
+      expect(spec.getResult().status).toEqual('pending');
+      expect(spec.getResult().pendingReason).toEqual('');
+    });
+
+    it('marks specs pending at runtime with a message', function() {
+      let spec;
+      const queueableFn = {
+        fn() {
+          spec.pend('some reason');
+        }
+      };
+      spec = new jasmineUnderTest.Spec({ queueableFn });
+
+      const { runQueue, suiteRunQueueArgs } = runSingleSpecSuite(spec);
+      suiteRunQueueArgs.queueableFns[0].fn();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueArgs = runQueue.calls.mostRecent().args[0];
+
+      expect(specRunQueueArgs.queueableFns[1]).toEqual(queueableFn);
+      queueableFn.fn();
+
+      expect(spec.getResult().status).toEqual('pending');
+      expect(spec.getResult().pendingReason).toEqual('some reason');
+    });
+
+    it('passes failSpecWithNoExp to Spec#executionFinished', async function() {
+      const spec = new jasmineUnderTest.Spec({
+        id: 'spec1',
+        queueableFn: {}
+      });
+      spyOn(spec, 'executionFinished');
+      const {
+        runQueue,
+        suiteRunQueueArgs,
+        executePromise
+      } = runSingleSpecSuite(spec, { failSpecWithNoExpectations: true });
+
+      suiteRunQueueArgs.queueableFns[0].fn();
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueArgs = runQueue.calls.mostRecent().args[0];
+      expect(specRunQueueArgs.queueableFns[1].type).toEqual('specCleanup');
+      specRunQueueArgs.queueableFns[1].fn();
+
+      expect(spec.executionFinished).toHaveBeenCalledWith(false, true);
+      await expectAsync(executePromise).toBePending();
+    });
+  });
+
+  describe('Suite execution', function() {
+    it('reports the duration of the suite', async function() {
+      const timer = jasmine.createSpyObj('timer', ['start', 'elapsed']);
+      const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+      const suite = new jasmineUnderTest.Suite({
+        id: 'suite1',
+        parentSuite: topSuite,
+        timer
+      });
+      topSuite.addChild(suite);
+      const executionTree = {
+        topSuite,
+        childrenOfTopSuite() {
+          return [{ suite }];
+        },
+        childrenOfSuiteSegment() {
+          return [];
+        },
+        isExcluded() {
+          return false;
+        }
+      };
+      const runQueue = jasmine.createSpy('runQueue');
+      const reportDispatcher = mockReportDispatcher();
+      const subject = new jasmineUnderTest.TreeRunner({
+        executionTree,
+        runQueue,
+        globalErrors: mockGlobalErrors(),
+        runableResources: mockRunableResources(),
+        reportDispatcher,
+        currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+        getConfig() {
+          return {};
+        },
+        reportChildrenOfBeforeAllFailure() {}
+      });
+
+      const executePromise = subject.execute();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      topSuiteRunQueueOpts.queueableFns[0].fn(function() {});
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      expect(timer.start).not.toHaveBeenCalled();
+      const suiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      suiteRunQueueOpts.queueableFns[0].fn();
+      expect(timer.start).toHaveBeenCalled();
+      expect(timer.elapsed).not.toHaveBeenCalled();
+
+      timer.elapsed.and.returnValue('the duration');
+      suiteRunQueueOpts.onComplete();
+      expect(timer.elapsed).toHaveBeenCalled();
+      const result = suite.getResult();
+      expect(result.duration).toEqual('the duration');
+      expect(reportDispatcher.suiteDone).toHaveBeenCalledWith(result);
+
+      await expectAsync(executePromise).toBePending();
+    });
+
+    it('returns false if a suite failed', async function() {
+      const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+      const failingSuite = new jasmineUnderTest.Suite({
+        id: 'failingSuite',
+        parentSuite: topSuite
+      });
+      const passingSuite = new jasmineUnderTest.Suite({
+        id: 'passingSuite',
+        parentSuite: topSuite
+      });
+      const executionTree = {
+        topSuite,
+        childrenOfTopSuite() {
+          return [{ suite: failingSuite }, { suite: passingSuite }];
+        },
+        childrenOfSuiteSegment() {
+          return [];
+        },
+        isExcluded() {
+          return false;
+        }
+      };
+      const runQueue = jasmine.createSpy('runQueue');
+      const reportDispatcher = mockReportDispatcher();
+      const subject = new jasmineUnderTest.TreeRunner({
+        executionTree,
+        runQueue,
+        globalErrors: mockGlobalErrors(),
+        runableResources: mockRunableResources(),
+        reportDispatcher,
+        currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+        getConfig() {
+          return {};
+        },
+        reportChildrenOfBeforeAllFailure() {}
+      });
+
+      const executePromise = subject.execute();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      topSuiteRunQueueOpts.queueableFns[0].fn(function() {});
+
+      // Fail the first suite.
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const failingSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      failingSuiteRunQueueOpts.queueableFns[0].fn();
+      failingSuite.addExpectationResult(false, {});
+      failingSuiteRunQueueOpts.onComplete();
+
+      // Passing the second suite should not reset the overall result.
+      topSuiteRunQueueOpts.queueableFns[1].fn(function() {});
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const passingSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      passingSuiteRunQueueOpts.queueableFns[0].fn();
+      passingSuiteRunQueueOpts.onComplete();
+
+      topSuiteRunQueueOpts.onComplete();
+
+      const result = await executePromise;
+      expect(result.hasFailures).toEqual(true);
+    });
+
+    it('reports children when there is a beforeAll failure', async function() {
+      const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+      const suite = new jasmineUnderTest.Suite({
+        id: 'suite',
+        parentSuite: topSuite
+      });
+      suite.beforeAll({ fn() {} });
+      const spec = new jasmineUnderTest.Spec({
+        id: 'spec',
+        parentSuite: suite,
+        queueableFn: { fn() {} }
+      });
+      suite.addChild(spec);
+      topSuite.addChild(suite);
+      const executionTree = {
+        topSuite,
+        childrenOfTopSuite() {
+          return [{ suite }];
+        },
+        childrenOfSuiteSegment() {
+          return [{ spec }];
+        },
+        isExcluded() {
+          return false;
+        }
+      };
+      const runQueue = jasmine.createSpy('runQueue');
+      const reportDispatcher = mockReportDispatcher();
+      const reportChildrenOfBeforeAllFailure = jasmine
+        .createSpy('reportChildrenOfBeforeAllFailure')
+        .and.returnValue(Promise.resolve());
+      const subject = new jasmineUnderTest.TreeRunner({
+        executionTree,
+        runQueue,
+        globalErrors: mockGlobalErrors(),
+        runableResources: mockRunableResources(),
+        reportDispatcher,
+        currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+        reportChildrenOfBeforeAllFailure,
+        getConfig() {
+          return {};
+        }
+      });
+
+      const executePromise = subject.execute();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      topSuiteRunQueueOpts.queueableFns[0].fn(function() {});
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const suiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      suiteRunQueueOpts.queueableFns[0].fn();
+      suite.hadBeforeAllFailure = true;
+      suiteRunQueueOpts.onComplete();
+
+      while (reportDispatcher.suiteDone.calls.count() === 0) {
+        await Promise.resolve();
+      }
+
+      expect(reportDispatcher.specDone).toHaveBeenCalledBefore(
+        reportDispatcher.suiteDone
+      );
+      await expectAsync(executePromise).toBePending();
+    });
+
+    it('throws if the wrong suite is completed', async function() {
+      const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+      const suite = new jasmineUnderTest.Suite({
+        id: 'suite',
+        parentSuite: topSuite
+      });
+      const spec = new jasmineUnderTest.Spec({
+        id: 'spec',
+        parentSuite: suite,
+        queueableFn: { fn() {} }
+      });
+      const executionTree = {
+        topSuite,
+        childrenOfTopSuite() {
+          return [{ suite }];
+        },
+        childrenOfSuiteSegment() {
+          return [{ spec }];
+        },
+        isExcluded() {
+          return false;
+        }
+      };
+      const runQueue = jasmine.createSpy('runQueue');
+      const reportDispatcher = mockReportDispatcher();
+      const subject = new jasmineUnderTest.TreeRunner({
+        executionTree,
+        runQueue,
+        globalErrors: mockGlobalErrors(),
+        runableResources: mockRunableResources(),
+        reportDispatcher,
+        currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+        getConfig() {
+          return {};
+        },
+        reportChildrenOfBeforeAllFailure() {}
+      });
+
+      const executePromise = subject.execute();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      topSuiteRunQueueOpts.queueableFns[0].fn(function() {});
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const suiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+
+      // Complete the suite without starting it
+      expect(function() {
+        suiteRunQueueOpts.onComplete();
+      }).toThrowError('Tried to complete the wrong suite');
+
+      await expectAsync(executePromise).toBePending();
+    });
+  });
+
+  it('does not remove before and after fns from the top suite', async function() {
+    const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+    spyOn(topSuite, 'cleanupBeforeAfter');
+    const executionTree = {
+      topSuite,
+      childrenOfTopSuite() {
+        return [];
+      },
+      isExcluded() {
+        return false;
+      }
+    };
+    const runQueue = jasmine.createSpy('runQueue');
+    const subject = new jasmineUnderTest.TreeRunner({
+      executionTree,
+      runQueue,
+      globalErrors: mockGlobalErrors(),
+      runableResources: mockRunableResources(),
+      reportDispatcher: mockReportDispatcher(),
+      currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+      getConfig() {
+        return {};
+      }
+    });
+
+    const executePromise = subject.execute();
+    expect(runQueue).toHaveBeenCalledTimes(1);
+    const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+    runQueue.calls.reset();
+
+    for (const qfn of topSuiteRunQueueOpts.queueableFns) {
+      qfn.fn();
+    }
+    topSuiteRunQueueOpts.onComplete();
+
+    await expectAsync(executePromise).toBeResolved();
+    expect(topSuite.cleanupBeforeAfter).not.toHaveBeenCalled();
+  });
+
+  describe('Late promise rejection handling', function() {
+    it('works for specs when the detectLateRejectionHandling param is true', function() {
+      const before = jasmine.createSpy('before');
+      const after = jasmine.createSpy('after');
+      const queueableFn = {
+        fn: jasmine.createSpy('test body').and.callFake(function() {
+          expect(before).toHaveBeenCalled();
+          expect(after).not.toHaveBeenCalled();
+        })
+      };
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn,
+        beforeAndAfterFns: function() {
+          return { befores: [before], afters: [after] };
+        }
+      });
+
+      const {
+        runQueue,
+        setTimeout,
+        suiteRunQueueArgs,
+        globalErrors
+      } = runSingleSpecSuite(spec, { detectLateRejectionHandling: true });
+
+      suiteRunQueueArgs.queueableFns[0].fn();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const specRunQueueOpts = runQueue.calls.mostRecent().args[0];
+
+      expect(specRunQueueOpts.queueableFns).toEqual([
+        { fn: jasmine.any(Function) },
+        before,
+        queueableFn,
+        after,
+        { fn: jasmine.any(Function) },
+        {
+          fn: jasmine.any(Function),
+          type: 'specCleanup'
+        }
+      ]);
+
+      const done = jasmine.createSpy('done');
+      specRunQueueOpts.queueableFns[4].fn(done);
+      expect(globalErrors.reportUnhandledRejections).not.toHaveBeenCalled();
+      expect(done).not.toHaveBeenCalled();
+
+      expect(setTimeout).toHaveBeenCalledOnceWith(jasmine.any(Function));
+      setTimeout.calls.argsFor(0)[0]();
+      expect(globalErrors.reportUnhandledRejections).toHaveBeenCalled();
+      expect(globalErrors.reportUnhandledRejections).toHaveBeenCalledBefore(
+        done
+      );
+    });
+
+    it('works for beforeAll when the detectLateRejectionHandling param is true', async function() {
+      const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+      const suite = new jasmineUnderTest.Suite({
+        id: 'suite',
+        parentSuite: topSuite
+      });
+      suite.beforeAll(function() {});
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn() {} },
+        parentSuite: suite
+      });
+      const executionTree = {
+        topSuite,
+        childrenOfTopSuite() {
+          return [{ suite }];
+        },
+        childrenOfSuiteSegment() {
+          return [{ spec }];
+        },
+        isExcluded() {
+          return false;
+        }
+      };
+      const runQueue = jasmine.createSpy('runQueue');
+      const reportDispatcher = mockReportDispatcher();
+      const globalErrors = mockGlobalErrors();
+      const setTimeout = jasmine.createSpy('setTimeout');
+      const subject = new jasmineUnderTest.TreeRunner({
+        executionTree,
+        runQueue,
+        globalErrors,
+        runableResources: mockRunableResources(),
+        reportDispatcher,
+        setTimeout,
+        currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+        getConfig() {
+          return { detectLateRejectionHandling: true };
+        },
+        reportChildrenOfBeforeAllFailure() {}
+      });
+
+      const executePromise = subject.execute();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      topSuiteRunQueueOpts.queueableFns[0].fn(function() {});
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const suiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      expect(suiteRunQueueOpts.queueableFns).toEqual([
+        { fn: jasmine.any(Function) }, // onStart
+        jasmine.objectContaining({ type: 'beforeAll' }),
+        { fn: jasmine.any(Function) }, // detect late rejection handling
+        { fn: jasmine.any(Function) } // spec
+      ]);
+      suiteRunQueueOpts.queueableFns[0].fn();
+      const done = jasmine.createSpy('done');
+      suiteRunQueueOpts.queueableFns[2].fn(done);
+      expect(globalErrors.reportUnhandledRejections).not.toHaveBeenCalled();
+
+      expect(setTimeout).toHaveBeenCalledOnceWith(jasmine.any(Function));
+      setTimeout.calls.argsFor(0)[0]();
+      expect(globalErrors.reportUnhandledRejections).toHaveBeenCalledBefore(
+        done
+      );
+
+      await expectAsync(executePromise).toBePending();
+    });
+
+    it('works for afterAll when the detectLateRejectionHandling param is true', async function() {
+      const topSuite = new jasmineUnderTest.Suite({ id: 'topSuite' });
+      const suite = new jasmineUnderTest.Suite({
+        id: 'suite',
+        parentSuite: topSuite
+      });
+      suite.afterAll(function() {});
+      const spec = new jasmineUnderTest.Spec({
+        queueableFn: { fn() {} },
+        parentSuite: suite
+      });
+      const executionTree = {
+        topSuite,
+        childrenOfTopSuite() {
+          return [{ suite }];
+        },
+        childrenOfSuiteSegment() {
+          return [{ spec }];
+        },
+        isExcluded() {
+          return false;
+        }
+      };
+      const runQueue = jasmine.createSpy('runQueue');
+      const reportDispatcher = mockReportDispatcher();
+      const globalErrors = mockGlobalErrors();
+      const setTimeout = jasmine.createSpy('setTimeout');
+      const subject = new jasmineUnderTest.TreeRunner({
+        executionTree,
+        runQueue,
+        globalErrors,
+        runableResources: mockRunableResources(),
+        reportDispatcher,
+        setTimeout,
+        currentRunableTracker: new jasmineUnderTest.CurrentRunableTracker(),
+        getConfig() {
+          return { detectLateRejectionHandling: true };
+        },
+        reportChildrenOfBeforeAllFailure() {}
+      });
+
+      const executePromise = subject.execute();
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const topSuiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      runQueue.calls.reset();
+      topSuiteRunQueueOpts.queueableFns[0].fn(function() {});
+
+      expect(runQueue).toHaveBeenCalledTimes(1);
+      const suiteRunQueueOpts = runQueue.calls.mostRecent().args[0];
+      expect(suiteRunQueueOpts.queueableFns).toEqual([
+        { fn: jasmine.any(Function) }, // onStart
+        { fn: jasmine.any(Function) }, // spec
+        jasmine.objectContaining({ type: 'afterAll' }),
+        { fn: jasmine.any(Function) } // detect late rejection handling
+      ]);
+      suiteRunQueueOpts.queueableFns[0].fn();
+      const done = jasmine.createSpy('done');
+      suiteRunQueueOpts.queueableFns[3].fn(done);
+      expect(globalErrors.reportUnhandledRejections).not.toHaveBeenCalled();
+
+      expect(setTimeout).toHaveBeenCalledOnceWith(jasmine.any(Function));
+      setTimeout.calls.argsFor(0)[0]();
+      expect(globalErrors.reportUnhandledRejections).toHaveBeenCalledBefore(
+        done
+      );
+
+      await expectAsync(executePromise).toBePending();
+    });
+  });
+
+  function runSingleSpecSuite(spec, optionalConfig) {
+    const topSuiteId = 'suite1';
+    spec.parentSuiteId = topSuiteId;
+    const topSuite = new jasmineUnderTest.Suite({ id: topSuiteId });
+    topSuite.addChild(spec);
+    const executionTree = {
+      topSuite,
+      childrenOfTopSuite() {
+        return [{ spec }];
+      },
+      isExcluded() {
+        return false;
+      }
+    };
+    const runQueue = jasmine.createSpy('runQueue');
+    const reportDispatcher = mockReportDispatcher();
+    const runableResources = mockRunableResources();
+    const globalErrors = mockGlobalErrors();
+    const setTimeout = jasmine.createSpy('setTimeout');
+    const currentRunableTracker = new jasmineUnderTest.CurrentRunableTracker();
+    const subject = new jasmineUnderTest.TreeRunner({
+      executionTree,
+      runQueue,
+      globalErrors,
+      setTimeout,
+      runableResources,
+      reportDispatcher,
+      currentRunableTracker,
+      getConfig() {
+        return optionalConfig || {};
+      },
+      reportChildrenOfBeforeAllFailure() {}
+    });
+
+    const executePromise = subject.execute();
+    expect(runQueue).toHaveBeenCalledTimes(1);
+    const suiteRunQueueArgs = runQueue.calls.mostRecent().args[0];
+    runQueue.calls.reset();
+
+    return {
+      runQueue,
+      globalErrors,
+      setTimeout,
+      currentRunableTracker,
+      runableResources,
+      reportDispatcher,
+      suiteRunQueueArgs,
+      executePromise
+    };
+  }
+
+  function mockReportDispatcher() {
+    const reportDispatcher = jasmine.createSpyObj(
+      'reportDispatcher',
+      jasmineUnderTest.reporterEvents
+    );
+
+    for (const k of jasmineUnderTest.reporterEvents) {
+      reportDispatcher[k].and.returnValue(Promise.resolve());
+    }
+
+    return reportDispatcher;
+  }
+
+  function mockRunableResources() {
+    return jasmine.createSpyObj('runableResources', [
+      'initForRunable',
+      'clearForRunable'
+    ]);
+  }
+
+  function mockGlobalErrors() {
+    return jasmine.createSpyObj('globalErrors', ['reportUnhandledRejections']);
+  }
+});

spec/core/UtilSpec.js

@@ -128,17 +128,6 @@ describe('util', function() {
     });
   });
 
-  describe('isUndefined', function() {
-    it('reports if a variable is defined', function() {
-      let a;
-      expect(jasmineUnderTest.util.isUndefined(a)).toBe(true);
-      expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(true);
-
-      const defined = 'diz be undefined yo';
-      expect(jasmineUnderTest.util.isUndefined(defined)).toBe(false);
-    });
-  });
-
   describe('cloneArgs', function() {
     it('clones primitives as-is', function() {
       expect(jasmineUnderTest.util.cloneArgs([true, false])).toEqual([

spec/core/baseSpec.js

@@ -2,8 +2,7 @@ describe('base helpers', function() {
   describe('isError_', function() {
     it('correctly handles WebSocket events', function(done) {
       if (typeof jasmine.getGlobal().WebSocket === 'undefined') {
-        done();
-        return;
+        pending('Environment does not provide WebSocket');
       }
 
       const obj = (function() {
@@ -179,7 +178,10 @@ describe('base helpers', function() {
         f2 = jasmine.createSpy('setTimeout callback for ' + (max + 1));
 
       // Suppress printing of TimeoutOverflowWarning in node
-      spyOn(console, 'error');
+      if (typeof process !== 'undefined' && process.emitWarning) {
+        spyOn(process, 'emitWarning'); // Node 22
+      }
+      spyOn(console, 'error'); // Node <22
 
       let id = setTimeout(f1, max);
       setTimeout(function() {

spec/core/buildExpectationResultSpec.js

@@ -79,7 +79,7 @@ describe('buildExpectationResult', function() {
 
   it('handles nodejs assertions', function() {
     if (typeof require === 'undefined') {
-      return;
+      pending('This test only runs in Node');
     }
     const assert = require('assert');
     const value = 8421;

spec/core/integration/MatchersSpec.js

@@ -469,6 +469,32 @@ describe('Matchers (Integration)', function() {
     });
   });
 
+  describe('toBeNullish', function() {
+    describe('with undefined', function() {
+      verifyPasses(function(env) {
+        env.expect(undefined).toBeNullish();
+      });
+    });
+
+    describe('with null', function() {
+      verifyPasses(function(env) {
+        env.expect(null).toBeNullish();
+      });
+    });
+
+    describe('with a truthy value', function() {
+      verifyFails(function(env) {
+        env.expect(1).toBeNullish();
+      });
+    });
+
+    describe('with a non-null falsy value', function() {
+      verifyFails(function(env) {
+        env.expect('').toBeNullish();
+      });
+    });
+  });
+
   describe('toContain', function() {
     verifyPasses(function(env) {
       env.addCustomEqualityTester(function(a, b) {
@@ -610,23 +636,31 @@ describe('Matchers (Integration)', function() {
   });
 
   describe('toHaveClass', function() {
-    beforeEach(function() {
-      this.domHelpers = jasmine.getEnv().domHelpers();
-    });
-
     verifyPasses(function(env) {
-      const domHelpers = jasmine.getEnv().domHelpers();
-      const el = domHelpers.createElementWithClassName('foo');
+      const el = specHelpers.domHelpers.createElementWithClassName('foo');
       env.expect(el).toHaveClass('foo');
     });
 
     verifyFails(function(env) {
-      const domHelpers = jasmine.getEnv().domHelpers();
-      const el = domHelpers.createElementWithClassName('foo');
+      const el = specHelpers.domHelpers.createElementWithClassName('foo');
       env.expect(el).toHaveClass('bar');
     });
   });
 
+  describe('toHaveClasses', function() {
+    verifyPasses(function(env) {
+      const el = specHelpers.domHelpers.createElementWithClassName(
+        'foo bar baz'
+      );
+      env.expect(el).toHaveClasses(['bar', 'baz']);
+    });
+
+    verifyFails(function(env) {
+      const el = specHelpers.domHelpers.createElementWithClassName('foo bar');
+      env.expect(el).toHaveClasses(['bar', 'baz']);
+    });
+  });
+
   describe('toHaveSpyInteractions', function() {
     let spyObj;
     beforeEach(function() {
@@ -639,13 +673,34 @@ describe('Matchers (Integration)', function() {
       env.expect(spyObj).toHaveSpyInteractions();
     });
 
-    verifyFails(function(env) {
-      env.expect(spyObj).toHaveSpyInteractions();
+    describe('with no methods called', function() {
+      verifyFails(function(env) {
+        env.expect(spyObj).toHaveSpyInteractions();
+      });
+    });
+
+    describe('with only non-spy methods called', function() {
+      verifyFails(function(env) {
+        spyObj.otherMethod();
+        env.expect(spyObj).toHaveSpyInteractions();
+      });
+    });
+  });
+
+  describe('toHaveNoOtherSpyInteractions', function() {
+    let spyObj;
+
+    beforeEach(function() {
+      spyObj = env.createSpyObj('NewClass', ['spyA', 'spyB']);
+    });
+
+    verifyPasses(function(env) {
+      env.expect(spyObj).toHaveNoOtherSpyInteractions();
     });
 
     verifyFails(function(env) {
-      spyObj.otherMethod();
-      env.expect(spyObj).toHaveSpyInteractions();
+      spyObj.spyA();
+      env.expect(spyObj).toHaveNoOtherSpyInteractions();
     });
   });
 

spec/core/integration/SpecRunningSpec.js

@@ -2,7 +2,7 @@ describe('spec running', function() {
   let env;
 
   beforeEach(function() {
-    jasmine.getEnv().registerIntegrationMatchers();
+    specHelpers.registerIntegrationMatchers();
     env = new jasmineUnderTest.Env();
     env.configure({ random: false });
   });
@@ -621,9 +621,14 @@ describe('spec running', function() {
       actions.push('spec3');
     });
 
+    spyOn(jasmineUnderTest.getEnv(), 'deprecated');
+
     await env.execute([spec2.id, spec3.id, spec1.id]);
 
     expect(actions).toEqual(['spec2', 'spec3', 'spec1']);
+    expect(jasmineUnderTest.getEnv().deprecated).toHaveBeenCalledWith(
+      'The specified spec/suite order splits up a suite, running unrelated specs in the middle of it. This will become an error in a future release.'
+    );
   });
 
   it('refuses to re-enter suites with a beforeAll', async function() {
@@ -866,7 +871,6 @@ describe('spec running', function() {
       const actions = [];
 
       env.describe('Something', function() {
-        // eslint-disable-next-line no-unused-vars
         env.beforeEach(function(innerDone) {
           actions.push('beforeEach');
         }, 1);

spec/core/matchers/DiffBuilderSpec.js

@@ -161,6 +161,63 @@ describe('DiffBuilder', function() {
     expect(diffBuilder.getMessage()).toEqual(expectedMsg);
   });
 
+  it('handles cases where only the expected has a custom object formatter', function() {
+    const formatter = function(x) {
+      if (typeof x === 'number') {
+        return '[number:' + x + ']';
+      }
+    };
+    const prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
+    const diffBuilder = new jasmineUnderTest.DiffBuilder({
+      prettyPrinter: prettyPrinter
+    });
+
+    diffBuilder.setRoots('five', 4);
+    diffBuilder.recordMismatch();
+
+    expect(diffBuilder.getMessage()).toEqual(
+      "Expected 'five' to equal [number:4]."
+    );
+  });
+
+  it('handles cases where only the actual has a custom object formatter', function() {
+    const formatter = function(x) {
+      if (typeof x === 'number') {
+        return '[number:' + x + ']';
+      }
+    };
+    const prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
+    const diffBuilder = new jasmineUnderTest.DiffBuilder({
+      prettyPrinter: prettyPrinter
+    });
+
+    diffBuilder.setRoots(5, 'four');
+    diffBuilder.recordMismatch();
+
+    expect(diffBuilder.getMessage()).toEqual(
+      "Expected [number:5] to equal 'four'."
+    );
+  });
+
+  it('handles complex cases where only one side has a custom object formatter', function() {
+    const formatter = function(x) {
+      if (typeof x === 'number') {
+        return '[number:' + x + ']';
+      }
+    };
+    const prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
+    const diffBuilder = new jasmineUnderTest.DiffBuilder({
+      prettyPrinter: prettyPrinter
+    });
+
+    diffBuilder.setRoots(5, { foo: 'bar', fnord: { graults: ['wombat'] } });
+    diffBuilder.recordMismatch();
+
+    expect(diffBuilder.getMessage()).toEqual(
+      "Expected [number:5] to equal Object({ foo: 'bar', fnord: Object({ graults: [ 'wombat' ] }) })."
+    );
+  });
+
   it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ at the root', function() {
     const prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
       diffBuilder = new jasmineUnderTest.DiffBuilder({

spec/core/matchers/async/toBePendingSpec.js

@@ -38,6 +38,8 @@ describe('toBePending', function() {
       return matcher.compare(actual);
     }
 
-    expect(f).toThrowError('Expected toBePending to be called on a promise.');
+    expect(f).toThrowError(
+      'Expected toBePending to be called on a promise but was on a string.'
+    );
   });
 });

spec/core/matchers/async/toBeRejectedSpec.js

@@ -28,6 +28,8 @@ describe('toBeRejected', function() {
       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 but was on a string.'
+    );
   });
 });

spec/core/matchers/async/toBeRejectedWithErrorSpec.js

@@ -232,7 +232,7 @@ describe('#toBeRejectedWithError', function() {
     }
 
     expect(f).toThrowError(
-      'Expected toBeRejectedWithError to be called on a promise.'
+      'Expected toBeRejectedWithError to be called on a promise but was on a string.'
     );
   });
 });

spec/core/matchers/async/toBeRejectedWithSpec.js

@@ -83,7 +83,7 @@ describe('#toBeRejectedWith', function() {
     }
 
     expect(f).toThrowError(
-      'Expected toBeRejectedWith to be called on a promise.'
+      'Expected toBeRejectedWith to be called on a promise but was on a string.'
     );
   });
 });

spec/core/matchers/async/toBeResolvedSpec.js

@@ -35,6 +35,8 @@ describe('toBeResolved', function() {
       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 but was on a string.'
+    );
   });
 });

spec/core/matchers/async/toBeResolvedToSpec.js

@@ -93,7 +93,7 @@ describe('#toBeResolvedTo', function() {
     }
 
     expect(f).toThrowError(
-      'Expected toBeResolvedTo to be called on a promise.'
+      'Expected toBeResolvedTo to be called on a promise but was on a string.'
     );
   });
 });

spec/core/matchers/matchersUtilSpec.js

@@ -250,10 +250,6 @@ describe('matchersUtil', function() {
     });
 
     it('passes for equivalent Promises (GitHub issue #1314)', function() {
-      if (typeof Promise === 'undefined') {
-        return;
-      }
-
       const p1 = new Promise(function() {}),
         p2 = new Promise(function() {}),
         matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -263,14 +259,13 @@ describe('matchersUtil', function() {
     });
 
     describe('when running in a browser', function() {
-      function isNotRunningInBrowser() {
-        return typeof document === 'undefined';
-      }
+      beforeEach(function() {
+        if (typeof document === 'undefined') {
+          pending('This test only runs in browsers');
+        }
+      });
 
       it('passes for equivalent DOM nodes', function() {
-        if (isNotRunningInBrowser()) {
-          return;
-        }
         const a = document.createElement('div');
         const matchersUtil = new jasmineUnderTest.MatchersUtil();
 
@@ -285,9 +280,6 @@ describe('matchersUtil', function() {
       });
 
       it('passes for equivalent objects from different frames', function() {
-        if (isNotRunningInBrowser()) {
-          return;
-        }
         const matchersUtil = new jasmineUnderTest.MatchersUtil();
         const iframe = document.createElement('iframe');
         document.body.appendChild(iframe);
@@ -299,9 +291,6 @@ describe('matchersUtil', function() {
       });
 
       it('fails for DOM nodes with different attributes or child nodes', function() {
-        if (isNotRunningInBrowser()) {
-          return;
-        }
         const matchersUtil = new jasmineUnderTest.MatchersUtil();
         const a = document.createElement('div');
         a.setAttribute('test-attr', 'attr-value');
@@ -325,14 +314,13 @@ describe('matchersUtil', function() {
     });
 
     describe('when running in Node', function() {
-      function isNotRunningInNode() {
-        return typeof require !== 'function';
-      }
+      beforeEach(function() {
+        if (typeof require !== 'function') {
+          pending('This test only runs in Node');
+        }
+      });
 
       it('passes for equivalent objects from different vm contexts', function() {
-        if (isNotRunningInNode()) {
-          return;
-        }
         const matchersUtil = new jasmineUnderTest.MatchersUtil();
         const vm = require('vm');
         const sandbox = {
@@ -344,9 +332,6 @@ describe('matchersUtil', function() {
       });
 
       it('passes for equivalent arrays from different vm contexts', function() {
-        if (isNotRunningInNode()) {
-          return;
-        }
         const matchersUtil = new jasmineUnderTest.MatchersUtil();
         const vm = require('vm');
         const sandbox = {
@@ -757,7 +742,9 @@ describe('matchersUtil', function() {
             const a2 = new TypedArrayCtor(2);
             a1[0] = a2[0] = 0;
             a1[1] = a2[1] = 1;
-            expect(matchersUtil.equals(a1, a2)).toBe(true);
+            const diffBuilder = new jasmineUnderTest.DiffBuilder();
+            expect(matchersUtil.equals(a1, a2, diffBuilder)).toBe(true);
+            jasmine.debugLog('Diff: ' + diffBuilder.getMessage());
           }
         );
 
@@ -766,7 +753,9 @@ describe('matchersUtil', function() {
           const a1 = new TypedArrayCtor(2);
           const a2 = new TypedArrayCtor(1);
           a1[0] = a1[1] = a2[0] = 0;
-          expect(matchersUtil.equals(a1, a2)).toBe(false);
+          const diffBuilder = new jasmineUnderTest.DiffBuilder();
+          expect(matchersUtil.equals(a1, a2, diffBuilder)).toBe(false);
+          jasmine.debugLog('Diff: ' + diffBuilder.getMessage());
         });
 
         it(
@@ -777,7 +766,9 @@ describe('matchersUtil', function() {
             const a2 = new TypedArrayCtor(1);
             a1[0] = 0;
             a2[0] = 1;
-            expect(matchersUtil.equals(a1, a2)).toBe(false);
+            const diffBuilder = new jasmineUnderTest.DiffBuilder();
+            expect(matchersUtil.equals(a1, a2, diffBuilder)).toBe(false);
+            jasmine.debugLog('Diff: ' + diffBuilder.getMessage());
           }
         );
 
@@ -824,9 +815,7 @@ describe('matchersUtil', function() {
             const matchersUtil = new jasmineUnderTest.MatchersUtil();
             const a1 = new TypedArrayCtor(2);
             const a2 = new TypedArrayCtor(2);
-            // eslint-disable-next-line compat/compat
             a1[0] = a2[0] = BigInt(0);
-            // eslint-disable-next-line compat/compat
             a1[1] = a2[1] = BigInt(1);
             expect(matchersUtil.equals(a1, a2)).toBe(true);
           }
@@ -837,7 +826,6 @@ describe('matchersUtil', function() {
           const matchersUtil = new jasmineUnderTest.MatchersUtil();
           const a1 = new TypedArrayCtor(2);
           const a2 = new TypedArrayCtor(1);
-          // eslint-disable-next-line compat/compat
           a1[0] = a1[1] = a2[0] = BigInt(0);
           expect(matchersUtil.equals(a1, a2)).toBe(false);
         });
@@ -849,9 +837,7 @@ describe('matchersUtil', function() {
             const matchersUtil = new jasmineUnderTest.MatchersUtil();
             const a1 = new TypedArrayCtor(2);
             const a2 = new TypedArrayCtor(2);
-            // eslint-disable-next-line compat/compat
             a1[0] = a1[1] = a2[0] = BigInt(0);
-            // eslint-disable-next-line compat/compat
             a2[1] = BigInt(1);
             expect(matchersUtil.equals(a1, a2)).toBe(false);
           }

spec/core/matchers/toBeNullishSpec.js

@@ -0,0 +1,57 @@
+describe('toBeNullish', function() {
+  it('passes for null values', function() {
+    const matcher = jasmineUnderTest.matchers.toBeNullish();
+    const result = matcher.compare(null);
+    expect(result.pass).toBe(true);
+  });
+
+  it('passes for undefined values', function() {
+    const matcher = jasmineUnderTest.matchers.toBeNullish();
+    const result = matcher.compare(void 0);
+    expect(result.pass).toBe(true);
+  });
+
+  it('fails when matching defined values', function() {
+    const matcher = jasmineUnderTest.matchers.toBeNullish();
+    const result = matcher.compare('foo');
+    expect(result.pass).toBe(false);
+  });
+
+  describe('falsy values', () => {
+    it('fails for 0', function() {
+      const matcher = jasmineUnderTest.matchers.toBeNullish();
+      const result = matcher.compare(0);
+      expect(result.pass).toBe(false);
+    });
+
+    it('fails for -0', function() {
+      const matcher = jasmineUnderTest.matchers.toBeNullish();
+      const result = matcher.compare(-0);
+      expect(result.pass).toBe(false);
+    });
+
+    it('fails for empty string', function() {
+      const matcher = jasmineUnderTest.matchers.toBeNullish();
+      const result = matcher.compare('');
+      expect(result.pass).toBe(false);
+    });
+
+    it('fails for false', function() {
+      const matcher = jasmineUnderTest.matchers.toBeNullish();
+      const result = matcher.compare(false);
+      expect(result.pass).toBe(false);
+    });
+
+    it('fails for NaN', function() {
+      const matcher = jasmineUnderTest.matchers.toBeNullish();
+      const result = matcher.compare(NaN);
+      expect(result.pass).toBe(false);
+    });
+
+    it('fails for 0n', function() {
+      const matcher = jasmineUnderTest.matchers.toBeNullish();
+      const result = matcher.compare(BigInt(0));
+      expect(result.pass).toBe(false);
+    });
+  });
+});

spec/core/matchers/toEqualSpec.js

@@ -1,4 +1,3 @@
-/* eslint-disable compat/compat */
 describe('toEqual', function() {
   'use strict';
 
@@ -96,6 +95,17 @@ describe('toEqual', function() {
     expect(compareEquals(actual, expected).message).toEqual(message);
   });
 
+  it('reports mismatches as well as missing or extra properties', function() {
+    const actual = { x: { z: 2 } },
+      expected = { x: { y: 1, z: 3 } },
+      message =
+        'Expected $.x to have properties\n' +
+        '    y: 1\n' +
+        'Expected $.x.z = 2 to equal 3.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
   it('reports missing symbol properties', function() {
     const actual = { x: {} },
       expected = { x: { [Symbol('y')]: 1 } },
@@ -448,9 +458,9 @@ describe('toEqual', function() {
   });
 
   it('reports mismatches between Functions', function() {
-    const actual = { x: function() {} },
-      expected = { x: function() {} },
-      message = 'Expected $.x = Function to equal Function.';
+    const actual = { x: function() {} };
+    const expected = { x: function() {} };
+    const message = "Expected $.x = Function 'x' to equal Function 'x'.";
 
     expect(compareEquals(actual, expected).message).toEqual(message);
   });

spec/core/matchers/toHaveBeenCalledBeforeSpec.js

@@ -112,4 +112,20 @@ describe('toHaveBeenCalledBefore', function() {
       'Expected spy first spy to not have been called before spy second spy, but it was'
     );
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+      firstSpy = new jasmineUnderTest.Spy('first spy'),
+      secondSpy = new jasmineUnderTest.Spy('second spy');
+
+    firstSpy();
+    secondSpy();
+
+    matcher.compare(firstSpy, secondSpy);
+
+    expect(firstSpy.calls.count()).toBe(1);
+    expect(firstSpy.calls.unverifiedCount()).toBe(0);
+    expect(secondSpy.calls.count()).toBe(1);
+    expect(secondSpy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledOnceWithSpec.js

@@ -105,4 +105,18 @@ describe('toHaveBeenCalledOnceWith', function() {
       matcher.compare(fn);
     }).toThrowError(/Expected a spy, but got Function./);
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const pp = jasmineUnderTest.makePrettyPrinter(),
+      util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
+      calledSpy = new jasmineUnderTest.Spy('called-spy');
+
+    calledSpy('x');
+
+    matcher.compare(calledSpy, 'x');
+
+    expect(calledSpy.calls.count()).toBe(1);
+    expect(calledSpy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -50,4 +50,16 @@ describe('toHaveBeenCalled', function() {
       'Expected spy sample-spy to have been called.'
     );
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
+      spy = new jasmineUnderTest.Spy('sample-spy');
+
+    spy();
+
+    matcher.compare(spy);
+
+    expect(spy.calls.count()).toBe(1);
+    expect(spy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledTimesSpec.js

@@ -87,4 +87,17 @@ describe('toHaveBeenCalledTimes', function() {
         ' times.'
     );
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+      spy = new jasmineUnderTest.Spy('sample-spy');
+
+    spy();
+    spy();
+
+    matcher.compare(spy, 2);
+
+    expect(spy.calls.count()).toBe(2);
+    expect(spy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -2,6 +2,7 @@ describe('toHaveBeenCalledWith', function() {
   it('passes when the actual was called with matching parameters', function() {
     const matchersUtil = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
+        equals: jasmine.createSpy('delegated-equals').and.returnValue(true),
         pp: jasmineUnderTest.makePrettyPrinter()
       },
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
@@ -92,4 +93,20 @@ describe('toHaveBeenCalledWith', function() {
       matcher.compare(fn);
     }).toThrowError(/Expected a spy, but got Function./);
   });
+
+  it('set the correct calls as verified when passing', function() {
+    const matchersUtil = {
+        contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
+        equals: jasmine.createSpy('delegated-equals').and.returnValue(true),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      },
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      calledSpy = new jasmineUnderTest.Spy('called-spy');
+
+    calledSpy('a', 'b');
+    matcher.compare(calledSpy, 'a', 'b');
+
+    expect(calledSpy.calls.count()).toBe(1);
+    expect(calledSpy.calls.unverifiedCount()).toBe(0);
+  });
 });

spec/core/matchers/toHaveClassSpec.js

@@ -1,12 +1,8 @@
 describe('toHaveClass', function() {
-  beforeEach(function() {
-    this.domHelpers = jasmine.getEnv().domHelpers();
-  });
-
   it('fails for a DOM element that lacks the expected class', function() {
     const matcher = jasmineUnderTest.matchers.toHaveClass(),
       result = matcher.compare(
-        this.domHelpers.createElementWithClassName(''),
+        specHelpers.domHelpers.createElementWithClassName(''),
         'foo'
       );
 
@@ -15,7 +11,7 @@ describe('toHaveClass', function() {
 
   it('passes for a DOM element that has the expected class', function() {
     const matcher = jasmineUnderTest.matchers.toHaveClass(),
-      el = this.domHelpers.createElementWithClassName('foo bar baz');
+      el = specHelpers.domHelpers.createElementWithClassName('foo bar baz');
 
     expect(matcher.compare(el, 'foo').pass).toBe(true);
     expect(matcher.compare(el, 'bar').pass).toBe(true);
@@ -24,7 +20,7 @@ describe('toHaveClass', function() {
 
   it('fails for a DOM element that only has other classes', function() {
     const matcher = jasmineUnderTest.matchers.toHaveClass(),
-      el = this.domHelpers.createElementWithClassName('foo bar');
+      el = specHelpers.domHelpers.createElementWithClassName('foo bar');
 
     expect(matcher.compare(el, 'fo').pass).toBe(false);
   });
@@ -42,7 +38,7 @@ describe('toHaveClass', function() {
       matcher.compare(undefined, 'foo');
     }).toThrowError('undefined is not a DOM element');
 
-    const textNode = this.domHelpers.document.createTextNode('');
+    const textNode = specHelpers.domHelpers.document.createTextNode('');
     expect(function() {
       matcher.compare(textNode, 'foo');
     }).toThrowError('HTMLNode is not a DOM element');

spec/core/matchers/toHaveClassesSpec.js

@@ -0,0 +1,48 @@
+describe('toHaveClasses', function() {
+  it('fails for a DOM element that lacks all the expected classes', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveClasses(),
+      result = matcher.compare(
+        specHelpers.domHelpers.createElementWithClassName(''),
+        ['foo', 'bar']
+      );
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for a DOM element that has all the expected classes', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveClasses(),
+      el = specHelpers.domHelpers.createElementWithClassName('foo bar baz');
+
+    expect(matcher.compare(el, ['foo', 'bar']).pass).toBe(true);
+  });
+
+  it('fails for a DOM element that only has some matching classes', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveClasses(),
+      el = specHelpers.domHelpers.createElementWithClassName('foo bar');
+
+    expect(matcher.compare(el, ['foo', 'can']).pass).toBe(false);
+  });
+
+  it('throws an exception when actual is not a DOM element', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveClasses({
+      pp: jasmineUnderTest.makePrettyPrinter()
+    });
+
+    expect(function() {
+      matcher.compare('x', ['foo']);
+    }).toThrowError("'x' is not a DOM element");
+
+    expect(function() {
+      matcher.compare(undefined, ['foo']);
+    }).toThrowError('undefined is not a DOM element');
+
+    const textNode = specHelpers.domHelpers.document.createTextNode('');
+    expect(function() {
+      matcher.compare(textNode, ['foo']);
+    }).toThrowError('HTMLNode is not a DOM element');
+
+    expect(function() {
+      matcher.compare({ classList: '' }, ['foo']);
+    }).toThrowError("Object({ classList: '' }) is not a DOM element");
+  });
+});

spec/core/matchers/toHaveNoOtherSpyInteractionsSpec.js

@@ -0,0 +1,154 @@
+describe('toHaveNoOtherSpyInteractions', function() {
+  it('passes when there are no spy interactions', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeTrue();
+  });
+
+  it('passes when there are multiple spy interactions where checked by toHaveBeenCalled', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let toHaveBeenCalledMatcher = jasmineUnderTest.matchers.toHaveBeenCalled();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA();
+    spyObj.spyB();
+    spyObj.spyA();
+    toHaveBeenCalledMatcher.compare(spyObj.spyA);
+    toHaveBeenCalledMatcher.compare(spyObj.spyB);
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeTrue();
+  });
+
+  it('fails when there are spy interactions', function() {
+    const matchersUtil = new jasmineUnderTest.MatchersUtil({
+      pp: jasmineUnderTest.makePrettyPrinter()
+    });
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions(
+      matchersUtil
+    );
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA('x');
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeFalse();
+    expect(result.message).toEqual(
+      'Expected a spy object to have no other spy interactions, but it had the following calls:\n' +
+        "  NewClass.spyA called with [ 'x' ]."
+    );
+  });
+
+  it('shows the right message is negated', function() {
+    const matchersUtil = new jasmineUnderTest.MatchersUtil({
+      pp: jasmineUnderTest.makePrettyPrinter()
+    });
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions(
+      matchersUtil
+    );
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA();
+    spyObj.spyB();
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeFalse();
+    expect(result.message).toEqual(
+      'Expected a spy object to have no other spy interactions, but it had the following calls:\n' +
+        '  NewClass.spyA called with [  ],\n' +
+        '  NewClass.spyB called with [  ].'
+    );
+  });
+
+  it('passes when only non-observed spy object interactions are interacted', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('NewClass', ['spyA', 'spyB']);
+    spyObj.otherMethod = function() {};
+
+    spyObj.otherMethod();
+
+    let result = matcher.compare(spyObj);
+    expect(result.pass).toBeTrue();
+    expect(result.message).toEqual(
+      "Expected a spy object to have other spy interactions but it didn't."
+    );
+  });
+
+  it('throws an error if a non-object is passed', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+
+    expect(function() {
+      matcher.compare(true);
+    }).toThrowError(Error, /Expected an object, but got/);
+
+    expect(function() {
+      matcher.compare(123);
+    }).toThrowError(Error, /Expected an object, but got/);
+
+    expect(function() {
+      matcher.compare('string');
+    }).toThrowError(Error, /Expected an object, but got/);
+  });
+
+  it('throws an error if arguments are passed', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    let spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('mySpyObj', ['spyA', 'spyB']);
+
+    expect(function() {
+      matcher.compare(spyObj, 'an argument');
+    }).toThrowError(Error, /Does not take arguments/);
+  });
+
+  it('throws an error if the spy object has no spies', function() {
+    let matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions();
+    const spyObj = jasmineUnderTest
+      .getEnv()
+      .createSpyObj('mySpyObj', ['notSpy']);
+    // Removing spy since spy objects cannot be created without spies.
+    spyObj.notSpy = function() {};
+
+    expect(function() {
+      matcher.compare(spyObj);
+    }).toThrowError(
+      Error,
+      /Expected an object with spies, but object has no spies/
+    );
+  });
+
+  it('handles multiple interactions with a single spy', function() {
+    const matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.matchers.toHaveNoOtherSpyInteractions(
+        matchersUtil
+      ),
+      toHaveBeenCalledWithMatcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(
+        matchersUtil
+      ),
+      spyObj = jasmineUnderTest
+        .getEnv()
+        .createSpyObj('NewClass', ['spyA', 'spyB']);
+
+    spyObj.spyA('x');
+    spyObj.spyA('y');
+
+    toHaveBeenCalledWithMatcher.compare(spyObj.spyA, 'x');
+
+    let result = matcher.compare(spyObj);
+
+    expect(result.pass).toBeFalse();
+  });
+});

spec/core/matchers/toHaveSizeSpec.js

@@ -15,6 +15,17 @@ describe('toHaveSize', function() {
     expect(result.pass).toBe(false);
   });
 
+  it('informs about the size of an array whose length does not match', function() {
+    const matcher = jasmineUnderTest.matchers.toHaveSize({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      result = matcher.compare([1, 2, 3], 2);
+
+    expect(result.message()).toEqual(
+      'Expected [ 1, 2, 3 ] with size 3 to have size 2.'
+    );
+  });
+
   it('passes for an object with the proper number of keys', function() {
     const matcher = jasmineUnderTest.matchers.toHaveSize(),
       result = matcher.compare({ a: 1, b: 2 }, 2);

spec/core/matchers/toHaveSpyInteractionsSpec.js

@@ -70,7 +70,7 @@ describe('toHaveSpyInteractions', function() {
     );
   });
 
-  it(`throws an error if a non-object is passed`, function() {
+  it('throws an error if a non-object is passed', function() {
     let matcher = jasmineUnderTest.matchers.toHaveSpyInteractions();
 
     expect(function() {

spec/core/matchers/toThrowErrorSpec.js

@@ -82,7 +82,7 @@ describe('toThrowError', function() {
 
     it('passes if thrown is an instanceof Error regardless of global that contains its constructor', function() {
       if (isNotRunningInBrowser()) {
-        return;
+        pending('This test only runs in browsers.');
       }
 
       const matcher = jasmineUnderTest.matchers.toThrowError();
@@ -281,22 +281,44 @@ describe('toThrowError', function() {
     );
   });
 
-  it('fails if thrown is a type of Error and the expected is a different Error', function() {
-    const matchersUtil = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
-        pp: jasmineUnderTest.makePrettyPrinter()
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
-      fn = function() {
-        throw new TypeError('foo');
-      };
+  describe('with a string', function() {
+    it('fails if thrown is a type of Error and the expected is a different Error', function() {
+      const matchersUtil = {
+          equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
+          pp: jasmineUnderTest.makePrettyPrinter()
+        },
+        matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
+        fn = function() {
+          throw new TypeError('foo');
+        };
 
-    const result = matcher.compare(fn, TypeError, 'bar');
+      const 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.pass).toBe(false);
+      expect(result.message()).toEqual(
+        "Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'."
+      );
+    });
+  });
+
+  describe('with a regex', function() {
+    it('fails if thrown is a type of Error and the expected is a different Error', function() {
+      const matchersUtil = {
+          equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
+          pp: jasmineUnderTest.makePrettyPrinter()
+        },
+        matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
+        fn = function() {
+          throw new TypeError('foo');
+        };
+
+      const 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'."
+      );
+    });
   });
 
   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() {
@@ -316,22 +338,4 @@ describe('toThrowError', function() {
       '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() {
-    const matchersUtil = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
-        pp: jasmineUnderTest.makePrettyPrinter()
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
-      fn = function() {
-        throw new TypeError('foo');
-      };
-
-    const 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'."
-    );
-  });
 });

spec/helpers/BrowserFlags.js

@@ -1,4 +1,4 @@
-(function(env) {
+(function() {
   function browserVersion(matchFn) {
     const userAgent = jasmine.getGlobal().navigator.userAgent;
     if (!userAgent) {
@@ -10,7 +10,7 @@
     return match ? parseFloat(match[1]) : void 0;
   }
 
-  env.firefoxVersion = browserVersion(function(userAgent) {
+  specHelpers.firefoxVersion = browserVersion(function(userAgent) {
     return /Firefox\/([0-9]{0,})/.exec(userAgent);
   });
-})(jasmine.getEnv());
+})();

spec/helpers/domHelpers.js

@@ -1,24 +1,20 @@
-(function(env) {
-  function domHelpers() {
-    let doc;
+(function() {
+  let doc;
 
-    if (typeof document !== 'undefined') {
-      doc = document;
-    } else {
-      const JSDOM = require('jsdom').JSDOM;
-      const dom = new JSDOM();
-      doc = dom.window.document;
-    }
-
-    return {
-      document: doc,
-      createElementWithClassName: function(className) {
-        const el = this.document.createElement('div');
-        el.className = className;
-        return el;
-      }
-    };
+  if (typeof document !== 'undefined') {
+    doc = document;
+  } else {
+    const JSDOM = require('jsdom').JSDOM;
+    const dom = new JSDOM();
+    doc = dom.window.document;
   }
 
-  env.domHelpers = domHelpers;
-})(jasmine.getEnv());
+  specHelpers.domHelpers = {
+    document: doc,
+    createElementWithClassName(className) {
+      const el = this.document.createElement('div');
+      el.className = className;
+      return el;
+    }
+  };
+})();

spec/helpers/init.js

@@ -0,0 +1 @@
+globalThis.specHelpers = {};

spec/helpers/integrationMatchers.js

@@ -1,5 +1,5 @@
-(function(env) {
-  env.registerIntegrationMatchers = function() {
+(function() {
+  specHelpers.registerIntegrationMatchers = function() {
     jasmine.addMatchers({
       toHaveFailedExpectationsForRunnable: function() {
         return {
@@ -51,4 +51,4 @@
       }
     });
   };
-})(jasmine.getEnv());
+})();

spec/helpers/nodeDefineJasmineUnderTest.js

@@ -12,14 +12,12 @@
   };
 
   function getSourceFiles() {
-    const src_files = ['core/**/*.js', 'version.js'].map(function(file) {
-      return path.join(__dirname, '../../', 'src/', file);
-    });
+    const globs = ['../../src/core/**/*.js', '../../src/version.js'];
+    const srcFiles = globs.flatMap(g => glob.sync(g, { cwd: __dirname }));
 
-    const files = src_files.flatMap(g => glob.sync(g));
-    files.forEach(function(resolvedFile) {
-      require(resolvedFile);
-    });
+    for (const file of srcFiles) {
+      require(file);
+    }
   }
 
   getSourceFiles();

spec/html/HtmlExactSpecFilterSpec.js

@@ -0,0 +1,63 @@
+describe('HtmlExactSpecFilter', function() {
+  it('matches everything when no string is provided', function() {
+    const specFilter = new jasmineUnderTest.HtmlExactSpecFilter({
+      queryString: {
+        getParam(name) {
+          return '';
+        }
+      }
+    });
+
+    expect(specFilter.matches({})).toBeTrue();
+  });
+
+  it('matches a spec with the exact same path', function() {
+    const specFilter = new jasmineUnderTest.HtmlExactSpecFilter({
+      queryString: {
+        getParam(name) {
+          if (name === 'spec') {
+            return '["a","b","c"]';
+          }
+        }
+      }
+    });
+
+    expect(specFilter.matches(stubSpec(['a', 'b', 'c']))).toBeTrue();
+  });
+
+  it('matches a spec whose path has the filter path as a prefix', function() {
+    const specFilter = new jasmineUnderTest.HtmlExactSpecFilter({
+      queryString: {
+        getParam(name) {
+          if (name === 'spec') {
+            return '["a","b"]';
+          }
+        }
+      }
+    });
+
+    expect(specFilter.matches(stubSpec(['a', 'b', 'c']))).toBeTrue();
+  });
+
+  it('does not match a spec with a different path', function() {
+    const specFilter = new jasmineUnderTest.HtmlExactSpecFilter({
+      queryString: {
+        getParam(name) {
+          if (name === 'spec') {
+            return '["a","b","c"]';
+          }
+        }
+      }
+    });
+
+    expect(specFilter.matches(stubSpec(['a', 'd', 'c']))).toBeFalse();
+  });
+
+  function stubSpec(path) {
+    return {
+      getPath() {
+        return path;
+      }
+    };
+  }
+});

spec/html/HtmlReporterSpec.js

@@ -499,7 +499,7 @@ describe('HtmlReporter', function() {
       expect(duration.innerHTML).toMatch(/finished in 0.1s/);
     });
 
-    it('reports the suite and spec names with status', function() {
+    it('reports the suite names with status, and spec names with status and duration', function() {
       const container = document.createElement('div'),
         getContainer = function() {
           return container;
@@ -528,11 +528,13 @@ describe('HtmlReporter', function() {
 
       let specResult = {
         id: 123,
+        parentSuiteId: 1,
         description: 'with a spec',
         fullName: 'A Suite with a spec',
         status: 'passed',
         failedExpectations: [],
-        passedExpectations: [{ passed: true }]
+        passedExpectations: [{ passed: true }],
+        duration: 1230
       };
       reporter.specStarted(specResult);
       reporter.specDone(specResult);
@@ -549,7 +551,8 @@ describe('HtmlReporter', function() {
         fullName: 'A Suite inner suite with another spec',
         status: 'passed',
         failedExpectations: [],
-        passedExpectations: [{ passed: true }]
+        passedExpectations: [{ passed: true }],
+        duration: 1240
       };
       reporter.specStarted(specResult);
       reporter.specDone(specResult);
@@ -567,7 +570,8 @@ describe('HtmlReporter', function() {
         fullName: 'A Suite inner with a failing spec',
         status: 'failed',
         failedExpectations: [{}],
-        passedExpectations: []
+        passedExpectations: [],
+        duration: 2090
       };
       reporter.specStarted(specResult);
       reporter.specDone(specResult);
@@ -602,7 +606,9 @@ describe('HtmlReporter', function() {
       const suiteDetail = outerSuite.childNodes[0];
       const suiteLink = suiteDetail.childNodes[0];
       expect(suiteLink.innerHTML).toEqual('A Suite');
-      expect(suiteLink.getAttribute('href')).toEqual('/?foo=bar&spec=A Suite');
+      expect(suiteLink.getAttribute('href')).toEqual(
+        '/?foo=bar&spec=["A Suite"]'
+      );
 
       const specs = outerSuite.childNodes[1];
       const spec = specs.childNodes[0];
@@ -612,8 +618,11 @@ describe('HtmlReporter', function() {
       const specLink = spec.childNodes[0];
       expect(specLink.innerHTML).toEqual('with a spec');
       expect(specLink.getAttribute('href')).toEqual(
-        '/?foo=bar&spec=A Suite with a spec'
+        '/?foo=bar&spec=["A Suite","with a spec"]'
       );
+
+      const specDuration = spec.childNodes[1];
+      expect(specDuration.innerHTML).toEqual('(1230ms)');
     });
 
     it('has an options menu', function() {
@@ -1359,6 +1368,11 @@ describe('HtmlReporter', function() {
           },
           createTextNode: function() {
             return document.createTextNode.apply(document, arguments);
+          },
+          queryString: {
+            getParam(name) {
+              return '';
+            }
           }
         };
         specStatus = {
@@ -1373,7 +1387,12 @@ describe('HtmlReporter', function() {
 
       describe('when the specs are not filtered', function() {
         beforeEach(function() {
-          reporterConfig.filterSpecs = false;
+          reporterConfig.queryString.getParam = function(name) {
+            if (name !== 'spec') {
+              throw new Error('Unexpected query param ' + name);
+            }
+            return '';
+          };
           reporter = new jasmineUnderTest.HtmlReporter(reporterConfig);
           reporter.initialize();
           reporter.jasmineStarted({ totalSpecsDefined: 1 });
@@ -1391,7 +1410,12 @@ describe('HtmlReporter', function() {
 
       describe('when the specs are filtered', function() {
         beforeEach(function() {
-          reporterConfig.filterSpecs = true;
+          reporterConfig.queryString.getParam = function(name) {
+            if (name !== 'spec') {
+              throw new Error('Unexpected query param ' + name);
+            }
+            return 'not the empty string';
+          };
           reporter = new jasmineUnderTest.HtmlReporter(reporterConfig);
           reporter.initialize();
           reporter.jasmineStarted({ totalSpecsDefined: 1 });
@@ -1535,6 +1559,7 @@ describe('HtmlReporter', function() {
 
         const failingSpecResult = {
           id: 124,
+          parentSuiteId: 2,
           status: 'failed',
           description: 'a failing spec',
           fullName: 'a suite inner suite a failing spec',
@@ -1658,16 +1683,18 @@ describe('HtmlReporter', function() {
         expect(links.length).toEqual(3);
         expect(links[0].textContent).toEqual('A suite');
 
-        expect(links[0].getAttribute('href')).toMatch(/\?foo=bar&spec=A suite/);
+        expect(links[0].getAttribute('href')).toEqual(
+          '/?foo=bar&spec=["A suite"]'
+        );
 
         expect(links[1].textContent).toEqual('inner suite');
-        expect(links[1].getAttribute('href')).toMatch(
-          /\?foo=bar&spec=A suite inner suite/
+        expect(links[1].getAttribute('href')).toEqual(
+          '/?foo=bar&spec=["A suite","inner suite"]'
         );
 
         expect(links[2].textContent).toEqual('a failing spec');
-        expect(links[2].getAttribute('href')).toMatch(
-          /\?foo=bar&spec=a suite inner suite a failing spec/
+        expect(links[2].getAttribute('href')).toEqual(
+          '/?foo=bar&spec=["A suite","inner suite","a failing spec"]'
         );
       });
 

spec/html/HtmlSpecFilterSpec.js

@@ -1,4 +1,4 @@
-describe('jasmineUnderTest.HtmlSpecFilter', function() {
+describe('HtmlSpecFilter', function() {
   it('should match when no string is provided', function() {
     const specFilter = new jasmineUnderTest.HtmlSpecFilter();
 
@@ -16,4 +16,17 @@ describe('jasmineUnderTest.HtmlSpecFilter', function() {
     expect(specFilter.matches('foo')).toBe(true);
     expect(specFilter.matches('bar')).toBe(false);
   });
+
+  it('copes with HtmlExactSpecFilterV2 filter strings', function() {
+    const specFilter = new jasmineUnderTest.HtmlSpecFilter({
+      filterString: function() {
+        return '["foo","bar"]';
+      }
+    });
+
+    expect(specFilter.matches('foo bar')).toBe(true);
+    expect(specFilter.matches('baz foo bar qux')).toBe(true);
+    expect(specFilter.matches('foo')).toBe(false);
+    expect(specFilter.matches('bar')).toBe(false);
+  });
 });