jasmine-core 2.99.2 → 3.0.0

data/lib/jasmine-core/jasmine.css

@@ -18,8 +18,8 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-passed:before { color: #007069; content: "\02022"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed { line-height: 9px; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-failed:before { color: #ca3a11; content: "\d7"; font-weight: bold; margin-left: -1px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-disabled { font-size: 14px; }
-.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-disabled:before { color: #bababa; content: "\02022"; }
+.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-excluded { font-size: 14px; }
+.jasmine_html-reporter .jasmine-symbol-summary li.jasmine-excluded:before { color: #bababa; content: "\02022"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-pending { line-height: 17px; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-pending:before { color: #ba9d37; content: "*"; }
 .jasmine_html-reporter .jasmine-symbol-summary li.jasmine-empty { font-size: 14px; }
@@ -29,11 +29,17 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-run-options .jasmine-payload { position: absolute; display: none; right: -1px; border: 1px solid #8a4182; background-color: #eee; white-space: nowrap; padding: 4px 8px; }
 .jasmine_html-reporter .jasmine-run-options .jasmine-payload.jasmine-open { display: block; }
 .jasmine_html-reporter .jasmine-bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
-.jasmine_html-reporter .jasmine-bar.jasmine-failed { background-color: #ca3a11; }
+.jasmine_html-reporter .jasmine-bar.jasmine-failed, .jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; border-bottom: 1px solid #eee; }
 .jasmine_html-reporter .jasmine-bar.jasmine-passed { background-color: #007069; }
+.jasmine_html-reporter .jasmine-bar.jasmine-incomplete { background-color: #bababa; }
 .jasmine_html-reporter .jasmine-bar.jasmine-skipped { background-color: #bababa; }
+<<<<<<< HEAD
+||||||| merged common ancestors
+.jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; }
+=======
 .jasmine_html-reporter .jasmine-bar.jasmine-errored { background-color: #ca3a11; }
 .jasmine_html-reporter .jasmine-bar.jasmine-warning { background-color: #ba9d37; color: #333; }
+>>>>>>> master
 .jasmine_html-reporter .jasmine-bar.jasmine-menu { background-color: #fff; color: #aaa; }
 .jasmine_html-reporter .jasmine-bar.jasmine-menu a { color: #333; }
 .jasmine_html-reporter .jasmine-bar a { color: white; }
@@ -47,12 +53,12 @@ body { overflow-y: scroll; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-failed a { color: #ca3a11; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-empty a { color: #ba9d37; }
 .jasmine_html-reporter .jasmine-summary li.jasmine-pending a { color: #ba9d37; }
-.jasmine_html-reporter .jasmine-summary li.jasmine-disabled a { color: #bababa; }
+.jasmine_html-reporter .jasmine-summary li.jasmine-excluded a { color: #bababa; }
 .jasmine_html-reporter .jasmine-description + .jasmine-suite { margin-top: 0; }
 .jasmine_html-reporter .jasmine-suite { margin-top: 14px; }
 .jasmine_html-reporter .jasmine-suite a { color: #333; }
 .jasmine_html-reporter .jasmine-failures .jasmine-spec-detail { margin-bottom: 28px; }
-.jasmine_html-reporter .jasmine-failures .jasmine-spec-detail .jasmine-description { background-color: #ca3a11; }
+.jasmine_html-reporter .jasmine-failures .jasmine-spec-detail .jasmine-description { background-color: #ca3a11; color: white; }
 .jasmine_html-reporter .jasmine-failures .jasmine-spec-detail .jasmine-description a { color: white; }
 .jasmine_html-reporter .jasmine-result-message { padding-top: 14px; color: #333; white-space: pre; }
 .jasmine_html-reporter .jasmine-result-message span.jasmine-result { display: block; }

data/lib/jasmine-core/jasmine.js

@@ -56,7 +56,8 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
     j$.Clock = jRequire.Clock();
     j$.DelayedFunctionScheduler = jRequire.DelayedFunctionScheduler(j$);
     j$.Env = jRequire.Env(j$);
-    j$.ExceptionFormatter = jRequire.ExceptionFormatter();
+    j$.StackTrace = jRequire.StackTrace(j$);
+    j$.ExceptionFormatter = jRequire.ExceptionFormatter(j$);
     j$.Expectation = jRequire.Expectation();
     j$.buildExpectationResult = jRequire.buildExpectationResult();
     j$.JsApiReporter = jRequire.JsApiReporter();
@@ -69,6 +70,7 @@ var getJasmineRequireObj = (function (jasmineGlobal) {
     j$.ReportDispatcher = jRequire.ReportDispatcher(j$);
     j$.Spec = jRequire.Spec(j$);
     j$.Spy = jRequire.Spy(j$);
+    j$.SpyFactory = jRequire.SpyFactory(j$);
     j$.SpyRegistry = jRequire.SpyRegistry(j$);
     j$.SpyStrategy = jRequire.SpyStrategy(j$);
     j$.StringMatching = jRequire.StringMatching(j$);
@@ -116,7 +118,8 @@ getJasmineRequireObj().requireMatchers = function(jRequire, j$) {
       'toHaveBeenCalledWith',
       'toMatch',
       'toThrow',
-      'toThrowError'
+      'toThrowError',
+      'toThrowMatching',
     ],
     matchers = {};
 
@@ -215,6 +218,17 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
     return j$.getType_(value) === '[object ' + typeName + ']';
   };
 
+  j$.isError_ = function(value) {
+    if (value instanceof Error) {
+      return true;
+    }
+    if (value && value.constructor && value.constructor.constructor &&
+      (value instanceof (value.constructor.constructor('return this')()).Error)) {
+      return true;
+    }
+    return false;
+  };
+
   j$.getType_ = function(value) {
     return Object.prototype.toString.apply(value);
   };
@@ -311,18 +325,6 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
     return new j$.ArrayWithExactContents(sample);
   };
 
-  /**
-   * Create a bare {@link Spy} object. This won't be installed anywhere and will not have any implementation behind it.
-   * @name jasmine.createSpy
-   * @function
-   * @param {String} [name] - Name to give the spy. This will be displayed in failure messages.
-   * @param {Function} [originalFn] - Function to act as the real implementation.
-   * @return {Spy}
-   */
-  j$.createSpy = function(name, originalFn) {
-    return j$.Spy(name, originalFn);
-  };
-
   j$.isSpy = function(putativeSpy) {
     if (!putativeSpy) {
       return false;
@@ -330,47 +332,6 @@ getJasmineRequireObj().base = function(j$, jasmineGlobal) {
     return putativeSpy.and instanceof j$.SpyStrategy &&
       putativeSpy.calls instanceof j$.CallTracker;
   };
-
-  /**
-   * Create an object with multiple {@link Spy}s as its members.
-   * @name jasmine.createSpyObj
-   * @function
-   * @param {String} [baseName] - Base name for the spies in the object.
-   * @param {String[]|Object} methodNames - Array of method names to create spies for, or Object whose keys will be method names and values the {@link Spy#and#returnValue|returnValue}.
-   * @return {Object}
-   */
-  j$.createSpyObj = function(baseName, methodNames) {
-    var baseNameIsCollection = j$.isObject_(baseName) || j$.isArray_(baseName);
-
-    if (baseNameIsCollection && j$.util.isUndefined(methodNames)) {
-      methodNames = baseName;
-      baseName = 'unknown';
-    }
-
-    var obj = {};
-    var spiesWereSet = false;
-
-    if (j$.isArray_(methodNames)) {
-      for (var i = 0; i < methodNames.length; i++) {
-        obj[methodNames[i]] = j$.createSpy(baseName + '.' + methodNames[i]);
-        spiesWereSet = true;
-      }
-    } else if (j$.isObject_(methodNames)) {
-      for (var key in methodNames) {
-        if (methodNames.hasOwnProperty(key)) {
-          obj[key] = j$.createSpy(baseName + '.' + key);
-          obj[key].and.returnValue(methodNames[key]);
-          spiesWereSet = true;
-        }
-      }
-    }
-
-    if (!spiesWereSet) {
-      throw 'createSpyObj requires a non-empty array or object of method names to create spies for';
-    }
-
-    return obj;
-  };
 };
 
 getJasmineRequireObj().util = function(j$) {
@@ -475,6 +436,54 @@ getJasmineRequireObj().util = function(j$) {
     return Object.prototype.hasOwnProperty.call(obj, key);
   };
 
+  function anyMatch(pattern, lines) {
+    var i;
+
+    for (i = 0; i < lines.length; i++) {
+      if (lines[i].match(pattern)) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function errorWithStack() {
+    // Don't throw and catch if we don't have to, because it makes it harder
+    // for users to debug their code with exception breakpoints.
+    var error = new Error();
+
+    if (error.stack) {
+      return error;
+    }
+
+    // But some browsers (e.g. Phantom) only provide a stack trace if we throw.
+    try {
+      throw new Error();
+    } catch (e) {
+      return e;
+    }
+  }
+
+  function callerFile() {
+    var trace = new j$.StackTrace(errorWithStack().stack);
+    return trace.frames[2].file;
+  }
+
+  util.jasmineFile = (function() {
+    var result;
+
+    return function() {
+      var trace;
+
+      if (!result) {
+        result = callerFile();
+      }
+
+      return result;
+    };
+  }());
+
   return util;
 };
 
@@ -537,10 +546,22 @@ getJasmineRequireObj().Spec = function(j$) {
     return this.expectationFactory(actual, this);
   };
 
-  Spec.prototype.execute = function(onComplete, enabled) {
+  Spec.prototype.execute = function(onComplete, excluded) {
     var self = this;
 
-    this.onStart(this);
+    var onStart = {
+      fn: function(done) {
+        self.onStart(self, done);
+      }
+    };
+
+    var complete = {
+      fn: function(done) {
+        self.queueableFn.fn = null;
+        self.result.status = self.status(excluded);
+        self.resultCallback(self.result, done);
+      }
+    };
 
     var fns = this.beforeAndAfterFns();
     var regularFns = fns.befores.concat(this.queueableFn);
@@ -549,27 +570,24 @@ getJasmineRequireObj().Spec = function(j$) {
       isLeaf: true,
       queueableFns: regularFns,
       cleanupFns: fns.afters,
-      onException: function() { self.onException.apply(self, arguments); },
-      onComplete: complete,
+      onException: function () {
+        self.onException.apply(self, arguments);
+      },
+      onComplete: function() {
+        onComplete(self.result.status === 'failed' && new j$.StopExecutionError('spec failed'));
+      },
       userContext: this.userContext()
     };
 
-    if (!this.isExecutable() || this.markedPending || enabled === false) {
+    if (this.markedPending || excluded === true) {
       runnerConfig.queueableFns = [];
       runnerConfig.cleanupFns = [];
-      runnerConfig.onComplete = function() { complete(enabled); };
     }
 
-    this.queueRunnerFactory(runnerConfig);
-
-    function complete(enabledAgain) {
-      self.result.status = self.status(enabledAgain);
-      self.resultCallback(self.result);
+    runnerConfig.queueableFns.unshift(onStart);
+    runnerConfig.cleanupFns.push(complete);
 
-      if (onComplete) {
-        onComplete();
-      }
-    }
+    this.queueRunnerFactory(runnerConfig);
   };
 
   Spec.prototype.onException = function onException(e) {
@@ -591,10 +609,6 @@ getJasmineRequireObj().Spec = function(j$) {
     }, true);
   };
 
-  Spec.prototype.disable = function() {
-    this.disabled = true;
-  };
-
   Spec.prototype.pend = function(message) {
     this.markedPending = true;
     if (message) {
@@ -607,9 +621,9 @@ getJasmineRequireObj().Spec = function(j$) {
     return this.result;
   };
 
-  Spec.prototype.status = function(enabled) {
-    if (this.disabled || enabled === false) {
-      return 'disabled';
+  Spec.prototype.status = function(excluded) {
+    if (excluded === true) {
+      return 'excluded';
     }
 
     if (this.markedPending) {
@@ -623,10 +637,6 @@ getJasmineRequireObj().Spec = function(j$) {
     }
   };
 
-  Spec.prototype.isExecutable = function() {
-    return !this.disabled;
-  };
-
   Spec.prototype.getFullName = function() {
     return this.getSpecName(this);
   };
@@ -716,12 +726,8 @@ getJasmineRequireObj().Env = function(j$) {
     var self = this;
     var global = options.global || j$.getGlobal();
 
-    var hasExecuted = false;
-
     var totalSpecsDefined = 0;
 
-    var catchExceptions = true;
-
     var realSetTimeout = j$.getGlobal().setTimeout;
     var realClearTimeout = j$.getGlobal().clearTimeout;
     var clearStack = j$.getClearStack(j$.getGlobal());
@@ -733,8 +739,11 @@ getJasmineRequireObj().Env = function(j$) {
     var currentlyExecutingSuites = [];
     var currentDeclarationSuite = null;
     var throwOnExpectationFailure = false;
-    var random = false;
+    var stopOnSpecFailure = false;
+    var random = true;
     var seed = null;
+    var handlingLoadErrors = true;
+    var hasFailures = false;
 
     var currentSuite = function() {
       return currentlyExecutingSuites[currentlyExecutingSuites.length - 1];
@@ -744,65 +753,29 @@ getJasmineRequireObj().Env = function(j$) {
       return currentSpec || currentSuite();
     };
 
-    /**
-     * This represents the available reporter callback for an object passed to {@link Env#addReporter}.
-     * @interface Reporter
-     */
-    var reporter = new j$.ReportDispatcher([
-      /**
-       * `jasmineStarted` is called after all of the specs have been loaded, but just before execution starts.
-       * @function
-       * @name Reporter#jasmineStarted
-       * @param {JasmineStartedInfo} suiteInfo Information about the full Jasmine suite that is being run
-       */
-      'jasmineStarted',
-      /**
-       * When the entire suite has finished execution `jasmineDone` is called
-       * @function
-       * @name Reporter#jasmineDone
-       * @param {JasmineDoneInfo} suiteInfo Information about the full Jasmine suite that just finished running.
-       */
-      'jasmineDone',
-      /**
-       * `suiteStarted` is invoked when a `describe` starts to run
-       * @function
-       * @name Reporter#suiteStarted
-       * @param {SuiteResult} result Information about the individual {@link describe} being run
-       */
-      'suiteStarted',
-      /**
-       * `suiteDone` is invoked when all of the child specs and suites for a given suite have been run
-       *
-       * While jasmine doesn't require any specific functions, not defining a `suiteDone` will make it impossible for a reporter to know when a suite has failures in an `afterAll`.
-       * @function
-       * @name Reporter#suiteDone
-       * @param {SuiteResult} result
-       */
-      'suiteDone',
-      /**
-       * `specStarted` is invoked when an `it` starts to run (including associated `beforeEach` functions)
-       * @function
-       * @name Reporter#specStarted
-       * @param {SpecResult} result Information about the individual {@link it} being run
-       */
-      'specStarted',
-      /**
-       * `specDone` is invoked when an `it` and its associated `beforeEach` and `afterEach` functions have been run.
-       *
-       * While jasmine doesn't require any specific functions, not defining a `specDone` will make it impossible for a reporter to know when a spec has failed.
-       * @function
-       * @name Reporter#specDone
-       * @param {SpecResult} result
-       */
-      'specDone'
-    ]);
-
     var globalErrors = new j$.GlobalErrors();
+    globalErrors.install();
+    globalErrors.pushListener(function(message, filename, lineno) {
+      topSuite.result.failedExpectations.push({
+        passed: false,
+        globalErrorType: 'load',
+        message: message,
+        filename: filename,
+        lineno: lineno
+      });
+    });
 
     this.specFilter = function() {
       return true;
     };
 
+    this.addSpyStrategy = function(name, fn) {
+      if(!currentRunnable()) {
+        throw new Error('Custom spy strategies must be added in a before function or a spec');
+      }
+      runnableResources[currentRunnable().id].customSpyStrategies[name] = fn;
+    };
+
     this.addCustomEqualityTester = function(tester) {
       if(!currentRunnable()) {
         throw new Error('Custom Equalities must be added in a before function or a spec');
@@ -847,7 +820,7 @@ getJasmineRequireObj().Env = function(j$) {
     };
 
     var defaultResourcesForRunnable = function(id, parentRunnableId) {
-      var resources = {spies: [], customEqualityTesters: [], customMatchers: {}};
+      var resources = {spies: [], customEqualityTesters: [], customMatchers: {}, customSpyStrategies: {}};
 
       if(runnableResources[parentRunnableId]){
         resources.customEqualityTesters = j$.util.clone(runnableResources[parentRunnableId].customEqualityTesters);
@@ -901,26 +874,9 @@ getJasmineRequireObj().Env = function(j$) {
           return buildExpectationResult(attrs);
         };
 
-    // TODO: fix this naming, and here's where the value comes in
-    this.catchExceptions = function(value) {
-      catchExceptions = !!value;
-      if (!catchExceptions) {
-        this.deprecated('The catchExceptions option is deprecated and will be replaced with stopOnSpecFailure in Jasmine 3.0');
-      }
-      return catchExceptions;
-    };
-
-    this.catchingExceptions = function() {
-      return catchExceptions;
-    };
-
     var maximumSpecCallbackDepth = 20;
     var currentSpecCallbackDepth = 0;
 
-    var catchException = function(e) {
-      return j$.Spec.isPendingSpecException(e) || catchExceptions;
-    };
-
     this.throwOnExpectationFailure = function(value) {
       throwOnExpectationFailure = !!value;
     };
@@ -929,6 +885,14 @@ getJasmineRequireObj().Env = function(j$) {
       return throwOnExpectationFailure;
     };
 
+    this.stopOnSpecFailure = function(value) {
+      stopOnSpecFailure = !!value;
+    };
+
+    this.stoppingOnSpecFailure = function() {
+      return stopOnSpecFailure;
+    };
+
     this.randomizeTests = function(value) {
       random = !!value;
     };
@@ -944,6 +908,13 @@ getJasmineRequireObj().Env = function(j$) {
       return seed;
     };
 
+    this.suppressLoadErrors = function() {
+      if (handlingLoadErrors) {
+        globalErrors.popListener();
+      }
+      handlingLoadErrors = false;
+    };
+
     this.deprecated = function(msg) {
       var runnable = currentRunnable() || topSuite;
       runnable.addDeprecationWarning(msg);
@@ -952,16 +923,24 @@ getJasmineRequireObj().Env = function(j$) {
       }
     };
 
-    var queueRunnerFactory = function(options) {
-      options.catchException = catchException;
+    var queueRunnerFactory = function(options, args) {
+      var failFast = false;
+      if (options.isLeaf) {
+        failFast = throwOnExpectationFailure;
+      } else if (!options.isReporter) {
+        failFast = stopOnSpecFailure;
+      }
       options.clearStack = options.clearStack || clearStack;
       options.timeout = {setTimeout: realSetTimeout, clearTimeout: realClearTimeout};
       options.fail = self.fail;
       options.globalErrors = globalErrors;
-      options.completeOnFirstError = throwOnExpectationFailure && options.isLeaf;
+      options.completeOnFirstError = failFast;
+      options.onException = options.onException || function(e) {
+        (currentRunnable() || topSuite).onException(e);
+      };
       options.deprecated = self.deprecated;
 
-      new j$.QueueRunner(options).execute();
+      new j$.QueueRunner(options).execute(args);
     };
 
     var topSuite = new j$.Suite({
@@ -978,12 +957,62 @@ getJasmineRequireObj().Env = function(j$) {
       return topSuite;
     };
 
-    this.execute = function(runnablesToRun) {
-      if (hasExecuted) {
-        this.deprecated('Executing the same Jasmine multiple times will no longer work in Jasmine 3.0');
-      }
+    /**
+     * This represents the available reporter callback for an object passed to {@link Env#addReporter}.
+     * @interface Reporter
+     */
+    var reporter = new j$.ReportDispatcher([
+      /**
+       * `jasmineStarted` is called after all of the specs have been loaded, but just before execution starts.
+       * @function
+       * @name Reporter#jasmineStarted
+       * @param {JasmineStartedInfo} suiteInfo Information about the full Jasmine suite that is being run
+       */
+      'jasmineStarted',
+      /**
+       * When the entire suite has finished execution `jasmineDone` is called
+       * @function
+       * @name Reporter#jasmineDone
+       * @param {JasmineDoneInfo} suiteInfo Information about the full Jasmine suite that just finished running.
+       */
+      'jasmineDone',
+      /**
+       * `suiteStarted` is invoked when a `describe` starts to run
+       * @function
+       * @name Reporter#suiteStarted
+       * @param {SuiteResult} result Information about the individual {@link describe} being run
+       */
+      'suiteStarted',
+      /**
+       * `suiteDone` is invoked when all of the child specs and suites for a given suite have been run
+       *
+       * While jasmine doesn't require any specific functions, not defining a `suiteDone` will make it impossible for a reporter to know when a suite has failures in an `afterAll`.
+       * @function
+       * @name Reporter#suiteDone
+       * @param {SuiteResult} result
+       */
+      'suiteDone',
+      /**
+       * `specStarted` is invoked when an `it` starts to run (including associated `beforeEach` functions)
+       * @function
+       * @name Reporter#specStarted
+       * @param {SpecResult} result Information about the individual {@link it} being run
+       */
+      'specStarted',
+      /**
+       * `specDone` is invoked when an `it` and its associated `beforeEach` and `afterEach` functions have been run.
+       *
+       * While jasmine doesn't require any specific functions, not defining a `specDone` will make it impossible for a reporter to know when a spec has failed.
+       * @function
+       * @name Reporter#specDone
+       * @param {SpecResult} result
+       */
+      'specDone'
+    ], queueRunnerFactory);
 
-      hasExecuted = true;
+    this.execute = function(runnablesToRun) {
+      var self = this;
+      this.suppressLoadErrors();
 
       if(!runnablesToRun) {
         if (focusedRunnables.length) {
@@ -1002,24 +1031,30 @@ getJasmineRequireObj().Env = function(j$) {
         tree: topSuite,
         runnableIds: runnablesToRun,
         queueRunnerFactory: queueRunnerFactory,
-        nodeStart: function(suite) {
+        nodeStart: function(suite, next) {
           currentlyExecutingSuites.push(suite);
           defaultResourcesForRunnable(suite.id, suite.parentSuite.id);
-          reporter.suiteStarted(suite.result);
+          reporter.suiteStarted(suite.result, next);
         },
-        nodeComplete: function(suite, result) {
+        nodeComplete: function(suite, result, next) {
           if (suite !== currentSuite()) {
             throw new Error('Tried to complete the wrong suite');
           }
 
-          if (!suite.markedPending) {
-            clearResourcesForRunnable(suite.id);
-          }
+          clearResourcesForRunnable(suite.id);
           currentlyExecutingSuites.pop();
-          reporter.suiteDone(result);
+
+          if (result.status === 'failed') {
+            hasFailures = true;
+          }
+
+          reporter.suiteDone(result, next);
         },
         orderChildren: function(node) {
           return order.sort(node.children);
+        },
+        excludeNode: function(spec) {
+          return !self.specFilter(spec);
         }
       });
 
@@ -1036,27 +1071,42 @@ getJasmineRequireObj().Env = function(j$) {
       reporter.jasmineStarted({
         totalSpecsDefined: totalSpecsDefined,
         order: order
-      });
+      }, function() {
+        currentlyExecutingSuites.push(topSuite);
 
-      currentlyExecutingSuites.push(topSuite);
-
-      globalErrors.install();
-      processor.execute(function() {
-        clearResourcesForRunnable(topSuite.id);
-        currentlyExecutingSuites.pop();
-        globalErrors.uninstall();
+        processor.execute(function () {
+          clearResourcesForRunnable(topSuite.id);
+          currentlyExecutingSuites.pop();
+          var overallStatus, incompleteReason;
+
+          if (hasFailures || topSuite.result.failedExpectations.length > 0) {
+            overallStatus = 'failed';
+          } else if (focusedRunnables.length > 0) {
+            overallStatus = 'incomplete';
+            incompleteReason = 'fit() or fdescribe() was found';
+          } else if (totalSpecsDefined === 0) {
+            overallStatus = 'incomplete';
+            incompleteReason = 'No specs found';
+          } else {
+            overallStatus = 'passed';
+          }
 
-        /**
-         * Information passed to the {@link Reporter#jasmineDone} event.
-         * @typedef JasmineDoneInfo
-         * @property {Order} order - Information about the ordering (random or not) of this execution of the suite.
-         * @property {Expectation[]} failedExpectations - List of expectations that failed in an {@link afterAll} at the global level.
-         * @property {Expectation[]} deprecationWarnings - List of deprecation warnings that occurred at the global level.
-         */
-        reporter.jasmineDone({
-          order: order,
-          failedExpectations: topSuite.result.failedExpectations,
-          deprecationWarnings: topSuite.result.deprecationWarnings
+          /**
+           * Information passed to the {@link Reporter#jasmineDone} event.
+           * @typedef JasmineDoneInfo
+           * @property {OverallStatus} - The overall result of the sute: 'passed', 'failed', or 'incomplete'.
+           * @property {IncompleteReason} - Explanation of why the suite was incimplete.
+           * @property {Order} order - Information about the ordering (random or not) of this execution of the suite.
+           * @property {Expectation[]} failedExpectations - List of expectations that failed in an {@link afterAll} at the global level.
+           * @property {Expectation[]} deprecationWarnings - List of deprecation warnings that occurred at the global level.
+           */
+          reporter.jasmineDone({
+            overallStatus: overallStatus,
+            incompleteReason: incompleteReason,
+            order: order,
+            failedExpectations: topSuite.result.failedExpectations,
+            deprecationWarnings: topSuite.result.deprecationWarnings
+          }, function() {});
         });
       });
     };
@@ -1080,12 +1130,27 @@ getJasmineRequireObj().Env = function(j$) {
       reporter.clearReporters();
     };
 
-    var spyRegistry = new j$.SpyRegistry({currentSpies: function() {
-      if(!currentRunnable()) {
-        throw new Error('Spies must be created in a before function or a spec');
+    var spyFactory = new j$.SpyFactory(function() {
+      var runnable = currentRunnable();
+
+      if (runnable) {
+        return runnableResources[runnable.id].customSpyStrategies;
+      }
+
+      return {};
+    });
+
+    var spyRegistry = new j$.SpyRegistry({
+      currentSpies: function() {
+        if(!currentRunnable()) {
+          throw new Error('Spies must be created in a before function or a spec');
+        }
+        return runnableResources[currentRunnable().id].spies;
+      },
+      createSpy: function(name, originalFn) {
+        return self.createSpy(name, originalFn);
       }
-      return runnableResources[currentRunnable().id].spies;
-    }});
+    });
 
     this.allowRespy = function(allow){
       spyRegistry.allowRespy(allow);
@@ -1099,6 +1164,14 @@ getJasmineRequireObj().Env = function(j$) {
       return spyRegistry.spyOnProperty.apply(spyRegistry, arguments);
     };
 
+    this.createSpy = function(name, originalFn) {
+      return spyFactory.createSpy(name, originalFn);
+    };
+
+    this.createSpyObj = function(baseName, methodNames) {
+      return spyFactory.createSpyObj(baseName, methodNames);
+    };
+
     var ensureIsFunction = function(fn, caller) {
       if (!j$.isFunction_(fn)) {
         throw new Error(caller + ' expects a function argument; received ' + j$.getType_(fn));
@@ -1158,7 +1231,6 @@ getJasmineRequireObj().Env = function(j$) {
     var focusedRunnables = [];
 
     this.fdescribe = function(description, specDefinitions) {
-      this.deprecated('fit and fdescribe will cause your suite to report an \'incomplete\' status in Jasmine 3.0');
       ensureIsNotNested('fdescribe');
       ensureIsFunction(specDefinitions, 'fdescribe');
       var suite = suiteFactory(description);
@@ -1184,9 +1256,7 @@ getJasmineRequireObj().Env = function(j$) {
       }
 
       if (declarationError) {
-        self.it('encountered a declaration exception', function() {
-          throw declarationError;
-        });
+        suite.onException(declarationError);
       }
 
       currentDeclarationSuite = parentSuite;
@@ -1237,22 +1307,23 @@ getJasmineRequireObj().Env = function(j$) {
         throwOnExpectationFailure: throwOnExpectationFailure
       });
 
-      if (!self.specFilter(spec)) {
-        spec.disable();
-      }
-
       return spec;
 
-      function specResultCallback(result) {
+      function specResultCallback(result, next) {
         clearResourcesForRunnable(spec.id);
         currentSpec = null;
-        reporter.specDone(result);
+
+        if (result.status === 'failed') {
+          hasFailures = true;
+        }
+
+        reporter.specDone(result, next);
       }
 
-      function specStarted(spec) {
+      function specStarted(spec, next) {
         currentSpec = spec;
         defaultResourcesForRunnable(spec.id, suite.id);
-        reporter.specStarted(spec.result);
+        reporter.specStarted(spec.result, next);
       }
     };
 
@@ -1284,7 +1355,6 @@ getJasmineRequireObj().Env = function(j$) {
     };
 
     this.fit = function(description, fn, timeout){
-      this.deprecated('fit and fdescribe will cause your suite to report an \'incomplete\' status in Jasmine 3.0');
       ensureIsNotNested('fit');
       ensureIsFunctionOrAsync(fn, 'fit');
       var spec = specFactory(description, fn, currentDeclarationSuite, timeout);
@@ -1540,10 +1610,7 @@ getJasmineRequireObj().Any = function(j$) {
     }
 
     if (this.expectedObject == Object) {
-      if (other === null) {
-        j$.getEnv().deprecated('jasmine.Any(Object) will no longer match null in Jasmine 3.0');
-      }
-      return typeof other == 'object';
+      return other !== null && typeof other == 'object';
     }
 
     if (this.expectedObject == Boolean) {
@@ -1986,22 +2053,10 @@ getJasmineRequireObj().Clock = function() {
     };
 
     self.setTimeout = function(fn, delay, params) {
-      if (legacyIE()) {
-        if (arguments.length > 2) {
-          throw new Error('IE < 9 cannot support extra params to setTimeout without a polyfill');
-        }
-        return timer.setTimeout(fn, delay);
-      }
       return Function.prototype.apply.apply(timer.setTimeout, [global, arguments]);
     };
 
     self.setInterval = function(fn, delay, params) {
-      if (legacyIE()) {
-        if (arguments.length > 2) {
-          throw new Error('IE < 9 cannot support extra params to setInterval without a polyfill');
-        }
-        return timer.setInterval(fn, delay);
-      }
       return Function.prototype.apply.apply(timer.setInterval, [global, arguments]);
     };
 
@@ -2036,11 +2091,6 @@ getJasmineRequireObj().Clock = function() {
         global.clearInterval === realTimingFunctions.clearInterval;
     }
 
-    function legacyIE() {
-      //if these methods are polyfilled, apply will be present
-      return !(realTimingFunctions.setTimeout || realTimingFunctions.setInterval).apply;
-    }
-
     function replace(dest, source) {
       for (var prop in source) {
         dest[prop] = source[prop];
@@ -2249,6 +2299,7 @@ getJasmineRequireObj().DelayedFunctionScheduler = function(j$) {
           }
           funcToRun.funcToCall.apply(null, funcToRun.params || []);
         });
+        deletedKeys = [];
       } while (scheduledLookup.length > 0 &&
               // checking first if we're out of time prevents setTimeout(0)
               // scheduled in a funcToRun from forcing an extra iteration
@@ -2275,8 +2326,10 @@ getJasmineRequireObj().errors = function() {
     ExpectationFailed: ExpectationFailed
   };
 };
-getJasmineRequireObj().ExceptionFormatter = function() {
-  function ExceptionFormatter() {
+getJasmineRequireObj().ExceptionFormatter = function(j$) {
+
+  function ExceptionFormatter(options) {
+    var jasmineFile = (options && options.jasmineFile) || j$.util.jasmineFile();
     this.message = function(error) {
       var message = '';
 
@@ -2298,8 +2351,34 @@ getJasmineRequireObj().ExceptionFormatter = function() {
     };
 
     this.stack = function(error) {
-      return error ? error.stack : null;
-    };
+      if (!error || !error.stack) {
+        return null;
+      }
+
+      var stackTrace = new j$.StackTrace(error.stack);
+      var lines = filterJasmine(stackTrace);
+
+      if (stackTrace.message) {
+        lines.unshift(stackTrace.message);
+      }
+
+      return lines.join('\n');
+    };
+
+    function filterJasmine(stackTrace) {
+      var result = [],
+        jasmineMarker = stackTrace.style === 'webkit' ? '<Jasmine>' : '    at <Jasmine>';
+ 
+      stackTrace.frames.forEach(function(frame) {
+        if (frame.file && frame.file !== jasmineFile) {
+          result.push(frame.raw);
+        } else if (result[result.length - 1] !== jasmineMarker) {
+          result.push(jasmineMarker);
+        }
+      });
+ 
+      return result;
+    }
   }
 
   return ExceptionFormatter;
@@ -2491,8 +2570,6 @@ getJasmineRequireObj().GlobalErrors = function(j$) {
       }
     };
 
-    this.uninstall = function noop() {};
-
     this.install = function install() {
       if (global.process && global.process.listeners && j$.isFunction_(global.process.on)) {
         var originalHandlers = global.process.listeners('uncaughtException');
@@ -2745,28 +2822,7 @@ getJasmineRequireObj().matchersUtil = function(j$) {
     var bIsDomNode = j$.isDomNode(b);
     if (aIsDomNode && bIsDomNode) {
       // At first try to use DOM3 method isEqualNode
-      if (a.isEqualNode) {
-        result = a.isEqualNode(b);
-        if (!result) {
-          diffBuilder.record(a, b);
-        }
-        return result;
-      }
-      // IE8 doesn't support isEqualNode, try to use outerHTML && innerText
-      var aIsElement = a instanceof Element;
-      var bIsElement = b instanceof Element;
-      if (aIsElement && bIsElement) {
-        result = a.outerHTML == b.outerHTML;
-        if (!result) {
-          diffBuilder.record(a, b);
-        }
-        return result;
-      }
-      if (aIsElement || bIsElement) {
-        diffBuilder.record(a, b);
-        return false;
-      }
-      result = a.innerText == b.innerText && a.textContent == b.textContent;
+      result = a.isEqualNode(b);
       if (!result) {
         diffBuilder.record(a, b);
       }
@@ -3553,8 +3609,8 @@ getJasmineRequireObj().toHaveBeenCalled = function(j$) {
         result.pass = actual.calls.any();
 
         result.message = result.pass ?
-          'Expected spy ' + actual.and.identity() + ' not to have been called.' :
-          'Expected spy ' + actual.and.identity() + ' to have been called.';
+          'Expected spy ' + actual.and.identity + ' not to have been called.' :
+          'Expected spy ' + actual.and.identity + ' to have been called.';
 
         return result;
       }
@@ -3589,11 +3645,11 @@ getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
         var result = { pass: false };
 
         if (!firstSpy.calls.count()) {
-          result.message = 'Expected spy ' +  firstSpy.and.identity() + ' to have been called.';
+          result.message = 'Expected spy ' +  firstSpy.and.identity + ' to have been called.';
           return result;
         }
         if (!latterSpy.calls.count()) {
-          result.message = 'Expected spy ' +  latterSpy.and.identity() + ' to have been called.';
+          result.message = 'Expected spy ' +  latterSpy.and.identity + ' to have been called.';
           return result;
         }
 
@@ -3603,17 +3659,17 @@ getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
         result.pass = latest1stSpyCall < first2ndSpyCall;
 
         if (result.pass) {
-          result.message = 'Expected spy ' + firstSpy.and.identity() + ' to not have been called before spy ' + latterSpy.and.identity() + ', but it was';
+          result.message = 'Expected spy ' + firstSpy.and.identity + ' to not have been called before spy ' + latterSpy.and.identity + ', but it was';
         } else {
           var first1stSpyCall = firstSpy.calls.first().invocationOrder;
           var latest2ndSpyCall = latterSpy.calls.mostRecent().invocationOrder;
 
           if(first1stSpyCall < first2ndSpyCall) {
-            result.message = 'Expected latest call to spy ' + firstSpy.and.identity() + ' to have been called before first call to spy ' + latterSpy.and.identity() + ' (no interleaved calls)';
+            result.message = 'Expected latest call to spy ' + firstSpy.and.identity + ' to have been called before first call to spy ' + latterSpy.and.identity + ' (no interleaved calls)';
           } else if (latest2ndSpyCall > latest1stSpyCall) {
-            result.message = 'Expected first call to spy ' + latterSpy.and.identity() + ' to have been called after latest call to spy ' + firstSpy.and.identity() + ' (no interleaved calls)';
+            result.message = 'Expected first call to spy ' + latterSpy.and.identity + ' to have been called after latest call to spy ' + firstSpy.and.identity + ' (no interleaved calls)';
           } else {
-            result.message = 'Expected spy ' + firstSpy.and.identity() + ' to have been called before spy ' + latterSpy.and.identity();
+            result.message = 'Expected spy ' + firstSpy.and.identity + ' to have been called before spy ' + latterSpy.and.identity;
           }
         }
 
@@ -3656,8 +3712,8 @@ getJasmineRequireObj().toHaveBeenCalledTimes = function(j$) {
         var timesMessage = expected === 1 ? 'once' : expected + ' times';
         result.pass = calls === expected;
         result.message = result.pass ?
-          'Expected spy ' + actual.and.identity() + ' not to have been called ' + timesMessage + '. It was called ' +  calls + ' times.' :
-          'Expected spy ' + actual.and.identity() + ' to have been called ' + timesMessage + '. It was called ' +  calls + ' times.';
+          'Expected spy ' + actual.and.identity + ' not to have been called ' + timesMessage + '. It was called ' +  calls + ' times.' :
+          'Expected spy ' + actual.and.identity + ' to have been called ' + timesMessage + '. It was called ' +  calls + ' times.';
         return result;
       }
     };
@@ -3691,15 +3747,15 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
         }
 
         if (!actual.calls.any()) {
-          result.message = function() { return 'Expected spy ' + actual.and.identity() + ' to have been called with ' + j$.pp(expectedArgs) + ' but it was never called.'; };
+          result.message = function() { return 'Expected spy ' + actual.and.identity + ' to have been called with ' + j$.pp(expectedArgs) + ' but it was never called.'; };
           return result;
         }
 
         if (util.contains(actual.calls.allArgs(), expectedArgs, customEqualityTesters)) {
           result.pass = true;
-          result.message = function() { return 'Expected spy ' + actual.and.identity() + ' not to have been called with ' + j$.pp(expectedArgs) + ' but it was.'; };
+          result.message = function() { return 'Expected spy ' + actual.and.identity + ' not to have been called with ' + j$.pp(expectedArgs) + ' but it was.'; };
         } else {
-          result.message = function() { return 'Expected spy ' + actual.and.identity() + ' to have been called with ' + j$.pp(expectedArgs) + ' but actual calls were ' + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + '.'; };
+          result.message = function() { return 'Expected spy ' + actual.and.identity + ' to have been called with ' + j$.pp(expectedArgs) + ' but actual calls were ' + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + '.'; };
         }
 
         return result;
@@ -3820,73 +3876,61 @@ getJasmineRequireObj().toThrowError = function(j$) {
   function toThrowError () {
     return {
       compare: function(actual) {
-        var threw = false,
-          pass = {pass: true},
-          fail = {pass: false},
+        var errorMatcher = getMatcher.apply(null, arguments),
           thrown;
 
         if (typeof actual != 'function') {
           throw new Error(getErrorMsg('Actual is not a Function'));
         }
 
-        var errorMatcher = getMatcher.apply(null, arguments);
-
         try {
           actual();
+          return fail('Expected function to throw an Error.');
         } catch (e) {
-          threw = true;
           thrown = e;
         }
 
-        if (!threw) {
-          fail.message = 'Expected function to throw an Error.';
-          return fail;
-        }
-
-        // Get Error constructor of thrown
-        if (!isErrorObject(thrown)) {
-          fail.message = function() { return 'Expected function to throw an Error, but it threw ' + j$.pp(thrown) + '.'; };
-          return fail;
+        if (!j$.isError_(thrown)) {
+          return fail(function() { return 'Expected function to throw an Error, but it threw ' + j$.pp(thrown) + '.'; });
         }
 
-        if (errorMatcher.hasNoSpecifics()) {
-          pass.message = 'Expected function not to throw an Error, but it threw ' + j$.fnNameFor(thrown) + '.';
-          return pass;
-        }
-
-        if (errorMatcher.matches(thrown)) {
-          pass.message = function() {
-            return 'Expected function not to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() + '.';
-          };
-          return pass;
-        } else {
-          fail.message = function() {
-            return 'Expected function to throw ' + errorMatcher.errorTypeDescription + errorMatcher.messageDescription() +
-              ', but it threw ' + errorMatcher.thrownDescription(thrown) + '.';
-          };
-          return fail;
-        }
+        return errorMatcher.match(thrown);
       }
     };
 
     function getMatcher() {
-      var expected = null,
-          errorType = null;
+      var expected, errorType;
 
-      if (arguments.length == 2) {
-        expected = arguments[1];
-        if (isAnErrorType(expected)) {
-          errorType = expected;
-          expected = null;
-        }
-      } else if (arguments.length > 2) {
+      if (arguments[2]) {
         errorType = arguments[1];
         expected = arguments[2];
         if (!isAnErrorType(errorType)) {
           throw new Error(getErrorMsg('Expected error type is not an Error.'));
         }
+
+        return exactMatcher(expected, errorType);
+      } else if (arguments[1]) {
+        expected = arguments[1];
+
+        if (isAnErrorType(arguments[1])) {
+          return exactMatcher(null, arguments[1]);
+        } else {
+          return exactMatcher(arguments[1], null);
+        }
+      } else {
+        return anyMatcher();
       }
+    }
 
+    function anyMatcher() {
+      return {
+        match: function(error) {
+          return pass('Expected function not to throw an Error, but it threw ' + j$.fnNameFor(error) + '.');
+        }
+      };
+    }
+
+    function exactMatcher(expected, errorType) {
       if (expected && !isStringOrRegExp(expected)) {
         if (errorType) {
           throw new Error(getErrorMsg('Expected error message is not a string or RegExp.'));
@@ -3903,33 +3947,46 @@ getJasmineRequireObj().toThrowError = function(j$) {
         }
       }
 
-      return {
-        errorTypeDescription: errorType ? j$.fnNameFor(errorType) : 'an exception',
-        thrownDescription: function(thrown) {
-          var thrownName = errorType ? j$.fnNameFor(thrown.constructor) : 'an exception',
-              thrownMessage = '';
+      var errorTypeDescription = errorType ? j$.fnNameFor(errorType) : 'an exception';
 
-          if (expected) {
-            thrownMessage = ' with message ' + j$.pp(thrown.message);
-          }
+      function thrownDescription(thrown) {
+        var thrownName = errorType ? j$.fnNameFor(thrown.constructor) : 'an exception',
+            thrownMessage = '';
 
-          return thrownName + thrownMessage;
-        },
-        messageDescription: function() {
-          if (expected === null) {
-            return '';
-          } else if (expected instanceof RegExp) {
-            return ' with a message matching ' + j$.pp(expected);
+        if (expected) {
+          thrownMessage = ' with message ' + j$.pp(thrown.message);
+        }
+
+        return thrownName + thrownMessage;
+      }
+
+      function messageDescription() {
+        if (expected === null) {
+          return '';
+        } else if (expected instanceof RegExp) {
+          return ' with a message matching ' + j$.pp(expected);
+        } else {
+          return ' with message ' + j$.pp(expected);
+        }
+      }
+
+      function matches(error) {
+        return (errorType === null || error instanceof errorType) &&
+          (expected === null || messageMatch(error.message));
+      }
+
+      return {
+        match: function(thrown) {
+          if (matches(thrown)) {
+            return pass(function() {
+              return 'Expected function not to throw ' + errorTypeDescription + messageDescription() + '.';
+            });
           } else {
-            return ' with message ' + j$.pp(expected);
+            return fail(function() {
+              return 'Expected function to throw ' + errorTypeDescription + messageDescription() +
+                ', but it threw ' + thrownDescription(thrown) + '.';
+            });
           }
-        },
-        hasNoSpecifics: function() {
-          return expected === null && errorType === null;
-        },
-        matches: function(error) {
-          return (errorType === null || error instanceof errorType) &&
-            (expected === null || messageMatch(error.message));
         }
       };
     }
@@ -3945,22 +4002,94 @@ getJasmineRequireObj().toThrowError = function(j$) {
 
       var Surrogate = function() {};
       Surrogate.prototype = type.prototype;
-      return isErrorObject(new Surrogate());
+      return j$.isError_(new Surrogate());
     }
+  }
 
-    function isErrorObject(thrown) {
-      if (thrown instanceof Error) {
-        return true;
-      }
-      if (thrown && thrown.constructor && thrown.constructor.constructor &&
-          (thrown instanceof (thrown.constructor.constructor('return this')()).Error)) {
-        return true;
+  function pass(message) {
+    return {
+      pass: true,
+      message: message
+    };
+  }
+
+  function fail(message) {
+    return {
+      pass: false,
+      message: message
+    };
+  }
+
+  return toThrowError;
+};
+
+getJasmineRequireObj().toThrowMatching = function(j$) {
+  var usageError =  j$.formatErrorMsg('<toThrowMatching>', 'expect(function() {<expectation>}).toThrowMatching(<Predicate>)');
+
+  /**
+   * {@link expect} a function to `throw` something matching a predicate.
+   * @function
+   * @name matchers#toThrowMatching
+   * @param {Function} predicate - A function that takes the thrown exception as its parameter and returns true if it matches.
+   * @example
+   * expect(function() { throw new Error('nope'); }).toThrowMatching(function(thrown) { return thrown.message === 'nope'; });
+   */
+  function toThrowMatching() {
+    return {
+      compare: function(actual, predicate) {
+        var thrown;
+
+        if (typeof actual !== 'function') {
+          throw new Error(usageError('Actual is not a Function'));
+        }
+
+        if (typeof predicate !== 'function') {
+          throw new Error(usageError('Predicate is not a Function'));
+        }
+
+        try {
+          actual();
+          return fail('Expected function to throw an exception.');
+        } catch (e) {
+          thrown = e;
+        }
+
+        if (predicate(thrown)) {
+          return pass('Expected function not to throw an exception matching a predicate.');
+        } else {
+            return fail(function() {
+              return 'Expected function to throw an exception matching a predicate, ' +
+                'but it threw ' + thrownDescription(thrown) + '.';
+            });
+        }
       }
-      return false;
+    };
+  }
+
+  function thrownDescription(thrown) {
+    if (thrown && thrown.constructor) {
+      return j$.fnNameFor(thrown.constructor) + ' with message ' +
+        j$.pp(thrown.message);
+    } else {
+      return j$.pp(thrown);
     }
   }
 
-  return toThrowError;
+  function pass(message) {
+    return {
+      pass: true,
+      message: message
+    };
+  }
+
+  function fail(message) {
+    return {
+      pass: false,
+      message: message
+    };
+  }
+
+  return toThrowMatching;
 };
 
 getJasmineRequireObj().MockDate = function() {
@@ -4077,11 +4206,13 @@ getJasmineRequireObj().pp = function(j$) {
       } else if (typeof value === 'string') {
         this.emitString(value);
       } else if (j$.isSpy(value)) {
-        this.emitScalar('spy on ' + value.and.identity());
+        this.emitScalar('spy on ' + value.and.identity);
       } else if (value instanceof RegExp) {
         this.emitScalar(value.toString());
       } else if (typeof value === 'function') {
         this.emitScalar('Function');
+      } else if (value.nodeType === 1) {
+        this.emitDomElement(value);
       } else if (typeof value.nodeType === 'number') {
         this.emitScalar('HTMLNode');
       } else if (value instanceof Date) {
@@ -4273,6 +4404,18 @@ getJasmineRequireObj().pp = function(j$) {
     this.append(constructorName + ' [ ' + itemsString + ' ]');
   };
 
+  PrettyPrinter.prototype.emitDomElement = function(el) {
+    var closingTag = '</' + el.tagName.toLowerCase() + '>';
+
+    if (el.innerHTML === '') {
+      this.append(el.outerHTML.replace(closingTag, ''));
+    } else {
+      var tagEnd = el.outerHTML.indexOf(el.innerHTML);
+      this.append(el.outerHTML.substring(0, tagEnd));
+      this.append('...' + closingTag);
+    }
+  };
+
   PrettyPrinter.prototype.formatProperty = function(obj, property, isGetter) {
       this.append(property);
       this.append(': ');
@@ -4347,6 +4490,9 @@ getJasmineRequireObj().pp = function(j$) {
 };
 
 getJasmineRequireObj().QueueRunner = function(j$) {
+  function StopExecutionError() {}
+  StopExecutionError.prototype = new Error();
+  j$.StopExecutionError = StopExecutionError;
 
   function once(fn) {
     var called = false;
@@ -4366,12 +4512,16 @@ getJasmineRequireObj().QueueRunner = function(j$) {
     this.onComplete = attrs.onComplete || function() {};
     this.clearStack = attrs.clearStack || function(fn) {fn();};
     this.onException = attrs.onException || function() {};
-    this.catchException = attrs.catchException || function() { return true; };
     this.userContext = attrs.userContext || new j$.UserContext();
     this.timeout = attrs.timeout || {setTimeout: setTimeout, clearTimeout: clearTimeout};
     this.fail = attrs.fail || function() {};
     this.globalErrors = attrs.globalErrors || { pushListener: function() {}, popListener: function() {} };
     this.completeOnFirstError = !!attrs.completeOnFirstError;
+    this.errored = false;
+
+    if (typeof(this.onComplete) !== 'function') {
+      throw new Error('invalid onComplete ' + JSON.stringify(this.onComplete));
+    }
     this.deprecated = attrs.deprecated;
   }
 
@@ -4392,135 +4542,134 @@ getJasmineRequireObj().QueueRunner = function(j$) {
     }
   };
 
-  QueueRunner.prototype.run = function(recursiveIndex) {
-    var length = this.queueableFns.length,
-      self = this,
-      iterativeIndex;
-
-
-    for(iterativeIndex = recursiveIndex; iterativeIndex < length; iterativeIndex++) {
-      var result = attempt(iterativeIndex);
-
-      if (!result.completedSynchronously) {
-        return;
-      }
-
-      if (this.completeOnFirstError && result.errored) {
-        this.skipToCleanup(iterativeIndex);
-        return;
-      }
-    }
+  QueueRunner.prototype.clearTimeout = function(timeoutId) {
+    Function.prototype.apply.apply(this.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]);
+  };
 
-    this.clearStack(function() {
-      self.globalErrors.popListener(self.handleFinalError);
-      self.onComplete();
-    });
+  QueueRunner.prototype.setTimeout = function(fn, timeout) {
+    return Function.prototype.apply.apply(this.timeout.setTimeout, [j$.getGlobal(), [fn, timeout]]);
+  };
 
-    function attempt() {
-      var clearTimeout = function () {
-          Function.prototype.apply.apply(self.timeout.clearTimeout, [j$.getGlobal(), [timeoutId]]);
-        },
-        setTimeout = function(delayedFn, delay) {
-          return Function.prototype.apply.apply(self.timeout.setTimeout, [j$.getGlobal(), [delayedFn, delay]]);
-        },
-        completedSynchronously = true,
-        handleError = function(error) {
-          onException(error);
-          next();
-        },
-        cleanup = once(function() {
-          clearTimeout(timeoutId);
-          self.globalErrors.popListener(handleError);
-        }),
-        next = once(function (err) {
-          cleanup();
-
-          if (err instanceof Error) {
-            self.deprecated('done callback received an Error object. Jasmine 3.0 will treat this as a failure');
-          }
+  QueueRunner.prototype.attempt = function attempt(iterativeIndex) {
+    var self = this, completedSynchronously = true,
+      handleError = function handleError(error) {
+        onException(error);
+        next(error);
+      },
+      cleanup = once(function cleanup() {
+        self.clearTimeout(timeoutId);
+        self.globalErrors.popListener(handleError);
+      }),
+      next = once(function next(err) {
+        cleanup();
 
-          function runNext() {
-            if (self.completeOnFirstError && errored) {
-              self.skipToCleanup(iterativeIndex);
-            } else {
-              self.run(iterativeIndex + 1);
-            }
+        if (j$.isError_(err)) {
+          if (!(err instanceof StopExecutionError)) {
+            self.fail(err);
           }
+          self.errored = errored = true;
+        }
 
-          if (completedSynchronously) {
-            setTimeout(runNext);
+        function runNext() {
+          if (self.completeOnFirstError && errored) {
+            self.skipToCleanup(iterativeIndex);
           } else {
-            runNext();
+            self.run(iterativeIndex + 1);
           }
-        }),
-        errored = false,
-        queueableFn = self.queueableFns[iterativeIndex],
-        timeoutId;
-
-      next.fail = function() {
-        self.fail.apply(null, arguments);
-        errored = true;
-        next();
-      };
+        }
 
-      self.globalErrors.pushListener(handleError);
+        if (completedSynchronously) {
+          self.setTimeout(runNext);
+        } else {
+          runNext();
+        }
+      }),
+      errored = false,
+      queueableFn = self.queueableFns[iterativeIndex],
+      timeoutId;
 
-      if (queueableFn.timeout) {
-        timeoutId = setTimeout(function() {
-          var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
-          onException(error);
-          next();
-        }, queueableFn.timeout());
-      }
+    next.fail = function nextFail() {
+      self.fail.apply(null, arguments);
+      self.errored = errored = true;
+      next();
+    };
 
-      try {
-        if (queueableFn.fn.length === 0) {
-          var maybeThenable = queueableFn.fn.call(self.userContext);
+    self.globalErrors.pushListener(handleError);
 
-          if (maybeThenable && j$.isFunction_(maybeThenable.then)) {
-            maybeThenable.then(next, onPromiseRejection);
-            completedSynchronously = false;
-            return { completedSynchronously: false };
-          }
-        } else {
-          queueableFn.fn.call(self.userContext, next);
+    if (queueableFn.timeout) {
+      timeoutId = self.setTimeout(function() {
+        var error = new Error('Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.');
+        onException(error);
+        next();
+      }, queueableFn.timeout());
+    }
+
+    try {
+      if (queueableFn.fn.length === 0) {
+        var maybeThenable = queueableFn.fn.call(self.userContext);
+
+        if (maybeThenable && j$.isFunction_(maybeThenable.then)) {
+          maybeThenable.then(next, onPromiseRejection);
           completedSynchronously = false;
           return { completedSynchronously: false };
         }
-      } catch (e) {
-        handleException(e, queueableFn);
-        errored = true;
+      } else {
+        queueableFn.fn.call(self.userContext, next);
+        completedSynchronously = false;
+        return { completedSynchronously: false };
       }
+    } catch (e) {
+      onException(e);
+      self.errored = errored = true;
+    }
 
-      cleanup();
-      return { completedSynchronously: true, errored: errored };
+    cleanup();
+    return { completedSynchronously: true, errored: errored };
 
-      function onException(e) {
-        self.onException(e);
-        errored = true;
-      }
+    function onException(e) {
+      self.onException(e);
+      self.errored = errored = true;
+    }
 
-      function onPromiseRejection(e) {
-        onException(e);
-        next();
+    function onPromiseRejection(e) {
+      onException(e);
+      next();
+    }
+  };
+
+  QueueRunner.prototype.run = function(recursiveIndex) {
+    var length = this.queueableFns.length,
+      self = this,
+      iterativeIndex;
+
+
+    for(iterativeIndex = recursiveIndex; iterativeIndex < length; iterativeIndex++) {
+      var result = this.attempt(iterativeIndex);
+
+      if (!result.completedSynchronously) {
+        return;
       }
 
-      function handleException(e, queueableFn) {
-        onException(e);
-        if (!self.catchException(e)) {
-          //TODO: set a var when we catch an exception and
-          //use a finally block to close the loop in a nice way..
-          throw e;
-        }
+      self.errored = result.errored;
+
+      if (this.completeOnFirstError && result.errored) {
+        this.skipToCleanup(iterativeIndex);
+        return;
       }
     }
+
+    this.clearStack(function() {
+      self.globalErrors.popListener(self.handleFinalError);
+      self.onComplete(self.errored && new StopExecutionError());
+    });
+
   };
 
   return QueueRunner;
 };
 
 getJasmineRequireObj().ReportDispatcher = function(j$) {
-  function ReportDispatcher(methods) {
+  function ReportDispatcher(methods, queueRunnerFactory) {
 
     var dispatchedMethods = methods || [];
 
@@ -4554,11 +4703,40 @@ getJasmineRequireObj().ReportDispatcher = function(j$) {
       if (reporters.length === 0 && fallbackReporter !== null) {
           reporters.push(fallbackReporter);
       }
+      var onComplete = args[args.length - 1];
+      args = j$.util.argsToArray(args).splice(0, args.length - 1);
+      var fns = [];
       for (var i = 0; i < reporters.length; i++) {
         var reporter = reporters[i];
-        if (reporter[method]) {
-          reporter[method].apply(reporter, j$.util.cloneArgs(args));
-        }
+        addFn(fns, reporter, method, args);
+      }
+
+      queueRunnerFactory({
+        queueableFns: fns,
+        onComplete: onComplete,
+        isReporter: true
+      });
+    }
+
+    function addFn(fns, reporter, method, args) {
+      var fn = reporter[method];
+      if (!fn) {
+        return;
+      }
+
+      var thisArgs = j$.util.cloneArgs(args);
+      if (fn.length <= 1) {
+        fns.push({
+          fn: function () {
+            return fn.apply(reporter, thisArgs);
+          }
+        });
+      } else {
+        fns.push({
+          fn: function (done) {
+            return fn.apply(reporter, thisArgs.concat([done]));
+          }
+        });
       }
     }
   }
@@ -4825,6 +5003,43 @@ getJasmineRequireObj().interface = function(jasmine, env) {
     return env.clock;
   };
 
+  /**
+   * Create a bare {@link Spy} object. This won't be installed anywhere and will not have any implementation behind it.
+   * @name jasmine.createSpy
+   * @function
+   * @param {String} [name] - Name to give the spy. This will be displayed in failure messages.
+   * @param {Function} [originalFn] - Function to act as the real implementation.
+   * @return {Spy}
+   */
+  jasmine.createSpy = function(name, originalFn) {
+    return env.createSpy(name, originalFn);
+  };
+
+  /**
+   * Create an object with multiple {@link Spy}s as its members.
+   * @name jasmine.createSpyObj
+   * @function
+   * @param {String} [baseName] - Base name for the spies in the object.
+   * @param {String[]|Object} methodNames - Array of method names to create spies for, or Object whose keys will be method names and values the {@link Spy#and#returnValue|returnValue}.
+   * @return {Object}
+   */
+  jasmine.createSpyObj = function(baseName, methodNames) {
+    return env.createSpyObj(baseName, methodNames);
+  };
+
+  /**
+   * Add a custom spy strategy for the current scope of specs.
+   *
+   * _Note:_ This is only callable from within a {@link beforeEach}, {@link it}, or {@link beforeAll}.
+   * @name jasmine.addSpyStrategy
+   * @function
+   * @param {String} name - The name of the strategy (i.e. what you call from `and`)
+   * @param {Function} factory - Factory function that returns the plan to be executed.
+   */
+  jasmine.addSpyStrategy = function(name, factory) {
+    return env.addSpyStrategy(name, factory);
+  };
+
   return jasmineInterface;
 };
 
@@ -4843,17 +5058,18 @@ getJasmineRequireObj().Spy = function (j$) {
    * @constructor
    * @name Spy
    */
-  function Spy(name, originalFn) {
+  function Spy(name, originalFn, customStrategies) {
     var numArgs = (typeof originalFn === 'function' ? originalFn.length : 0),
       wrapper = makeFunc(numArgs, function () {
         return spy.apply(this, Array.prototype.slice.call(arguments));
       }),
-      spyStrategy = new j$.SpyStrategy({
+      strategyDispatcher = new SpyStrategyDispatcher({
         name: name,
         fn: originalFn,
         getSpy: function () {
           return wrapper;
-        }
+        },
+        customStrategies: customStrategies
       }),
       callTracker = new j$.CallTracker(),
       spy = function () {
@@ -4870,7 +5086,7 @@ getJasmineRequireObj().Spy = function (j$) {
         };
 
         callTracker.track(callData);
-        var returnValue = spyStrategy.exec.apply(this, arguments);
+        var returnValue = strategyDispatcher.exec(this, arguments);
         callData.returnValue = returnValue;
 
         return returnValue;
@@ -4899,15 +5115,144 @@ getJasmineRequireObj().Spy = function (j$) {
       wrapper[prop] = originalFn[prop];
     }
 
-    wrapper.and = spyStrategy;
+    /**
+     * @member {SpyStrategy} - Accesses the default strategy for the spy. This strategy will be used
+     * whenever the spy is called with arguments that don't match any strategy
+     * created with {@link Spy#withArgs}.
+     * @name Spy#and
+     * @example
+     * spyOn(someObj, 'func').and.returnValue(42);
+     */
+    wrapper.and = strategyDispatcher.and;
+    /**
+     * Specifies a strategy to be used for calls to the spy that have the
+     * specified arguments.
+     * @name Spy#withArgs
+     * @function
+     * @param {...*} args - The arguments to match
+     * @type {SpyStrategy}
+     * @example
+     * spyOn(someObj, 'func').withArgs(1, 2, 3).and.returnValue(42);
+     * someObj.func(1, 2, 3); // returns 42
+     */
+    wrapper.withArgs = function() {
+      return strategyDispatcher.withArgs.apply(strategyDispatcher, arguments);
+    };
     wrapper.calls = callTracker;
 
     return wrapper;
   }
 
+
+  function SpyStrategyDispatcher(strategyArgs) {
+    var baseStrategy = new j$.SpyStrategy(strategyArgs);
+    var argsStrategies = new StrategyDict(function() {
+      return new j$.SpyStrategy(strategyArgs);
+    });
+
+    this.and = baseStrategy;
+
+    this.exec = function(spy, args) {
+      var strategy = argsStrategies.get(args);
+
+      if (!strategy) {
+        if (argsStrategies.any() && !baseStrategy.isConfigured()) {
+          throw new Error('Spy \'' + strategyArgs.name + '\' receieved a call with arguments ' + j$.pp(Array.prototype.slice.call(args)) + ' but all configured strategies specify other arguments.');
+        } else {
+          strategy = baseStrategy;
+        }
+      }
+
+      return strategy.exec(spy, args);
+    };
+
+    this.withArgs = function() {
+      return { and: argsStrategies.getOrCreate(arguments) };
+    };
+  }
+
+  function StrategyDict(strategyFactory) {
+    this.strategies = [];
+    this.strategyFactory = strategyFactory;
+  }
+
+  StrategyDict.prototype.any = function() {
+    return this.strategies.length > 0;
+  };
+
+  StrategyDict.prototype.getOrCreate = function(args) {
+    var strategy = this.get(args);
+
+    if (!strategy) {
+      strategy = this.strategyFactory();
+      this.strategies.push({
+        args: args,
+        strategy: strategy
+      });
+    }
+
+    return strategy;
+  };
+
+  StrategyDict.prototype.get = function(args) {
+    var i;
+
+    for (i = 0; i < this.strategies.length; i++) {
+      if (j$.matchersUtil.equals(args, this.strategies[i].args)) {
+        return this.strategies[i].strategy;
+      }
+    }
+  };
+
   return Spy;
 };
 
+getJasmineRequireObj().SpyFactory = function(j$) {
+
+  function SpyFactory(getCustomStrategies) {
+    var self = this;
+
+    this.createSpy = function(name, originalFn) {
+      return j$.Spy(name, originalFn, getCustomStrategies());
+    };
+
+    this.createSpyObj = function(baseName, methodNames) {
+      var baseNameIsCollection = j$.isObject_(baseName) || j$.isArray_(baseName);
+
+      if (baseNameIsCollection && j$.util.isUndefined(methodNames)) {
+        methodNames = baseName;
+        baseName = 'unknown';
+      }
+
+      var obj = {};
+      var spiesWereSet = false;
+
+      if (j$.isArray_(methodNames)) {
+        for (var i = 0; i < methodNames.length; i++) {
+          obj[methodNames[i]] = self.createSpy(baseName + '.' + methodNames[i]);
+          spiesWereSet = true;
+        }
+      } else if (j$.isObject_(methodNames)) {
+        for (var key in methodNames) {
+          if (methodNames.hasOwnProperty(key)) {
+            obj[key] = self.createSpy(baseName + '.' + key);
+            obj[key].and.returnValue(methodNames[key]);
+            spiesWereSet = true;
+          }
+        }
+      }
+
+      if (!spiesWereSet) {
+        throw 'createSpyObj requires a non-empty array or object of method names to create spies for';
+      }
+
+      return obj;
+    };
+  }
+
+  return SpyFactory;
+};
+
 getJasmineRequireObj().SpyRegistry = function(j$) {
 
   var getErrorMsg = j$.formatErrorMsg('<spyOn>', 'spyOn(<object>, <methodName>)');
@@ -4915,6 +5260,7 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
   function SpyRegistry(options) {
     options = options || {};
     var global = options.global || j$.getGlobal();
+    var createSpy = options.createSpy;
     var currentSpies = options.currentSpies || function() { return []; };
 
     this.allowRespy = function(allow){
@@ -4943,19 +5289,14 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
         }
       }
 
-      var descriptor;
-      try {
-        descriptor = Object.getOwnPropertyDescriptor(obj, methodName);
-      } catch(e) {
-        // IE 8 doesn't support `definePropery` on non-DOM nodes
-      }
+      var descriptor = Object.getOwnPropertyDescriptor(obj, methodName);
 
       if (descriptor && !(descriptor.writable || descriptor.set)) {
         throw new Error(getErrorMsg(methodName + ' is not declared writable or has no setter'));
       }
 
       var originalMethod = obj[methodName],
-        spiedMethod = j$.createSpy(methodName, originalMethod),
+        spiedMethod = createSpy(methodName, originalMethod),
         restoreStrategy;
 
       if (Object.prototype.hasOwnProperty.call(obj, methodName) || (obj === global && methodName === 'onerror')) {
@@ -4990,12 +5331,7 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
         throw new Error('No property name supplied');
       }
 
-      var descriptor;
-      try {
-        descriptor = j$.util.getPropertyDescriptor(obj, propertyName);
-      } catch(e) {
-        // IE 8 doesn't support `definePropery` on non-DOM nodes
-      }
+      var descriptor = j$.util.getPropertyDescriptor(obj, propertyName);
 
       if (!descriptor) {
         throw new Error(propertyName + ' property does not exist');
@@ -5015,7 +5351,7 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
       }
 
       var originalDescriptor = j$.util.clone(descriptor),
-        spy = j$.createSpy(propertyName, descriptor[accessType]),
+        spy = createSpy(propertyName, descriptor[accessType]),
         restoreStrategy;
 
       if (Object.prototype.hasOwnProperty.call(obj, propertyName)) {
@@ -5054,112 +5390,213 @@ getJasmineRequireObj().SpyRegistry = function(j$) {
 getJasmineRequireObj().SpyStrategy = function(j$) {
 
   /**
-   * @namespace Spy#and
+   * @interface SpyStrategy
    */
   function SpyStrategy(options) {
     options = options || {};
 
-    var identity = options.name || 'unknown',
-        originalFn = options.fn || function() {},
-        getSpy = options.getSpy || function() {},
-        plan = function() {};
-
     /**
-     * Return the identifying information for the spy.
-     * @name Spy#and#identity
-     * @function
-     * @returns {String}
+     * Get the identifying information for the spy.
+     * @name SpyStrategy#identity
+     * @member
+     * @type {String}
      */
-    this.identity = function() {
-      return identity;
-    };
+    this.identity = options.name || 'unknown';
+    this.originalFn = options.fn || function() {};
+    this.getSpy = options.getSpy || function() {};
+    this.plan = this._defaultPlan = function() {};
 
-    /**
-     * Execute the current spy strategy.
-     * @name Spy#and#exec
-     * @function
-     */
-    this.exec = function() {
-      return plan.apply(this, arguments);
-    };
+    var k, cs = options.customStrategies || {};
+    for (k in cs) {
+      if (j$.util.has(cs, k) && !this[k]) {
+        this[k] = createCustomPlan(cs[k]);
+      }
+    }
+  }
 
-    /**
-     * Tell the spy to call through to the real implementation when invoked.
-     * @name Spy#and#callThrough
-     * @function
-     */
-    this.callThrough = function() {
-      plan = originalFn;
-      return getSpy();
-    };
+  function createCustomPlan(factory) {
+    return function() {
+      var plan = factory.apply(null, arguments);
 
-    /**
-     * Tell the spy to return the value when invoked.
-     * @name Spy#and#returnValue
-     * @function
-     * @param {*} value The value to return.
-     */
-    this.returnValue = function(value) {
-      plan = function() {
-        return value;
-      };
-      return getSpy();
+      if (!j$.isFunction_(plan)) {
+        throw new Error('Spy strategy must return a function');
+      }
+
+      this.plan = plan;
+      return this.getSpy();
     };
+  }
 
-    /**
-     * Tell the spy to return one of the specified values (sequentially) each time the spy is invoked.
-     * @name Spy#and#returnValues
-     * @function
-     * @param {...*} values - Values to be returned on subsequent calls to the spy.
-     */
-    this.returnValues = function() {
-      var values = Array.prototype.slice.call(arguments);
-      plan = function () {
-        return values.shift();
-      };
-      return getSpy();
+  /**
+   * Execute the current spy strategy.
+   * @name SpyStrategy#exec
+   * @function
+   */
+  SpyStrategy.prototype.exec = function(context, args) {
+    return this.plan.apply(context, args);
+  };
+
+  /**
+   * Tell the spy to call through to the real implementation when invoked.
+   * @name SpyStrategy#callThrough
+   * @function
+   */
+  SpyStrategy.prototype.callThrough = function() {
+    this.plan = this.originalFn;
+    return this.getSpy();
+  };
+
+  /**
+   * Tell the spy to return the value when invoked.
+   * @name SpyStrategy#returnValue
+   * @function
+   * @param {*} value The value to return.
+   */
+  SpyStrategy.prototype.returnValue = function(value) {
+    this.plan = function() {
+      return value;
     };
+    return this.getSpy();
+  };
 
-    /**
-     * Tell the spy to throw an error when invoked.
-     * @name Spy#and#throwError
-     * @function
-     * @param {Error|String} something Thing to throw
-     */
-    this.throwError = function(something) {
-      var error = (something instanceof Error) ? something : new Error(something);
-      plan = function() {
-        throw error;
-      };
-      return getSpy();
+  /**
+   * Tell the spy to return one of the specified values (sequentially) each time the spy is invoked.
+   * @name SpyStrategy#returnValues
+   * @function
+   * @param {...*} values - Values to be returned on subsequent calls to the spy.
+   */
+  SpyStrategy.prototype.returnValues = function() {
+    var values = Array.prototype.slice.call(arguments);
+    this.plan = function () {
+      return values.shift();
     };
+    return this.getSpy();
+  };
 
-    /**
-     * Tell the spy to call a fake implementation when invoked.
-     * @name Spy#and#callFake
-     * @function
-     * @param {Function} fn The function to invoke with the passed parameters.
-     */
-    this.callFake = function(fn) {
-      if(!(j$.isFunction_(fn) || j$.isAsyncFunction_(fn))) {
-        throw new Error('Argument passed to callFake should be a function, got ' + fn);
-      }
-      plan = fn;
-      return getSpy();
+  /**
+   * Tell the spy to throw an error when invoked.
+   * @name SpyStrategy#throwError
+   * @function
+   * @param {Error|String} something Thing to throw
+   */
+  SpyStrategy.prototype.throwError = function(something) {
+    var error = (something instanceof Error) ? something : new Error(something);
+    this.plan = function() {
+      throw error;
     };
+    return this.getSpy();
+  };
 
-    /**
-     * Tell the spy to do nothing when invoked. This is the default.
-     * @name Spy#and#stub
-     * @function
-     */
-    this.stub = function(fn) {
-      plan = function() {};
-      return getSpy();
+  /**
+   * Tell the spy to call a fake implementation when invoked.
+   * @name SpyStrategy#callFake
+   * @function
+   * @param {Function} fn The function to invoke with the passed parameters.
+   */
+  SpyStrategy.prototype.callFake = function(fn) {
+    if(!(j$.isFunction_(fn) || j$.isAsyncFunction_(fn))) {
+      throw new Error('Argument passed to callFake should be a function, got ' + fn);
+    }
+    this.plan = fn;
+    return this.getSpy();
+  };
+
+  /**
+   * Tell the spy to do nothing when invoked. This is the default.
+   * @name SpyStrategy#stub
+   * @function
+   */
+  SpyStrategy.prototype.stub = function(fn) {
+    this.plan = function() {};
+    return this.getSpy();
+  };
+
+  SpyStrategy.prototype.isConfigured = function() {
+    return this.plan !== this._defaultPlan;
+  };
+
+  return SpyStrategy;
+};
+
+getJasmineRequireObj().StackTrace = function(j$) {
+  function StackTrace(rawTrace) {
+    var lines = rawTrace
+      .split('\n')
+      .filter(function(line) { return line !== ''; });
+
+    if (lines[0].match(/^Error/)) {
+      this.message = lines.shift();
+    } else {
+      this.message = undefined;
+    }
+
+    var parseResult = tryParseFrames(lines);
+    this.frames = parseResult.frames;
+    this.style = parseResult.style;
+  }
+
+  var framePatterns = [
+    // PhantomJS on Linux, Node, Chrome, IE, Edge
+    // e.g. "   at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)"
+    // Note that the "function name" can include a surprisingly large set of
+    // characters, including angle brackets and square brackets.
+    { re: /^\s*at ([^\)]+) \(([^\)]+)\)$/, fnIx: 1, fileLineColIx: 2, style: 'v8' },
+
+    // NodeJS alternate form, often mixed in with the Chrome style
+    // e.g. "  at /some/path:4320:20
+    { re: /\s*at (.+)$/, fileLineColIx: 1, style: 'v8' },
+
+    // PhantomJS on OS X, Safari, Firefox
+    // e.g. "run@http://localhost:8888/__jasmine__/jasmine.js:4320:27"
+    // or "http://localhost:8888/__jasmine__/jasmine.js:4320:27"
+    { re: /^(([^@\s]+)@)?([^\s]+)$/, fnIx: 2, fileLineColIx: 3, style: 'webkit' }
+  ];
+
+  // regexes should capture the function name (if any) as group 1
+  // and the file, line, and column as group 2.
+  function tryParseFrames(lines) {
+    var style = null;
+    var frames = lines.map(function(line) {
+      var convertedLine = first(framePatterns, function(pattern) {
+        var overallMatch = line.match(pattern.re),
+          fileLineColMatch;
+        if (!overallMatch) { return null; }
+
+        fileLineColMatch = overallMatch[pattern.fileLineColIx].match(
+          /^(.*):(\d+):\d+$/);
+        if (!fileLineColMatch) { return null; }
+
+        style = style || pattern.style;
+        return {
+          raw: line,
+          file: fileLineColMatch[1],
+          line: parseInt(fileLineColMatch[2], 10),
+          func: overallMatch[pattern.fnIx]
+        };
+      });
+
+      return convertedLine || { raw: line };
+    });
+
+    return {
+      style: style,
+      frames: frames
     };
   }
 
-  return SpyStrategy;
+  function first(items, fn) {
+    var i, result;
+
+    for (i = 0; i < items.length; i++) {
+      result = fn(items[i]);
+
+      if (result) {
+        return result;
+      }
+    }
+  }
+  
+  return StackTrace;
 };
 
 getJasmineRequireObj().Suite = function(j$) {
@@ -5231,6 +5668,19 @@ getJasmineRequireObj().Suite = function(j$) {
     this.afterAllFns.unshift(fn);
   };
 
+  function removeFns(queueableFns) {
+    for(var i = 0; i < queueableFns.length; i++) {
+      queueableFns[i].fn = null;
+    }
+  }
+
+  Suite.prototype.cleanupBeforeAfter = function() {
+    removeFns(this.beforeAllFns);
+    removeFns(this.afterAllFns);
+    removeFns(this.beforeFns);
+    removeFns(this.afterFns);
+  };
+
   Suite.prototype.addChild = function(child) {
     this.children.push(child);
   };
@@ -5243,14 +5693,10 @@ getJasmineRequireObj().Suite = function(j$) {
     if (this.result.failedExpectations.length > 0) {
       return 'failed';
     } else {
-      return 'finished';
+      return 'passed';
     }
   };
 
-  Suite.prototype.isExecutable = function() {
-    return !this.markedPending;
-  };
-
   Suite.prototype.canBeReentered = function() {
     return this.beforeAllFns.length === 0 && this.afterAllFns.length === 0;
   };
@@ -5277,39 +5723,29 @@ getJasmineRequireObj().Suite = function(j$) {
       return;
     }
 
-    if(isAfterAll(this.children)) {
-      var data = {
-        matcherName: '',
-        passed: false,
-        expected: '',
-        actual: '',
-        error: arguments[0]
-      };
-      this.result.failedExpectations.push(this.expectationResultFactory(data));
-    } else {
-      for (var i = 0; i < this.children.length; i++) {
-        var child = this.children[i];
-        child.onException.apply(child, arguments);
-      }
+    var data = {
+      matcherName: '',
+      passed: false,
+      expected: '',
+      actual: '',
+      error: arguments[0]
+    };
+    var failedExpectation = this.expectationResultFactory(data);
+
+    if (!this.parentSuite) {
+      failedExpectation.globalErrorType = 'afterAll';
     }
+
+    this.result.failedExpectations.push(failedExpectation);
   };
 
   Suite.prototype.addExpectationResult = function () {
-    if(isAfterAll(this.children) && isFailure(arguments)){
+    if(isFailure(arguments)) {
       var data = arguments[1];
       this.result.failedExpectations.push(this.expectationResultFactory(data));
       if(this.throwOnExpectationFailure) {
         throw new j$.errors.ExpectationFailed();
       }
-    } else {
-      for (var i = 0; i < this.children.length; i++) {
-        var child = this.children[i];
-        try {
-          child.addExpectationResult.apply(child, arguments);
-        } catch(e) {
-          // keep going
-        }
-      }
     }
   };
 
@@ -5317,10 +5753,6 @@ getJasmineRequireObj().Suite = function(j$) {
     this.result.deprecationWarnings.push(this.expectationResultFactory({ message: msg }));
   };
 
-  function isAfterAll(children) {
-    return children && children[0].result.status;
-  }
-
   function isFailure(args) {
     return !args[0];
   }
@@ -5363,13 +5795,14 @@ getJasmineRequireObj().TreeProcessor = function() {
         nodeStart = attrs.nodeStart || function() {},
         nodeComplete = attrs.nodeComplete || function() {},
         orderChildren = attrs.orderChildren || function(node) { return node.children; },
+        excludeNode = attrs.excludeNode || function(node) { return false; },
         stats = { valid: true },
         processed = false,
         defaultMin = Infinity,
         defaultMax = 1 - Infinity;
 
     this.processTree = function() {
-      processNode(tree, false);
+      processNode(tree, true);
       processed = true;
       return stats;
     };
@@ -5403,18 +5836,18 @@ getJasmineRequireObj().TreeProcessor = function() {
       }
     }
 
-    function processNode(node, parentEnabled) {
+    function processNode(node, parentExcluded) {
       var executableIndex = runnableIndex(node.id);
 
       if (executableIndex !== undefined) {
-        parentEnabled = true;
+        parentExcluded = false;
       }
 
-      parentEnabled = parentEnabled && node.isExecutable();
-
       if (!node.children) {
+        var excluded = parentExcluded || excludeNode(node);
         stats[node.id] = {
-          executable: parentEnabled && node.isExecutable(),
+          excluded: excluded,
+          willExecute: !excluded && !node.markedPending,
           segments: [{
             index: 0,
             owner: node,
@@ -5431,7 +5864,7 @@ getJasmineRequireObj().TreeProcessor = function() {
         for (var i = 0; i < orderedChildren.length; i++) {
           var child = orderedChildren[i];
 
-          processNode(child, parentEnabled);
+          processNode(child, parentExcluded);
 
           if (!stats.valid) {
             return;
@@ -5439,11 +5872,12 @@ getJasmineRequireObj().TreeProcessor = function() {
 
           var childStats = stats[child.id];
 
-          hasExecutableChild = hasExecutableChild || childStats.executable;
+          hasExecutableChild = hasExecutableChild || childStats.willExecute;
         }
 
         stats[node.id] = {
-          executable: hasExecutableChild
+          excluded: parentExcluded,
+          willExecute: hasExecutableChild
         };
 
         segmentChildren(node, orderedChildren, stats[node.id], executableIndex);
@@ -5521,16 +5955,20 @@ getJasmineRequireObj().TreeProcessor = function() {
       if (node.children) {
         return {
           fn: function(done) {
-            nodeStart(node);
+            var onStart = {
+              fn: function(next) {
+                nodeStart(node, next);
+              }
+            };
 
             queueRunnerFactory({
-              onComplete: function() {
-                nodeComplete(node, node.getResult());
-                done();
+              onComplete: function () {
+                node.cleanupBeforeAfter();
+                nodeComplete(node, node.getResult(), done);
               },
-              queueableFns: wrapChildren(node, segmentNumber),
+              queueableFns: [onStart].concat(wrapChildren(node, segmentNumber)),
               userContext: node.sharedUserContext(),
-              onException: function() {
+              onException: function () {
                 node.onException.apply(node, arguments);
               }
             });
@@ -5538,7 +5976,7 @@ getJasmineRequireObj().TreeProcessor = function() {
         };
       } else {
         return {
-          fn: function(done) { node.execute(done, stats[node.id].executable); }
+          fn: function(done) { node.execute(done, stats[node.id].excluded); }
         };
       }
     }
@@ -5551,7 +5989,7 @@ getJasmineRequireObj().TreeProcessor = function() {
         result.push(executeNode(segmentChildren[i].owner, segmentChildren[i].index));
       }
 
-      if (!stats[node.id].executable) {
+      if (!stats[node.id].willExecute) {
         return result;
       }
 
@@ -5582,5 +6020,5 @@ getJasmineRequireObj().UserContext = function(j$) {
 };
 
 getJasmineRequireObj().version = function() {
-  return '2.99.0';
+  return '3.0.0';
 };