jasmine-core 2.0.0.rc5 → 2.0.0

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

@@ -13,20 +13,20 @@ describe('Exceptions:', function() {
           throw new Error('I should hit a breakpoint!');
         });
       });
-      var dont_change = 'I will never change!';
+      var spy = jasmine.createSpy('spy');
 
       try {
         env.execute();
-        dont_change = 'oops I changed';
+        spy();
       }
       catch (e) {}
 
-      expect(dont_change).toEqual('I will never change!');
+      expect(spy).not.toHaveBeenCalled();
     });
   });
 
   describe("with catch on exception", function() {
-    it('should handle exceptions thrown, but continue', function() {
+    it('should handle exceptions thrown, but continue', function(done) {
       var secondTest = jasmine.createSpy('second test');
       env.describe('Suite for handles exceptions', function () {
         env.it('should be a test that fails because it throws an exception', function() {
@@ -35,11 +35,16 @@ describe('Exceptions:', function() {
         env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
       });
 
+      expectations = function() {
+        expect(secondTest).toHaveBeenCalled();
+        done();
+      };
+
+      env.addReporter({ jasmineDone: expectations });
       env.execute();
-      expect(secondTest).toHaveBeenCalled();
     });
 
-    it("should handle exceptions thrown directly in top-level describe blocks and continue", function () {
+    it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
       var secondDescribe = jasmine.createSpy("second describe");
       env.describe("a suite that throws an exception", function () {
         env.it("is a test that should pass", function () {
@@ -50,8 +55,13 @@ describe('Exceptions:', function() {
       });
       env.describe("a suite that doesn't throw an exception", secondDescribe);
 
+      expectations = function() {
+        expect(secondDescribe).toHaveBeenCalled();
+        done();
+      };
+
+      env.addReporter({ jasmineDone: expectations });
       env.execute();
-      expect(secondDescribe).toHaveBeenCalled();
     });
   });
 });

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

@@ -9,7 +9,7 @@ describe("buildExpectationResult", function() {
     expect(result.message).toBe('Passed.');
   });
 
-  it("message returns the message for failing expecations", function() {
+  it("message returns the message for failing expectations", function() {
     var result = j$.buildExpectationResult({passed: false, message: 'some-value'});
     expect(result.message).toBe('some-value');
   });

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

@@ -46,7 +46,7 @@ describe("Expectation", function() {
     expect(expectation.toFoo).toBeUndefined();
   });
 
-  it("Factory builds an expectaion/negative expectation", function() {
+  it("Factory builds an expectation/negative expectation", function() {
     var builtExpectation = j$.Expectation.Factory();
 
     expect(builtExpectation instanceof j$.Expectation).toBe(true);
@@ -254,7 +254,7 @@ describe("Expectation", function() {
         }
       },
       util = {
-        buildFailureMessage: function() { return "default messge"; }
+        buildFailureMessage: function() { return "default message"; }
       },
       addExpectationResult = jasmine.createSpy("addExpectationResult"),
       actual = "an actual",
@@ -277,7 +277,7 @@ describe("Expectation", function() {
       passed: false,
       expected: "hello",
       actual: actual,
-      message: "default messge"
+      message: "default message"
     });
   });
 

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

@@ -26,7 +26,7 @@ describe("Spec", function() {
         description: 'my test',
         id: 'some-id',
         fn: function() {},
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
     spec.execute();
@@ -42,7 +42,7 @@ describe("Spec", function() {
         description: 'foo bar',
         fn: function() {},
         onStart: startCallback,
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
     spec.execute();
@@ -69,7 +69,7 @@ describe("Spec", function() {
           }]
         },
         onStart: startCallback,
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
     spec.execute();
@@ -93,7 +93,7 @@ describe("Spec", function() {
         afterFns: function() {
           return [after]
         },
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
     spec.execute();
@@ -111,7 +111,7 @@ describe("Spec", function() {
         onStart: startCallback,
         fn: null,
         resultCallback: resultCallback,
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
 
@@ -127,7 +127,7 @@ describe("Spec", function() {
         onStart:startCallback,
         fn: specBody,
         resultCallback: resultCallback,
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
     spec.disable();
@@ -154,7 +154,7 @@ describe("Spec", function() {
         getSpecName: function() {
           return "a suite with a spec"
         },
-        queueRunner: fakeQueueRunner
+        queueRunnerFactory: fakeQueueRunner
       });
 
     spec.pend();
@@ -181,7 +181,7 @@ describe("Spec", function() {
         fn: function() {},
         catchExceptions: function() { return false; },
         resultCallback: function() {},
-        queueRunner: function(attrs) { attrs.onComplete(); }
+        queueRunnerFactory: function(attrs) { attrs.onComplete(); }
       });
 
     spec.execute(done);
@@ -208,17 +208,99 @@ describe("Spec", function() {
   });
 
   it("can return its full name", function() {
-    var spec;
-    spec = new j$.Spec({
-      getSpecName: function(passedVal) {
-//        expect(passedVal).toBe(spec);  TODO: a exec time, spec is undefined WTF?
-        return 'expected val';
-      }
+    var specNameSpy = jasmine.createSpy('specNameSpy').and.returnValue('expected val');
+
+    var spec = new j$.Spec({
+      getSpecName: specNameSpy
     });
 
     expect(spec.getFullName()).toBe('expected val');
+    expect(specNameSpy.calls.mostRecent().args[0].id).toEqual(spec.id);
   });
 
+  it("sets a timeout for async functions to keep them from running forever", function() {
+    var queueRunnerSpy = jasmine.createSpy('queue runner'),
+      setTimeoutSpy = jasmine.createSpy('setTimeout'),
+      spec = new j$.Spec({
+        beforeFns: function() { return [function(done) { }]; },
+        fn: function(done) { },
+        afterFns: function() { return [function(done) { }]; },
+        timer: {
+          setTimeout: setTimeoutSpy,
+          clearTimeout: function() {}
+        },
+        queueRunnerFactory: queueRunnerSpy
+      });
+
+    spec.execute();
+    var fns = queueRunnerSpy.calls.mostRecent().args[0].fns;
+
+    for (var i = 0; i < fns.length; i++) {
+      fns[i]();
+    }
+
+    expect(setTimeoutSpy.calls.count()).toEqual(3);
+    expect(setTimeoutSpy).toHaveBeenCalledWith(jasmine.any(Function), j$.DEFAULT_TIMEOUT_INTERVAL);
+  });
+
+  it("resets the timeout timer when an async before throws an exception", function() {
+    var queueRunnerSpy = jasmine.createSpy('queueRunner'),
+      clearTimeoutSpy = jasmine.createSpy('clear timeout'),
+      spec = new j$.Spec({
+        beforeFns: function() { return [function(done) {}]; },
+        fn: function() { },
+        timer: {
+          setTimeout: function () { return 920; },
+          clearTimeout: clearTimeoutSpy
+        },
+        queueRunnerFactory: queueRunnerSpy
+      });
+
+    spec.execute();
+    queueRunnerSpy.calls.mostRecent().args[0].fns[0]();
+    queueRunnerSpy.calls.mostRecent().args[0].onException(new Error());
+
+    expect(clearTimeoutSpy).toHaveBeenCalledWith(920);
+  });
+
+  it("resets the timeout timer when an async spec throws an exception", function() {
+    var queueRunnerSpy = jasmine.createSpy('queueRunner'),
+      clearTimeoutSpy = jasmine.createSpy('clear timeout'),
+      spec = new j$.Spec({
+        fn: function(done) { },
+        timer: {
+          setTimeout: function () { return 920; },
+          clearTimeout: clearTimeoutSpy
+        },
+        queueRunnerFactory: queueRunnerSpy
+      });
+
+    spec.execute();
+    queueRunnerSpy.calls.mostRecent().args[0].fns[0]();
+    queueRunnerSpy.calls.mostRecent().args[0].onException(new Error());
+
+    expect(clearTimeoutSpy).toHaveBeenCalledWith(920);
+  });
+
+  it("resets the timeout timer when an async after spec throws an exception", function() {
+    var queueRunnerSpy = jasmine.createSpy('queueRunner'),
+      clearTimeoutSpy = jasmine.createSpy('clear timeout'),
+      spec = new j$.Spec({
+        fn: function() { },
+        afterFns: function() { return [function(done) {}]; },
+        timer: {
+          setTimeout: function () { return 920; },
+          clearTimeout: clearTimeoutSpy
+        },
+        queueRunnerFactory: queueRunnerSpy
+      });
+
+    spec.execute();
+    queueRunnerSpy.calls.mostRecent().args[0].fns[1]();
+    queueRunnerSpy.calls.mostRecent().args[0].onException(new Error());
+
+    expect(clearTimeoutSpy).toHaveBeenCalledWith(920);
+  });
   describe("when a spec is marked pending during execution", function() {
     it("should mark the spec as pending", function() {
       var fakeQueueRunner = function(opts) {
@@ -228,7 +310,7 @@ describe("Spec", function() {
           description: 'my test',
           id: 'some-id',
           fn: function() { },
-          queueRunner: fakeQueueRunner
+          queueRunnerFactory: fakeQueueRunner
         });
 
       spec.execute();

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

@@ -14,7 +14,7 @@ describe('Spies', function () {
       expect(spy.bob).toEqual("test");
     });
 
-    it("warns the user that we indend to overwrite an existing property", function() {
+    it("warns the user that we intend to overwrite an existing property", function() {
       TestClass.prototype.someFunction.and = "turkey";
 
       expect(function() {
@@ -28,6 +28,25 @@ describe('Spies', function () {
       expect(spy.and).toEqual(jasmine.any(j$.SpyStrategy));
       expect(spy.calls).toEqual(jasmine.any(j$.CallTracker));
     });
+
+    it("tracks the argument of calls", function () {
+      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var trackSpy = spyOn(spy.calls, "track");
+
+      spy("arg");
+
+      expect(trackSpy.calls.mostRecent().args[0].args).toEqual(["arg"]);
+    });
+
+    it("tracks the context of calls", function () {
+      var spy = j$.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+      var trackSpy = spyOn(spy.calls, "track");
+
+      var contextObject = { spyMethod: spy };
+      contextObject.spyMethod();
+
+      expect(trackSpy.calls.mostRecent().args[0].object).toEqual(contextObject);
+    });
   });
 
   describe("createSpyObj", function() {

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

@@ -0,0 +1,488 @@
+describe("Env integration", function() {
+
+  it("Suites execute as expected (no nesting)", function(done) {
+    var env = new j$.Env(),
+        calls = [];
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        "with a spec",
+        "and another spec"
+      ]);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions});
+
+    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 j$.Env(),
+        calls = [];
+
+    var assertions = function() {
+      expect(calls).toEqual([
+        'an outer spec',
+        'an inner spec',
+        'another inner spec'
+      ]);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+
+    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 j$.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.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("calls associated befores/specs/afters with the same 'this'", function(done) {
+    var env = new j$.Env();
+
+    env.addReporter({jasmineDone: done});
+
+    env.describe("tests", function() {
+      var firstTimeThrough = true, firstSpecContext, secondSpecContext;
+
+      env.beforeEach(function() {
+        if (firstTimeThrough) {
+          firstSpecContext = this;
+        } else {
+          secondSpecContext = this;
+        }
+        expect(this).toEqual({});
+      });
+
+      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 j$.Env();
+
+    env.addReporter({jasmineDone: done});
+
+    env.describe("with an async spec", function() {
+      var specContext;
+
+      env.beforeEach(function() {
+        specContext = this;
+        expect(this).toEqual({});
+      });
+
+      env.it("sync spec", function(underTestCallback) {
+        expect(this).toBe(specContext);
+        underTestCallback();
+      });
+
+      env.afterEach(function() {
+        expect(this).toBe(specContext);
+      });
+    });
+
+    env.execute();
+  });
+
+  it("Allows specifying which specs and suites to run", function(done) {
+    var env = new j$.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("Functions can be spied on and have their calls tracked", function () {
+      var env = new j$.Env();
+
+      var originalFunctionWasCalled = false;
+      var subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
+
+      var spy = env.spyOn(subject, 'spiedFunc');
+
+      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(originalFunctionWasCalled).toEqual(false);
+
+      subject.spiedFunc('bar');
+      expect(subject.spiedFunc.calls.count()).toEqual(2);
+      expect(subject.spiedFunc.calls.mostRecent().args).toEqual(['bar']);
+  });
+
+  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 j$.Env({global: { setTimeout: globalSetTimeout }});
+
+    var assertions = function() {
+      expect(delayedFunctionForMockClock).toHaveBeenCalled();
+      expect(globalSetTimeout).toHaveBeenCalledWith(delayedFunctionForGlobalClock, 100);
+
+      done();
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+
+    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 j$.Env(), mutatedVar;
+
+    env.describe("tests", function() {
+      env.beforeEach(function() {
+        mutatedVar = 2;
+      });
+
+      env.it("async spec", function(underTestCallback) {
+        setTimeout(function() {
+          expect(mutatedVar).toEqual(2);
+          underTestCallback();
+          done();
+        }, 0);
+      });
+
+      env.it("after async spec", function() {
+        mutatedVar = 3;
+      });
+    });
+
+    env.execute();
+  });
+
+  describe("with a mock clock", function() {
+    var originalTimeout;
+
+    beforeEach(function() {
+      originalTimeout = j$.DEFAULT_TIMEOUT_INTERVAL;
+      jasmine.getEnv().clock.install();
+    });
+
+    afterEach(function() {
+      jasmine.getEnv().clock.uninstall();
+      j$.DEFAULT_TIMEOUT_INTERVAL = originalTimeout;
+    });
+
+    it("should wait a specified interval before failing specs haven't called done yet", function(done) {
+      var env = new j$.Env(),
+          reporter = jasmine.createSpyObj('fakeReporter', [ "specDone" ]);
+
+      reporter.specDone.and.callFake(function() {
+        expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({status: 'failed'}));
+        done();
+      });
+
+      env.addReporter(reporter);
+      j$.DEFAULT_TIMEOUT_INTERVAL = 8414;
+
+      env.it("async spec that doesn't call done", function(underTestCallback) {
+        env.expect(true).toBeTruthy();
+        jasmine.getEnv().clock.tick(8415);
+      });
+
+      env.execute();
+    });
+  });
+
+  // TODO: something is wrong with this spec
+  it("should report as expected", function(done) {
+    var env = new j$.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.jasmineStarted).toHaveBeenCalledWith({
+        totalSpecsDefined: 3
+      });
+      var suiteResult = reporter.suiteStarted.calls.first().args[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 a pending spec", function() {
+          env.expect(true).toBe(true);
+        });
+        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 j$.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 j$.Env({global: { setTimeout: setTimeout }}),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "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.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 matchers should be per spec", function() {
+    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+        matchers = {
+          toFoo: function() {}
+        },
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+    env.addReporter(reporter);
+
+    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.execute();
+  });
+
+  it("Custom equality testers for toContain should be per spec", function(done) {
+    var env = new j$.Env({global: { setTimeout: setTimeout }}),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "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.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();
+  });
+});
+