jasmine-core 2.99.2 → 3.0.0

data/lib/jasmine-core/spec/core/asymmetric_equality/StringMatchingSpec.js

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

data/lib/jasmine-core/spec/core/formatErrorMsgSpec.js

@@ -0,0 +1,13 @@
+describe('formatErrorMsg', function () {
+  it('should format an error with a domain', function() {
+    var formator = jasmineUnderTest.formatErrorMsg('api');
+    expect(formator('message')).toBe('api : message');
+    expect(formator('message2')).toBe('api : message2');
+  });
+
+  it('should format an error with a domain and usage', function() {
+    var formator = jasmineUnderTest.formatErrorMsg('api', 'with a param');
+    expect(formator('message')).toBe('api : message\nUsage: with a param');
+    expect(formator('message2')).toBe('api : message2\nUsage: with a param');
+  });
+});

data/lib/jasmine-core/spec/core/integration/CustomMatchersSpec.js

@@ -0,0 +1,200 @@
+describe("Custom Matchers (Integration)", function() {
+  var env;
+  var fakeTimer;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+    env.randomizeTests(false);
+  });
+
+  it("allows adding more matchers local to a spec", function(done) {
+    env.it('spec defining a custom matcher', function() {
+      env.addMatchers({
+        matcherForSpec: function() {
+          return {
+            compare: function(actual, expected) {
+              return { pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected };
+            }
+          }
+        }
+      });
+
+      env.expect("zzz").matcherForSpec("yyy");
+    });
+
+    env.it("spec without custom matcher defined", function() {
+      expect(env.expect("zzz").matcherForSpec).toBeUndefined();
+    });
+
+    var specDoneSpy = jasmine.createSpy("specDoneSpy");
+    var expectations = function() {
+      var firstSpecResult = specDoneSpy.calls.first().args[0];
+      expect(firstSpecResult.status).toEqual("failed");
+      expect(firstSpecResult.failedExpectations[0].message).toEqual("matcherForSpec: actual: zzz; expected: yyy");
+      done();
+    };
+    env.addReporter({ specDone:specDoneSpy, jasmineDone: expectations});
+
+    env.execute();
+  });
+
+  it("passes the spec if the custom matcher passes", function(done) {
+    env.it("spec using custom matcher", function() {
+      env.addMatchers({
+        toBeReal: function() {
+          return { compare: function() { return { pass: true }; } };
+        }
+      });
+
+      env.expect(true).toBeReal();
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('passed');
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers", function(done) {
+    env.it("spec using custom equality matcher", function() {
+      var customEqualityFn = function(a, b) {
+        // All "foo*" strings match each other.
+        if (typeof a == "string" && typeof b == "string" &&
+            a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+          return true;
+        }
+      };
+
+      env.addCustomEqualityTester(customEqualityFn);
+      env.expect({foo: 'fooValue'}).toEqual(jasmineUnderTest.objectContaining({foo: 'fooBar'}));
+      env.expect(['fooValue', 'things']).toEqual(jasmineUnderTest.arrayContaining(['fooBar']));
+      env.expect(['fooValue']).toEqual(jasmineUnderTest.arrayWithExactContents(['fooBar']));
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('passed');
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("displays an appropriate failure message if a custom equality matcher fails", function(done) {
+    env.it("spec using custom equality matcher", function() {
+      var customEqualityFn = function(a, b) {
+        // "foo" is not equal to anything
+        if (a === 'foo' || b === 'foo') {
+          return false;
+        }
+      };
+
+      env.addCustomEqualityTester(customEqualityFn);
+      env.expect({foo: 'foo'}).toEqual({foo: 'foo'});
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('failed');
+      expect(result.failedExpectations[0].message).toEqual(
+        "Expected $.foo = 'foo' to equal 'foo'."
+      );
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("uses the negative compare function for a negative comparison, if provided", function(done) {
+    env.it("spec with custom negative comparison matcher", function() {
+      env.addMatchers({
+        toBeReal: function() {
+          return {
+            compare: function() { return { pass: true }; },
+            negativeCompare: function() { return { pass: true }; }
+          };
+        }
+      });
+
+      env.expect(true).not.toBeReal();
+    });
+
+    var specExpectations = function(result) {
+      expect(result.status).toEqual('passed');
+    }
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("generates messages with the same rules as built in matchers absent a custom message", function(done) {
+    env.it('spec with an expectation', function() {
+      env.addMatchers({
+        toBeReal: function() {
+          return {
+            compare: function() {
+              return { pass: false };
+            }
+          }
+        }
+      });
+
+      env.expect("a").toBeReal();
+    });
+
+    var specExpectations = function(result) {
+      expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("passes the expected and actual arguments to the comparison function", function(done) {
+    var argumentSpy = jasmine.createSpy("argument spy").and.returnValue({ pass: true });
+
+    env.it('spec with an expectation', function () {
+      env.addMatchers({
+        toBeReal: function() {
+          return { compare: argumentSpy };
+        }
+      });
+
+      env.expect(true).toBeReal();
+      env.expect(true).toBeReal("arg");
+      env.expect(true).toBeReal("arg1", "arg2");
+    });
+
+    var specExpectations = function() {
+      expect(argumentSpy).toHaveBeenCalledWith(true);
+      expect(argumentSpy).toHaveBeenCalledWith(true, "arg");
+      expect(argumentSpy).toHaveBeenCalledWith(true, "arg1", "arg2");
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+
+  it("passes the jasmine utility and current equality matchers to the expectation factory", function(done) {
+    var matcherFactory = function() { return { compare: function() { return {pass: true}; }}; },
+        argumentSpy = jasmine.createSpy("argument spy").and.returnValue(matcherFactory),
+        customEqualityFn = function() { return true; };
+
+
+    env.it("spec with expectation", function() {
+      env.addCustomEqualityTester(customEqualityFn);
+      env.addMatchers({
+        toBeReal: argumentSpy
+      });
+
+      env.expect(true).toBeReal();
+    });
+
+    var specExpectations = function() {
+      expect(argumentSpy).toHaveBeenCalledWith(jasmineUnderTest.matchersUtil, [customEqualityFn]);
+    };
+
+    env.addReporter({ specDone: specExpectations, jasmineDone: done });
+    env.execute();
+  });
+});

data/lib/jasmine-core/spec/core/integration/CustomSpyStrategiesSpec.js

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

data/lib/jasmine-core/spec/core/integration/EnvSpec.js

@@ -0,0 +1,2344 @@
+describe("Env integration", function() {
+  beforeEach(function() {
+    jasmine.getEnv().registerIntegrationMatchers();
+  });
+
+  it("Suites execute as expected (no nesting)", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        calls = [];
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        "with a spec",
+        "and another spec"
+      ]);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions});
+    env.randomizeTests(false);
+
+    env.describe("A Suite", function() {
+      env.it("with a spec", function() {
+        calls.push("with a spec");
+      });
+      env.it("and another spec", function() {
+        calls.push("and another spec");
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Nested Suites execute as expected", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        calls = [];
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        'an outer spec',
+        'an inner spec',
+        'another inner spec'
+      ]);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+    env.randomizeTests(false);
+
+    env.describe("Outer suite", function() {
+      env.it("an outer spec", function() {
+        calls.push('an outer spec')
+      });
+      env.describe("Inner suite", function() {
+        env.it("an inner spec", function() {
+          calls.push('an inner spec');
+        });
+        env.it("another inner spec", function() {
+          calls.push('another inner spec');
+        });
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Multiple top-level Suites execute as expected", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        calls = [];
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        'an outer spec',
+        'an inner spec',
+        'another inner spec',
+        'a 2nd outer spec'
+      ]);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+    env.randomizeTests(false);
+
+
+    env.describe("Outer suite", function() {
+      env.it("an outer spec", function() {
+        calls.push('an outer spec');
+      });
+      env.describe("Inner suite", function() {
+        env.it("an inner spec", function() {
+          calls.push('an inner spec');
+        });
+        env.it("another inner spec", function() {
+          calls.push('another inner spec');
+        });
+      });
+    });
+
+    env.describe("Another outer suite", function() {
+      env.it("a 2nd outer spec", function() {
+        calls.push('a 2nd outer spec')
+      });
+    });
+
+    env.execute();
+  });
+
+  it('explicitly fails a spec', function(done) {
+    var env = new jasmineUnderTest.Env(),
+        specDone = jasmine.createSpy('specDone');
+
+    env.addReporter({
+      specDone: specDone,
+      jasmineDone: function() {
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'has a default message',
+          failedExpectations: [jasmine.objectContaining({
+            message: 'Failed'
+          })]
+        }));
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'specifies a message',
+          failedExpectations: [jasmine.objectContaining({
+            message: 'Failed: messy message'
+          })]
+        }));
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'has a message and stack trace from an Error',
+          failedExpectations: [jasmine.objectContaining({
+            message: 'Failed: error message',
+            stack: {
+              asymmetricMatch: function(other) {
+                if (!other) {
+                  // IE doesn't give us a stacktrace so just ignore it.
+                  return true;
+                }
+                var split = other.split('\n'),
+                    firstLine = split[0];
+                if (firstLine.indexOf('error message') >= 0) {
+                  // Chrome inserts the message and a newline before the first stacktrace line.
+                  firstLine = split[1];
+                }
+                return firstLine.indexOf('EnvSpec') >= 0;
+              }
+            }
+          })]
+        }));
+        expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'pretty prints objects',
+          failedExpectations: [jasmine.objectContaining({
+            message: 'Failed: Object({ prop: \'value\', arr: [ \'works\', true ] })'
+          })]
+        }));
+        done();
+      }
+    });
+
+    env.describe('failing', function() {
+      env.it('has a default message', function() {
+        env.fail();
+      });
+
+      env.it('specifies a message', function() {
+        env.fail('messy message');
+      });
+
+      env.it('has a message and stack trace from an Error', function() {
+        env.fail(new Error('error message'));
+      });
+
+      env.it('pretty prints objects', function() {
+        env.fail({prop: 'value', arr: ['works', true]});
+      })
+    });
+
+    env.execute();
+  });
+
+  it("produces an understandable error message when 'fail' is used outside of a current spec", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', ['jasmineDone']);
+
+    reporter.jasmineDone.and.callFake(done);
+    env.addReporter(reporter);
+
+    env.describe("A Suite", function() {
+      env.it("an async spec that is actually synchronous", function(underTestCallback) {
+        underTestCallback();
+      });
+      expect(function() { env.fail(); }).toThrowError(/'fail' was used when there was no current spec/);
+    });
+
+    env.execute();
+  });
+
+
+  it("calls associated befores/specs/afters with the same 'this'", function(done) {
+    var env = new jasmineUnderTest.Env();
+
+    env.addReporter({jasmineDone: done});
+    env.randomizeTests(false);
+    env.describe("tests", function() {
+      var firstTimeThrough = true, firstSpecContext, secondSpecContext;
+
+      env.beforeEach(function() {
+        if (firstTimeThrough) {
+          firstSpecContext = this;
+        } else {
+          secondSpecContext = this;
+        }
+        expect(this).toEqual(new jasmineUnderTest.UserContext());
+      });
+
+      env.it("sync spec", function() {
+        expect(this).toBe(firstSpecContext);
+      });
+
+      env.it("another sync spec", function() {
+        expect(this).toBe(secondSpecContext);
+      });
+
+      env.afterEach(function() {
+        if (firstTimeThrough) {
+          expect(this).toBe(firstSpecContext);
+          firstTimeThrough = false;
+        } else {
+          expect(this).toBe(secondSpecContext);
+        }
+      });
+    });
+
+    env.execute();
+  });
+
+  it("calls associated befores/its/afters with the same 'this' for an async spec", function(done) {
+    var env = new jasmineUnderTest.Env();
+
+    env.addReporter({jasmineDone: done});
+
+    env.describe("with an async spec", function() {
+      var specContext;
+
+      env.beforeEach(function() {
+        specContext = this;
+        expect(this).toEqual(new jasmineUnderTest.UserContext());
+      });
+
+      env.it("sync spec", function(underTestCallback) {
+        expect(this).toBe(specContext);
+        underTestCallback();
+      });
+
+      env.afterEach(function() {
+        expect(this).toBe(specContext);
+      });
+    });
+
+    env.execute();
+  });
+
+  it("calls associated beforeAlls/afterAlls only once per suite", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        before = jasmine.createSpy('beforeAll'),
+        after = jasmine.createSpy('afterAll');
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(after).toHaveBeenCalled();
+        expect(after.calls.count()).toBe(1);
+        expect(before.calls.count()).toBe(1);
+        done();
+      }
+    });
+
+    env.describe("with beforeAll and afterAll", function() {
+      env.it("spec", function() {
+        expect(before).toHaveBeenCalled();
+        expect(after).not.toHaveBeenCalled();
+      });
+
+      env.it("another spec", function() {
+        expect(before).toHaveBeenCalled();
+        expect(after).not.toHaveBeenCalled();
+      });
+
+      env.beforeAll(before);
+      env.afterAll(after);
+    });
+
+    env.execute();
+  });
+
+  it("calls associated beforeAlls/afterAlls only once per suite for async", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        before = jasmine.createSpy('beforeAll'),
+        after = jasmine.createSpy('afterAll');
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(after).toHaveBeenCalled();
+        expect(after.calls.count()).toBe(1);
+        expect(before.calls.count()).toBe(1);
+        done();
+      }
+    });
+
+    env.describe("with beforeAll and afterAll", function() {
+      env.it("spec", function() {
+        expect(before).toHaveBeenCalled();
+        expect(after).not.toHaveBeenCalled();
+      });
+
+      env.it("another spec", function() {
+        expect(before).toHaveBeenCalled();
+        expect(after).not.toHaveBeenCalled();
+      });
+
+      env.beforeAll(function(beforeCallbackUnderTest) {
+        before();
+        beforeCallbackUnderTest();
+      });
+
+      env.afterAll(function(afterCallbackUnderTest) {
+        after();
+        afterCallbackUnderTest();
+      });
+    });
+
+    env.execute();
+  });
+
+  it("calls associated beforeAlls/afterAlls with the cascaded 'this'", function(done) {
+    var env = new jasmineUnderTest.Env();
+
+    env.addReporter({jasmineDone: done});
+
+    env.describe("with beforeAll and afterAll", function() {
+      env.beforeAll(function() {
+        this.x = 1;
+      });
+
+      env.it("has an x at the root", function() {
+        expect(this.x).toBe(1);
+      });
+
+      env.describe("child that deletes", function() {
+        env.beforeAll(function() {
+          expect(this.x).toBe(1);
+          delete this.x;
+        });
+
+        env.it("has no x", function() {
+          expect(this.x).not.toBeDefined();
+        });
+      });
+
+      env.describe("child should still have x", function() {
+        env.beforeAll(function(innerDone) {
+          expect(this.x).toBe(1);
+          innerDone();
+        });
+
+        env.it("has an x", function() {
+          expect(this.x).toBe(1);
+          delete this.x;
+        });
+
+        env.it("still has an x", function() {
+          expect(this.x).toBe(1);
+        });
+
+        env.it("adds a y", function() {
+          this.y = 2;
+          expect(this.y).toBe(2);
+        });
+
+        env.it("doesn't have y that was added in sibling", function() {
+          expect(this.y).not.toBeDefined();
+        });
+      });
+    });
+
+    env.execute();
+  });
+
+  it("tags top-level afterAll failures with a type", function(done) {
+    var env = new jasmineUnderTest.Env();
+
+    env.addReporter({jasmineDone: function(result) {
+      expect(result.failedExpectations[0].globalErrorType).toEqual('afterAll');
+      done();
+    }});
+
+    env.it('has a spec', function() {});
+
+    env.afterAll(function() {
+      throw 'nope';
+    });
+
+    env.execute();
+  });
+
+  it("does not tag suite afterAll failures with a type", function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = {
+        jasmineDone: function() {
+          expect(reporter.suiteDone).toHaveBeenCalled();
+          done();
+        },
+        suiteDone: jasmine.createSpy('suiteDone').and.callFake(function(result) {
+          expect(result.failedExpectations[0].globalErrorType).toBeFalsy();
+        })
+      };
+
+    env.addReporter(reporter);
+
+    env.describe('a suite', function() {
+      env.it('has a spec', function() {});
+
+      env.afterAll(function() {
+        throw 'nope';
+      });
+    });
+
+    env.execute();
+  });
+
+  it("when the beforeAll fails, error at suite level", function (done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "suiteDone", "jasmineDone" ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.specDone.calls.count()).toEqual(2);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('A suite spec that will pass', []);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('A suite nesting another spec to pass', []);
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('A suite', ['Expected 1 to be 2.']);
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe('A suite', function(){
+      env.beforeAll(function() {
+        env.expect(1).toBe(2);
+      });
+
+      env.it("spec that will pass", function() {
+      });
+
+      env.describe("nesting", function() {
+        env.it("another spec to pass", function() {
+        });
+      });
+    });
+
+    env.execute();
+  });
+
+  it("copes with async failures after done has been called", function(done) {
+    var global = {
+      setTimeout: function(fn, delay) { setTimeout(fn, delay) },
+      clearTimeout: function(fn, delay) { clearTimeout(fn, delay) },
+    };
+    spyOn(jasmineUnderTest, 'getGlobal').and.returnValue(global);
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone", "suiteDone" ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.specDone).not.toHaveFailedExpectationsForRunnable('A suite fails', ['fail thrown']);
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('A suite', ['fail thrown']);
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.fdescribe('A suite', function() {
+      env.it('fails', function(specDone) {
+        setTimeout(function() {
+          specDone();
+          setTimeout(function() {
+          setTimeout(function() {
+            global.onerror('fail');
+          });
+          });
+        });
+      });
+    });
+
+    env.describe('Ignored', function() {
+      env.it('is not run', function() {});
+    });
+
+    env.execute();
+  });
+
+  describe('suiteDone reporting', function(){
+    it("reports when an afterAll fails an expectation", function(done) {
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('my suite', [
+          'Expected 1 to equal 2.',
+          'Expected 2 to equal 3.'
+        ]);
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.describe('my suite', function() {
+        env.it('my spec', function() {
+        });
+
+        env.afterAll(function() {
+          env.expect(1).toEqual(2);
+          env.expect(2).toEqual(3);
+        });
+      });
+
+      env.execute();
+    });
+
+    it("if there are no specs, it still reports correctly", function(done) {
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer suite', [
+          'Expected 1 to equal 2.',
+          'Expected 2 to equal 3.'
+        ]);
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.describe('outer suite', function() {
+        env.describe('inner suite', function() {
+          env.it('spec', function(){ });
+        });
+
+        env.afterAll(function() {
+          env.expect(1).toEqual(2);
+          env.expect(2).toEqual(3);
+        });
+      });
+
+      env.execute();
+    });
+
+    it("reports when afterAll throws an exception", function(done) {
+      var env = new jasmineUnderTest.Env(),
+        error = new Error('After All Exception'),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('my suite', [
+          (/^Error: After All Exception/)
+        ]);
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.describe('my suite', function() {
+        env.it('my spec', function() {
+        });
+
+        env.afterAll(function() {
+          throw error;
+        });
+      });
+
+      env.execute();
+    });
+
+    it("reports when an async afterAll fails an expectation", function(done) {
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('my suite', [
+          'Expected 1 to equal 2.'
+        ]);
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.describe('my suite', function() {
+        env.it('my spec', function() {
+        });
+
+        env.afterAll(function(afterAllDone) {
+          env.expect(1).toEqual(2);
+          afterAllDone();
+        });
+      });
+
+      env.execute();
+    });
+
+    it("reports when an async afterAll throws an exception", function(done) {
+      var env = new jasmineUnderTest.Env(),
+        error = new Error('After All Exception'),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
+
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('my suite', [
+          (/^Error: After All Exception/)
+        ]);
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.describe('my suite', function() {
+        env.it('my spec', function() {
+        });
+
+        env.afterAll(function(afterAllDone) {
+          throw error;
+        });
+      });
+
+      env.execute();
+    });
+  });
+
+  it('reports expectation failures in global beforeAll', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj(['specDone', 'jasmineDone']);
+
+    reporter.jasmineDone.and.callFake(function(results) {
+      expect(results.failedExpectations).toEqual([jasmine.objectContaining({ message: 'Expected 1 to be 0.' })]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('is a spec', []);
+      done();
+    });
+
+    env.beforeAll(function() {
+      env.expect(1).toBe(0);
+    });
+
+    env.it('is a spec', function() {
+      env.expect(true).toBe(true);
+    });
+
+    env.addReporter(reporter);
+
+    env.execute();
+  });
+
+  it('reports expectation failures in global afterAll', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj(['jasmineDone']);
+
+    reporter.jasmineDone.and.callFake(function(results) {
+      expect(results.failedExpectations).toEqual([jasmine.objectContaining({ message: 'Expected 1 to be 0.' })]);
+      done();
+    });
+
+    env.afterAll(function() {
+      env.expect(1).toBe(0);
+    });
+
+    env.it('is a spec', function() {
+      env.expect(true).toBe(true);
+    });
+
+    env.addReporter(reporter);
+
+    env.execute();
+  });
+
+  it("Allows specifying which specs and suites to run", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        calls = [],
+        suiteCallback = jasmine.createSpy('suite callback'),
+        firstSpec,
+        secondSuite;
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        'third spec',
+        'first spec'
+      ]);
+      expect(suiteCallback).toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions, suiteDone: suiteCallback});
+
+    env.describe("first suite", function() {
+      firstSpec = env.it("first spec", function() {
+        calls.push('first spec');
+      });
+      env.it("second spec", function() {
+        calls.push('second spec');
+      });
+    });
+
+    secondSuite = env.describe("second suite", function() {
+      env.it("third spec", function() {
+        calls.push('third spec');
+      });
+    });
+
+    env.execute([secondSuite.id, firstSpec.id]);
+  });
+
+  it('runs before and after all functions for runnables provided to .execute()', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      calls = [],
+      first_spec,
+      second_spec;
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        "before",
+        "first spec",
+        "second spec",
+        "after"
+      ]);
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.describe("first suite", function() {
+      env.beforeAll(function() {
+        calls.push("before");
+      });
+      env.afterAll(function() {
+        calls.push("after")
+      });
+      first_spec = env.it("spec", function() {
+        calls.push('first spec');
+      });
+      second_spec = env.it("spec 2", function() {
+        calls.push("second spec");
+      });
+    });
+
+    env.execute([first_spec.id, second_spec.id]);
+  });
+
+  it("Allows filtering out specs and suites to run programmatically", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        calls = [],
+        suiteCallback = jasmine.createSpy('suite callback'),
+        firstSpec,
+        secondSuite;
+
+    var assertions = function() {
+      expect(calls.length).toEqual(2);
+      expect(calls).toEqual(jasmine.arrayContaining([
+        'first spec',
+        'second spec'
+      ]));
+      expect(suiteCallback).toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions, suiteDone: suiteCallback});
+
+    env.describe("first suite", function() {
+      env.it("first spec", function() {
+        calls.push('first spec');
+      });
+      env.it("second spec", function() {
+        calls.push('second spec');
+      });
+    });
+
+    secondSuite = env.describe("second suite", function() {
+      env.it("third spec", function() {
+        calls.push('third spec');
+      });
+    });
+
+    env.specFilter = function(spec) {
+      return /^first suite/.test(spec.getFullName());
+    };
+
+    env.execute();
+  });
+
+  it("Functions can be spied on and have their calls tracked", function (done) {
+    var env = new jasmineUnderTest.Env();
+
+    var originalFunctionWasCalled = false;
+    var subject = {
+      spiedFunc: function() {
+        originalFunctionWasCalled = true;
+        return "original result";
+      }
+    };
+
+    env.addReporter({jasmineDone: done});
+
+    env.it("works with spies", function() {
+      var spy = env.spyOn(subject, 'spiedFunc').and.returnValue("stubbed result");
+
+      expect(subject.spiedFunc).toEqual(spy);
+      expect(subject.spiedFunc.calls.any()).toEqual(false);
+      expect(subject.spiedFunc.calls.count()).toEqual(0);
+
+      subject.spiedFunc('foo');
+
+      expect(subject.spiedFunc.calls.any()).toEqual(true);
+      expect(subject.spiedFunc.calls.count()).toEqual(1);
+      expect(subject.spiedFunc.calls.mostRecent().args).toEqual(['foo']);
+      expect(subject.spiedFunc.calls.mostRecent().object).toEqual(subject);
+      expect(subject.spiedFunc.calls.mostRecent().returnValue).toEqual("stubbed result");
+      expect(originalFunctionWasCalled).toEqual(false);
+
+      subject.spiedFunc.and.callThrough();
+      subject.spiedFunc('bar');
+      expect(subject.spiedFunc.calls.count()).toEqual(2);
+      expect(subject.spiedFunc.calls.mostRecent().args).toEqual(['bar']);
+      expect(subject.spiedFunc.calls.mostRecent().returnValue).toEqual("original result");
+      expect(originalFunctionWasCalled).toEqual(true);
+    });
+
+    env.execute();
+  });
+
+  it('can be configured to allow respying on functions', function (done) {
+    var env = new jasmineUnderTest.Env(),
+        foo = {
+          bar: function () {
+            return 1;
+          }
+        };
+
+    env.allowRespy(true);
+    env.addReporter({ jasmineDone: done });
+
+    env.describe('test suite', function(){
+      env.it('spec 0', function(){
+        env.spyOn(foo,'bar');
+
+        var error = null;
+
+        expect(function() {
+          env.spyOn(foo, 'bar');
+        }).not.toThrow();
+      });
+    });
+
+    env.execute();
+  });
+
+  it('removes all spies added in a spec after the spec is complete', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      originalFoo = function() {},
+      testObj = {
+        foo: originalFoo
+      },
+      firstSpec = jasmine.createSpy('firstSpec').and.callFake(function() {
+        env.spyOn(testObj, 'foo');
+      }),
+      secondSpec = jasmine.createSpy('secondSpec').and.callFake(function() {
+        expect(testObj.foo).toBe(originalFoo);
+      });
+      env.describe('test suite', function() {
+        env.it('spec 0', firstSpec);
+        env.it('spec 1', secondSpec);
+      });
+
+    var assertions = function() {
+      expect(firstSpec).toHaveBeenCalled();
+      expect(secondSpec).toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+
+    env.execute();
+  });
+
+  it('removes all spies added in a suite after the suite is complete', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      originalFoo = function() {},
+      testObj = {
+        foo: originalFoo
+      };
+
+      env.describe('test suite', function() {
+        env.beforeAll(function() { env.spyOn(testObj, 'foo');})
+
+        env.it('spec 0', function() {
+          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
+        });
+
+        env.it('spec 1', function() {
+          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
+        });
+      });
+
+      env.describe('another suite', function() {
+        env.it('spec 2', function() {
+          expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(false);
+        });
+      });
+
+    env.addReporter({ jasmineDone: done });
+
+    env.execute();
+  });
+
+  it('removes a spy from the top suite after the run is complete', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      originalFoo = function() {},
+      testObj = {
+        foo: originalFoo
+      };
+
+    env.beforeAll(function() {
+      env.spyOn(testObj, 'foo');
+    });
+
+    env.it('spec', function() {
+      expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(true);
+    });
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(jasmineUnderTest.isSpy(testObj.foo)).toBe(false);
+        done();
+      }
+    });
+
+    env.execute();
+  });
+
+  it("Mock clock can be installed and used in tests", function(done) {
+    var globalSetTimeout = jasmine.createSpy('globalSetTimeout'),
+        delayedFunctionForGlobalClock = jasmine.createSpy('delayedFunctionForGlobalClock'),
+        delayedFunctionForMockClock = jasmine.createSpy('delayedFunctionForMockClock'),
+        env = new jasmineUnderTest.Env({global: { setTimeout: globalSetTimeout }});
+
+    var assertions = function() {
+      expect(delayedFunctionForMockClock).toHaveBeenCalled();
+      expect(globalSetTimeout).toHaveBeenCalledWith(delayedFunctionForGlobalClock, 100);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+    env.randomizeTests(false);
+
+    env.describe("tests", function() {
+      env.it("test with mock clock", function() {
+        env.clock.install();
+        env.clock.setTimeout(delayedFunctionForMockClock, 100);
+        env.clock.tick(100);
+        env.clock.uninstall();
+      });
+      env.it("test without mock clock", function() {
+        env.clock.setTimeout(delayedFunctionForGlobalClock, 100);
+      });
+    });
+
+    expect(globalSetTimeout).not.toHaveBeenCalled();
+    expect(delayedFunctionForMockClock).not.toHaveBeenCalled();
+
+    env.execute();
+  });
+
+  it("should run async specs in order, waiting for them to complete", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('reporter', ['jasmineDone']),
+        mutatedVar;
+
+    reporter.jasmineDone.and.callFake(function() {
+      done();
+    });
+    env.addReporter(reporter);
+
+    env.describe("tests", function() {
+      env.beforeEach(function() {
+        mutatedVar = 2;
+      });
+
+      env.it("async spec", function(underTestCallback) {
+        setTimeout(function() {
+          expect(mutatedVar).toEqual(2);
+          underTestCallback();
+        }, 0);
+      });
+
+      env.it("after async spec", function() {
+        mutatedVar = 3;
+      });
+    });
+
+    env.execute();
+  });
+
+  describe("with a mock clock", function() {
+    var realSetTimeout;
+    beforeEach(function() {
+      this.originalTimeout = jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL;
+      realSetTimeout = setTimeout;
+      jasmine.clock().install();
+    });
+
+    afterEach(function() {
+      jasmine.clock().tick(1);
+      jasmine.clock().tick(1);
+      jasmine.clock().uninstall();
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = this.originalTimeout;
+    });
+
+    it("should wait a default interval before failing specs that haven't called done yet", function(done) {
+      var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]);
+
+      reporter.specDone.and.callFake(function(result) {
+        expect(result).toEqual(jasmine.objectContaining({status: 'failed'}));
+        realSetTimeout(function() {
+          jasmine.clock().tick(1);
+        }, 0);
+      });
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.specDone.calls.count()).toEqual(1);
+        jasmine.clock().tick(1);
+        realSetTimeout(done);
+      });
+
+      env.addReporter(reporter);
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 8414;
+
+      env.it("async spec that doesn't call done", function(underTestCallback) {
+        env.expect(true).toBeTruthy();
+        jasmine.clock().tick(8416);
+        jasmine.clock().tick(1);
+      });
+
+      env.execute();
+    });
+
+    it("should not use the mock clock for asynchronous timeouts", function(done){
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]),
+        clock = env.clock;
+
+      reporter.specDone.and.callFake(function() {
+        realSetTimeout(function() {
+          jasmine.clock().tick(1);
+        }, 0);
+      });
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.specDone).toHaveBeenCalledTimes(1);
+        expect(reporter.specDone.calls.argsFor(0)[0]).toEqual(jasmine.objectContaining({status: 'passed'}));
+        jasmine.clock().tick(1);
+        realSetTimeout(done);
+      });
+
+      env.addReporter(reporter);
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 5;
+
+      env.beforeAll(function() {
+        clock.install();
+      });
+
+      env.afterAll(function() {
+        clock.uninstall();
+      });
+
+      env.it("spec that should not time out", function(innerDone) {
+        clock.tick(6);
+        expect(true).toEqual(true);
+        realSetTimeout(innerDone);
+      });
+
+      env.execute();
+    });
+
+    it('should wait a custom interval before reporting async functions that fail to call done', function(done) {
+      var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone', 'suiteDone', 'specDone']),
+          timeoutFailure = (/^Error: Timeout - Async callback was not invoked within timeout specified by jasmine\.DEFAULT_TIMEOUT_INTERVAL\./);
+
+      reporter.specDone.and.callFake(function(r) {
+        realSetTimeout(function() {
+          jasmine.clock().tick(1);
+        }, 0);
+      });
+
+      reporter.suiteDone.and.callFake(function(r) {
+        realSetTimeout(function() {
+          jasmine.clock().tick(1);
+        }, 0);
+      });
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('suite beforeAll', [ timeoutFailure ]);
+        expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('suite afterAll', [ timeoutFailure ]);
+        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite beforeEach times out', [ timeoutFailure ]);
+        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite afterEach times out', [ timeoutFailure ]);
+        expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite it times out', [ timeoutFailure ]);
+
+        jasmine.clock().tick(1);
+        realSetTimeout(done);
+      });
+
+      env.addReporter(reporter);
+      jasmineUnderTest.DEFAULT_TIMEOUT_INTERVAL = 10000;
+
+      env.describe('suite', function() {
+        env.afterAll(function() {
+          realSetTimeout(function() {
+            try {
+              jasmine.clock().tick(10);
+            } catch(e) {
+              // don't worry if the clock is already uninstalled
+            }
+          }, 100);
+        });
+        env.describe('beforeAll', function() {
+          env.beforeAll(function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(5001);
+            }, 0);
+          }, 5000);
+
+          env.it('times out', function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(1);
+              innerDone();
+            }, 0);
+          });
+        });
+
+        env.describe('afterAll', function() {
+          env.afterAll(function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(2001);
+            }, 0);
+          }, 2000);
+
+          env.it('times out', function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(1);
+              innerDone();
+            }, 0);
+          });
+        });
+
+        env.describe('beforeEach', function() {
+          env.beforeEach(function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(1001);
+            }, 0);
+          }, 1000);
+
+          env.it('times out', function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(1);
+              innerDone();
+            }, 0);
+          });
+        });
+
+        env.describe('afterEach', function() {
+          env.afterEach(function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(4001);
+            }, 0);
+          }, 4000);
+
+          env.it('times out', function(innerDone) {
+            realSetTimeout(function() {
+              jasmine.clock().tick(1);
+              innerDone();
+            }, 0);
+          });
+        });
+
+        env.it('it times out', function(innerDone) {
+          realSetTimeout(function() {
+            jasmine.clock().tick(6001);
+          }, 0);
+        }, 6000);
+      });
+
+      env.execute();
+    });
+  });
+
+  it('explicitly fails an async spec', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      specDone = jasmine.createSpy('specDone');
+
+    env.addReporter({
+      specDone: specDone,
+      jasmineDone: function() {
+        expect(specDone).toHaveFailedExpectationsForRunnable('failing has a default message',
+          ['Failed']
+        );
+        expect(specDone).toHaveFailedExpectationsForRunnable('failing specifies a message',
+          ['Failed: messy message']
+        );
+        expect(specDone).toHaveFailedExpectationsForRunnable('failing fails via the done callback',
+          ['Failed: done failed']
+        );
+        expect(specDone).toHaveFailedExpectationsForRunnable('failing has a message from an Error',
+          ['Failed: error message']
+        );
+        expect(specDone).toHaveFailedExpectationsForRunnable('failing has a message from an Error to done',
+          ['Failed: done error']
+        );
+
+        setTimeout(done);
+      }
+    });
+
+    env.describe('failing', function() {
+      env.it('has a default message', function(innerDone) {
+        setTimeout(function() {
+          env.fail();
+          innerDone();
+        }, 1);
+      });
+
+      env.it('specifies a message', function(innerDone) {
+        setTimeout(function() {
+          env.fail('messy message');
+          innerDone();
+        }, 1);
+      });
+
+      env.it('fails via the done callback', function(innerDone) {
+        setTimeout(function() {
+          innerDone.fail('done failed');
+        }, 1);
+      });
+
+      env.it('has a message from an Error', function(innerDone) {
+        setTimeout(function() {
+          env.fail(new Error('error message'));
+          innerDone();
+        }, 1);
+      });
+
+      env.it('has a message from an Error to done', function(innerDone) {
+        setTimeout(function() {
+          innerDone(new Error('done error'));
+        }, 1);
+      });
+    });
+
+    env.execute();
+  });
+
+  describe('focused tests', function() {
+    it('should only run the focused tests', function(done) {
+      var env = new jasmineUnderTest.Env(),
+        calls = [];
+
+      var assertions = function() {
+        expect(calls).toEqual(['focused']);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.describe('a suite', function() {
+        env.fit('is focused', function() {
+          calls.push('focused');
+        });
+
+        env.it('is not focused', function() {
+          calls.push('freakout');
+        })
+      });
+
+      env.execute();
+    });
+
+    it('should only run focused suites', function(done){
+      var env = new jasmineUnderTest.Env(),
+        calls = [];
+
+      var assertions = function() {
+        expect(calls).toEqual(['focused']);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+
+      env.fdescribe('a focused suite', function() {
+        env.it('is focused', function() {
+          calls.push('focused');
+        });
+      });
+
+      env.describe('a regular suite', function() {
+        env.it('is not focused', function() {
+          calls.push('freakout');
+        })
+      });
+
+      env.execute();
+    });
+
+    it('should run focused tests inside an xdescribe', function(done) {
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.jasmineStarted).toHaveBeenCalledWith({
+          totalSpecsDefined: 1,
+          order: jasmine.any(jasmineUnderTest.Order)
+        });
+
+        expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'with a fit spec',
+          status: 'failed'
+        }));
+
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.xdescribe("xd suite", function() {
+        env.fit("with a fit spec", function() {
+          env.expect(true).toBe(false);
+        });
+      });
+
+      env.execute();
+    });
+
+    it('should run focused suites inside an xdescribe', function(done) {
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.jasmineStarted).toHaveBeenCalledWith({
+          totalSpecsDefined: 1,
+          order: jasmine.any(jasmineUnderTest.Order)
+        });
+
+        expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+          description: 'with a spec',
+          status: 'failed'
+        }));
+
+        done();
+      });
+
+      env.addReporter(reporter);
+
+      env.xdescribe("xd suite", function() {
+        env.fdescribe("fd suite", function() {
+          env.it("with a spec", function() {
+            env.expect(true).toBe(false);
+          });
+        });
+      });
+
+      env.execute();
+    });
+  });
+
+  it("should report as expected", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.jasmineStarted).toHaveBeenCalledWith({
+        totalSpecsDefined: 5,
+        order: jasmine.any(jasmineUnderTest.Order)
+      });
+
+      expect(reporter.specDone.calls.count()).toBe(5);
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        description: 'with a top level spec',
+        status: 'passed'
+      }));
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        description: "with an x'ed spec",
+        status: 'pending'
+      }));
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        description: 'with a spec',
+        status: 'failed'
+      }));
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        description: 'is pending',
+        status: 'pending'
+      }));
+
+      var suiteResult = reporter.suiteStarted.calls.argsFor(0)[0];
+      expect(suiteResult.description).toEqual("A Suite");
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe("A Suite", function() {
+      env.it("with a top level spec", function() {
+        env.expect(true).toBe(true);
+      });
+      env.describe("with a nested suite", function() {
+        env.xit("with an x'ed spec", function() {
+          env.expect(true).toBe(true);
+        });
+        env.it("with a spec", function() {
+          env.expect(true).toBe(false);
+        });
+      });
+
+      env.describe('with only non-executable specs', function() {
+        env.it('is pending');
+        env.xit('is xed', function() {
+          env.expect(true).toBe(true);
+        });
+      });
+    });
+
+    env.execute();
+  });
+
+  it("should report the random seed at the beginning and end of execution", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+    env.randomizeTests(true);
+    env.seed('123456');
+
+    reporter.jasmineDone.and.callFake(function(doneArg) {
+      expect(reporter.jasmineStarted).toHaveBeenCalled();
+      var startedArg = reporter.jasmineStarted.calls.argsFor(0)[0];
+      expect(startedArg.order.random).toEqual(true);
+      expect(startedArg.order.seed).toEqual('123456');
+
+      expect(doneArg.order.random).toEqual(true);
+      expect(doneArg.order.seed).toEqual('123456');
+      done();
+    });
+
+    env.addReporter(reporter);
+    env.randomizeTests(true);
+    env.execute();
+  });
+
+  it('should report pending spec messages', function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          'specDone',
+          'jasmineDone'
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var specStatus = reporter.specDone.calls.argsFor(0)[0];
+
+      expect(specStatus.status).toBe('pending');
+      expect(specStatus.pendingReason).toBe('with a message');
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.it('will be pending', function() {
+      env.pending('with a message');
+    });
+
+    env.execute();
+  });
+
+  it('should report pending spec messages from promise-returning functions', function(done) {
+    function StubPromise(fn) {
+      try {
+        fn();
+      } catch (e) {
+        this.exception = e;
+      }
+    }
+
+    StubPromise.prototype.then = function(resolve, reject) {
+      reject(this.exception);
+    };
+
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          'specDone',
+          'jasmineDone'
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var specStatus = reporter.specDone.calls.argsFor(0)[0];
+
+      expect(specStatus.status).toBe('pending');
+      expect(specStatus.pendingReason).toBe('with a message');
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.it('will be pending', function() {
+      return new StubPromise(function() {
+        env.pending('with a message');
+      });
+    });
+
+    env.execute();
+  });
+
+  it('should report using fallback reporter', function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          'specDone',
+          'jasmineDone'
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.specDone).toHaveBeenCalled();
+
+      done();
+    });
+
+    env.provideFallbackReporter(reporter);
+
+    env.it('will be pending', function() {
+      env.pending('with a message');
+    });
+
+    env.execute();
+  });
+
+  it('should report xdescribes as expected', function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.jasmineStarted).toHaveBeenCalledWith({
+        totalSpecsDefined: 1,
+        order: jasmine.any(jasmineUnderTest.Order)
+      });
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({ status: 'pending' }));
+      expect(reporter.suiteDone).toHaveBeenCalledWith(jasmine.objectContaining({ description: 'xd out', status: 'pending' }));
+      expect(reporter.suiteDone.calls.count()).toBe(4);
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe("A Suite", function() {
+      env.describe("nested", function() {
+        env.xdescribe("xd out", function() {
+          env.describe("nested again", function() {
+            env.it("with a spec", function() {
+              env.expect(true).toBe(false);
+            });
+          });
+        });
+      });
+    });
+
+    env.execute();
+  });
+
+  it("should be possible to get full name from a spec", function() {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        topLevelSpec, nestedSpec, doublyNestedSpec;
+
+    env.describe("my tests", function() {
+      topLevelSpec = env.it("are sometimes top level", function() {
+      });
+      env.describe("are sometimes", function() {
+        nestedSpec = env.it("singly nested", function() {
+        });
+        env.describe("even", function() {
+          doublyNestedSpec = env.it("doubly nested", function() {
+          });
+        });
+      });
+    });
+
+    expect(topLevelSpec.getFullName()).toBe("my tests are sometimes top level");
+    expect(nestedSpec.getFullName()).toBe("my tests are sometimes singly nested");
+    expect(doublyNestedSpec.getFullName()).toBe("my tests are sometimes even doubly nested");
+  });
+
+  it("Custom equality testers should be per spec", function(done) {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineDone",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var firstSpecResult = reporter.specDone.calls.first().args[0],
+          secondSpecResult = reporter.specDone.calls.mostRecent().args[0];
+
+      expect(firstSpecResult.status).toEqual("passed");
+      expect(secondSpecResult.status).toEqual("failed");
+
+      done();
+    });
+
+    env.addReporter(reporter);
+    env.randomizeTests(false);
+
+    env.describe("testing custom equality testers", function() {
+      env.it("with a custom tester", function() {
+        env.addCustomEqualityTester(function(a, b) { return true; });
+        env.expect("a").toEqual("b");
+      });
+
+      env.it("without a custom tester", function() {
+        env.expect("a").toEqual("b");
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Custom equality testers should be per suite", function(done) {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineDone",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var firstSpecResult = reporter.specDone.calls.first().args[0],
+          secondSpecResult = reporter.specDone.calls.argsFor(0)[0],
+          thirdSpecResult = reporter.specDone.calls.mostRecent().args[0];
+
+      expect(firstSpecResult.status).toEqual("passed");
+      expect(secondSpecResult.status).toEqual("passed");
+      expect(thirdSpecResult.status).toEqual("failed");
+
+      done();
+    });
+
+    env.addReporter(reporter);
+    env.randomizeTests(false);
+
+    env.describe("testing custom equality testers", function() {
+      env.beforeAll(function() { env.addCustomEqualityTester(function(a, b) { return true; }); });
+
+      env.it("with a custom tester", function() {
+        env.expect("a").toEqual("b");
+      });
+
+      env.it("with the same custom tester", function() {
+        env.expect("a").toEqual("b");
+      });
+    });
+
+    env.describe("another suite", function() {
+      env.it("without the custom tester", function(){
+        env.expect("a").toEqual("b");
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Custom equality testers for toContain should be per spec", function(done) {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineDone",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var firstSpecResult = reporter.specDone.calls.first().args[0],
+          secondSpecResult = reporter.specDone.calls.mostRecent().args[0];
+
+      expect(firstSpecResult.status).toEqual("passed");
+      expect(secondSpecResult.status).toEqual("failed");
+
+      done();
+    });
+
+    env.addReporter(reporter);
+    env.randomizeTests(false);
+
+    env.describe("testing custom equality testers", function() {
+      env.it("with a custom tester", function() {
+        env.addCustomEqualityTester(function(a, b) { return true; });
+        env.expect(["a"]).toContain("b");
+      });
+
+      env.it("without a custom tester", function() {
+        env.expect(["a"]).toContain("b");
+      });
+    });
+
+    env.execute();
+  });
+
+  it("produces an understandable error message when an 'expect' is used outside of a current spec", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', ['jasmineDone']);
+
+    reporter.jasmineDone.and.callFake(done);
+    env.addReporter(reporter);
+
+    env.describe("A Suite", function() {
+      env.it("an async spec that is actually synchronous", function(underTestCallback) {
+        underTestCallback();
+      });
+      expect(function() { env.expect('a').toEqual('a'); }).toThrowError(/'expect' was used when there was no current spec/);
+    });
+
+    env.execute();
+  });
+
+  it("Custom equality testers for toContain should be per suite", function(done) {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineDone",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var firstSpecResult = reporter.specDone.calls.first().args[0],
+          secondSpecResult = reporter.specDone.calls.argsFor(1)[0],
+          thirdSpecResult = reporter.specDone.calls.mostRecent().args[0];
+
+      expect(firstSpecResult.status).toEqual("passed");
+      expect(secondSpecResult.status).toEqual("passed");
+      expect(thirdSpecResult.status).toEqual("failed");
+
+      done();
+    });
+
+    env.addReporter(reporter);
+    env.randomizeTests(false);
+
+    env.describe("testing custom equality testers", function() {
+      env.beforeAll(function() { env.addCustomEqualityTester(function(a, b) { return true; })});
+
+      env.it("with a custom tester", function() {
+        env.expect(["a"]).toContain("b");
+      });
+
+      env.it("also with the custom tester", function() {
+        env.expect(["a"]).toContain("b");
+      });
+    });
+
+    env.describe("another suite", function() {
+      env.it("without the custom tester", function() {
+        env.expect(["a"]).toContain("b");
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Custom matchers should be per spec", function(done) {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        matchers = {
+          toFoo: function() {}
+        };
+
+    env.describe("testing custom matchers", function() {
+      env.it("with a custom matcher", function() {
+        env.addMatchers(matchers);
+        expect(env.expect().toFoo).toBeDefined();
+      });
+
+      env.it("without a custom matcher", function() {
+        expect(env.expect().toFoo).toBeUndefined();
+      });
+    });
+
+    env.addReporter({jasmineDone: done});
+
+    env.execute();
+  });
+
+  it("Custom matchers should be per suite", function(done) {
+    var env = new jasmineUnderTest.Env({global: { setTimeout: setTimeout }}),
+        matchers = {
+          toFoo: function() {}
+        };
+
+    env.describe("testing custom matchers", function() {
+      env.beforeAll(function() { env.addMatchers(matchers); });
+
+      env.it("with a custom matcher", function() {
+        expect(env.expect().toFoo).toBeDefined();
+      });
+
+      env.it("with the same custom matcher", function() {
+        expect(env.expect().toFoo).toBeDefined();
+      });
+    });
+
+    env.describe("another suite", function() {
+      env.it("no longer has the custom matcher", function() {
+        expect(env.expect().toFoo).not.toBeDefined();
+      });
+    });
+
+    env.addReporter({jasmineDone: done});
+
+    env.execute();
+  });
+
+  it('throws an exception if you try to create a spy outside of a runnable', function (done) {
+    var env = new jasmineUnderTest.Env(),
+      obj = {fn: function () {}},
+      exception;
+
+    env.describe("a suite", function () {
+      try {
+        env.spyOn(obj, 'fn');
+      } catch(e) {
+        exception = e;
+      }
+    });
+
+    var assertions = function() {
+      expect(exception.message).toBe('Spies must be created in a before function or a spec');
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it('throws an exception if you try to add a matcher outside of a runnable', function (done) {
+    var env = new jasmineUnderTest.Env(),
+      obj = {fn: function () {}},
+      exception;
+
+    env.describe("a suite", function () {
+      try {
+        env.addMatchers({myMatcher: function(actual,expected){return false;}});
+      } catch(e) {
+        exception = e;
+      }
+    });
+
+    var assertions = function() {
+      expect(exception.message).toBe('Matchers must be added in a before function or a spec');
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it('throws an exception if you try to add a custom equality outside of a runnable', function (done) {
+    var env = new jasmineUnderTest.Env(),
+      obj = {fn: function () {}},
+      exception;
+
+    env.describe("a suite", function () {
+      try {
+        env.addCustomEqualityTester(function(first, second) {return true;});
+      } catch(e) {
+        exception = e;
+      }
+    });
+
+    var assertions = function() {
+      expect(exception.message).toBe('Custom Equalities must be added in a before function or a spec');
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it("should associate errors thrown from async code with the correct runnable", function(done) {
+    var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone','specDone']);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('async suite', [
+        /^(((Uncaught )?Error: suite( thrown)?)|(suite thrown))$/
+      ]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite async spec', [
+        /^(((Uncaught )?Error: spec( thrown)?)|(spec thrown))$/
+      ]);
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe('async suite', function() {
+      env.afterAll(function(innerDone) {
+        setTimeout(function() { throw new Error('suite'); }, 1);
+      }, 10);
+
+      env.it('spec', function() {});
+    });
+
+    env.describe('suite', function() {
+      env.it('async spec', function(innerDone) {
+        setTimeout(function() { throw new Error('spec'); }, 1);
+      }, 10);
+    });
+
+    env.execute();
+  });
+
+  it('should throw on suites/specs/befores/afters nested in methods other than \'describe\'', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var msg = /\'.*\' should only be used in \'describe\' function/;
+
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite describe', [msg]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite xdescribe', [msg]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('suite fdescribe', [msg]);
+
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('spec it', [msg]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('spec xit', [msg]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('spec fit', [msg]);
+
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('beforeAll', [msg]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('beforeEach spec', [msg]);
+
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('afterAll', [msg]);
+      expect(reporter.specDone).toHaveFailedExpectationsForRunnable('afterEach spec', [msg]);
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe('suite', function() {
+      env.it('describe', function() { env.describe('inner suite', function() {}); });
+      env.it('xdescribe', function() { env.xdescribe('inner suite', function() {}); });
+      env.it('fdescribe', function() { env.fdescribe('inner suite', function() {}); });
+    });
+
+    env.describe('spec', function() {
+      env.it('it', function() { env.it('inner spec', function() {}); });
+      env.it('xit', function() { env.xit('inner spec', function() {}); });
+      env.it('fit', function() { env.fit('inner spec', function() {}); });
+    });
+
+    env.describe('beforeAll', function() {
+      env.beforeAll(function() { env.beforeAll(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.describe('beforeEach', function() {
+      env.beforeEach(function() { env.beforeEach(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.describe('afterAll', function() {
+      env.afterAll(function() { env.afterAll(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.describe('afterEach', function() {
+      env.afterEach(function() { env.afterEach(function() {}); });
+      env.it('spec', function() {});
+    });
+
+    env.execute();
+  });
+
+  it('reports errors that occur during loading', function(done) {
+    var global = {
+      setTimeout: function(fn, delay) { setTimeout(fn, delay) },
+      clearTimeout: function(fn, delay) { clearTimeout(fn, delay) },
+    };
+    spyOn(jasmineUnderTest, 'getGlobal').and.returnValue(global);
+
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+    reporter.jasmineDone.and.callFake(function(e) {
+      expect(e.failedExpectations).toEqual([
+        {
+          passed: false,
+          globalErrorType: 'load',
+          message: 'Uncaught SyntaxError: Unexpected end of input',
+          filename: 'borkenSpec.js',
+          lineno: 42
+        },
+        {
+          passed: false,
+          globalErrorType: 'load',
+          message: 'Uncaught Error: ENOCHEESE',
+          filename: undefined,
+          lineno: undefined
+        }
+      ]);
+
+      done();
+    });
+
+    env.addReporter(reporter);
+    global.onerror('Uncaught SyntaxError: Unexpected end of input', 'borkenSpec.js', 42);
+    global.onerror('Uncaught Error: ENOCHEESE');
+
+    env.execute();
+  });
+
+  describe('If suppressLoadErrors was called', function() {
+    it('does not report or handle errors that occur during loading', function(done) {
+      var global = {
+        setTimeout: function(fn, delay) { setTimeout(fn, delay) },
+        clearTimeout: function(fn, delay) { clearTimeout(fn, delay) }
+      };
+      spyOn(jasmineUnderTest, 'getGlobal').and.returnValue(global);
+      var globalErrors = new jasmineUnderTest.GlobalErrors(global);
+      var onerror = jasmine.createSpy('onerror');
+      globalErrors.pushListener(onerror);
+      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
+
+      var env = new jasmineUnderTest.Env(),
+        reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+      reporter.jasmineDone.and.callFake(function(e) {
+        expect(e.failedExpectations).toEqual([]);
+        expect(onerror).toHaveBeenCalledWith('Uncaught Error: ENOCHEESE');
+        done();
+      });
+
+      env.addReporter(reporter);
+      env.suppressLoadErrors(true);
+      global.onerror('Uncaught Error: ENOCHEESE');
+
+      env.execute();
+    });
+  });
+
+  describe('Overall status in the jasmineDone event', function() {
+    describe('When everything passes', function() {
+      it('is "passed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('passed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.it('passes', function() {});
+        env.execute();
+      });
+    });
+
+    describe('When a spec fails', function() {
+      it('is "failed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.it('fails', function() {
+          env.expect(true).toBe(false);
+        });
+        env.execute();
+      });
+    });
+
+    describe('When a top-level beforeAll fails', function() {
+      it('is "failed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.beforeAll(function() {
+          throw new Error('nope');
+        });
+        env.it('does not run', function() {});
+        env.execute();
+      });
+    });
+
+    describe('When a suite beforeAll fails', function() {
+      it('is "failed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.describe('something', function() {
+          env.beforeAll(function() {
+            throw new Error('nope');
+          });
+          env.it('does not run', function() {});
+        });
+        env.execute();
+      });
+    });
+
+    describe('When a top-level afterAll fails', function() {
+      it('is "failed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.afterAll(function() {
+          throw new Error('nope');
+        });
+        env.it('does not run', function() {});
+        env.execute();
+      });
+    });
+
+    describe('When a suite afterAll fails', function() {
+      it('is "failed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.describe('something', function() {
+          env.afterAll(function() {
+            throw new Error('nope');
+          });
+          env.it('does not run', function() {});
+        });
+        env.execute();
+      });
+    });
+
+    describe("When there are load errors", function() {
+      it('is "failed"', function(done) {
+        var global = {
+          setTimeout: function(fn, delay) { setTimeout(fn, delay) },
+          clearTimeout: function(fn, delay) { clearTimeout(fn, delay) },
+        };
+        spyOn(jasmineUnderTest, 'getGlobal').and.returnValue(global);
+
+        var env = new jasmineUnderTest.Env();
+        var reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.it('passes', function() {});
+        global.onerror('Uncaught Error: ENOCHEESE');
+        env.execute();
+      });
+    });
+
+    describe('When there are no specs', function() {
+      it('is "incomplete"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('incomplete');
+          expect(e.incompleteReason).toEqual('No specs found');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.execute();
+      });
+    });
+
+    describe('When a spec is focused', function() {
+      it('is "incomplete"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('incomplete');
+          expect(e.incompleteReason).toEqual('fit() or fdescribe() was found');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.fit('is focused', function() {});
+        env.execute();
+      });
+    });
+
+    describe('When a suite is focused', function() {
+      it('is "incomplete"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('incomplete');
+          expect(e.incompleteReason).toEqual('fit() or fdescribe() was found');
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.fdescribe('something focused', function() {
+          env.it('does a thing', function() {});
+        });
+        env.execute();
+      });
+    });
+
+    describe('When there are both failures and focused specs', function() {
+      it('is "failed"', function(done) {
+        var env = new jasmineUnderTest.Env(),
+          reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+        reporter.jasmineDone.and.callFake(function(e) {
+          expect(e.overallStatus).toEqual('failed');
+          expect(e.incompleteReason).toBeUndefined();
+          done();
+        });
+
+        env.addReporter(reporter);
+        env.fit('is focused', function() {
+          env.expect(true).toBe(false);
+        });
+        env.execute();
+      });
+    });
+  });
+
+  it('should report deprecation warnings on the correct specs and suites', function(done) {
+    var env = new jasmineUnderTest.Env(),
+      reporter = jasmine.createSpyObj('reporter', ['jasmineDone', 'suiteDone', 'specDone']);
+
+    reporter.jasmineDone.and.callFake(function(result) {
+      expect(result.deprecationWarnings).toEqual([
+        jasmine.objectContaining({ message: 'top level deprecation' })
+      ]);
+
+      expect(reporter.suiteDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        fullName: 'suite',
+        deprecationWarnings: [
+          jasmine.objectContaining({ message: 'suite level deprecation' })
+        ]
+      }));
+
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({
+        fullName: 'suite spec',
+        deprecationWarnings: [
+          jasmine.objectContaining({ message: 'spec level deprecation' })
+        ]
+      }));
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.deprecated('top level deprecation');
+
+    env.describe('suite', function() {
+      env.beforeAll(function() {
+        env.deprecated('suite level deprecation');
+      });
+
+      env.it('spec', function() {
+        env.deprecated('spec level deprecation');
+      });
+    });
+
+    env.execute();
+  });
+});