jasmine-core 2.99.2 → 3.0.0

data/lib/jasmine-core/spec/core/matchers/nothingSpec.js

@@ -0,0 +1,8 @@
+describe('nothing', function() {
+  it('should pass', function() {
+    var matcher = jasmineUnderTest.matchers.nothing(),
+      result = matcher.compare();
+
+    expect(result.pass).toBe(true);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeCloseToSpec.js

@@ -0,0 +1,93 @@
+describe("toBeCloseTo", function() {
+  it("passes when within two decimal places by default", function() {
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(0, 0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.001);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.005);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when not within two decimal places by default", function() {
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(0, 0.01);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(0, 0.05);
+    expect(result.pass).toBe(false);
+  });
+
+  it("accepts an optional precision argument", function() {
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(0, 0.1, 0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.5, 0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.0001, 3);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.0005, 3);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.00001, 4);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0, 0.00005, 4);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when one of the arguments is null", function() {
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo();
+
+    expect(function() {
+      matcher.compare(null, null);
+    }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(null).');
+
+    expect(function() {
+      matcher.compare(0, null);
+    }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(0).toBeCloseTo(null).');
+
+    expect(function() {
+      matcher.compare(null, 0);
+    }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).');
+  });
+
+  it("rounds expected values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
+      result;
+
+    result = matcher.compare(1.23, 1.229);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.23, 1.226);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.23, 1.225);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.23, 1.235);
+    expect(result.pass).toBe(true);
+
+    // 1.2249999 will be rounded to 1.225
+    result = matcher.compare(1.23, 1.2249999);
+    expect(result.pass).toBe(true);
+
+    // 1.2249999 will be rounded to 1.224
+    result = matcher.compare(1.23, 1.2244999);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1.23, 1.234);
+    expect(result.pass).toBe(true);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeDefinedSpec.js

@@ -0,0 +1,18 @@
+describe("toBeDefined", function() {
+  it("matches for defined values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeDefined(),
+      result;
+
+
+    result = matcher.compare('foo');
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when matching undefined values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeDefined(),
+      result;
+
+    result = matcher.compare(void 0);
+    expect(result.pass).toBe(false);
+  })
+});

data/lib/jasmine-core/spec/core/matchers/toBeFalsySpec.js

@@ -0,0 +1,38 @@
+describe("toBeFalsy", function() {
+  it("passes for 'falsy' values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeFalsy(),
+      result;
+
+    result = matcher.compare(false);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(0);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare('');
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(void 0);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails for 'truthy' values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeFalsy(),
+      result;
+
+    result = matcher.compare(true);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare("foo");
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare({});
+    expect(result.pass).toBe(false);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeGreaterThanOrEqualSpec.js

@@ -0,0 +1,29 @@
+describe("toBeGreaterThanOrEqual", function() {
+  it("passes when actual >= expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
+      result;
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.0000001, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1.0, 1.0);
+    expect(result.pass).toBe(true);
+  })
+
+  it("fails when actual < expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThanOrEqual(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1, 1.0000001);
+    expect(result.pass).toBe(false);
+  })
+});

data/lib/jasmine-core/spec/core/matchers/toBeGreaterThanSpec.js

@@ -0,0 +1,20 @@
+describe("toBeGreaterThan", function() {
+  it("passes when actual > expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
+      result;
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual <= expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeGreaterThan(),
+      result;
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(false);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeLessThanOrEqualSpec.js

@@ -0,0 +1,29 @@
+describe("toBeLessThanOrEqual", function() {
+  it("passes when actual <= expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1, 1.0000001);
+    expect(result.pass).toBe(true);
+    
+    result = matcher.compare(1.0, 1.0);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual < expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
+      result;
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(1.0000001, 1);
+    expect(result.pass).toBe(false);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeLessThanSpec.js

@@ -0,0 +1,20 @@
+describe("toBeLessThan", function() {
+  it("passes when actual < expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeLessThan(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual <= expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBeLessThan(),
+      result;
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(2, 1);
+    expect(result.pass).toBe(false);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeNaNSpec.js

@@ -0,0 +1,37 @@
+describe("toBeNaN", function() {
+  it("passes for NaN with a custom .not fail", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNaN(),
+      result;
+
+    result = matcher.compare(Number.NaN);
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected actual not to be NaN.");
+  });
+
+  it("fails for anything not a NaN", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNaN(),
+      result;
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(void 0);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare('');
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(Number.POSITIVE_INFINITY);
+    expect(result.pass).toBe(false);
+  });
+
+  it("has a custom message on failure", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNaN(),
+      result = matcher.compare(0);
+
+    expect(result.message()).toEqual("Expected 0 to be NaN.");
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeNegativeInfinitySpec.js

@@ -0,0 +1,31 @@
+describe("toBeNegativeInfinity", function() {
+  it("fails for anything that isn't -Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+      result;
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(Number.NaN);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(false);
+  });
+
+  it("has a custom message on failure", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+      result = matcher.compare(0);
+
+    expect(result.message()).toEqual("Expected 0 not to be -Infinity.")
+  });
+
+  it("succeeds for -Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
+      result = matcher.compare(Number.NEGATIVE_INFINITY);
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected actual to be -Infinity.")
+  });
+
+});

data/lib/jasmine-core/spec/core/matchers/toBeNullSpec.js

@@ -0,0 +1,17 @@
+describe("toBeNull", function() {
+  it("passes for null", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNull(),
+      result;
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails for non-null", function() {
+    var matcher = jasmineUnderTest.matchers.toBeNull(),
+      result;
+
+    result = matcher.compare('foo');
+    expect(result.pass).toBe(false);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBePositiveInfinitySpec.js

@@ -0,0 +1,31 @@
+describe("toBePositiveInfinity", function() {
+  it("fails for anything that isn't Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+      result;
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(Number.NaN);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(false);
+  });
+
+  it("has a custom message on failure", function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+      result = matcher.compare(0);
+
+    expect(result.message()).toEqual("Expected 0 not to be Infinity.")
+  });
+
+  it("succeeds for Infinity", function() {
+    var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
+      result = matcher.compare(Number.POSITIVE_INFINITY);
+
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual("Expected actual to be Infinity.")
+  });
+
+});

data/lib/jasmine-core/spec/core/matchers/toBeSpec.js

@@ -0,0 +1,17 @@
+describe("toBe", function() {
+  it("passes when actual === expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(),
+      result;
+
+    result = matcher.compare(1, 1);
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails when actual !== expected", function() {
+    var matcher = jasmineUnderTest.matchers.toBe(),
+      result;
+
+    result = matcher.compare(1, 2);
+    expect(result.pass).toBe(false);
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toBeTruthySpec.js

@@ -0,0 +1,38 @@
+describe("toBeTruthy", function() {
+  it("passes for 'truthy' values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeTruthy(),
+      result;
+
+    result = matcher.compare(true);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare(1);
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare("foo");
+    expect(result.pass).toBe(true);
+
+    result = matcher.compare({});
+    expect(result.pass).toBe(true);
+  });
+
+  it("fails for 'falsy' values", function() {
+    var matcher = jasmineUnderTest.matchers.toBeTruthy(),
+      result;
+
+    result = matcher.compare(false);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(0);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare('');
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(null);
+    expect(result.pass).toBe(false);
+
+    result = matcher.compare(void 0);
+    expect(result.pass).toBe(false);
+  });
+});