evergreen 1.1.0 → 1.1.2

data/lib/jasmine/lib/jasmine-core/version.rb

@@ -1,6 +1,6 @@
 module Jasmine
   module Core
-    VERSION = "1.2.0"
+    VERSION = "1.3.1"
   end
 end
 

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

@@ -32,118 +32,144 @@ describe('Exceptions:', function() {
     expect(jasmine.util.formatException(sampleWebkitException)).toEqual(expected);
   });
 
-  it('should handle exceptions thrown, but continue', function() {
-    var fakeTimer = new jasmine.FakeTimer();
-    env.setTimeout = fakeTimer.setTimeout;
-    env.clearTimeout = fakeTimer.clearTimeout;
-    env.setInterval = fakeTimer.setInterval;
-    env.clearInterval = fakeTimer.clearInterval;
-    
-    //we run two exception tests to make sure we continue after throwing an exception
-    var suite = env.describe('Suite for handles exceptions', function () {
-      env.it('should be a test that fails because it throws an exception', function() {
-        throw new Error('fake error 1');
+  describe('with break on exception', function() {
+    it('should not catch the exception', function() {
+      var suite = env.describe('suite for break on exceptions', function() {
+        env.it('should break when an exception is thrown', function() {
+          throw new Error('I should hit a breakpoint!');
+        });
       });
+      var runner = env.currentRunner();
+      var dont_change = 'I will never change!';
+
+      var oldCatch = jasmine.CATCH_EXCEPTIONS;
+      jasmine.CATCH_EXCEPTIONS = false;
+      try {
+        suite.execute();
+        dont_change = 'oops I changed';
+      }
+      catch (e) {}
+      finally {
+        jasmine.CATCH_EXCEPTIONS = oldCatch;
+      }
+
+      expect(dont_change).toEqual('I will never change!');
+    });
+  });
 
-      env.it('should be another test that fails because it throws an exception', function() {
-        this.runs(function () {
-          throw new Error('fake error 2');
+  describe("with catch on exception", function() {
+    it('should handle exceptions thrown, but continue', function() {
+      var fakeTimer = new jasmine.FakeTimer();
+      env.setTimeout = fakeTimer.setTimeout;
+      env.clearTimeout = fakeTimer.clearTimeout;
+      env.setInterval = fakeTimer.setInterval;
+      env.clearInterval = fakeTimer.clearInterval;
+
+      //we run two exception tests to make sure we continue after throwing an exception
+      var suite = env.describe('Suite for handles exceptions', function () {
+        env.it('should be a test that fails because it throws an exception', function() {
+          throw new Error('fake error 1');
         });
-        this.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-      });
 
-      env.it('should be a passing test that runs after exceptions are thrown', function() {
-        this.expect(true).toEqual(true);
-      });
+        env.it('should be another test that fails because it throws an exception', function() {
+          this.runs(function () {
+            throw new Error('fake error 2');
+          });
+          this.runs(function () {
+            this.expect(true).toEqual(true);
+          });
+        });
 
-      env.it('should be another test that fails because it throws an exception after a wait', function() {
-        this.runs(function () {
-          var foo = 'foo';
+        env.it('should be a passing test that runs after exceptions are thrown', function() {
+          this.expect(true).toEqual(true);
         });
-        this.waits(250);
-        this.runs(function () {
-          throw new Error('fake error 3');
+
+        env.it('should be another test that fails because it throws an exception after a wait', function() {
+          this.runs(function () {
+            var foo = 'foo';
+          });
+          this.waits(250);
+          this.runs(function () {
+            throw new Error('fake error 3');
+          });
         });
-      });
 
-      env.it('should be a passing test that runs after exceptions are thrown from a async test', function() {
-        this.expect(true).toEqual(true);
+        env.it('should be a passing test that runs after exceptions are thrown from a async test', function() {
+          this.expect(true).toEqual(true);
+        });
       });
-    });
-
-    var runner = env.currentRunner();
-    suite.execute();
-    fakeTimer.tick(2500);
 
-    var suiteResults = suite.results();
-    var specResults = suiteResults.getItems();
+      var runner = env.currentRunner();
+      suite.execute();
+      fakeTimer.tick(2500);
 
-    expect(suiteResults.passed()).toEqual(false);
-    //
-    expect(specResults.length).toEqual(5);
-    expect(specResults[0].passed()).toMatch(false);
-    var blockResults = specResults[0].getItems();
-    expect(blockResults[0].passed()).toEqual(false);
-    expect(blockResults[0].message).toMatch(/fake error 1/);
+      var suiteResults = suite.results();
+      var specResults = suiteResults.getItems();
 
-    expect(specResults[1].passed()).toEqual(false);
-    blockResults = specResults[1].getItems();
-    expect(blockResults[0].passed()).toEqual(false);
-    expect(blockResults[0].message).toMatch(/fake error 2/);
-    expect(blockResults[1].passed()).toEqual(true);
+      expect(suiteResults.passed()).toEqual(false);
+      //
+      expect(specResults.length).toEqual(5);
+      expect(specResults[0].passed()).toMatch(false);
+      var blockResults = specResults[0].getItems();
+      expect(blockResults[0].passed()).toEqual(false);
+      expect(blockResults[0].message).toMatch(/fake error 1/);
 
-    expect(specResults[2].passed()).toEqual(true);
+      expect(specResults[1].passed()).toEqual(false);
+      blockResults = specResults[1].getItems();
+      expect(blockResults[0].passed()).toEqual(false);
+      expect(blockResults[0].message).toMatch(/fake error 2/);
+      expect(blockResults[1].passed()).toEqual(true);
 
-    expect(specResults[3].passed()).toEqual(false);
-    blockResults = specResults[3].getItems();
-    expect(blockResults[0].message).toMatch(/fake error 3/);
+      expect(specResults[2].passed()).toEqual(true);
 
-    expect(specResults[4].passed()).toEqual(true);
-  });
+      expect(specResults[3].passed()).toEqual(false);
+      blockResults = specResults[3].getItems();
+      expect(blockResults[0].message).toMatch(/fake error 3/);
 
+      expect(specResults[4].passed()).toEqual(true);
+    });
 
-  it("should handle exceptions thrown directly in top-level describe blocks and continue", function () {
-     var suite = env.describe("a top level describe block that throws an exception", function () {
-       env.it("is a test that should pass", function () {
+    it("should handle exceptions thrown directly in top-level describe blocks and continue", function () {
+      var suite = env.describe("a top level describe block that throws an exception", function () {
+        env.it("is a test that should pass", function () {
          this.expect(true).toEqual(true);
-       });
+        });
 
-       throw new Error("top level error");
-     });
+        throw new Error("top level error");
+      });
 
-     suite.execute();
-     var suiteResults = suite.results();
-     var specResults = suiteResults.getItems();
+      suite.execute();
+      var suiteResults = suite.results();
+      var specResults = suiteResults.getItems();
 
-     expect(suiteResults.passed()).toEqual(false);
-     expect(specResults.length).toEqual(2);
+      expect(suiteResults.passed()).toEqual(false);
+      expect(specResults.length).toEqual(2);
 
-     expect(specResults[1].description).toMatch(/encountered a declaration exception/);
-   });
+      expect(specResults[1].description).toMatch(/encountered a declaration exception/);
+    });
 
-   it("should handle exceptions thrown directly in nested describe blocks and continue", function () {
-     var suite = env.describe("a top level describe", function () {
-       env.describe("a mid-level describe that throws an exception", function () {
-         env.it("is a test that should pass", function () {
-           this.expect(true).toEqual(true);
-         });
+    it("should handle exceptions thrown directly in nested describe blocks and continue", function () {
+      var suite = env.describe("a top level describe", function () {
+        env.describe("a mid-level describe that throws an exception", function () {
+          env.it("is a test that should pass", function () {
+            this.expect(true).toEqual(true);
+          });
 
-         throw new Error("a mid-level error");
-       });
-     });
+          throw new Error("a mid-level error");
+        });
+      });
 
-     suite.execute();
-     var suiteResults = suite.results();
-     var specResults = suiteResults.getItems();
+      suite.execute();
+      var suiteResults = suite.results();
+      var specResults = suiteResults.getItems();
 
-     expect(suiteResults.passed()).toEqual(false);
-     expect(specResults.length).toEqual(1);
+      expect(suiteResults.passed()).toEqual(false);
+      expect(specResults.length).toEqual(1);
 
-     var nestedSpecResults = specResults[0].getItems();
+      var nestedSpecResults = specResults[0].getItems();
 
-     expect(nestedSpecResults.length).toEqual(2);
-     expect(nestedSpecResults[1].description).toMatch(/encountered a declaration exception/);
-   });
-});
+      expect(nestedSpecResults.length).toEqual(2);
+      expect(nestedSpecResults[1].description).toMatch(/encountered a declaration exception/);
+    });
+  });
+});

data/lib/jasmine/spec/core/MatchersSpec.js

@@ -75,6 +75,18 @@ describe("jasmine.Matchers", function() {
     expect((match(parseInt('5', 10)).toEqual(5))).toPass();
     expect((match(5).toNotEqual(5))).toFail();
     expect((match(parseInt('5', 10)).toNotEqual(5))).toFail();
+
+    expect((match(/1/i).toEqual(/1/i))).toPass();
+    expect((match(/1/i).toNotEqual(/1/i))).toFail();
+    expect((match(/[abc]/gm).toEqual(/1/i))).toFail();
+    expect((match(/[abc]/gm).toNotEqual(/1/i))).toPass();
+
+    // only test if the browser supports the sticky option on a regExp see pull #234
+    if (RegExp.prototype.sticky !== undefined) {
+      var sticky_regexp = new RegExp("[abc]", "y");
+      expect((match(sticky_regexp).toEqual(/1/i))).toFail();
+      expect((match(sticky_regexp).toNotEqual(/1/i))).toPass();
+    }
   });
 
   it("toEqual to build an Expectation Result", function() {
@@ -281,6 +293,29 @@ describe("jasmine.Matchers", function() {
     expect(result.actual).toEqual(actual);
   });
 
+	it("toBeNaN", function() {
+		expect(match(Number.NaN).toBeNaN()).toPass();
+		expect(match(0).toBeNaN()).toFail();
+		expect(match(1).toBeNaN()).toFail();
+		expect(match(null).toBeNaN()).toFail();
+		expect(match(Number.POSITIVE_INFINITY).toBeNaN()).toFail();
+		expect(match(Number.NEGATIVE_INFINITY).toBeNaN()).toFail();
+		expect(match('NaN').toBeNaN()).toFail();
+	});
+
+	it("toBeNaN to build an ExpectationResult", function() {
+		var actual = 'a';
+		var matcher = match(actual);
+		matcher.toBeNaN();
+
+		var result = lastResult();
+
+		expect(result.matcherName).toEqual("toBeNaN");
+		expect(result.passed()).toFail();
+		expect(result.message).toMatch("Expected 'a' to be NaN.");
+		expect(result.actual).toMatch(actual);
+	});
+
   it("toBeFalsy", function() {
     expect(match(false).toBeFalsy()).toPass();
     expect(match(true).toBeFalsy()).toFail();
@@ -510,6 +545,11 @@ describe("jasmine.Matchers", function() {
       expect(-1.23).not.toBeCloseTo(-1.24);
     });
 
+    it("expects close numbers to 'be close' and further numbers not to", function() {
+      expect(1.225).not.toBeCloseTo(1.234); // difference is 0.009
+      expect(1.225).toBeCloseTo(1.224);     // difference is 0.001
+    });
+
     it("accepts an optional precision argument", function() {
       expect(1).toBeCloseTo(1.1, 0);
       expect(1.2).toBeCloseTo(1.23, 1);
@@ -771,7 +811,13 @@ describe("jasmine.Matchers", function() {
         TestClass.spyFunction('d', 'e', 'f');
         var expected = match(TestClass.spyFunction);
         expect(expected.toHaveBeenCalledWith('a', 'b')).toFail();
-        expect(lastResult().message).toEqual("Expected spy My spy to have been called with [ 'a', 'b' ] but was called with [ [ 'a', 'b', 'c' ], [ 'd', 'e', 'f' ] ]");
+        expect(lastResult().message).toEqual("Expected spy My spy to have been called with [ 'a', 'b' ] but actual calls were [ 'a', 'b', 'c' ], [ 'd', 'e', 'f' ]");
+      });
+
+      it("should return a decent message when it hasn't been called", function() {
+        var expected = match(TestClass.spyFunction);
+        expect(expected.toHaveBeenCalledWith('a', 'b')).toFail();
+        expect(lastResult().message).toEqual("Expected spy My spy to have been called with [ 'a', 'b' ] but it was never called.");
       });
 
       it("should return a decent message when inverted", function() {
@@ -779,7 +825,7 @@ describe("jasmine.Matchers", function() {
         TestClass.spyFunction('d', 'e', 'f');
         var expected = match(TestClass.spyFunction);
         expect(expected.not.toHaveBeenCalledWith('a', 'b', 'c')).toFail();
-        expect(lastResult().message).toEqual("Expected spy My spy not to have been called with [ 'a', 'b', 'c' ] but was called with [ [ 'a', 'b', 'c' ], [ 'd', 'e', 'f' ] ]");
+        expect(lastResult().message).toEqual("Expected spy My spy not to have been called with [ 'a', 'b', 'c' ] but it was.");
       });
 
       it('should throw an exception when invoked on a non-spy', shouldThrowAnExceptionWhenInvokedOnANonSpy('toHaveBeenCalledWith'));

data/lib/jasmine/spec/core/PrettyPrintSpec.js

@@ -32,6 +32,36 @@ describe("jasmine.pp", function () {
     }, bar: [1, 2, 3]})).toEqual("{ foo : Function, bar : [ 1, 2, 3 ] }");
   });
 
+  it("should not include inherited properties when stringifying an object", function() {
+    var SomeClass = function() {};
+    SomeClass.prototype.foo = "inherited foo";
+    var instance = new SomeClass();
+    instance.bar = "my own bar";
+    expect(jasmine.pp(instance)).toEqual("{ bar : 'my own bar' }");
+  });
+
+  it("should not recurse objects and arrays more deeply than jasmine.MAX_PRETTY_PRINT_DEPTH", function() {
+    var originalMaxDepth = jasmine.MAX_PRETTY_PRINT_DEPTH;
+    var nestedObject = { level1: { level2: { level3: { level4: "leaf" } } } };
+    var nestedArray  = [1, [2, [3, [4, "leaf"]]]];
+
+    try {
+      jasmine.MAX_PRETTY_PRINT_DEPTH = 2;
+      expect(jasmine.pp(nestedObject)).toEqual("{ level1 : { level2 : Object } }");
+      expect(jasmine.pp(nestedArray)).toEqual("[ 1, [ 2, Array ] ]");
+
+      jasmine.MAX_PRETTY_PRINT_DEPTH = 3;
+      expect(jasmine.pp(nestedObject)).toEqual("{ level1 : { level2 : { level3 : Object } } }");
+      expect(jasmine.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, Array ] ] ]");
+
+      jasmine.MAX_PRETTY_PRINT_DEPTH = 4;
+      expect(jasmine.pp(nestedObject)).toEqual("{ level1 : { level2 : { level3 : { level4 : 'leaf' } } } }");
+      expect(jasmine.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
+    } finally {
+      jasmine.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
+    }
+  });
+
   it("should stringify RegExp objects properly", function() {
     expect(jasmine.pp(/x|y|z/)).toEqual("/x|y|z/");
   });

data/lib/jasmine/spec/core/RunnerSpec.js

@@ -105,6 +105,19 @@ describe('RunnerTest', function() {
       expect(runnerResults.totalCount).toEqual(3);
       expect(runnerResults.passedCount).toEqual(3);
     });
+
+    it('should run after a failing spec', function () {
+      var afterEach = jasmine.createSpy();
+      env.afterEach(afterEach);
+
+      env.describe('suite', function () {
+        env.it('fails', function () {
+          this.explodes();
+        });
+      }).execute();
+
+      expect(afterEach).toHaveBeenCalled();
+    });
   });
 
 

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

@@ -398,6 +398,123 @@ describe("jasmine spec running", function () {
       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() {
@@ -579,90 +696,6 @@ describe("jasmine spec running", function () {
     expect(quux).toEqual(1);
   });
 
-  describe('#waitsFor should allow 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("#beforeEach should be able to eval runs and waits blocks", function () {
     var foo = 0;
     var bar = 0;