rally-jasmine-core 1.2.0.0

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

@@ -0,0 +1,1291 @@
+describe("jasmine spec running", function () {
+  var env;
+  var fakeTimer;
+
+  beforeEach(function() {
+    env = new jasmine.Env();
+    env.updateInterval = 0;
+
+    fakeTimer = new jasmine.FakeTimer();
+    env.setTimeout = fakeTimer.setTimeout;
+    env.clearTimeout = fakeTimer.clearTimeout;
+    env.setInterval = fakeTimer.setInterval;
+    env.clearInterval = fakeTimer.clearInterval;
+  });
+
+  it('should assign spec ids sequentially', function() {
+    var it0, it1, it2, it3, it4;
+    env.describe('test suite', function() {
+      it0 = env.it('spec 0', function() {
+      });
+      it1 = env.it('spec 1', function() {
+      });
+      it2 = env.xit('spec 2', function() {
+      });
+      it3 = env.it('spec 3', function() {
+      });
+    });
+    env.describe('test suite 2', function() {
+      it4 = env.it('spec 4', function() {
+      });
+    });
+
+    expect(it0.id).toEqual(0);
+    expect(it1.id).toEqual(1);
+    expect(it2.id).toEqual(2);
+    expect(it3.id).toEqual(3);
+    expect(it4.id).toEqual(4);
+  });
+
+  it("should build up some objects with results we can inspect", function() {
+
+    var specWithNoBody, specWithExpectation, specWithFailingExpectations, specWithMultipleExpectations;
+
+    var suite = env.describe('default current suite', function() {
+      specWithNoBody = env.it('new spec');
+
+      specWithExpectation = env.it('spec with an expectation').runs(function () {
+        var foo = 'bar';
+        this.expect(foo).toEqual('bar');
+      });
+
+      specWithFailingExpectations = env.it('spec with failing expectation').runs(function () {
+        var foo = 'bar';
+        this.expect(foo).toEqual('baz');
+      });
+
+      specWithMultipleExpectations = env.it('spec with multiple expectations').runs(function () {
+        var foo = 'bar';
+        var baz = 'quux';
+
+        this.expect(foo).toEqual('bar');
+        this.expect(baz).toEqual('quux');
+      });
+    });
+
+    suite.execute();
+
+    expect(specWithNoBody.description).toEqual('new spec');
+
+    expect(specWithExpectation.results().getItems().length).toEqual(1); // "Results aren't there after a spec was executed"
+    expect(specWithExpectation.results().getItems()[0].passed()).toEqual(true); // "Results has a result, but it's true"
+    expect(specWithExpectation.results().description).toEqual('spec with an expectation'); // "Spec's results did not get the spec's description"
+
+    expect(specWithFailingExpectations.results().getItems()[0].passed()).toEqual(false); // "Expectation that failed, passed"
+
+    expect(specWithMultipleExpectations.results().getItems().length).toEqual(2); // "Spec doesn't support multiple expectations"
+  });
+
+  it("should work without a runs block", function() {
+    var another_spec;
+    env.describe('default current suite', function() {
+      another_spec = env.it('spec with an expectation', function () {
+        var foo = 'bar';
+        this.expect(foo).toEqual('bar');
+        this.expect(foo).toEqual('baz');
+      });
+    });
+
+    another_spec.execute();
+    another_spec.done = true;
+
+    expect(another_spec.results().getItems().length).toEqual(2);
+    expect(another_spec.results().getItems()[0].passed()).toEqual(true); // "In a spec without a run block, expected first expectation result to be true but was false"
+    expect(another_spec.results().getItems()[1].passed()).toEqual(false); // "In a spec without a run block, expected second expectation result to be false but was true";
+    expect(another_spec.results().description).toEqual('spec with an expectation'); // "In a spec without a run block, results did not include the spec's description";
+  });
+
+  it('should queue waits and runs that it encounters while executing specs', function() {
+    var specWithRunsAndWaits;
+    var foo = 0;
+    env.describe('test async spec', function() {
+      specWithRunsAndWaits = env.it('spec w/ queued statments', function () {
+        this.runs(function () {
+          foo++;
+        });
+        this.waits(500);
+        this.runs(function () {
+          foo++;
+        });
+        this.waits(500);
+        this.runs(function () {
+          foo++;
+        });
+      });
+    });
+
+    expect(foo).toEqual(0);
+    specWithRunsAndWaits.execute();
+
+    expect(foo).toEqual(1);
+    fakeTimer.tick(500);
+    expect(foo).toEqual(2);
+    fakeTimer.tick(500);
+    expect(foo).toEqual(3);
+  });
+
+  it("should run asynchronous tests", function () {
+    var foo = 0;
+
+    var a_spec;
+    env.describe('test async spec', function() {
+      a_spec = env.it('spec w/ queued statments', function () {
+        this.runs(function () {
+          foo++;
+        });
+        this.runs(function () {
+          this.expect(foo).toEqual(1);
+        });
+      });
+    });
+
+    a_spec.execute();
+
+    expect(a_spec.results().getItems().length).toEqual(1); // 'No call to waits(): Spec queue did not run all functions';
+    expect(a_spec.results().getItems()[0].passed()).toEqual(true); // 'No call to waits(): Queued expectation failed';
+
+    foo = 0;
+    env.describe('test async spec', function() {
+      a_spec = env.it('spec w/ queued statments', function () {
+        this.runs(function () {
+          fakeTimer.setTimeout(function() {
+            foo++;
+          }, 500);
+        });
+        this.waits(1000);
+        this.runs(function() {
+          this.expect(foo).toEqual(1);
+        });
+      });
+    });
+
+    a_spec.execute();
+
+    expect(a_spec.results().getItems().length).toEqual(0);
+
+    fakeTimer.tick(500);
+    expect(a_spec.results().getItems().length).toEqual(0);
+
+    fakeTimer.tick(500);
+    expect(a_spec.results().getItems().length).toEqual(1); // 'Calling waits(): Spec queue did not run all functions';
+
+    expect(a_spec.results().getItems()[0].passed()).toEqual(true); // 'Calling waits(): Queued expectation failed';
+
+    var bar = 0;
+    var another_spec;
+    env.describe('test async spec', function() {
+      another_spec = env.it('spec w/ queued statments', function () {
+        this.runs(function () {
+          fakeTimer.setTimeout(function() {
+            bar++;
+          }, 250);
+
+        });
+        this.waits(500);
+        this.runs(function () {
+          fakeTimer.setTimeout(function() {
+            bar++;
+          }, 250);
+        });
+        this.waits(500);
+        this.runs(function () {
+          this.expect(bar).toEqual(2);
+        });
+      });
+    });
+
+
+    another_spec.execute();
+
+    fakeTimer.tick(1000);
+
+    expect(another_spec.results().getItems().length).toEqual(1);
+    expect(another_spec.results().getItems()[0].passed()).toEqual(true);
+
+    var baz = 0;
+    var yet_another_spec;
+    env.describe('test async spec', function() {
+      yet_another_spec = env.it('spec w/ async fail', function () {
+        this.runs(function () {
+          fakeTimer.setTimeout(function() {
+            baz++;
+          }, 250);
+        });
+        this.waits(100);
+        this.runs(function() {
+          this.expect(baz).toEqual(1);
+        });
+      });
+    });
+
+
+    yet_another_spec.execute();
+    //tick twice so that second runs gets eval'd first: mockClock bug?
+    fakeTimer.tick(100);
+    fakeTimer.tick(150);
+
+
+    expect(yet_another_spec.results().getItems().length).toEqual(1);
+    expect(yet_another_spec.results().getItems()[0].passed()).toEqual(false);
+  });
+
+  it("testAsyncSpecsWithMockSuite", function () {
+    var bar = 0;
+    var another_spec;
+    env.describe('test async spec', function() {
+      another_spec = env.it('spec w/ queued statments', function () {
+        this.runs(function () {
+          fakeTimer.setTimeout(function() {
+            bar++;
+          }, 250);
+        });
+        this.waits(500);
+        this.runs(function () {
+          fakeTimer.setTimeout(function() {
+            bar++;
+          }, 250);
+        });
+        this.waits(1500);
+        this.runs(function() {
+          this.expect(bar).toEqual(2);
+        });
+      });
+    });
+
+    another_spec.execute();
+    fakeTimer.tick(2000);
+    expect(another_spec.results().getItems().length).toEqual(1);
+    expect(another_spec.results().getItems()[0].passed()).toEqual(true);
+  });
+
+  describe("waitsFor", function() {
+    var latchFunction = function() {
+      return true;
+    };
+    var spec;
+
+    function makeWaitsForSpec() {
+      var args = jasmine.util.argsToArray(arguments);
+      env.describe('suite', function() {
+        spec = env.it('spec', function() {
+          this.waitsFor.apply(this, args);
+        });
+      });
+      env.execute();
+    }
+
+    it("should accept args (latchFunction, timeoutMessage, timeout)", function() {
+      makeWaitsForSpec(latchFunction, "message", 123);
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(123);
+      expect(block.message).toEqual('message');
+    });
+
+    it("should accept args (latchFunction, timeout)", function() {
+      makeWaitsForSpec(latchFunction, 123);
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(123);
+      expect(block.message).toEqual(null);
+    });
+
+    it("should accept args (latchFunction, timeoutMessage)", function() {
+      env.defaultTimeoutInterval = 4321;
+      makeWaitsForSpec(latchFunction, "message");
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(4321);
+      expect(block.message).toEqual('message');
+    });
+
+    it("should accept args (latchFunction)", function() {
+      env.defaultTimeoutInterval = 4321;
+      makeWaitsForSpec(latchFunction);
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(4321);
+      expect(block.message).toEqual(null);
+    });
+
+    it("should accept deprecated args order (timeout, latchFunction, timeoutMessage)", function() {
+      makeWaitsForSpec(123, latchFunction, "message");
+      var block = spec.queue.blocks[1];
+      expect(block.latchFunction).toBe(latchFunction);
+      expect(block.timeout).toEqual(123);
+      expect(block.message).toEqual('message');
+    });
+
+    it("testWaitsFor", function() {
+      var doneWaiting = false;
+      var runsBlockExecuted = false;
+
+      var spec;
+      env.describe('foo', function() {
+        spec = env.it('has a waits for', function() {
+          this.runs(function() {
+          });
+
+          this.waitsFor(500, function() {
+            return doneWaiting;
+          });
+
+          this.runs(function() {
+            runsBlockExecuted = true;
+          });
+        });
+      });
+
+      spec.execute();
+      expect(runsBlockExecuted).toEqual(false); //, 'should not have executed runs block yet');
+      fakeTimer.tick(100);
+      doneWaiting = true;
+      fakeTimer.tick(100);
+      expect(runsBlockExecuted).toEqual(true); //, 'should have executed runs block');
+    });
+
+    it("fails with message", function() {
+      var spec;
+      env.describe('foo', function() {
+        spec = env.it('has a waits for', function() {
+          this.runs(function() {
+          });
+
+          this.waitsFor(500, function() {
+            return false; // force a timeout
+          }, 'my awesome condition');
+
+          this.runs(function() {
+          });
+        });
+      });
+
+      spec.execute();
+      fakeTimer.tick(1000);
+      expect(spec.results().getItems()[0].message).toEqual('timeout: timed out after 500 msec waiting for my awesome condition');
+    });
+
+    it("fails and skips the rest of the spec if timeout is reached and the latch function hasn't returned true", function() {
+      var runsBlockExecuted = false;
+      var subsequentSpecRan = false;
+
+      var timeoutSpec, subsequentSpec;
+      var suite = env.describe('foo', function() {
+        timeoutSpec = env.it('has a waits for', function() {
+          this.runs(function() {
+          });
+
+          this.waitsFor(500, function() {
+            return false;
+          });
+
+          this.runs(function() {
+            runsBlockExecuted = true;
+          });
+        });
+
+        subsequentSpec = env.it('then carries on to the next test', function() {
+          subsequentSpecRan = true;
+        });
+      });
+
+      env.execute();
+      expect(runsBlockExecuted).toEqual(false);
+      fakeTimer.tick(100);
+      expect(runsBlockExecuted).toEqual(false);
+      fakeTimer.tick(400);
+      expect(runsBlockExecuted).toEqual(false);
+      expect(timeoutSpec.results().getItems()[0].message).toEqual('timeout: timed out after 500 msec waiting for something to happen');
+      expect(subsequentSpecRan).toEqual(true);
+    });
+
+    it("runs afterEach after timing out", function() {
+      var afterEach = jasmine.createSpy('afterEach');
+
+      env.describe('foo', function () {
+        env.afterEach(afterEach);
+
+        env.it('waitsFor', function () {
+          this.waitsFor(100, function() {
+            return false;
+          });
+        });
+      }).execute();
+
+      fakeTimer.tick(500);
+      expect(afterEach).toHaveBeenCalled();
+    });
+
+    it("runs single-spec after functions after timing out", function() {
+      var after = jasmine.createSpy('after');
+
+      env.describe('foo', function () {
+        env.it('waitsFor', function () {
+          this.after(after);
+          this.waitsFor(100, function() {
+            return false;
+          });
+        });
+      }).execute();
+
+      fakeTimer.tick(500);
+      expect(after).toHaveBeenCalled();
+    });
+
+    describe('with consecutive calls', function () {
+      var foo;
+      beforeEach(function () {
+        foo = 0;
+      });
+
+      it('exits immediately (does not stack) if the latchFunction times out', function () {
+        var reachedFirstWaitsFor = false;
+        var reachedSecondWaitsFor = false;
+        env.describe('suite that waits', function () {
+          env.it('should stack timeouts', function() {
+            this.waitsFor(500, function () {
+              reachedFirstWaitsFor = true;
+              return false;
+            });
+            this.waitsFor(500, function () {
+              reachedSecondWaitsFor = true;
+            });
+            this.runs(function () {
+              foo++;
+            });
+          });
+        });
+
+        expect(reachedFirstWaitsFor).toEqual(false);
+        env.execute();
+
+        expect(reachedFirstWaitsFor).toEqual(true);
+        expect(foo).toEqual(0);
+        expect(reachedSecondWaitsFor).toEqual(false);
+        fakeTimer.tick(500);
+        expect(reachedSecondWaitsFor).toEqual(false);
+        expect(foo).toEqual(0);
+        fakeTimer.tick(500);
+        expect(reachedSecondWaitsFor).toEqual(false);
+        expect(foo).toEqual(0);
+      });
+
+      it('stacks latchFunctions', function () {
+        var firstWaitsResult = false;
+        var secondWaitsResult = false;
+        var waitsSuite = env.describe('suite that waits', function () {
+          env.it('spec with waitsFors', function() {
+            this.waitsFor(600, function () {
+              fakeTimer.setTimeout(function () {
+                firstWaitsResult = true;
+              }, 300);
+              return firstWaitsResult;
+            });
+            this.waitsFor(600, function () {
+              fakeTimer.setTimeout(function () {
+                secondWaitsResult = true;
+              }, 300);
+              return secondWaitsResult;
+            });
+            this.runs(function () {
+              foo++;
+            });
+          });
+        });
+
+        expect(firstWaitsResult).toEqual(false);
+        expect(secondWaitsResult).toEqual(false);
+        waitsSuite.execute();
+
+        expect(firstWaitsResult).toEqual(false);
+        expect(secondWaitsResult).toEqual(false);
+        expect(foo).toEqual(0);
+
+        fakeTimer.tick(300);
+
+        expect(firstWaitsResult).toEqual(true);
+        expect(secondWaitsResult).toEqual(false);
+        expect(foo).toEqual(0);
+
+        fakeTimer.tick(300);
+
+        expect(firstWaitsResult).toEqual(true);
+        expect(secondWaitsResult).toEqual(true);
+        expect(foo).toEqual(1);
+
+      });
+    });
+  });
+
+  it("testSpecAfter", function() {
+    var log = "";
+    var spec;
+    var suite = env.describe("has after", function() {
+      spec = env.it('spec with after', function() {
+        this.runs(function() {
+          log += "spec";
+        });
+      });
+    });
+    spec.after(function() {
+      log += "after1";
+    });
+    spec.after(function() {
+      log += "after2";
+    });
+
+    suite.execute();
+
+    expect(log).toEqual("specafter2after1");
+  });
+
+  describe('test suite declaration', function() {
+    var suite;
+    var dummyFunction = function() {
+    };
+
+    it('should give the suite a description', function() {
+      suite = env.describe('one suite description', dummyFunction);
+      expect(suite.description).toEqual('one suite description');
+    });
+
+    it('should enqueue functions for multipart tests and support waits, and run any ready runs() blocks', function() {
+      var foo = 0;
+      var bar = 0;
+
+      suite = env.describe('one suite description', function () {
+        env.it('should be a test with queuedFunctions', function() {
+          this.runs(function() {
+            foo++;
+          });
+          this.waits(100);
+          this.runs(function() {
+            bar++;
+          });
+        });
+      });
+
+      suite.execute();
+
+      expect(foo).toEqual(1);
+      expect(bar).toEqual(0);
+
+      fakeTimer.tick(100);
+      expect(bar).toEqual(1);
+    });
+
+  });
+
+  it("testBeforeAndAfterCallbacks", function () {
+    var suiteWithBefore = env.describe('one suite with a before', function () {
+
+      this.beforeEach(function () {
+        this.foo = 1;
+      });
+
+      env.it('should be a spec', function () {
+        this.runs(function() {
+          this.foo++;
+          this.expect(this.foo).toEqual(2);
+        });
+      });
+
+      env.it('should be another spec', function () {
+        this.runs(function() {
+          this.foo++;
+          this.expect(this.foo).toEqual(2);
+        });
+      });
+    });
+
+    suiteWithBefore.execute();
+
+    var suite = suiteWithBefore;
+
+    expect(suite.results().getItems()[0].passed()).toEqual(true); // "testBeforeAndAfterCallbacks: the first spec's foo should have been 2");
+    expect(suite.results().getItems()[1].passed()).toEqual(true); // "testBeforeAndAfterCallbacks: the second spec's this.foo should have been 2");
+
+
+    var foo = 1;
+    var suiteWithAfter = env.describe('one suite with an after_each', function () {
+
+      env.it('should be a spec with an after_each', function () {
+        this.expect(foo).toEqual(1);
+        foo++;
+        this.expect(foo).toEqual(2);
+      });
+
+      env.it('should be another spec with an after_each', function () {
+        this.expect(foo).toEqual(0);
+        foo++;
+        this.expect(foo).toEqual(1);
+      });
+
+      this.afterEach(function () {
+        foo = 0;
+      });
+    });
+
+    suiteWithAfter.execute();
+
+    suite = suiteWithAfter;
+    expect(suite.afterEach.length).toEqual(1);
+    expect(suite.results().getItems()[0].passed()).toEqual(true);
+    expect(suite.results().getItems()[1].passed()).toEqual(true);
+    expect(foo).toEqual(0);
+
+  });
+
+  it('#waits should allow consecutive waits calls', function () {
+    var foo = 0;
+    var waitsSuite = env.describe('suite that waits', function () {
+      env.it('should wait', function() {
+        this.waits(500);
+        this.waits(500);
+        this.runs(function () {
+          foo++;
+        });
+      });
+    });
+
+    waitsSuite.execute();
+    expect(foo).toEqual(0);
+    fakeTimer.tick(500);
+    expect(foo).toEqual(0);
+    fakeTimer.tick(500);
+
+    expect(foo).toEqual(1);
+  });
+
+  it('nested suites', function () {
+
+    var foo = 0;
+    var bar = 0;
+    var baz = 0;
+    var quux = 0;
+    var nested = env.describe('suite', function () {
+      env.describe('nested', function () {
+        env.it('should run nested suites', function () {
+          foo++;
+        });
+        env.it('should run nested suites', function () {
+          bar++;
+        });
+      });
+
+      env.describe('nested 2', function () {
+        env.it('should run suites following nested suites', function () {
+          baz++;
+        });
+      });
+
+      env.it('should run tests following nested suites', function () {
+        quux++;
+      });
+    });
+
+    expect(foo).toEqual(0);
+    expect(bar).toEqual(0);
+    expect(baz).toEqual(0);
+    expect(quux).toEqual(0);
+    nested.execute();
+
+    expect(foo).toEqual(1);
+    expect(bar).toEqual(1);
+    expect(baz).toEqual(1);
+    expect(quux).toEqual(1);
+  });
+
+  it("#beforeEach should be able to eval runs and waits blocks", function () {
+    var foo = 0;
+    var bar = 0;
+    var suiteWithBefore = env.describe('one suite with a before', function () {
+      this.beforeEach(function () {
+        this.runs(function () {
+          foo++;
+        });
+        this.waits(500);
+        this.runs(function () {
+          foo++;
+        });
+        this.waits(500);
+      });
+
+      env.it('should be a spec', function () {
+        bar = 1;
+        foo++;
+      });
+
+    });
+
+    expect(foo).toEqual(0);
+    expect(bar).toEqual(0);
+    suiteWithBefore.execute();
+
+    expect(bar).toEqual(0);
+    expect(foo).toEqual(1);
+    fakeTimer.tick(500);
+
+    expect(bar).toEqual(0);
+    expect(foo).toEqual(2);
+    fakeTimer.tick(500);
+    expect(bar).toEqual(1);
+    expect(foo).toEqual(3);
+  });
+
+  it("#afterEach should be able to eval runs and waits blocks", function () {
+    var foo = 0;
+    var firstSpecHasRun = false;
+    var secondSpecHasRun = false;
+    var suiteWithAfter = env.describe('one suite with a before', function () {
+      this.afterEach(function () {
+        this.waits(500);
+        this.runs(function () {
+          foo++;
+        });
+        this.waits(500);
+      });
+
+      env.it('should be the first spec', function () {
+        firstSpecHasRun = true;
+      });
+
+      env.it('should be a spec', function () {
+        secondSpecHasRun = true;
+        foo++;
+      });
+
+    });
+
+    expect(firstSpecHasRun).toEqual(false);
+    expect(secondSpecHasRun).toEqual(false);
+    expect(foo).toEqual(0);
+
+    suiteWithAfter.execute();
+
+
+    expect(firstSpecHasRun).toEqual(true);
+    expect(secondSpecHasRun).toEqual(false);
+    expect(foo).toEqual(0);
+
+    fakeTimer.tick(500);
+
+    expect(foo).toEqual(1);
+    expect(secondSpecHasRun).toEqual(false);
+    fakeTimer.tick(500);
+
+    expect(foo).toEqual(2);
+    expect(secondSpecHasRun).toEqual(true);
+
+  });
+
+  it("Spec#after should be able to eval runs and waits blocks", function () {
+    var runsBeforeAfter = false;
+    var firstSpecHasRun = false;
+    var secondSpecHasRun = false;
+    var afterHasRun = false;
+    var suiteWithAfter = env.describe('one suite with a before', function () {
+
+      env.it('should be the first spec', function () {
+        firstSpecHasRun = true;
+        this.after(function () {
+          this.waits(500);
+          this.runs(function () {
+            afterHasRun = true;
+          });
+          this.waits(500);
+        }, true);
+        this.waits(500);
+        this.runs(function () {
+          runsBeforeAfter = true;
+        });
+      });
+
+      env.it('should be a spec', function () {
+        secondSpecHasRun = true;
+      });
+
+    });
+
+    expect(firstSpecHasRun).toEqual(false);
+    expect(runsBeforeAfter).toEqual(false);
+    expect(afterHasRun).toEqual(false);
+    expect(secondSpecHasRun).toEqual(false);
+
+    suiteWithAfter.execute();
+
+    expect(firstSpecHasRun).toEqual(true);
+    expect(runsBeforeAfter).toEqual(false);
+    expect(afterHasRun).toEqual(false);
+    expect(secondSpecHasRun).toEqual(false);
+
+    fakeTimer.tick(500);
+
+    expect(firstSpecHasRun).toEqual(true);
+    expect(runsBeforeAfter).toEqual(true);
+    expect(afterHasRun).toEqual(false);
+    expect(secondSpecHasRun).toEqual(false);
+
+    fakeTimer.tick(500);
+
+    expect(firstSpecHasRun).toEqual(true);
+    expect(runsBeforeAfter).toEqual(true);
+    expect(afterHasRun).toEqual(true);
+    expect(secondSpecHasRun).toEqual(false);
+
+    fakeTimer.tick(500);
+
+    expect(firstSpecHasRun).toEqual(true);
+    expect(runsBeforeAfter).toEqual(true);
+    expect(afterHasRun).toEqual(true);
+    expect(secondSpecHasRun).toEqual(true);
+  });
+
+  it("handles waits", function () {
+    var firstSpecHasRun = false;
+    var secondSpecHasRun = false;
+    var suiteWithAfter = env.describe('one suite with a before', function () {
+
+      env.it('should be the first spec', function () {
+        this.waits(500);
+        this.runs(function () {
+          firstSpecHasRun = true;
+        });
+      });
+
+      env.it('should be a spec', function () {
+        secondSpecHasRun = true;
+      });
+
+    });
+
+    expect(firstSpecHasRun).toEqual(false);
+    expect(secondSpecHasRun).toEqual(false);
+
+    suiteWithAfter.execute();
+
+    expect(firstSpecHasRun).toEqual(false);
+    expect(secondSpecHasRun).toEqual(false);
+
+    fakeTimer.tick(500);
+
+    expect(firstSpecHasRun).toEqual(true);
+    expect(secondSpecHasRun).toEqual(true);
+  });
+
+  it("testBeforeExecutesSafely", function() {
+    var report = "";
+    var suite = env.describe('before fails on first test, passes on second', function() {
+      var counter = 0;
+      this.beforeEach(function() {
+        counter++;
+        if (counter == 1) {
+          throw "before failure";
+        }
+      });
+      env.it("first should not run because before fails", function() {
+        this.runs(function() {
+          report += "first";
+          this.expect(true).toEqual(true);
+        });
+      });
+      env.it("second should run and pass because before passes", function() {
+        this.runs(function() {
+          report += "second";
+          this.expect(true).toEqual(true);
+        });
+      });
+    });
+
+    suite.execute();
+
+    expect(report).toEqual("firstsecond");
+    var suiteResults = suite.results();
+    expect(suiteResults.getItems()[0].getItems()[0].passed()).toEqual(false);
+    expect(suiteResults.getItems()[1].getItems()[0].passed()).toEqual(true);
+  });
+
+  it("testAfterExecutesSafely", function() {
+    var report = "";
+    var suite = env.describe('after fails on first test, then passes', function() {
+      var counter = 0;
+      this.afterEach(function() {
+        counter++;
+        if (counter == 1) {
+          throw "after failure";
+        }
+      });
+      env.it("first should run, expectation passes, but spec fails because after fails", function() {
+        this.runs(function() {
+          report += "first";
+          this.expect(true).toEqual(true);
+        });
+      });
+      env.it("second should run and pass because after passes", function() {
+        this.runs(function() {
+          report += "second";
+          this.expect(true).toEqual(true);
+        });
+      });
+      env.it("third should run and pass because after passes", function() {
+        this.runs(function() {
+          report += "third";
+          this.expect(true).toEqual(true);
+        });
+      });
+    });
+
+    suite.execute();
+
+    expect(report).toEqual("firstsecondthird"); // "all tests should run");
+    //After each errors should not go in spec results because it confuses the count.
+    var suiteResults = suite.results();
+    expect(suiteResults.getItems().length).toEqual(3, 'testAfterExecutesSafely should have results for three specs');
+
+    expect(suiteResults.getItems()[0].getItems()[0].passed()).toEqual(true, "testAfterExecutesSafely 1st spec should pass");
+    expect(suiteResults.getItems()[1].getItems()[0].passed()).toEqual(true, "testAfterExecutesSafely 2nd spec should pass");
+    expect(suiteResults.getItems()[2].getItems()[0].passed()).toEqual(true, "testAfterExecutesSafely 3rd spec should pass");
+
+    expect(suiteResults.getItems()[0].getItems()[0].passed()).toEqual(true, "testAfterExecutesSafely 1st result for 1st suite spec should pass");
+    expect(suiteResults.getItems()[0].getItems()[1].passed()).toEqual(false, "testAfterExecutesSafely 2nd result for 1st suite spec should fail because afterEach failed");
+    expect(suiteResults.getItems()[1].getItems()[0].passed()).toEqual(true, "testAfterExecutesSafely 2nd suite spec should pass");
+    expect(suiteResults.getItems()[2].getItems()[0].passed()).toEqual(true, "testAfterExecutesSafely 3rd suite spec should pass");
+  });
+
+  it("should permit nested describes", function() {
+    var actions = [];
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('outer beforeEach');
+      });
+
+      env.afterEach(function() {
+        actions.push('outer afterEach');
+      });
+
+      env.it('does it 1', function() {
+        actions.push('outer it 1');
+      });
+
+      env.describe('Inner 1', function() {
+        env.beforeEach(function() {
+          actions.push('inner 1 beforeEach');
+        });
+
+        env.afterEach(function() {
+          actions.push('inner 1 afterEach');
+        });
+
+        env.it('does it 2', function() {
+          actions.push('inner 1 it');
+        });
+      });
+
+      env.it('does it 3', function() {
+        actions.push('outer it 2');
+      });
+
+      env.describe('Inner 2', function() {
+        env.beforeEach(function() {
+          actions.push('inner 2 beforeEach');
+        });
+
+        env.afterEach(function() {
+          actions.push('inner 2 afterEach');
+        });
+
+        env.it('does it 2', function() {
+          actions.push('inner 2 it');
+        });
+      });
+    });
+
+    env.execute();
+
+
+    var expected = [
+      "runner beforeEach",
+      "outer beforeEach",
+      "outer it 1",
+      "outer afterEach",
+      "runner afterEach",
+
+      "runner beforeEach",
+      "outer beforeEach",
+      "inner 1 beforeEach",
+      "inner 1 it",
+      "inner 1 afterEach",
+      "outer afterEach",
+      "runner afterEach",
+
+      "runner beforeEach",
+      "outer beforeEach",
+      "outer it 2",
+      "outer afterEach",
+      "runner afterEach",
+
+      "runner beforeEach",
+      "outer beforeEach",
+      "inner 2 beforeEach",
+      "inner 2 it",
+      "inner 2 afterEach",
+      "outer afterEach",
+      "runner afterEach"
+    ];
+    expect(actions).toEqual(expected);
+  });
+
+  it("should run multiple befores and afters in the order they are declared", function() {
+    var actions = [];
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach1');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach1');
+    });
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach2');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach2');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('beforeEach1');
+      });
+
+      env.afterEach(function() {
+        actions.push('afterEach1');
+      });
+
+      env.beforeEach(function() {
+        actions.push('beforeEach2');
+      });
+
+      env.afterEach(function() {
+        actions.push('afterEach2');
+      });
+
+      env.it('does it 1', function() {
+        actions.push('outer it 1');
+      });
+    });
+
+    env.execute();
+
+    var expected = [
+      "runner beforeEach1",
+      "runner beforeEach2",
+      "beforeEach1",
+      "beforeEach2",
+      "outer it 1",
+      "afterEach2",
+      "afterEach1",
+      "runner afterEach2",
+      "runner afterEach1"
+    ];
+    expect(actions).toEqual(expected);
+  });
+
+  it("builds up nested names", function() {
+    var nestedSpec;
+    env.describe('Test Subject', function() {
+      env.describe('when under circumstance A', function() {
+        env.describe('and circumstance B', function() {
+          nestedSpec = env.it('behaves thusly', function() {
+          });
+        });
+      });
+    });
+
+    expect(nestedSpec.getFullName()).toEqual('Test Subject when under circumstance A and circumstance B behaves thusly.'); //, "Spec.fullName was incorrect: " + nestedSpec.getFullName());
+  });
+
+  it("should skip empty suites", function () {
+    env.describe('NonEmptySuite1', function() {
+      env.it('should pass', function() {
+        this.expect(true).toEqual(true);
+      });
+      env.describe('NestedEmptySuite', function() {
+      });
+      env.it('should pass', function() {
+        this.expect(true).toEqual(true);
+      });
+    });
+
+    env.describe('EmptySuite', function() {
+    });
+
+    env.describe('NonEmptySuite2', function() {
+      env.it('should pass', function() {
+        this.expect(true).toEqual(true);
+      });
+    });
+
+    env.execute();
+
+    var runnerResults = env.currentRunner_.results();
+    expect(runnerResults.totalCount).toEqual(3);
+    expect(runnerResults.passedCount).toEqual(3);
+    expect(runnerResults.failedCount).toEqual(0);
+  });
+
+  it("should bind 'this' to the running spec within the spec body", function() {
+    var spec;
+    var suite = env.describe('one suite description', function () {
+      env.it('should be a test with queuedFunctions', function() {
+        spec = this.runs(function() {
+          this.foo = 0;
+          this.foo++;
+        });
+
+        this.runs(function() {
+          var that = this;
+          fakeTimer.setTimeout(function() {
+            that.foo++;
+          }, 250);
+        });
+
+        this.runs(function() {
+          this.expect(this.foo).toEqual(2);
+        });
+
+        this.waits(300);
+
+        this.runs(function() {
+          this.expect(this.foo).toEqual(2);
+        });
+      });
+
+    });
+
+    suite.execute();
+    fakeTimer.tick(600);
+    expect(spec.foo).toEqual(2);
+    var suiteResults = suite.results();
+    expect(suiteResults.getItems()[0].getItems().length).toEqual(2);
+    expect(suiteResults.getItems()[0].getItems()[0].passed()).toEqual(false);
+    expect(suiteResults.getItems()[0].getItems()[1].passed()).toEqual(true);
+  });
+
+  it("shouldn't run disabled tests", function() {
+    var xitSpecWasRun = false;
+    var suite = env.describe('default current suite', function() {
+      env.xit('disabled spec').runs(function () {
+        xitSpecWasRun = true;
+      });
+
+      env.it('enabled spec').runs(function () {
+        var foo = 'bar';
+        expect(foo).toEqual('bar');
+      });
+    });
+
+    suite.execute();
+    expect(xitSpecWasRun).toEqual(false);
+  });
+
+  it('shouldn\'t execute specs in disabled suites', function() {
+    var spy = jasmine.createSpy();
+    var disabledSuite = env.xdescribe('a disabled suite', function() {
+      env.it('enabled spec, but should not be run', function() {
+        spy();
+      });
+    });
+
+    disabledSuite.execute();
+
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  it('#explodes should throw an exception when it is called inside a spec', function() {
+    var exceptionMessage = false;
+    var anotherSuite = env.describe('Spec', function () {
+      env.it('plodes', function() {
+        try {
+          this.explodes();
+        }
+        catch (e) {
+          exceptionMessage = e;
+        }
+        expect(exceptionMessage).toNotEqual(false);
+      });
+    });
+
+    anotherSuite.execute();
+
+    expect(exceptionMessage).toEqual('explodes function should not have been called');
+  });
+
+  it("should recover gracefully when there are errors in describe functions", function() {
+    var specs = [];
+    var superSimpleReporter = new jasmine.Reporter();
+    superSimpleReporter.reportSpecResults = function(spec) {
+      specs.push("Spec: " + spec.getFullName());
+      var results = spec.results().getItems();
+      for (var i = 0; i < results.length; i++) {
+        var result = results[i];
+        specs.push("Result: " + result);
+      }
+    };
+
+    try {
+      env.describe("outer1", function() {
+        env.describe("inner1", function() {
+          env.it("should thingy", function() {
+            this.expect(true).toEqual(true);
+          });
+
+          throw new Error("fake error");
+        });
+
+        env.describe("inner2", function() {
+          env.it("should other thingy", function() {
+            this.expect(true).toEqual(true);
+          });
+        });
+
+        throw new Error("fake error");
+
+      });
+    } catch(e) {
+    }
+
+    env.describe("outer2", function() {
+      env.it("should xxx", function() {
+        this.expect(true).toEqual(true);
+      });
+    });
+
+    env.addReporter(superSimpleReporter);
+    env.execute();
+
+    expect(specs.join('')).toMatch(new RegExp(
+      'Spec: outer1 inner1 should thingy.' +
+        'Result: Passed.' +
+        'Spec: outer1 inner1 encountered a declaration exception.' +
+        'Result: Error: fake error.*' +
+        'Spec: outer1 inner2 should other thingy.' +
+        'Result: Passed.' +
+        'Spec: outer1 encountered a declaration exception.' +
+        'Result: Error: fake error.*' +
+        'Spec: outer2 should xxx.' +
+        'Result: Passed.'
+      ));
+  });
+
+});