Run Prettier on all files

package.json

@@ -13,9 +13,9 @@
     "bdd"
   ],
   "scripts": {
-    "posttest": "eslint \"src/**/*.js\" \"spec/**/*.js\" && prettier --check src/**/*.js spec/**/*.js",
+    "posttest": "eslint \"src/**/*.js\" \"spec/**/*.js\" && prettier --check \"src/**/*.js\" \"spec/**/*.js\"",
     "test": "grunt --stack execSpecsInNode",
-    "cleanup": "prettier --write src/**/*.js spec/**/*.js",
+    "cleanup": "prettier --write \"src/**/*.js\" \"spec/**/*.js\"",
     "build": "grunt buildDistribution",
     "serve": "node spec/support/localJasmineBrowser.js",
     "serve:performance": "node spec/support/localJasmineBrowser.js jasmine-browser-performance.json",

spec/.eslintrc.js

@@ -1,23 +1,20 @@
 module.exports = {
-  "ignorePatterns": [
+  ignorePatterns: ['support/ci.js', 'support/jasmine-browser.js'],
-    "support/ci.js",
-    "support/jasmine-browser.js"
-  ],
   rules: {
     // Relax rules for now to allow for the quirks of the test suite
     // TODO: We should probably remove these & fix the resulting errors
-    "quotes": "off",
+    quotes: 'off',
-    "semi": "off",
+    semi: 'off',
-    "key-spacing": "off",
+    'key-spacing': 'off',
-    "space-before-blocks": "off",
+    'space-before-blocks': 'off',
-    "no-unused-vars": "off",
+    'no-unused-vars': 'off',
-    "no-trailing-spaces": "off",
+    'no-trailing-spaces': 'off',
-    "block-spacing": "off",
+    'block-spacing': 'off',
 
     // Since linting is done at the end of the process and doesn't stop us
     // from running tests, it makes sense to fail if debugger statements
     // or console references are present.
-    "no-debugger": "error",
+    'no-debugger': 'error',
-    "no-console": "error",
+    'no-console': 'error'
   }
 };

spec/core/asymmetric_equality/AnySpec.js

@@ -1,35 +1,35 @@
-describe("Any", function() {
+describe('Any', function() {
-  it("matches a string", function() {
+  it('matches a string', function() {
     var any = new jasmineUnderTest.Any(String);
 
-    expect(any.asymmetricMatch("foo")).toBe(true);
+    expect(any.asymmetricMatch('foo')).toBe(true);
   });
 
-  it("matches a number", function() {
+  it('matches a number', function() {
     var any = new jasmineUnderTest.Any(Number);
 
     expect(any.asymmetricMatch(1)).toBe(true);
   });
 
-  it("matches a function", function() {
+  it('matches a function', function() {
     var any = new jasmineUnderTest.Any(Function);
 
-    expect(any.asymmetricMatch(function(){})).toBe(true);
+    expect(any.asymmetricMatch(function() {})).toBe(true);
   });
 
-  it("matches an Object", function() {
+  it('matches an Object', function() {
     var any = new jasmineUnderTest.Any(Object);
 
     expect(any.asymmetricMatch({})).toBe(true);
   });
 
-  it("matches a Boolean", function() {
+  it('matches a Boolean', function() {
     var any = new jasmineUnderTest.Any(Boolean);
 
     expect(any.asymmetricMatch(true)).toBe(true);
   });
 
-  it("matches a Map", function() {
+  it('matches a Map', function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var any = new jasmineUnderTest.Any(Map);
@@ -37,7 +37,7 @@ describe("Any", function() {
     expect(any.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Set", function() {
+  it('matches a Set', function() {
     jasmine.getEnv().requireFunctioningSets();
 
     var any = new jasmineUnderTest.Any(Set);
@@ -45,7 +45,7 @@ describe("Any", function() {
     expect(any.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a TypedArray", function() {
+  it('matches a TypedArray', function() {
     jasmine.getEnv().requireFunctioningTypedArrays();
 
     var any = new jasmineUnderTest.Any(Uint32Array); // eslint-disable-line compat/compat
@@ -53,7 +53,7 @@ describe("Any", function() {
     expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Symbol", function() {
+  it('matches a Symbol', function() {
     jasmine.getEnv().requireFunctioningSymbols();
 
     var any = new jasmineUnderTest.Any(Symbol); // eslint-disable-line compat/compat
@@ -61,14 +61,14 @@ describe("Any", function() {
     expect(any.asymmetricMatch(Symbol())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches another constructed object", function() {
+  it('matches another constructed object', function() {
     var Thing = function() {},
       any = new jasmineUnderTest.Any(Thing);
 
     expect(any.asymmetricMatch(new Thing())).toBe(true);
   });
 
-  it("does not treat null as an Object", function() {
+  it('does not treat null as an Object', function() {
     var any = new jasmineUnderTest.Any(Object);
 
     expect(any.asymmetricMatch(null)).toBe(false);
@@ -81,8 +81,8 @@ describe("Any", function() {
     expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
   });
 
-  describe("when called without an argument", function() {
+  describe('when called without an argument', function() {
-    it("tells the user to pass a constructor or use jasmine.anything()", function() {
+    it('tells the user to pass a constructor or use jasmine.anything()', function() {
       expect(function() {
         new jasmineUnderTest.Any();
       }).toThrowError(TypeError, /constructor.*anything/);

spec/core/asymmetric_equality/AnythingSpec.js

@@ -1,29 +1,29 @@
-describe("Anything", function() {
+describe('Anything', function() {
-  it("matches a string", function() {
+  it('matches a string', function() {
     var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch('foo')).toBe(true);
   });
 
-  it("matches a number", function() {
+  it('matches a number', function() {
     var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch(42)).toBe(true);
   });
 
-  it("matches an object", function() {
+  it('matches an object', function() {
     var anything = new jasmineUnderTest.Anything();
 
     expect(anything.asymmetricMatch({ foo: 'bar' })).toBe(true);
   });
 
-  it("matches an array", function() {
+  it('matches an array', function() {
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.asymmetricMatch([1,2,3])).toBe(true);
+    expect(anything.asymmetricMatch([1, 2, 3])).toBe(true);
   });
 
-  it("matches a Map", function() {
+  it('matches a Map', function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var anything = new jasmineUnderTest.Anything();
@@ -31,7 +31,7 @@ describe("Anything", function() {
     expect(anything.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Set", function() {
+  it('matches a Set', function() {
     jasmine.getEnv().requireFunctioningSets();
 
     var anything = new jasmineUnderTest.Anything();
@@ -39,7 +39,7 @@ describe("Anything", function() {
     expect(anything.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a TypedArray", function() {
+  it('matches a TypedArray', function() {
     jasmine.getEnv().requireFunctioningTypedArrays();
 
     var anything = new jasmineUnderTest.Anything();
@@ -47,7 +47,7 @@ describe("Anything", function() {
     expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
   });
 
-  it("matches a Symbol", function() {
+  it('matches a Symbol', function() {
     jasmine.getEnv().requireFunctioningSymbols();
 
     var anything = new jasmineUnderTest.Anything();
@@ -71,6 +71,6 @@ describe("Anything", function() {
   it("jasmineToString's itself", function() {
     var anything = new jasmineUnderTest.Anything();
 
-    expect(anything.jasmineToString()).toEqual("<jasmine.anything>");
+    expect(anything.jasmineToString()).toEqual('<jasmine.anything>');
   });
 });

spec/core/asymmetric_equality/ArrayContainingSpec.js

@@ -1,47 +1,47 @@
-describe("ArrayContaining", function() {
+describe('ArrayContaining', function() {
-  it("matches any actual to an empty array", function() {
+  it('matches any actual to an empty array', function() {
     var containing = new jasmineUnderTest.ArrayContaining([]);
 
-    expect(containing.asymmetricMatch("foo")).toBe(true);
+    expect(containing.asymmetricMatch('foo')).toBe(true);
   });
 
-  it("does not work when not passed an array", function() {
+  it('does not work when not passed an array', function() {
-    var containing = new jasmineUnderTest.ArrayContaining("foo");
+    var containing = new jasmineUnderTest.ArrayContaining('foo');
 
     expect(function() {
       containing.asymmetricMatch([]);
     }).toThrowError(/not 'foo'/);
   });
 
-  it("matches when the item is in the actual", function() {
+  it('matches when the item is in the actual', function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(["foo"], matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch(['foo'], matchersUtil)).toBe(true);
   });
 
-  it("matches when additional items are in the actual", function() {
+  it('matches when additional items are in the actual', function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(["foo", "bar"], matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch(['foo', 'bar'], matchersUtil)).toBe(true);
   });
 
-  it("does not match when the item is not in the actual", function() {
+  it('does not match when the item is not in the actual', function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch(["bar"], matchersUtil)).toBe(false);
+    expect(containing.asymmetricMatch(['bar'], matchersUtil)).toBe(false);
   });
 
-  it("does not match when the actual is not an array", function() {
+  it('does not match when the actual is not an array', function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
+    var containing = new jasmineUnderTest.ArrayContaining(['foo']);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch("foo", matchersUtil)).toBe(false);
+    expect(containing.asymmetricMatch('foo', matchersUtil)).toBe(false);
   });
 
-  it("jasmineToStrings itself", function() {
+  it('jasmineToStrings itself', function() {
     var sample = [],
       matcher = new jasmineUnderTest.ArrayContaining(sample),
       pp = jasmine.createSpy('pp').and.returnValue('sample');
@@ -52,17 +52,23 @@ describe("ArrayContaining", function() {
     expect(pp).toHaveBeenCalledWith(sample);
   });
 
-  it("uses custom equality testers", function() {
+  it('uses custom equality testers', function() {
     var tester = function(a, b) {
       // All "foo*" strings match each other.
-      if (typeof a == "string" && typeof b == "string" &&
+      if (
-          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        typeof a == 'string' &&
+        typeof b == 'string' &&
+        a.substr(0, 3) == 'foo' &&
+        b.substr(0, 3) == 'foo'
+      ) {
         return true;
       }
     };
-    var containing = new jasmineUnderTest.ArrayContaining(["fooVal"]);
+    var containing = new jasmineUnderTest.ArrayContaining(['fooVal']);
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(containing.asymmetricMatch(["fooBar"], matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
   });
 });

spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js

@@ -1,35 +1,37 @@
-describe("ArrayWithExactContents", function() {
+describe('ArrayWithExactContents', function() {
-  it("matches an array with the same items in a different order", function() {
+  it('matches an array with the same items in a different order', function() {
     var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
     expect(matcher.asymmetricMatch([2, 'a', /a/], matchersUtil)).toBe(true);
   });
 
-  it("does not work when not passed an array", function() {
+  it('does not work when not passed an array', function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents("foo");
+    var matcher = new jasmineUnderTest.ArrayWithExactContents('foo');
 
     expect(function() {
       matcher.asymmetricMatch([]);
     }).toThrowError(/not 'foo'/);
   });
 
-  it("does not match when an item is missing", function() {
+  it('does not match when an item is missing', function() {
     var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
     expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
-    expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(false);
+    expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(
+      false
+    );
   });
 
-  it("does not match when there is an extra item", function() {
+  it('does not match when there is an extra item', function() {
     var matcher = new jasmineUnderTest.ArrayWithExactContents(['a']);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
     expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
   });
 
-  it("jasmineToStrings itself", function() {
+  it('jasmineToStrings itself', function() {
     var sample = [],
       matcher = new jasmineUnderTest.ArrayWithExactContents(sample),
       pp = jasmine.createSpy('pp').and.returnValue('sample');
@@ -40,17 +42,23 @@ describe("ArrayWithExactContents", function() {
     expect(pp).toHaveBeenCalledWith(sample);
   });
 
-  it("uses custom equality testers", function() {
+  it('uses custom equality testers', function() {
     var tester = function(a, b) {
       // All "foo*" strings match each other.
-      if (typeof a == "string" && typeof b == "string" &&
+      if (
-          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        typeof a == 'string' &&
+        typeof b == 'string' &&
+        a.substr(0, 3) == 'foo' &&
+        b.substr(0, 3) == 'foo'
+      ) {
         return true;
       }
     };
-    var matcher = new jasmineUnderTest.ArrayWithExactContents(["fooVal"]);
+    var matcher = new jasmineUnderTest.ArrayWithExactContents(['fooVal']);
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(matcher.asymmetricMatch(["fooBar"], matchersUtil)).toBe(true);
+    expect(matcher.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
   });
 });

spec/core/asymmetric_equality/EmptySpec.js

@@ -1,27 +1,27 @@
-describe("Empty", function () {
+describe('Empty', function() {
-  it("matches an empty object", function () {
+  it('matches an empty object', function() {
     var empty = new jasmineUnderTest.Empty();
 
     expect(empty.asymmetricMatch({})).toBe(true);
-    expect(empty.asymmetricMatch({undefined: false})).toBe(false);
+    expect(empty.asymmetricMatch({ undefined: false })).toBe(false);
   });
 
-  it("matches an empty array", function () {
+  it('matches an empty array', function() {
     var empty = new jasmineUnderTest.Empty();
 
     expect(empty.asymmetricMatch([])).toBe(true);
     expect(empty.asymmetricMatch([1, 12, 3])).toBe(false);
   });
 
-  it("matches an empty string", function () {
+  it('matches an empty string', function() {
     var empty = new jasmineUnderTest.Empty();
 
-    expect(empty.asymmetricMatch("")).toBe(true);
+    expect(empty.asymmetricMatch('')).toBe(true);
     expect(empty.asymmetricMatch('')).toBe(true);
     expect(empty.asymmetricMatch('12312')).toBe(false);
   });
 
-  it("matches an empty map", function () {
+  it('matches an empty map', function() {
     jasmine.getEnv().requireFunctioningMaps();
     var empty = new jasmineUnderTest.Empty();
     var fullMap = new Map(); // eslint-disable-line compat/compat
@@ -31,7 +31,7 @@ describe("Empty", function () {
     expect(empty.asymmetricMatch(fullMap)).toBe(false);
   });
 
-  it("matches an empty set", function () {
+  it('matches an empty set', function() {
     jasmine.getEnv().requireFunctioningSets();
     var empty = new jasmineUnderTest.Empty();
     var fullSet = new Set(); // eslint-disable-line compat/compat
@@ -41,11 +41,11 @@ describe("Empty", function () {
     expect(empty.asymmetricMatch(fullSet)).toBe(false);
   });
 
-  it("matches an empty typed array", function() {
+  it('matches an empty typed array', function() {
     jasmine.getEnv().requireFunctioningTypedArrays();
     var empty = new jasmineUnderTest.Empty();
 
     expect(empty.asymmetricMatch(new Int16Array())).toBe(true); // eslint-disable-line compat/compat
-    expect(empty.asymmetricMatch(new Int16Array([1,2]))).toBe(false); // eslint-disable-line compat/compat
+    expect(empty.asymmetricMatch(new Int16Array([1, 2]))).toBe(false); // eslint-disable-line compat/compat
   });
 });

spec/core/asymmetric_equality/FalsySpec.js

@@ -1,38 +1,38 @@
-describe("Falsy", function() {
+describe('Falsy', function() {
-    it("is true for an empty string", function() {
+  it('is true for an empty string', function() {
-        var falsy = new jasmineUnderTest.Falsy();
+    var falsy = new jasmineUnderTest.Falsy();
 
-        expect(falsy.asymmetricMatch("")).toBe(true);
+    expect(falsy.asymmetricMatch('')).toBe(true);
-        expect(falsy.asymmetricMatch('')).toBe(true);
+    expect(falsy.asymmetricMatch('')).toBe(true);
-        expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
+    expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
-    });
+  });
 
-    it("is false for a number that is 0", function() {
+  it('is false for a number that is 0', function() {
-        var falsy = new jasmineUnderTest.Falsy(Number);
+    var falsy = new jasmineUnderTest.Falsy(Number);
 
-        expect(falsy.asymmetricMatch(1)).toBe(false);
+    expect(falsy.asymmetricMatch(1)).toBe(false);
-        expect(falsy.asymmetricMatch(0)).toBe(true);
+    expect(falsy.asymmetricMatch(0)).toBe(true);
-        expect(falsy.asymmetricMatch(-23)).toBe(false);
+    expect(falsy.asymmetricMatch(-23)).toBe(false);
-        expect(falsy.asymmetricMatch(-3.1)).toBe(false);
+    expect(falsy.asymmetricMatch(-3.1)).toBe(false);
-    });
+  });
 
-    it("is true for a null or undefined", function() {
+  it('is true for a null or undefined', function() {
-        var falsy = new jasmineUnderTest.Falsy(Function);
+    var falsy = new jasmineUnderTest.Falsy(Function);
 
-        expect(falsy.asymmetricMatch(null)).toBe(true);
+    expect(falsy.asymmetricMatch(null)).toBe(true);
-        expect(falsy.asymmetricMatch(undefined )).toBe(true);
+    expect(falsy.asymmetricMatch(undefined)).toBe(true);
-    });
+  });
 
-    it("is true for NaN", function() {
+  it('is true for NaN', function() {
-        var falsy = new jasmineUnderTest.Falsy(Object);
+    var falsy = new jasmineUnderTest.Falsy(Object);
 
-        expect(falsy.asymmetricMatch(NaN)).toBe(true);
+    expect(falsy.asymmetricMatch(NaN)).toBe(true);
-    });
+  });
 
-    it("is true for a false Boolean", function() {
+  it('is true for a false Boolean', function() {
-        var falsy = new jasmineUnderTest.Falsy(Boolean);
+    var falsy = new jasmineUnderTest.Falsy(Boolean);
 
-        expect(falsy.asymmetricMatch(false)).toBe(true);
+    expect(falsy.asymmetricMatch(false)).toBe(true);
-        expect(falsy.asymmetricMatch(true)).toBe(false);
+    expect(falsy.asymmetricMatch(true)).toBe(false);
-    });
+  });
 });

spec/core/asymmetric_equality/MapContainingSpec.js

@@ -1,6 +1,7 @@
 /* eslint-disable compat/compat */
 describe('MapContaining', function() {
-  function MapI(iterable) {    // for IE11
+  function MapI(iterable) {
+    // for IE11
     var map = new Map();
     iterable.forEach(function(kv) {
       map.set(kv[0], kv[1]);
@@ -12,7 +13,6 @@ describe('MapContaining', function() {
     jasmine.getEnv().requireFunctioningMaps();
   });
 
-
   it('matches any actual map to an empty map', function() {
     var actualMap = new MapI([['foo', 'bar']]);
     var containing = new jasmineUnderTest.MapContaining(new Map());
@@ -23,14 +23,11 @@ describe('MapContaining', function() {
   it('matches when all the key/value pairs in sample have matches in actual', function() {
     var actualMap = new MapI([
       ['foo', [1, 2, 3]],
-      [{'foo': 'bar'}, 'baz'],
+      [{ foo: 'bar' }, 'baz'],
-      ['other', 'any'],
+      ['other', 'any']
     ]);
 
-    var containingMap = new MapI([
+    var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
-      [{'foo': 'bar'}, 'baz'],
-      ['foo', [1, 2, 3]],
-    ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
@@ -40,13 +37,10 @@ describe('MapContaining', function() {
   it('does not match when a key is not in actual', function() {
     var actualMap = new MapI([
       ['foo', [1, 2, 3]],
-      [{'foo': 'not a bar'}, 'baz'],
+      [{ foo: 'not a bar' }, 'baz']
     ]);
 
-    var containingMap = new MapI([
+    var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
-      [{'foo': 'bar'}, 'baz'],
-      ['foo', [1, 2, 3]],
-    ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
@@ -54,15 +48,9 @@ describe('MapContaining', function() {
   });
 
   it('does not match when a value is not in actual', function() {
-    var actualMap = new MapI([
+    var actualMap = new MapI([['foo', [1, 2, 3]], [{ foo: 'bar' }, 'baz']]);
-      ['foo', [1, 2, 3]],
-      [{'foo': 'bar'}, 'baz'],
-    ]);
 
-    var containingMap = new MapI([
+    var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2]]]);
-      [{'foo': 'bar'}, 'baz'],
-      ['foo', [1, 2]],
-    ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
@@ -73,18 +61,12 @@ describe('MapContaining', function() {
     var actualMap = new MapI([
       ['foo1', 'not a bar'],
       ['foo2', 'bar'],
-      ['baz', [1, 2, 3, 4]],
+      ['baz', [1, 2, 3, 4]]
     ]);
 
     var containingMap = new MapI([
-      [
+      [jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
-        jasmineUnderTest.stringMatching(/^foo\d/),
+      ['baz', jasmineUnderTest.arrayContaining([2, 3])]
-        'bar'
-      ],
-      [
-        'baz',
-        jasmineUnderTest.arrayContaining([2, 3])
-      ],
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -93,20 +75,11 @@ describe('MapContaining', function() {
   });
 
   it('does not match when a key in sample has no asymmetric matches in actual', function() {
-    var actualMap = new MapI([
+    var actualMap = new MapI([['a-foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
-      ['a-foo1', 'bar'],
-      ['baz', [1, 2, 3, 4]],
-    ]);
 
     var containingMap = new MapI([
-      [
+      [jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
-        jasmineUnderTest.stringMatching(/^foo\d/),
+      ['baz', jasmineUnderTest.arrayContaining([2, 3])]
-        'bar'
-      ],
-      [
-        'baz',
-        jasmineUnderTest.arrayContaining([2, 3])
-      ],
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -115,20 +88,11 @@ describe('MapContaining', function() {
   });
 
   it('does not match when a value in sample has no asymmetric matches in actual', function() {
-    var actualMap = new MapI([
+    var actualMap = new MapI([['foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
-      ['foo1', 'bar'],
-      ['baz', [1, 2, 3, 4]],
-    ]);
 
     var containingMap = new MapI([
-      [
+      [jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
-        jasmineUnderTest.stringMatching(/^foo\d/),
+      ['baz', jasmineUnderTest.arrayContaining([4, 5])]
-        'bar'
-      ],
-      [
-        'baz',
-        jasmineUnderTest.arrayContaining([4, 5])
-      ],
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -140,18 +104,12 @@ describe('MapContaining', function() {
     var actualMap = new MapI([
       ['foo', new MapI([['foo1', 1], ['foo2', 2]])],
       [new MapI([[1, 'bar1'], [2, 'bar2']]), 'bar'],
-      ['other', 'any'],
+      ['other', 'any']
     ]);
 
     var containingMap = new MapI([
-      [
+      ['foo', new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))],
-        'foo',
+      [new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])), 'bar']
-        new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))
-      ],
-      [
-        new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])),
-        'bar'
-      ],
     ]);
     var containing = new jasmineUnderTest.MapContaining(containingMap);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -162,25 +120,41 @@ describe('MapContaining', function() {
   it('uses custom equality testers', function() {
     function tester(a, b) {
       // treat all negative numbers as equal
-      return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
+      return typeof a == 'number' && typeof b == 'number'
+        ? a < 0 && b < 0
+        : a === b;
     }
     var actualMap = new MapI([['foo', -1]]);
-    var containing = new jasmineUnderTest.MapContaining(new MapI([['foo', -2]]));
+    var containing = new jasmineUnderTest.MapContaining(
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
+      new MapI([['foo', -2]])
+    );
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
     expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
   });
 
   it('does not match when actual is not a map', function() {
     var containingMap = new MapI([['foo', 'bar']]);
-    expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')).toBe(false);
+    expect(
-    expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)).toBe(false);
+      new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')
-    expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({'foo': 'bar'})).toBe(false);
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({
+        foo: 'bar'
+      })
+    ).toBe(false);
   });
 
   it('throws an error when sample is not a map', function() {
     expect(function() {
-      new jasmineUnderTest.MapContaining({'foo': 'bar'}).asymmetricMatch(new Map());
+      new jasmineUnderTest.MapContaining({ foo: 'bar' }).asymmetricMatch(
+        new Map()
+      );
     }).toThrowError(/You must provide a map/);
   });
 

spec/core/asymmetric_equality/NotEmptySpec.js

@@ -1,27 +1,27 @@
-describe("NotEmpty", function () {
+describe('NotEmpty', function() {
-  it("matches a non empty object", function () {
+  it('matches a non empty object', function() {
     var notEmpty = new jasmineUnderTest.NotEmpty();
 
-    expect(notEmpty.asymmetricMatch({undefined: false})).toBe(true);
+    expect(notEmpty.asymmetricMatch({ undefined: false })).toBe(true);
     expect(notEmpty.asymmetricMatch({})).toBe(false);
   });
 
-  it("matches a non empty array", function () {
+  it('matches a non empty array', function() {
     var notEmpty = new jasmineUnderTest.NotEmpty();
 
     expect(notEmpty.asymmetricMatch([1, 12, 3])).toBe(true);
     expect(notEmpty.asymmetricMatch([])).toBe(false);
   });
 
-  it("matches a non empty string", function () {
+  it('matches a non empty string', function() {
     var notEmpty = new jasmineUnderTest.NotEmpty();
 
     expect(notEmpty.asymmetricMatch('12312')).toBe(true);
-    expect(notEmpty.asymmetricMatch("")).toBe(false);
+    expect(notEmpty.asymmetricMatch('')).toBe(false);
     expect(notEmpty.asymmetricMatch('')).toBe(false);
   });
 
-  it("matches a non empty map", function () {
+  it('matches a non empty map', function() {
     jasmine.getEnv().requireFunctioningMaps();
     var notEmpty = new jasmineUnderTest.NotEmpty();
     var fullMap = new Map(); // eslint-disable-line compat/compat
@@ -32,7 +32,7 @@ describe("NotEmpty", function () {
     expect(notEmpty.asymmetricMatch(emptyMap)).toBe(false);
   });
 
-  it("matches a non empty set", function () {
+  it('matches a non empty set', function() {
     jasmine.getEnv().requireFunctioningSets();
     var notEmpty = new jasmineUnderTest.NotEmpty();
     var filledSet = new Set(); // eslint-disable-line compat/compat
@@ -43,11 +43,11 @@ describe("NotEmpty", function () {
     expect(notEmpty.asymmetricMatch(emptySet)).toBe(false);
   });
 
-  it("matches a non empty typed array", function() {
+  it('matches a non empty typed array', function() {
     jasmine.getEnv().requireFunctioningTypedArrays();
     var notEmpty = new jasmineUnderTest.NotEmpty();
 
-    expect(notEmpty.asymmetricMatch(new Int16Array([1,2,3]))).toBe(true); // eslint-disable-line compat/compat
+    expect(notEmpty.asymmetricMatch(new Int16Array([1, 2, 3]))).toBe(true); // eslint-disable-line compat/compat
     expect(notEmpty.asymmetricMatch(new Int16Array())).toBe(false); // eslint-disable-line compat/compat
   });
 });

spec/core/asymmetric_equality/ObjectContainingSpec.js

@@ -1,47 +1,55 @@
-describe("ObjectContaining", function() {
+describe('ObjectContaining', function() {
-
+  it('matches any object actual to an empty object', function() {
-  it("matches any object actual to an empty object", function() {
     var containing = new jasmineUnderTest.ObjectContaining({});
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({foo: 1}, matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch({ foo: 1 }, matchersUtil)).toBe(true);
   });
 
-  it("does not match when the actual is not an object", function() {
+  it('does not match when the actual is not an object', function() {
     var containing = new jasmineUnderTest.ObjectContaining({});
 
-    [1, true, undefined, "a string"].forEach(function(actual) {
+    [1, true, undefined, 'a string'].forEach(function(actual) {
       expect(containing.asymmetricMatch(actual)).toBe(false);
     });
   });
 
-  it("does not match an empty object actual", function() {
+  it('does not match an empty object actual', function() {
-    var containing = new jasmineUnderTest.ObjectContaining("foo");
+    var containing = new jasmineUnderTest.ObjectContaining('foo');
 
     expect(function() {
-      containing.asymmetricMatch({})
+      containing.asymmetricMatch({});
-    }).toThrowError(/not 'foo'/)
+    }).toThrowError(/not 'foo'/);
   });
 
-  it("matches when the key/value pair is present in the actual", function() {
+  it('matches when the key/value pair is present in the actual', function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"}, matchersUtil)).toBe(true);
+    expect(
+      containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
+    ).toBe(true);
   });
 
-  it("does not match when the key/value pair is not present in the actual", function() {
+  it('does not match when the key/value pair is not present in the actual', function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({bar: "barVal", quux: "quuxVal"}, matchersUtil)).toBe(false);
+    expect(
+      containing.asymmetricMatch(
+        { bar: 'barVal', quux: 'quuxVal' },
+        matchersUtil
+      )
+    ).toBe(false);
   });
 
-  it("does not match when the key is present but the value is different in the actual", function() {
+  it('does not match when the key is present but the value is different in the actual', function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "other"});
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'other' });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"}, matchersUtil)).toBe(false);
+    expect(
+      containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
+    ).toBe(false);
   });
 
   it("jasmineToString's itself", function() {
@@ -53,46 +61,55 @@ describe("ObjectContaining", function() {
       '<jasmine.objectContaining(sample)>'
     );
     expect(pp).toHaveBeenCalledWith(sample);
-
   });
 
-  it("matches recursively", function() {
+  it('matches recursively', function() {
-    var containing = new jasmineUnderTest.ObjectContaining({one: new jasmineUnderTest.ObjectContaining({two: {}})});
+    var containing = new jasmineUnderTest.ObjectContaining({
+      one: new jasmineUnderTest.ObjectContaining({ two: {} })
+    });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({one: {two: {}}}, matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch({ one: { two: {} } }, matchersUtil)).toBe(
+      true
+    );
   });
 
-  it("matches when key is present with undefined value", function() {
+  it('matches when key is present with undefined value', function() {
     var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(
+      true
+    );
   });
 
-  it("does not match when key with undefined value is not present", function() {
+  it('does not match when key with undefined value is not present', function() {
     var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
     expect(containing.asymmetricMatch({}, matchersUtil)).toBe(false);
   });
 
-  it("matches defined properties", function(){
+  it('matches defined properties', function() {
-    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
     var definedPropertyObject = {};
-    Object.defineProperty(definedPropertyObject, "foo", {
+    Object.defineProperty(definedPropertyObject, 'foo', {
-      get: function() { return "fooVal" }
+      get: function() {
+        return 'fooVal';
+      }
     });
-    expect(containing.asymmetricMatch(definedPropertyObject, matchersUtil)).toBe(true);
+    expect(
+      containing.asymmetricMatch(definedPropertyObject, matchersUtil)
+    ).toBe(true);
   });
 
-  it("matches prototype properties", function(){
+  it('matches prototype properties', function() {
-    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
-    var prototypeObject = {foo: "fooVal"};
+    var prototypeObject = { foo: 'fooVal' };
     var obj;
 
     if (Object.create) {
@@ -107,23 +124,31 @@ describe("ObjectContaining", function() {
     expect(containing.asymmetricMatch(obj, matchersUtil)).toBe(true);
   });
 
-  it("uses custom equality testers", function() {
+  it('uses custom equality testers', function() {
     var tester = function(a, b) {
       // All "foo*" strings match each other.
-      if (typeof a == "string" && typeof b == "string" &&
+      if (
-          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+        typeof a == 'string' &&
+        typeof b == 'string' &&
+        a.substr(0, 3) == 'foo' &&
+        b.substr(0, 3) == 'foo'
+      ) {
         return true;
       }
     };
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
+    var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
-    expect(containing.asymmetricMatch({foo: "fooBar"}, matchersUtil)).toBe(true);
+    expect(containing.asymmetricMatch({ foo: 'fooBar' }, matchersUtil)).toBe(
+      true
+    );
   });
 
-  describe("valuesForDiff_", function() {
+  describe('valuesForDiff_', function() {
-    describe("when other is not an object", function() {
+    describe('when other is not an object', function() {
-      it("sets self to jasmineToString()", function () {
+      it('sets self to jasmineToString()', function() {
         var containing = new jasmineUnderTest.ObjectContaining({}),
           pp = jasmineUnderTest.makePrettyPrinter(),
           result = containing.valuesForDiff_('a', pp);
@@ -135,27 +160,31 @@ describe("ObjectContaining", function() {
       });
     });
 
-    describe("when other is an object", function() {
+    describe('when other is an object', function() {
-      it("includes keys that are present in both other and sample", function() {
+      it('includes keys that are present in both other and sample', function() {
-        var sample = {a: 1, b: 2},
+        var sample = { a: 1, b: 2 },
-          other = {a: 3, b: 4},
+          other = { a: 3, b: 4 },
           containing = new jasmineUnderTest.ObjectContaining(sample),
           result = containing.valuesForDiff_(other);
 
-        expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
+        expect(result.self).not.toBeInstanceOf(
+          jasmineUnderTest.ObjectContaining
+        );
         expect(result).toEqual({
           self: sample,
           other: other
         });
       });
 
-      it("includes keys that are present only in sample", function() {
+      it('includes keys that are present only in sample', function() {
-        var sample = {a: 1, b: 2},
+        var sample = { a: 1, b: 2 },
-          other = {a: 3},
+          other = { a: 3 },
           containing = new jasmineUnderTest.ObjectContaining(sample),
           result = containing.valuesForDiff_(other);
 
-        expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
+        expect(result.self).not.toBeInstanceOf(
+          jasmineUnderTest.ObjectContaining
+        );
         expect(containing.valuesForDiff_(other)).toEqual({
           self: sample,
           other: {
@@ -165,13 +194,15 @@ describe("ObjectContaining", function() {
         });
       });
 
-      it("omits keys that are present only in other", function() {
+      it('omits keys that are present only in other', function() {
-        var sample = {a: 1, b: 2},
+        var sample = { a: 1, b: 2 },
-          other = {a: 3, b: 4, c: 5},
+          other = { a: 3, b: 4, c: 5 },
           containing = new jasmineUnderTest.ObjectContaining(sample),
           result = containing.valuesForDiff_(other);
 
-        expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
+        expect(result.self).not.toBeInstanceOf(
+          jasmineUnderTest.ObjectContaining
+        );
         expect(result).toEqual({
           self: sample,
           other: {

spec/core/asymmetric_equality/SetContainingSpec.js

@@ -1,6 +1,7 @@
 /* eslint-disable compat/compat */
 describe('SetContaining', function() {
-  function SetI(iterable) {    // for IE11
+  function SetI(iterable) {
+    // for IE11
     var set = new Set();
     iterable.forEach(function(v) {
       set.add(v);
@@ -12,7 +13,6 @@ describe('SetContaining', function() {
     jasmine.getEnv().requireFunctioningSets();
   });
 
-
   it('matches any actual set to an empty set', function() {
     var actualSet = new SetI(['foo', 'bar']);
     var containing = new jasmineUnderTest.SetContaining(new Set());
@@ -21,13 +21,9 @@ describe('SetContaining', function() {
   });
 
   it('matches when all the values in sample have matches in actual', function() {
-    var actualSet = new SetI([
+    var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
-      {'foo': 'bar'}, 'baz', [1, 2, 3]
-    ]);
 
-    var containingSet = new SetI([
+    var containingSet = new SetI([[1, 2, 3], { foo: 'bar' }]);
-      [1, 2, 3], {'foo': 'bar'}
-    ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
@@ -35,13 +31,9 @@ describe('SetContaining', function() {
   });
 
   it('does not match when a value is not in actual', function() {
-    var actualSet = new SetI([
+    var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
-      {'foo': 'bar'}, 'baz', [1, 2, 3]
-    ]);
 
-    var containingSet = new SetI([
+    var containingSet = new SetI([[1, 2], { foo: 'bar' }]);
-      [1, 2], {'foo': 'bar'}
-    ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
 
@@ -49,13 +41,11 @@ describe('SetContaining', function() {
   });
 
   it('matches when all the values in sample have asymmetric matches in actual', function() {
-    var actualSet = new SetI([
+    var actualSet = new SetI([[1, 2, 3, 4], 'other', 'foo1']);
-      [1, 2, 3, 4], 'other', 'foo1'
-    ]);
 
     var containingSet = new SetI([
       jasmineUnderTest.stringMatching(/^foo\d/),
-      jasmineUnderTest.arrayContaining([2, 3]),
+      jasmineUnderTest.arrayContaining([2, 3])
     ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -64,13 +54,11 @@ describe('SetContaining', function() {
   });
 
   it('does not match when a value in sample has no asymmetric matches in actual', function() {
-    var actualSet = new SetI([
+    var actualSet = new SetI(['a-foo1', [1, 2, 3, 4], 'other']);
-      'a-foo1', [1, 2, 3, 4], 'other'
-    ]);
 
     var containingSet = new SetI([
       jasmine.stringMatching(/^foo\d/),
-      jasmine.arrayContaining([2, 3]),
+      jasmine.arrayContaining([2, 3])
     ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -79,12 +67,11 @@ describe('SetContaining', function() {
   });
 
   it('matches recursively', function() {
-    var actualSet = new SetI([
+    var actualSet = new SetI(['foo', new SetI([1, 'bar', 2]), 'other']);
-      'foo', new SetI([1, 'bar', 2]), 'other'
-    ]);
 
     var containingSet = new SetI([
-      new jasmineUnderTest.SetContaining(new SetI(['bar'])), 'foo'
+      new jasmineUnderTest.SetContaining(new SetI(['bar'])),
+      'foo'
     ]);
     var containing = new jasmineUnderTest.SetContaining(containingSet);
     var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -95,25 +82,37 @@ describe('SetContaining', function() {
   it('uses custom equality testers', function() {
     function tester(a, b) {
       // treat all negative numbers as equal
-      return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
+      return typeof a == 'number' && typeof b == 'number'
+        ? a < 0 && b < 0
+        : a === b;
     }
     var actualSet = new SetI(['foo', -1]);
     var containing = new jasmineUnderTest.SetContaining(new SetI([-2, 'foo']));
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+      customTesters: [tester]
+    });
 
     expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
   });
 
   it('does not match when actual is not a set', function() {
     var containingSet = new SetI(['foo']);
-    expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')).toBe(false);
+    expect(
-    expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)).toBe(false);
+      new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')
-    expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])).toBe(false);
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)
+    ).toBe(false);
+    expect(
+      new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])
+    ).toBe(false);
   });
 
   it('throws an error when sample is not a set', function() {
     expect(function() {
-      new jasmineUnderTest.SetContaining({'foo': 'bar'}).asymmetricMatch(new Set());
+      new jasmineUnderTest.SetContaining({ foo: 'bar' }).asymmetricMatch(
+        new Set()
+      );
     }).toThrowError(/You must provide a set/);
   });
 

spec/core/asymmetric_equality/StringMatchingSpec.js

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

spec/core/asymmetric_equality/TruthySpec.js

@@ -1,12 +1,12 @@
-describe("Truthy", function () {
+describe('Truthy', function() {
-  it("is true for a non empty string", function () {
+  it('is true for a non empty string', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
-    expect(truthy.asymmetricMatch("foo")).toBe(true);
+    expect(truthy.asymmetricMatch('foo')).toBe(true);
-    expect(truthy.asymmetricMatch("")).toBe(false);
+    expect(truthy.asymmetricMatch('')).toBe(false);
   });
 
-  it("is true for a number that is not 0", function () {
+  it('is true for a number that is not 0', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch(1)).toBe(true);
@@ -15,49 +15,47 @@ describe("Truthy", function () {
     expect(truthy.asymmetricMatch(-3.1)).toBe(true);
   });
 
-  it("is true for a function", function () {
+  it('is true for a function', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
-    expect(truthy.asymmetricMatch(function () {
+    expect(truthy.asymmetricMatch(function() {})).toBe(true);
-    })).toBe(true);
   });
 
-  it("is true for an Object", function () {
+  it('is true for an Object', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch({})).toBe(true);
   });
 
-  it("is true for a truthful Boolean", function () {
+  it('is true for a truthful Boolean', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch(true)).toBe(true);
     expect(truthy.asymmetricMatch(false)).toBe(false);
   });
 
-  it("is true for an empty object", function () {
+  it('is true for an empty object', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch({})).toBe(true);
   });
 
-  it("is true for an empty array", function () {
+  it('is true for an empty array', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch([])).toBe(true);
   });
 
-  it("is true for a date", function () {
+  it('is true for a date', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch(new Date())).toBe(true);
   });
 
-  it("is true for a infiniti", function () {
+  it('is true for a infiniti', function() {
     var truthy = new jasmineUnderTest.Truthy();
 
     expect(truthy.asymmetricMatch(Infinity)).toBe(true);
     expect(truthy.asymmetricMatch(-Infinity)).toBe(true);
   });
 });
-

spec/core/integration/AsymmetricEqualityTestersSpec.js

@@ -1,12 +1,12 @@
-describe('Asymmetric equality testers (Integration)', function () {
+describe('Asymmetric equality testers (Integration)', function() {
   function verifyPasses(expectations, setup) {
-    it('passes', function (done) {
+    it('passes', function(done) {
       var env = new jasmineUnderTest.Env();
-      env.it('a spec', function () {
+      env.it('a spec', function() {
         expectations(env);
       });
 
-      var specExpectations = function (result) {
+      var specExpectations = function(result) {
         expect(result.status).toEqual('passed');
         expect(result.passedExpectations.length)
           .withContext('Number of passed expectations')
@@ -14,115 +14,122 @@ describe('Asymmetric equality testers (Integration)', function () {
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(0);
-        expect(result.failedExpectations[0] && result.failedExpectations[0].message)
+        expect(
+          result.failedExpectations[0] && result.failedExpectations[0].message
+        )
           .withContext('Failure message')
           .toBeUndefined();
       };
 
-      env.addReporter({specDone: specExpectations});
+      env.addReporter({ specDone: specExpectations });
       env.execute(null, done);
     });
   }
 
   function verifyFails(expectations) {
-    it('fails', function (done) {
+    it('fails', function(done) {
       var env = new jasmineUnderTest.Env();
-      env.it('a spec', function () {
+      env.it('a spec', function() {
         expectations(env);
       });
 
-      var specExpectations = function (result) {
+      var specExpectations = function(result) {
         expect(result.status).toEqual('failed');
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(1);
         expect(result.failedExpectations[0].message)
-          .withContext('Failed with a thrown error rather than a matcher failure')
+          .withContext(
+            'Failed with a thrown error rather than a matcher failure'
+          )
           .not.toMatch(/^Error: /);
-        expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
+        expect(result.failedExpectations[0].matcherName)
+          .withContext('Matcher name')
           .not.toEqual('');
       };
 
-      env.addReporter({specDone: specExpectations});
+      env.addReporter({ specDone: specExpectations });
       env.execute(null, done);
     });
   }
 
-  describe('any', function () {
+  describe('any', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect(5).toEqual(jasmineUnderTest.any(Number));
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
-      env.expect("five").toEqual(jasmineUnderTest.any(Number));
+      env.expect('five').toEqual(jasmineUnderTest.any(Number));
     });
   });
 
-  describe('anything', function () {
+  describe('anything', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect('').toEqual(jasmineUnderTest.anything());
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect(null).toEqual(jasmineUnderTest.anything());
     });
   });
 
-  describe('arrayContaining', function () {
+  describe('arrayContaining', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
-      env.addCustomEqualityTester(function (a, b) {
+      env.addCustomEqualityTester(function(a, b) {
         return a.toString() === b.toString();
       });
-      env.expect([1, 2, 3]).toEqual(jasmineUnderTest.arrayContaining(["2"]));
+      env.expect([1, 2, 3]).toEqual(jasmineUnderTest.arrayContaining(['2']));
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect(null).toEqual(jasmineUnderTest.arrayContaining([2]));
     });
   });
 
-  describe('arrayWithExactContents', function () {
+  describe('arrayWithExactContents', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
-      env.addCustomEqualityTester(function (a, b) {
+      env.addCustomEqualityTester(function(a, b) {
         return a.toString() === b.toString();
       });
-      env.expect([1, 2]).toEqual(jasmineUnderTest.arrayWithExactContents(["2", "1"]));
+      env
+        .expect([1, 2])
+        .toEqual(jasmineUnderTest.arrayWithExactContents(['2', '1']));
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect([]).toEqual(jasmineUnderTest.arrayWithExactContents([2]));
     });
   });
 
-  describe('empty', function () {
+  describe('empty', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect([]).toEqual(jasmineUnderTest.empty());
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect([1]).toEqual(jasmineUnderTest.empty());
     });
   });
 
-  describe('falsy', function () {
+  describe('falsy', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect(false).toEqual(jasmineUnderTest.falsy());
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect(true).toEqual(jasmineUnderTest.falsy());
     });
   });
 
-  describe('mapContaining', function () {
+  describe('mapContaining', function() {
     if (jasmine.getEnv().hasFunctioningMaps()) {
-      verifyPasses(function (env) {
+      verifyPasses(function(env) {
         var actual = new Map();
-        actual.set('a', "2");
+        actual.set('a', '2');
         var expected = new Map();
         expected.set('a', 2);
 
-        env.addCustomEqualityTester(function (a, b) {
+        env.addCustomEqualityTester(function(a, b) {
           return a.toString() === b.toString();
         });
 
@@ -130,54 +137,62 @@ describe('Asymmetric equality testers (Integration)', function () {
       });
     } else {
       it('passes', function() {
-        jasmine.getEnv().pending('Browser has incomplete or missing support for Maps');
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Maps');
       });
     }
 
     if (jasmine.getEnv().hasFunctioningMaps()) {
-      verifyFails(function (env) {
+      verifyFails(function(env) {
-        env.expect('something').toEqual(jasmineUnderTest.mapContaining(new Map()));
+        env
+          .expect('something')
+          .toEqual(jasmineUnderTest.mapContaining(new Map()));
       });
     } else {
       it('fails', function() {
-        jasmine.getEnv().pending('Browser has incomplete or missing support for Maps');
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Maps');
       });
     }
   });
 
-  describe('notEmpty', function () {
+  describe('notEmpty', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect([1]).toEqual(jasmineUnderTest.notEmpty());
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect([]).toEqual(jasmineUnderTest.notEmpty());
     });
   });
 
-  describe('objectContaining', function () {
+  describe('objectContaining', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
-      env.addCustomEqualityTester(function (a, b) {
+      env.addCustomEqualityTester(function(a, b) {
         return a.toString() === b.toString();
       });
 
-      env.expect({a: 1, b: 2}).toEqual(jasmineUnderTest.objectContaining({a: "1"}));
+      env
+        .expect({ a: 1, b: 2 })
+        .toEqual(jasmineUnderTest.objectContaining({ a: '1' }));
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
-      env.expect({}).toEqual(jasmineUnderTest.objectContaining({a: "1"}));
+      env.expect({}).toEqual(jasmineUnderTest.objectContaining({ a: '1' }));
     });
   });
 
-  describe('setContaining', function () {
+  describe('setContaining', function() {
     if (jasmine.getEnv().hasFunctioningSets()) {
-      verifyPasses(function (env) {
+      verifyPasses(function(env) {
         var actual = new Set();
-        actual.add("1");
+        actual.add('1');
         var expected = new Set();
         actual.add(1);
 
-        env.addCustomEqualityTester(function (a, b) {
+        env.addCustomEqualityTester(function(a, b) {
           return a.toString() === b.toString();
         });
 
@@ -185,37 +200,43 @@ describe('Asymmetric equality testers (Integration)', function () {
       });
     } else {
       it('pases', function() {
-        jasmine.getEnv().pending('Browser has incomplete or missing support for Sets');
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Sets');
       });
     }
 
     if (jasmine.getEnv().hasFunctioningSets()) {
-      verifyFails(function (env) {
+      verifyFails(function(env) {
-        env.expect('something').toEqual(jasmineUnderTest.setContaining(new Set()));
+        env
+          .expect('something')
+          .toEqual(jasmineUnderTest.setContaining(new Set()));
       });
     } else {
       it('fails', function() {
-        jasmine.getEnv().pending('Browser has incomplete or missing support for Sets');
+        jasmine
+          .getEnv()
+          .pending('Browser has incomplete or missing support for Sets');
       });
     }
   });
 
-  describe('stringMatching', function () {
+  describe('stringMatching', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect('foo').toEqual(jasmineUnderTest.stringMatching(/o/));
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect('bar').toEqual(jasmineUnderTest.stringMatching(/o/));
     });
   });
 
-  describe('truthy', function () {
+  describe('truthy', function() {
-    verifyPasses(function (env) {
+    verifyPasses(function(env) {
       env.expect(true).toEqual(jasmineUnderTest.truthy());
     });
 
-    verifyFails(function (env) {
+    verifyFails(function(env) {
       env.expect(false).toEqual(jasmineUnderTest.truthy());
     });
   });

spec/core/integration/CustomAsyncMatchersSpec.js

@@ -4,7 +4,7 @@ describe('Custom Async Matchers (Integration)', function() {
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
   afterEach(function() {
@@ -17,7 +17,11 @@ describe('Custom Async Matchers (Integration)', function() {
     env.it('spec using custom async matcher', function() {
       env.addAsyncMatchers({
         toBeReal: function() {
-          return { compare: function() { return Promise.resolve({ pass: true }); } };
+          return {
+            compare: function() {
+              return Promise.resolve({ pass: true });
+            }
+          };
         }
       });
 
@@ -39,8 +43,12 @@ describe('Custom Async Matchers (Integration)', function() {
       env.addAsyncMatchers({
         toBeReal: function() {
           return {
-            compare: function() { return Promise.resolve({ pass: true }); },
+            compare: function() {
-            negativeCompare: function() { return Promise.resolve({ pass: true }); }
+              return Promise.resolve({ pass: true });
+            },
+            negativeCompare: function() {
+              return Promise.resolve({ pass: true });
+            }
           };
         }
       });
@@ -74,7 +82,9 @@ describe('Custom Async Matchers (Integration)', function() {
     });
 
     var specExpectations = function(result) {
-      expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
+      expect(result.failedExpectations[0].message).toEqual(
+        "Expected 'a' to be real."
+      );
     };
 
     env.addReporter({ specDone: specExpectations });
@@ -82,22 +92,24 @@ describe('Custom Async Matchers (Integration)', function() {
   });
 
   // TODO: remove this in the next major release.
-  it("passes the jasmine utility and current equality testers to the matcher factory", function(done) {
+  it('passes the jasmine utility and current equality testers to the matcher factory', function(done) {
     jasmine.getEnv().requirePromises();
 
-    var matcherFactory = function () {
+    var matcherFactory = function() {
         return {
-          compare: function () {
+          compare: function() {
-            return Promise.resolve({pass: true});
+            return Promise.resolve({ pass: true });
           }
         };
       },
-      matcherFactorySpy = jasmine.createSpy("matcherFactorySpy").and.callFake(matcherFactory),
+      matcherFactorySpy = jasmine
-      customEqualityFn = function () {
+        .createSpy('matcherFactorySpy')
+        .and.callFake(matcherFactory),
+      customEqualityFn = function() {
         return true;
       };
 
-    env.it("spec with expectation", function() {
+    env.it('spec with expectation', function() {
       env.addCustomEqualityTester(customEqualityFn);
       env.addAsyncMatchers({
         toBeReal: matcherFactorySpy
@@ -117,31 +129,35 @@ describe('Custom Async Matchers (Integration)', function() {
     env.execute(null, done);
   });
 
-  it("provides custom equality testers to the matcher factory via matchersUtil", function(done) {
+  it('provides custom equality testers to the matcher factory via matchersUtil', function(done) {
     jasmine.getEnv().requirePromises();
 
-    var matcherFactory = function (matchersUtil) {
+    var matcherFactory = function(matchersUtil) {
         return {
-          compare: function (actual, expected) {
+          compare: function(actual, expected) {
-            return Promise.resolve({pass: matchersUtil.equals(actual[0], expected)});
+            return Promise.resolve({
+              pass: matchersUtil.equals(actual[0], expected)
+            });
           }
         };
       },
-      customEqualityFn = jasmine.createSpy("customEqualityFn").and.callFake(function (a, b) {
+      customEqualityFn = jasmine
-        return a.toString() === b;
+        .createSpy('customEqualityFn')
-      });
+        .and.callFake(function(a, b) {
+          return a.toString() === b;
+        });
 
-    env.it("spec with expectation", function() {
+    env.it('spec with expectation', function() {
       env.addCustomEqualityTester(customEqualityFn);
       env.addAsyncMatchers({
         toBeArrayWithFirstElement: matcherFactory
       });
 
-      return env.expectAsync([1, 2]).toBeArrayWithFirstElement("1");
+      return env.expectAsync([1, 2]).toBeArrayWithFirstElement('1');
     });
 
     var specExpectations = function(result) {
-      expect(customEqualityFn).toHaveBeenCalledWith(1, "1");
+      expect(customEqualityFn).toHaveBeenCalledWith(1, '1');
       expect(result.failedExpectations).toEqual([]);
     };
 

spec/core/integration/CustomMatchersSpec.js

@@ -1,52 +1,65 @@
-describe("Custom Matchers (Integration)", function () {
+describe('Custom Matchers (Integration)', function() {
   var env;
   var fakeTimer;
 
-  beforeEach(function () {
+  beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
   afterEach(function() {
     env.cleanup_();
   });
 
-  it("allows adding more matchers local to a spec", function (done) {
+  it('allows adding more matchers local to a spec', function(done) {
-    env.it('spec defining a custom matcher', function () {
+    env.it('spec defining a custom matcher', function() {
       env.addMatchers({
-        matcherForSpec: function () {
+        matcherForSpec: function() {
           return {
-            compare: function (actual, expected) {
+            compare: function(actual, expected) {
-              return {pass: false, message: "matcherForSpec: actual: " + actual + "; expected: " + expected};
+              return {
+                pass: false,
+                message:
+                  'matcherForSpec: actual: ' +
+                  actual +
+                  '; expected: ' +
+                  expected
+              };
             }
-          }
+          };
         }
       });
 
-      env.expect("zzz").matcherForSpec("yyy");
+      env.expect('zzz').matcherForSpec('yyy');
     });
 
-    env.it("spec without custom matcher defined", function() {
+    env.it('spec without custom matcher defined', function() {
-      expect(env.expect("zzz").matcherForSpec).toBeUndefined();
+      expect(env.expect('zzz').matcherForSpec).toBeUndefined();
     });
 
-    var specDoneSpy = jasmine.createSpy("specDoneSpy");
+    var specDoneSpy = jasmine.createSpy('specDoneSpy');
     var expectations = function() {
       var firstSpecResult = specDoneSpy.calls.first().args[0];
-      expect(firstSpecResult.status).toEqual("failed");
+      expect(firstSpecResult.status).toEqual('failed');
-      expect(firstSpecResult.failedExpectations[0].message).toEqual("matcherForSpec: actual: zzz; expected: yyy");
+      expect(firstSpecResult.failedExpectations[0].message).toEqual(
+        'matcherForSpec: actual: zzz; expected: yyy'
+      );
       done();
     };
-    env.addReporter({ specDone:specDoneSpy });
+    env.addReporter({ specDone: specDoneSpy });
 
     env.execute(null, expectations);
   });
 
-  it("passes the spec if the custom matcher passes", function(done) {
+  it('passes the spec if the custom matcher passes', function(done) {
-    env.it("spec using custom matcher", function() {
+    env.it('spec using custom matcher', function() {
       env.addMatchers({
         toBeReal: function() {
-          return { compare: function() { return { pass: true }; } };
+          return {
+            compare: function() {
+              return { pass: true };
+            }
+          };
         }
       });
 
@@ -61,20 +74,30 @@ describe("Custom Matchers (Integration)", function () {
     env.execute(null, done);
   });
 
-  it("passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers", function(done) {
+  it('passes the spec if the custom equality matcher passes for types nested inside asymmetric equality testers', function(done) {
-    env.it("spec using custom equality matcher", function() {
+    env.it('spec using custom equality matcher', function() {
       var customEqualityFn = function(a, b) {
         // All "foo*" strings match each other.
-        if (typeof a == "string" && typeof b == "string" &&
+        if (
-            a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
+          typeof a == 'string' &&
+          typeof b == 'string' &&
+          a.substr(0, 3) == 'foo' &&
+          b.substr(0, 3) == 'foo'
+        ) {
           return true;
         }
       };
 
       env.addCustomEqualityTester(customEqualityFn);
-      env.expect({foo: 'fooValue'}).toEqual(jasmineUnderTest.objectContaining({foo: 'fooBar'}));
+      env
-      env.expect(['fooValue', 'things']).toEqual(jasmineUnderTest.arrayContaining(['fooBar']));
+        .expect({ foo: 'fooValue' })
-      env.expect(['fooValue']).toEqual(jasmineUnderTest.arrayWithExactContents(['fooBar']));
+        .toEqual(jasmineUnderTest.objectContaining({ foo: 'fooBar' }));
+      env
+        .expect(['fooValue', 'things'])
+        .toEqual(jasmineUnderTest.arrayContaining(['fooBar']));
+      env
+        .expect(['fooValue'])
+        .toEqual(jasmineUnderTest.arrayWithExactContents(['fooBar']));
     });
 
     var specExpectations = function(result) {
@@ -85,26 +108,30 @@ describe("Custom Matchers (Integration)", function () {
     env.execute(null, done);
   });
 
-  it("supports asymmetric equality testers that take a list of custom equality testers", function(done) {
+  it('supports asymmetric equality testers that take a list of custom equality testers', function(done) {
     // TODO: remove this in the next major release.
     spyOn(jasmineUnderTest, 'getEnv').and.returnValue(env);
 
-    env.it("spec using custom asymmetric equality tester", function() {
+    env.it('spec using custom asymmetric equality tester', function() {
       var customEqualityFn = function(a, b) {
-        if (a === 2 && b === "two") {
+        if (a === 2 && b === 'two') {
           return true;
         }
       };
       var arrayWithFirstElement = function(sample) {
         return {
-          asymmetricMatch: function (actual, customEqualityTesters) {
+          asymmetricMatch: function(actual, customEqualityTesters) {
-            return jasmineUnderTest.matchersUtil.equals(sample, actual[0], customEqualityTesters);
+            return jasmineUnderTest.matchersUtil.equals(
+              sample,
+              actual[0],
+              customEqualityTesters
+            );
           }
         };
       };
 
       env.addCustomEqualityTester(customEqualityFn);
-      env.expect(["two"]).toEqual(arrayWithFirstElement(2));
+      env.expect(['two']).toEqual(arrayWithFirstElement(2));
     });
 
     var specExpectations = function(result) {
@@ -115,8 +142,8 @@ describe("Custom Matchers (Integration)", function () {
     env.execute(null, done);
   });
 
-  it("displays an appropriate failure message if a custom equality matcher fails", function(done) {
+  it('displays an appropriate failure message if a custom equality matcher fails', function(done) {
-    env.it("spec using custom equality matcher", function() {
+    env.it('spec using custom equality matcher', function() {
       var customEqualityFn = function(a, b) {
         // "foo" is not equal to anything
         if (a === 'foo' || b === 'foo') {
@@ -125,7 +152,7 @@ describe("Custom Matchers (Integration)", function () {
       };
 
       env.addCustomEqualityTester(customEqualityFn);
-      env.expect({foo: 'foo'}).toEqual({foo: 'foo'});
+      env.expect({ foo: 'foo' }).toEqual({ foo: 'foo' });
     });
 
     var specExpectations = function(result) {
@@ -139,13 +166,17 @@ describe("Custom Matchers (Integration)", function () {
     env.execute(null, done);
   });
 
-  it("uses the negative compare function for a negative comparison, if provided", function(done) {
+  it('uses the negative compare function for a negative comparison, if provided', function(done) {
-    env.it("spec with custom negative comparison matcher", function() {
+    env.it('spec with custom negative comparison matcher', function() {
       env.addMatchers({
         toBeReal: function() {
           return {
-            compare: function() { return { pass: true }; },
+            compare: function() {
-            negativeCompare: function() { return { pass: true }; }
+              return { pass: true };
+            },
+            negativeCompare: function() {
+              return { pass: true };
+            }
           };
         }
       });
@@ -161,7 +192,7 @@ describe("Custom Matchers (Integration)", function () {
     env.execute(null, done);
   });
 
-  it("generates messages with the same rules as built in matchers absent a custom message", function(done) {
+  it('generates messages with the same rules as built in matchers absent a custom message', function(done) {
     env.it('spec with an expectation', function() {
       env.addMatchers({
         toBeReal: function() {
@@ -169,25 +200,29 @@ describe("Custom Matchers (Integration)", function () {
             compare: function() {
               return { pass: false };
             }
-          }
+          };
         }
       });
 
-      env.expect("a").toBeReal();
+      env.expect('a').toBeReal();
     });
 
     var specExpectations = function(result) {
-      expect(result.failedExpectations[0].message).toEqual("Expected 'a' to be real.");
+      expect(result.failedExpectations[0].message).toEqual(
+        "Expected 'a' to be real."
+      );
     };
 
     env.addReporter({ specDone: specExpectations });
     env.execute(null, done);
   });
 
-  it("passes the expected and actual arguments to the comparison function", function(done) {
+  it('passes the expected and actual arguments to the comparison function', function(done) {
-    var argumentSpy = jasmine.createSpy("argument spy").and.returnValue({ pass: true });
+    var argumentSpy = jasmine
+      .createSpy('argument spy')
+      .and.returnValue({ pass: true });
 
-    env.it('spec with an expectation', function () {
+    env.it('spec with an expectation', function() {
       env.addMatchers({
         toBeReal: function() {
           return { compare: argumentSpy };
@@ -195,14 +230,14 @@ describe("Custom Matchers (Integration)", function () {
       });
 
       env.expect(true).toBeReal();
-      env.expect(true).toBeReal("arg");
+      env.expect(true).toBeReal('arg');
-      env.expect(true).toBeReal("arg1", "arg2");
+      env.expect(true).toBeReal('arg1', 'arg2');
     });
 
     var specExpectations = function() {
       expect(argumentSpy).toHaveBeenCalledWith(true);
-      expect(argumentSpy).toHaveBeenCalledWith(true, "arg");
+      expect(argumentSpy).toHaveBeenCalledWith(true, 'arg');
-      expect(argumentSpy).toHaveBeenCalledWith(true, "arg1", "arg2");
+      expect(argumentSpy).toHaveBeenCalledWith(true, 'arg1', 'arg2');
     };
 
     env.addReporter({ specDone: specExpectations });
@@ -210,13 +245,22 @@ describe("Custom Matchers (Integration)", function () {
   });
 
   // TODO: remove this in the next major release.
-  it("passes the jasmine utility and current equality testers to the matcher factory", function(done) {
+  it('passes the jasmine utility and current equality testers to the matcher factory', function(done) {
-    var matcherFactory = function() { return { compare: function() { return {pass: true}; }}; },
+    var matcherFactory = function() {
-        matcherFactorySpy = jasmine.createSpy("matcherFactorySpy").and.callFake(matcherFactory),
+        return {
-        customEqualityFn = function() { return true; };
+          compare: function() {
+            return { pass: true };
+          }
+        };
+      },
+      matcherFactorySpy = jasmine
+        .createSpy('matcherFactorySpy')
+        .and.callFake(matcherFactory),
+      customEqualityFn = function() {
+        return true;
+      };
 
-
+    env.it('spec with expectation', function() {
-    env.it("spec with expectation", function() {
       env.addCustomEqualityTester(customEqualityFn);
       env.addMatchers({
         toBeReal: matcherFactorySpy
@@ -236,33 +280,35 @@ describe("Custom Matchers (Integration)", function () {
     env.execute(null, done);
   });
 
-  it("provides custom equality testers to the matcher factory via matchersUtil", function (done) {
+  it('provides custom equality testers to the matcher factory via matchersUtil', function(done) {
-    var matcherFactory = function (matchersUtil) {
+    var matcherFactory = function(matchersUtil) {
         return {
-          compare: function (actual, expected) {
+          compare: function(actual, expected) {
-            return {pass: matchersUtil.equals(actual[0], expected)};
+            return { pass: matchersUtil.equals(actual[0], expected) };
           }
         };
       },
-      customEqualityFn = jasmine.createSpy("customEqualityFn").and.callFake(function (a, b) {
+      customEqualityFn = jasmine
-        return a.toString() === b;
+        .createSpy('customEqualityFn')
-      });
+        .and.callFake(function(a, b) {
+          return a.toString() === b;
+        });
 
-    env.it("spec with expectation", function () {
+    env.it('spec with expectation', function() {
       env.addCustomEqualityTester(customEqualityFn);
       env.addMatchers({
         toBeArrayWithFirstElement: matcherFactory
       });
 
-      env.expect([1, 2]).toBeArrayWithFirstElement("1");
+      env.expect([1, 2]).toBeArrayWithFirstElement('1');
     });
 
-    var specExpectations = function (result) {
+    var specExpectations = function(result) {
-      expect(customEqualityFn).toHaveBeenCalledWith(1, "1");
+      expect(customEqualityFn).toHaveBeenCalledWith(1, '1');
       expect(result.failedExpectations).toEqual([]);
     };
 
-    env.addReporter({specDone: specExpectations});
+    env.addReporter({ specDone: specExpectations });
     env.execute(null, done);
   });
 });

spec/core/integration/CustomObjectFormatterSpec.js

@@ -1,14 +1,16 @@
-describe("Custom object formatters", function() {
+describe('Custom object formatters', function() {
   var env;
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
-  it("scopes custom object formatters to a spec", function(done) {
+  it('scopes custom object formatters to a spec', function(done) {
     env.it('a spec with custom pretty-printer', function() {
-      env.addCustomObjectFormatter(function(obj) { return 'custom(' + obj + ')'; });
+      env.addCustomObjectFormatter(function(obj) {
+        return 'custom(' + obj + ')';
+      });
       env.expect(42).toBeUndefined();
     });
 
@@ -21,23 +23,29 @@ describe("Custom object formatters", function() {
       specResults.push(result);
     };
     var expectations = function() {
-      expect(specResults[0].failedExpectations[0].message).toEqual("Expected custom(42) to be undefined.");
+      expect(specResults[0].failedExpectations[0].message).toEqual(
-      expect(specResults[1].failedExpectations[0].message).toEqual("Expected 42 to be undefined.");
+        'Expected custom(42) to be undefined.'
+      );
+      expect(specResults[1].failedExpectations[0].message).toEqual(
+        'Expected 42 to be undefined.'
+      );
       done();
     };
-    env.addReporter({ specDone:specDone });
+    env.addReporter({ specDone: specDone });
 
     env.execute(null, expectations);
   });
 
-  it("scopes custom object formatters to a suite", function(done) {
+  it('scopes custom object formatters to a suite', function(done) {
     env.it('a spec without custom pretty-printer', function() {
       env.expect(42).toBeUndefined();
     });
 
     env.describe('with custom pretty-printer', function() {
       env.beforeEach(function() {
-        env.addCustomObjectFormatter(function(obj) { return 'custom(' + obj + ')'; });
+        env.addCustomObjectFormatter(function(obj) {
+          return 'custom(' + obj + ')';
+        });
       });
 
       env.it('a spec', function() {
@@ -50,18 +58,24 @@ describe("Custom object formatters", function() {
       specResults.push(result);
     };
     var expectations = function() {
-      expect(specResults[0].failedExpectations[0].message).toEqual("Expected 42 to be undefined.");
+      expect(specResults[0].failedExpectations[0].message).toEqual(
-      expect(specResults[1].failedExpectations[0].message).toEqual("Expected custom(42) to be undefined.");
+        'Expected 42 to be undefined.'
+      );
+      expect(specResults[1].failedExpectations[0].message).toEqual(
+        'Expected custom(42) to be undefined.'
+      );
       done();
     };
-    env.addReporter({ specDone:specDone });
+    env.addReporter({ specDone: specDone });
 
     env.execute(null, expectations);
   });
 
-  it("throws an exception if you try to add a custom object formatter outside a runable", function() {
+  it('throws an exception if you try to add a custom object formatter outside a runable', function() {
     expect(function() {
       env.addCustomObjectFormatter(function() {});
-    }).toThrowError('Custom object formatters must be added in a before function or a spec')
+    }).toThrowError(
+      'Custom object formatters must be added in a before function or a spec'
+    );
   });
 });

spec/core/integration/CustomSpyStrategiesSpec.js

@@ -3,7 +3,7 @@ describe('Custom Spy Strategies (Integration)', function() {
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
   afterEach(function() {
@@ -11,10 +11,8 @@ describe('Custom Spy Strategies (Integration)', function() {
   });
 
   it('allows adding more strategies local to a suite', function(done) {
-    var plan = jasmine.createSpy('custom strategy plan')
+    var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
-      .and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
-    var strategy = jasmine.createSpy('custom strategy')
-      .and.returnValue(plan);
     var jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.describe('suite defining a custom spy strategy', function() {
@@ -45,10 +43,8 @@ describe('Custom Spy Strategies (Integration)', function() {
   });
 
   it('allows adding more strategies local to a spec', function(done) {
-    var plan = jasmine.createSpy('custom strategy plan')
+    var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
-      .and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
-    var strategy = jasmine.createSpy('custom strategy')
-      .and.returnValue(plan);
     var jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.it('spec defining a custom spy strategy', function() {
@@ -74,17 +70,17 @@ describe('Custom Spy Strategies (Integration)', function() {
   });
 
   it('allows using custom strategies on a per-argument basis', function(done) {
-    var plan = jasmine.createSpy('custom strategy plan')
+    var plan = jasmine.createSpy('custom strategy plan').and.returnValue(42);
-      .and.returnValue(42);
+    var strategy = jasmine.createSpy('custom strategy').and.returnValue(plan);
-    var strategy = jasmine.createSpy('custom strategy')
-      .and.returnValue(plan);
     var jasmineDone = jasmine.createSpy('jasmineDone');
 
     env.it('spec defining a custom spy strategy', function() {
       env.addSpyStrategy('frobnicate', strategy);
-      var spy = env.createSpy('something')
+      var spy = env
+        .createSpy('something')
         .and.returnValue('no args return')
-        .withArgs(1, 2, 3).and.frobnicate(17);
+        .withArgs(1, 2, 3)
+        .and.frobnicate(17);
 
       expect(spy()).toEqual('no args return');
       expect(plan).not.toHaveBeenCalled();
@@ -114,7 +110,6 @@ describe('Custom Spy Strategies (Integration)', function() {
       specDone = jasmine.createSpy('specDone'),
       jasmineDone = jasmine.createSpy('jasmineDone');
 
-
     env.beforeEach(function() {
       env.addSpyStrategy('frobnicate', strategy1);
       env.addSpyStrategy('jiggle', strategy2);

spec/core/integration/DefaultSpyStrategySpec.js

@@ -3,7 +3,7 @@ describe('Default Spy Strategy (Integration)', function() {
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
   afterEach(function() {
@@ -13,7 +13,7 @@ describe('Default Spy Strategy (Integration)', function() {
   it('allows defining a default spy strategy', function(done) {
     env.describe('suite with default strategy', function() {
       env.beforeEach(function() {
-        env.setDefaultSpyStrategy(function (and) {
+        env.setDefaultSpyStrategy(function(and) {
           and.returnValue(42);
         });
       });
@@ -40,12 +40,16 @@ describe('Default Spy Strategy (Integration)', function() {
     env.execute(null, expectations);
   });
 
-  it('uses the default spy strategy defined when the spy is created', function (done) {
+  it('uses the default spy strategy defined when the spy is created', function(done) {
     env.it('spec', function() {
       var a = env.createSpy('a');
-      env.setDefaultSpyStrategy(function (and) { and.returnValue(42); });
+      env.setDefaultSpyStrategy(function(and) {
+        and.returnValue(42);
+      });
       var b = env.createSpy('b');
-      env.setDefaultSpyStrategy(function (and) { and.stub(); });
+      env.setDefaultSpyStrategy(function(and) {
+        and.stub();
+      });
       var c = env.createSpy('c');
       env.setDefaultSpyStrategy();
       var d = env.createSpy('d');

spec/core/integration/MatchersSpec.js

@@ -23,7 +23,9 @@ describe('Matchers (Integration)', function() {
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(0);
-        expect(result.failedExpectations[0] && result.failedExpectations[0].message)
+        expect(
+          result.failedExpectations[0] && result.failedExpectations[0].message
+        )
           .withContext('Failure message')
           .toBeUndefined();
       };
@@ -45,12 +47,17 @@ describe('Matchers (Integration)', function() {
           .withContext('Number of failed expectations')
           .toEqual(1);
         expect(result.failedExpectations[0].message)
-          .withContext('Failed with a thrown error rather than a matcher failure')
+          .withContext(
+            'Failed with a thrown error rather than a matcher failure'
+          )
           .not.toMatch(/^Error: /);
         expect(result.failedExpectations[0].message)
-          .withContext('Failed with a thrown type error rather than a matcher failure')
+          .withContext(
+            'Failed with a thrown type error rather than a matcher failure'
+          )
           .not.toMatch(/^TypeError: /);
-        expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
+        expect(result.failedExpectations[0].matcherName)
+          .withContext('Matcher name')
           .not.toEqual('');
       };
 
@@ -61,18 +68,19 @@ describe('Matchers (Integration)', function() {
 
   function verifyFailsWithCustomObjectFormatters(config) {
     it('uses custom object formatters', function(done) {
-      env.it('a spec', function () {
+      env.it('a spec', function() {
         env.addCustomObjectFormatter(config.formatter);
         config.expectations(env);
       });
 
-      var specExpectations = function (result) {
+      var specExpectations = function(result) {
         expect(result.status).toEqual('failed');
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(1);
-        expect(result.failedExpectations[0].message)
+        expect(result.failedExpectations[0].message).toEqual(
-          .toEqual(config.expectedMessage);
+          config.expectedMessage
+        );
       };
 
       env.addReporter({ specDone: specExpectations });
@@ -96,7 +104,9 @@ describe('Matchers (Integration)', function() {
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(0);
-        expect(result.failedExpectations[0] && result.failedExpectations[0].message)
+        expect(
+          result.failedExpectations[0] && result.failedExpectations[0].message
+        )
           .withContext('Failure message')
           .toBeUndefined();
       };
@@ -120,9 +130,12 @@ describe('Matchers (Integration)', function() {
           .withContext('Number of failed expectations')
           .toEqual(1);
         expect(result.failedExpectations[0].message)
-          .withContext('Failed with a thrown error rather than a matcher failure')
+          .withContext(
+            'Failed with a thrown error rather than a matcher failure'
+          )
           .not.toMatch(/^Error: /);
-        expect(result.failedExpectations[0].matcherName).withContext('Matcher name')
+        expect(result.failedExpectations[0].matcherName)
+          .withContext('Matcher name')
           .not.toEqual('');
       };
 
@@ -135,18 +148,19 @@ describe('Matchers (Integration)', function() {
     it('uses custom object formatters', function(done) {
       var env = new jasmineUnderTest.Env();
       jasmine.getEnv().requirePromises();
-      env.it('a spec', function () {
+      env.it('a spec', function() {
         env.addCustomObjectFormatter(config.formatter);
         return config.expectations(env);
       });
 
-      var specExpectations = function (result) {
+      var specExpectations = function(result) {
         expect(result.status).toEqual('failed');
         expect(result.failedExpectations.length)
           .withContext('Number of failed expectations')
           .toEqual(1);
-        expect(result.failedExpectations[0].message)
+        expect(result.failedExpectations[0].message).toEqual(
-          .toEqual(config.expectedMessage);
+          config.expectedMessage
+        );
       };
 
       env.addReporter({ specDone: specExpectations });
@@ -154,7 +168,6 @@ describe('Matchers (Integration)', function() {
     });
   }
 
-
   describe('nothing', function() {
     verifyPasses(function(env) {
       env.expect().nothing();
@@ -330,16 +343,18 @@ describe('Matchers (Integration)', function() {
         env.expect(1).toBePositiveInfinity();
       },
       expectedMessage: 'Expected |1| to be Infinity.'
-    })
+    });
   });
 
   describe('toBeResolved', function() {
     verifyPassesAsync(function(env) {
-      return env.expectAsync(Promise.resolve()).toBeResolved(); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve()).toBeResolved();
     });
 
     verifyFailsAsync(function(env) {
-      return env.expectAsync(Promise.reject()).toBeResolved(); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.reject()).toBeResolved();
     });
   });
 
@@ -348,11 +363,13 @@ describe('Matchers (Integration)', function() {
       env.addCustomEqualityTester(function(a, b) {
         return a.toString() === b.toString();
       });
-      return env.expectAsync(Promise.resolve('5')).toBeResolvedTo(5); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve('5')).toBeResolvedTo(5);
     });
 
     verifyFailsAsync(function(env) {
-      return env.expectAsync(Promise.resolve('foo')).toBeResolvedTo('bar'); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve('foo')).toBeResolvedTo('bar');
     });
 
     verifyFailsWithCustomObjectFormattersAsync({
@@ -360,20 +377,24 @@ describe('Matchers (Integration)', function() {
         return '|' + val + '|';
       },
       expectations: function(env) {
-        return env.expectAsync(Promise.resolve('x')).toBeResolvedTo('y'); // eslint-disable-line compat/compat
+        // eslint-disable-next-line compat/compat
+        return env.expectAsync(Promise.resolve('x')).toBeResolvedTo('y');
       },
-      expectedMessage: 'Expected a promise to be resolved to |y| ' +
+      expectedMessage:
+        'Expected a promise to be resolved to |y| ' +
         'but it was resolved to |x|.'
     });
   });
 
   describe('toBeRejected', function() {
     verifyPassesAsync(function(env) {
-      return env.expectAsync(Promise.reject('nope')).toBeRejected(); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.reject('nope')).toBeRejected();
     });
 
     verifyFailsAsync(function(env) {
-      return env.expectAsync(Promise.resolve()).toBeRejected(); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve()).toBeRejected();
     });
   });
 
@@ -382,11 +403,13 @@ describe('Matchers (Integration)', function() {
       env.addCustomEqualityTester(function(a, b) {
         return a.toString() === b.toString();
       });
-      return env.expectAsync(Promise.reject('5')).toBeRejectedWith(5); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.reject('5')).toBeRejectedWith(5);
     });
 
     verifyFailsAsync(function(env) {
-      return env.expectAsync(Promise.resolve()).toBeRejectedWith('nope'); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve()).toBeRejectedWith('nope');
     });
 
     verifyFailsWithCustomObjectFormattersAsync({
@@ -394,20 +417,28 @@ describe('Matchers (Integration)', function() {
         return '|' + val + '|';
       },
       expectations: function(env) {
-        return env.expectAsync(Promise.reject('x')).toBeRejectedWith('y'); // eslint-disable-line compat/compat
+        // eslint-disable-next-line compat/compat
+        return env.expectAsync(Promise.reject('x')).toBeRejectedWith('y');
       },
-      expectedMessage: 'Expected a promise to be rejected with |y| ' +
+      expectedMessage:
+        'Expected a promise to be rejected with |y| ' +
         'but it was rejected with |x|.'
     });
   });
 
   describe('toBeRejectedWithError', function() {
     verifyPassesAsync(function(env) {
-      return env.expectAsync(Promise.reject(new Error())).toBeRejectedWithError(Error); // eslint-disable-line compat/compat
+      return (
+        env
+          // eslint-disable-next-line compat/compat
+          .expectAsync(Promise.reject(new Error()))
+          .toBeRejectedWithError(Error)
+      );
     });
 
     verifyFailsAsync(function(env) {
-      return env.expectAsync(Promise.resolve()).toBeRejectedWithError(Error); // eslint-disable-line compat/compat
+      // eslint-disable-next-line compat/compat
+      return env.expectAsync(Promise.resolve()).toBeRejectedWithError(Error);
     });
 
     verifyFailsWithCustomObjectFormattersAsync({
@@ -415,9 +446,15 @@ describe('Matchers (Integration)', function() {
         return '|' + val + '|';
       },
       expectations: function(env) {
-        return env.expectAsync(Promise.reject('foo')).toBeRejectedWithError('foo'); // eslint-disable-line compat/compat
+        return (
+          env
+            // eslint-disable-next-line compat/compat
+            .expectAsync(Promise.reject('foo'))
+            .toBeRejectedWithError('foo')
+        );
       },
-      expectedMessage: 'Expected a promise to be rejected with Error: |foo| ' +
+      expectedMessage:
+        'Expected a promise to be rejected with Error: |foo| ' +
         'but it was rejected with |foo|.'
     });
   });
@@ -486,7 +523,7 @@ describe('Matchers (Integration)', function() {
         }
       },
       expectations: function(env) {
-        env.expect([{foo: 4}]).toEqual([{foo: 5}]);
+        env.expect([{ foo: 4 }]).toEqual([{ foo: 5 }]);
       },
       expectedMessage: 'Expected $[0].foo = four to equal five.'
     });
@@ -494,11 +531,11 @@ describe('Matchers (Integration)', function() {
 
   describe('toHaveSize', function() {
     verifyPasses(function(env) {
-      env.expect(['a','b']).toHaveSize(2);
+      env.expect(['a', 'b']).toHaveSize(2);
     });
 
     verifyFails(function(env) {
-      env.expect(['a','b']).toHaveSize(1);
+      env.expect(['a', 'b']).toHaveSize(1);
     });
   });
 
@@ -517,14 +554,16 @@ describe('Matchers (Integration)', function() {
 
   describe('toHaveBeenCalledBefore', function() {
     verifyPasses(function(env) {
-      var a = env.createSpy('a'), b = env.createSpy('b');
+      var a = env.createSpy('a'),
+        b = env.createSpy('b');
       a();
       b();
       env.expect(a).toHaveBeenCalledBefore(b);
     });
 
     verifyFails(function(env) {
-      var a = env.createSpy('a'), b = env.createSpy('b');
+      var a = env.createSpy('a'),
+        b = env.createSpy('b');
       b();
       a();
       env.expect(a).toHaveBeenCalledBefore(b);
@@ -567,7 +606,8 @@ describe('Matchers (Integration)', function() {
         var spy = env.createSpy('foo');
         env.expect(spy).toHaveBeenCalledWith('x');
       },
-      expectedMessage: 'Expected spy foo to have been called with:\n' +
+      expectedMessage:
+        'Expected spy foo to have been called with:\n' +
         '  |x|\n' +
         'but it was never called.'
     });
@@ -622,7 +662,11 @@ describe('Matchers (Integration)', function() {
       env.addCustomEqualityTester(function(a, b) {
         return a.toString() === b.toString();
       });
-      env.expect(function() { throw '5'; }).toThrow(5);
+      env
+        .expect(function() {
+          throw '5';
+        })
+        .toThrow(5);
     });
 
     verifyFails(function(env) {
@@ -635,9 +679,11 @@ describe('Matchers (Integration)', function() {
       },
       expectations: function(env) {
         var spy = env.createSpy('foo');
-        env.expect(function() {
+        env
-          throw 'x'
+          .expect(function() {
-        }).not.toThrow();
+            throw 'x';
+          })
+          .not.toThrow();
       },
       expectedMessage: 'Expected function not to throw, but it threw |x|.'
     });
@@ -645,11 +691,15 @@ describe('Matchers (Integration)', function() {
 
   describe('toThrowError', function() {
     verifyPasses(function(env) {
-      env.expect(function() { throw new Error(); }).toThrowError();
+      env
+        .expect(function() {
+          throw new Error();
+        })
+        .toThrowError();
     });
 
     verifyFails(function(env) {
-      env.expect(function() { }).toThrowError();
+      env.expect(function() {}).toThrowError();
     });
 
     verifyFailsWithCustomObjectFormatters({
@@ -658,9 +708,11 @@ describe('Matchers (Integration)', function() {
       },
       expectations: function(env) {
         var spy = env.createSpy('foo');
-        env.expect(function() {
+        env
-          throw 'x'
+          .expect(function() {
-        }).toThrowError();
+            throw 'x';
+          })
+          .toThrowError();
       },
       expectedMessage: 'Expected function to throw an Error, but it threw |x|.'
     });
@@ -672,11 +724,15 @@ describe('Matchers (Integration)', function() {
     }
 
     verifyPasses(function(env) {
-      env.expect(throws).toThrowMatching(function() { return true; });
+      env.expect(throws).toThrowMatching(function() {
+        return true;
+      });
     });
 
     verifyFails(function(env) {
-      env.expect(throws).toThrowMatching(function() { return false; });
+      env.expect(throws).toThrowMatching(function() {
+        return false;
+      });
     });
 
     verifyFailsWithCustomObjectFormatters({
@@ -685,13 +741,16 @@ describe('Matchers (Integration)', function() {
       },
       expectations: function(env) {
         var spy = env.createSpy('foo');
-        env.expect(function() {
+        env
-          throw new Error('nope')
+          .expect(function() {
-        }).toThrowMatching(function() {
+            throw new Error('nope');
-          return false;
+          })
-        });
+          .toThrowMatching(function() {
+            return false;
+          });
       },
-      expectedMessage: 'Expected function to throw an exception matching ' +
+      expectedMessage:
+        'Expected function to throw an exception matching ' +
         'a predicate, but it threw Error with message |nope|.'
     });
   });

spec/core/integration/SpecRunningSpec.js

@@ -1,10 +1,10 @@
-describe("spec running", function () {
+describe('spec running', function() {
   var env;
 
   beforeEach(function() {
     jasmine.getEnv().registerIntegrationMatchers();
     env = new jasmineUnderTest.Env();
-    env.configure({random: false});
+    env.configure({ random: false });
   });
 
   afterEach(function() {
@@ -14,18 +14,13 @@ describe("spec running", function () {
   it('should assign spec ids sequentially', function() {
     var it0, it1, it2, it3, it4;
     env.describe('test suite', function() {
-      it0 = env.it('spec 0', function() {
+      it0 = env.it('spec 0', function() {});
-      });
+      it1 = env.it('spec 1', function() {});
-      it1 = env.it('spec 1', function() {
+      it2 = env.xit('spec 2', function() {});
-      });
+      it3 = env.it('spec 3', 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() {
+      it4 = env.it('spec 4', function() {});
-      });
     });
 
     expect(it0.id).toEqual('spec0');
@@ -35,29 +30,28 @@ describe("spec running", function () {
     expect(it4.id).toEqual('spec4');
   });
 
-  it('nested suites', function (done) {
+  it('nested suites', function(done) {
-
     var foo = 0;
     var bar = 0;
     var baz = 0;
     var quux = 0;
-    var nested = env.describe('suite', function () {
+    var nested = env.describe('suite', function() {
-      env.describe('nested', function () {
+      env.describe('nested', function() {
-        env.it('should run nested suites', function () {
+        env.it('should run nested suites', function() {
           foo++;
         });
-        env.it('should run nested suites', function () {
+        env.it('should run nested suites', function() {
           bar++;
         });
       });
 
-      env.describe('nested 2', function () {
+      env.describe('nested 2', function() {
-        env.it('should run suites following nested suites', function () {
+        env.it('should run suites following nested suites', function() {
           baz++;
         });
       });
 
-      env.it('should run tests following nested suites', function () {
+      env.it('should run tests following nested suites', function() {
         quux++;
       });
     });
@@ -76,14 +70,14 @@ describe("spec running", function () {
     });
   });
 
-  it("should permit nested describes", function(done) {
+  it('should permit nested describes', function(done) {
     var actions = [];
 
-    env.beforeEach(function () {
+    env.beforeEach(function() {
       actions.push('topSuite beforeEach');
     });
 
-    env.afterEach(function () {
+    env.afterEach(function() {
       actions.push('topSuite afterEach');
     });
 
@@ -135,40 +129,40 @@ describe("spec running", function () {
 
     env.execute(null, function() {
       var expected = [
-        "topSuite beforeEach",
+        'topSuite beforeEach',
-        "outer beforeEach",
+        'outer beforeEach',
-        "outer it 1",
+        'outer it 1',
-        "outer afterEach",
+        'outer afterEach',
-        "topSuite afterEach",
+        'topSuite afterEach',
 
-        "topSuite beforeEach",
+        'topSuite beforeEach',
-        "outer beforeEach",
+        'outer beforeEach',
-        "inner 1 beforeEach",
+        'inner 1 beforeEach',
-        "inner 1 it",
+        'inner 1 it',
-        "inner 1 afterEach",
+        'inner 1 afterEach',
-        "outer afterEach",
+        'outer afterEach',
-        "topSuite afterEach",
+        'topSuite afterEach',
 
-        "topSuite beforeEach",
+        'topSuite beforeEach',
-        "outer beforeEach",
+        'outer beforeEach',
-        "outer it 2",
+        'outer it 2',
-        "outer afterEach",
+        'outer afterEach',
-        "topSuite afterEach",
+        'topSuite afterEach',
 
-        "topSuite beforeEach",
+        'topSuite beforeEach',
-        "outer beforeEach",
+        'outer beforeEach',
-        "inner 2 beforeEach",
+        'inner 2 beforeEach',
-        "inner 2 it",
+        'inner 2 it',
-        "inner 2 afterEach",
+        'inner 2 afterEach',
-        "outer afterEach",
+        'outer afterEach',
-        "topSuite afterEach"
+        'topSuite afterEach'
       ];
       expect(actions).toEqual(expected);
       done();
     });
   });
 
-  it("should run multiple befores and afters ordered so functions declared later are treated as more specific", function(done) {
+  it('should run multiple befores and afters ordered so functions declared later are treated as more specific', function(done) {
     var actions = [];
 
     env.beforeAll(function() {
@@ -187,19 +181,19 @@ describe("spec running", function () {
       actions.push('runner afterAll2');
     });
 
-    env.beforeEach(function () {
+    env.beforeEach(function() {
       actions.push('runner beforeEach1');
     });
 
-    env.afterEach(function () {
+    env.afterEach(function() {
       actions.push('runner afterEach1');
     });
 
-    env.beforeEach(function () {
+    env.beforeEach(function() {
       actions.push('runner beforeEach2');
     });
 
-    env.afterEach(function () {
+    env.afterEach(function() {
       actions.push('runner afterEach2');
     });
 
@@ -227,19 +221,19 @@ describe("spec running", function () {
 
     env.execute(null, function() {
       var expected = [
-        "runner beforeAll1",
+        'runner beforeAll1',
-        "runner beforeAll2",
+        'runner beforeAll2',
-        "runner beforeEach1",
+        'runner beforeEach1',
-        "runner beforeEach2",
+        'runner beforeEach2',
-        "beforeEach1",
+        'beforeEach1',
-        "beforeEach2",
+        'beforeEach2',
-        "outer it 1",
+        'outer it 1',
-        "afterEach2",
+        'afterEach2',
-        "afterEach1",
+        'afterEach1',
-        "runner afterEach2",
+        'runner afterEach2',
-        "runner afterEach1",
+        'runner afterEach1',
-        "runner afterAll2",
+        'runner afterAll2',
-        "runner afterAll1"
+        'runner afterAll1'
       ];
       expect(actions).toEqual(expected);
       done();
@@ -257,11 +251,11 @@ describe("spec running", function () {
       actions.push('runner afterAll');
     });
 
-    env.beforeEach(function () {
+    env.beforeEach(function() {
       actions.push('runner beforeEach');
     });
 
-    env.afterEach(function () {
+    env.afterEach(function() {
       actions.push('runner afterEach');
     });
 
@@ -289,15 +283,15 @@ describe("spec running", function () {
 
     env.execute(null, function() {
       var expected = [
-        "runner beforeAll",
+        'runner beforeAll',
-        "inner beforeAll",
+        'inner beforeAll',
-        "runner beforeEach",
+        'runner beforeEach',
-        "inner beforeEach",
+        'inner beforeEach',
-        "it",
+        'it',
-        "inner afterEach",
+        'inner afterEach',
-        "runner afterEach",
+        'runner afterEach',
-        "inner afterAll",
+        'inner afterAll',
-        "runner afterAll"
+        'runner afterAll'
       ];
       expect(actions).toEqual(expected);
       done();
@@ -317,11 +311,11 @@ describe("spec running", function () {
       actions.push('runner afterAll');
     });
 
-    env.beforeEach(function () {
+    env.beforeEach(function() {
       actions.push('runner beforeEach');
     });
 
-    env.afterEach(function () {
+    env.afterEach(function() {
       actions.push('runner afterEach');
     });
 
@@ -353,38 +347,38 @@ describe("spec running", function () {
 
     env.execute([spec2.id, spec.id], function() {
       var expected = [
-        "runner beforeAll",
+        'runner beforeAll',
-        "inner beforeAll",
+        'inner beforeAll',
-        "runner beforeEach",
+        'runner beforeEach',
-        "inner beforeEach",
+        'inner beforeEach',
-        "it2",
+        'it2',
-        "inner afterEach",
+        'inner afterEach',
-        "runner afterEach",
+        'runner afterEach',
 
-        "runner beforeEach",
+        'runner beforeEach',
-        "inner beforeEach",
+        'inner beforeEach',
-        "it",
+        'it',
-        "inner afterEach",
+        'inner afterEach',
-        "runner afterEach",
+        'runner afterEach',
-        "inner afterAll",
+        'inner afterAll',
-        "runner afterAll"
+        'runner afterAll'
       ];
       expect(actions).toEqual(expected);
       done();
     });
   });
 
-  it('only runs *Alls once in a focused suite', function(done){
+  it('only runs *Alls once in a focused suite', function(done) {
     var actions = [];
 
     env.fdescribe('Suite', function() {
-      env.beforeAll(function(){
+      env.beforeAll(function() {
         actions.push('beforeAll');
       });
       env.it('should run beforeAll once', function() {
         actions.push('spec');
       });
-      env.afterAll(function(){
+      env.afterAll(function() {
         actions.push('afterAll');
       });
     });
@@ -398,20 +392,28 @@ describe("spec running", function () {
   describe('focused runnables', function() {
     it('runs the relevant alls and eachs for each runnable', function(done) {
       var actions = [];
-      env.beforeAll(function() {actions.push('beforeAll')});
+      env.beforeAll(function() {
-      env.afterAll(function() {actions.push('afterAll')});
+        actions.push('beforeAll');
-      env.beforeEach(function() {actions.push('beforeEach')});
+      });
-      env.afterEach(function() {actions.push('afterEach')});
+      env.afterAll(function() {
+        actions.push('afterAll');
+      });
+      env.beforeEach(function() {
+        actions.push('beforeEach');
+      });
+      env.afterEach(function() {
+        actions.push('afterEach');
+      });
 
       env.fdescribe('a focused suite', function() {
         env.it('is run', function() {
-          actions.push('spec in fdescribe')
+          actions.push('spec in fdescribe');
         });
       });
 
       env.describe('an unfocused suite', function() {
         env.fit('has a focused spec', function() {
-          actions.push('focused spec')
+          actions.push('focused spec');
         });
       });
 
@@ -432,15 +434,15 @@ describe("spec running", function () {
       });
     });
 
-    it('focused specs in focused suites cause non-focused siblings to not run', function(done){
+    it('focused specs in focused suites cause non-focused siblings to not run', function(done) {
       var actions = [];
 
       env.fdescribe('focused suite', function() {
         env.it('unfocused spec', function() {
-          actions.push('unfocused spec')
+          actions.push('unfocused spec');
         });
         env.fit('focused spec', function() {
-          actions.push('focused spec')
+          actions.push('focused spec');
         });
       });
 
@@ -451,12 +453,12 @@ describe("spec running", function () {
       });
     });
 
-    it('focused suites in focused suites cause non-focused siblings to not run', function(done){
+    it('focused suites in focused suites cause non-focused siblings to not run', function(done) {
       var actions = [];
 
       env.fdescribe('focused suite', function() {
         env.it('unfocused spec', function() {
-          actions.push('unfocused spec')
+          actions.push('unfocused spec');
         });
         env.fdescribe('inner focused suite', function() {
           env.it('inner spec', function() {
@@ -477,7 +479,7 @@ describe("spec running", function () {
 
       env.fdescribe('focused suite', function() {
         env.it('unfocused spec', function() {
-          actions.push('unfocused spec')
+          actions.push('unfocused spec');
         });
         env.describe('inner focused suite', function() {
           env.fit('focused spec', function() {
@@ -495,12 +497,12 @@ describe("spec running", function () {
   });
 
   it("shouldn't run disabled suites", function(done) {
-    var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
+    var specInADisabledSuite = jasmine.createSpy('specInADisabledSuite'),
-    suite = env.describe('A Suite', function() {
+      suite = env.describe('A Suite', function() {
-      env.xdescribe('with a disabled suite', function(){
+        env.xdescribe('with a disabled suite', function() {
-        env.it('spec inside a disabled suite', specInADisabledSuite);
+          env.it('spec inside a disabled suite', specInADisabledSuite);
+        });
       });
-    });
 
     env.execute(null, function() {
       expect(specInADisabledSuite).not.toHaveBeenCalled();
@@ -509,16 +511,16 @@ describe("spec running", function () {
   });
 
   it("shouldn't run before/after functions in disabled suites", function(done) {
-    var shouldNotRun = jasmine.createSpy("shouldNotRun"),
+    var shouldNotRun = jasmine.createSpy('shouldNotRun'),
-    suite = env.xdescribe('A disabled Suite', function() {
+      suite = env.xdescribe('A disabled Suite', function() {
-      // None of the before/after functions should run.
+        // None of the before/after functions should run.
-      env.beforeAll(shouldNotRun);
+        env.beforeAll(shouldNotRun);
-      env.beforeEach(shouldNotRun);
+        env.beforeEach(shouldNotRun);
-      env.afterEach(shouldNotRun);
+        env.afterEach(shouldNotRun);
-      env.afterAll(shouldNotRun);
+        env.afterAll(shouldNotRun);
 
-      env.it('spec inside a disabled suite', shouldNotRun);
+        env.it('spec inside a disabled suite', shouldNotRun);
-    });
+      });
 
     env.execute(null, function() {
       expect(shouldNotRun).not.toHaveBeenCalled();
@@ -526,9 +528,9 @@ describe("spec running", function () {
     });
   });
 
-  it("should allow top level suites to be disabled", function(done) {
+  it('should allow top level suites to be disabled', function(done) {
-    var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
+    var specInADisabledSuite = jasmine.createSpy('specInADisabledSuite'),
-      otherSpec = jasmine.createSpy("otherSpec");
+      otherSpec = jasmine.createSpy('otherSpec');
 
     env.xdescribe('A disabled suite', function() {
       env.it('spec inside a disabled suite', specInADisabledSuite);
@@ -544,19 +546,19 @@ describe("spec running", function () {
     });
   });
 
-  it("should set all pending specs to pending when a suite is run", function(done) {
+  it('should set all pending specs to pending when a suite is run', function(done) {
     var pendingSpec,
       suite = env.describe('default current suite', function() {
-        pendingSpec = env.it("I am a pending spec");
+        pendingSpec = env.it('I am a pending spec');
       });
 
     env.execute(null, function() {
-      expect(pendingSpec.status()).toBe("pending");
+      expect(pendingSpec.status()).toBe('pending');
       done();
     });
   });
 
-  it("should recover gracefully when there are errors in describe functions", function(done) {
+  it('should recover gracefully when there are errors in describe functions', function(done) {
     var specs = [],
       reporter = jasmine.createSpyObj(['specDone', 'suiteDone']);
 
@@ -565,83 +567,95 @@ describe("spec running", function () {
     });
 
     expect(function() {
-      env.describe("outer1", function() {
+      env.describe('outer1', function() {
-        env.describe("inner1", function() {
+        env.describe('inner1', function() {
-          env.it("should thingy", function() {
+          env.it('should thingy', function() {
             this.expect(true).toEqual(true);
           });
 
-          throw new Error("inner error");
+          throw new Error('inner error');
         });
 
-        env.describe("inner2", function() {
+        env.describe('inner2', function() {
-          env.it("should other thingy", function() {
+          env.it('should other thingy', function() {
             this.expect(true).toEqual(true);
           });
         });
 
-        throw new Error("outer error");
+        throw new Error('outer error');
-
       });
     }).not.toThrow();
 
-    env.describe("outer2", function() {
+    env.describe('outer2', function() {
-      env.it("should xxx", function() {
+      env.it('should xxx', function() {
         this.expect(true).toEqual(true);
       });
     });
 
     env.addReporter(reporter);
     env.execute(null, function() {
-      expect(specs).toEqual(['outer1 inner1 should thingy', 'outer1 inner2 should other thingy', 'outer2 should xxx']);
+      expect(specs).toEqual([
-      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1 inner1', [/inner error/]);
+        'outer1 inner1 should thingy',
-      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1', [/outer error/]);
+        'outer1 inner2 should other thingy',
+        'outer2 should xxx'
+      ]);
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable(
+        'outer1 inner1',
+        [/inner error/]
+      );
+      expect(reporter.suiteDone).toHaveFailedExpectationsForRunnable('outer1', [
+        /outer error/
+      ]);
       done();
     });
   });
 
-  it("re-enters suites that have no *Alls", function(done) {
+  it('re-enters suites that have no *Alls', function(done) {
     var actions = [],
-        spec1, spec2, spec3;
+      spec1,
+      spec2,
+      spec3;
 
-    env.describe("top", function() {
+    env.describe('top', function() {
-      spec1 = env.it("spec1", function() {
+      spec1 = env.it('spec1', function() {
-        actions.push("spec1");
+        actions.push('spec1');
       });
 
-      spec2 = env.it("spec2", function() {
+      spec2 = env.it('spec2', function() {
-        actions.push("spec2");
+        actions.push('spec2');
       });
     });
 
-    spec3 = env.it("spec3", function() {
+    spec3 = env.it('spec3', function() {
-      actions.push("spec3");
+      actions.push('spec3');
     });
 
     env.execute([spec2.id, spec3.id, spec1.id], function() {
-      expect(actions).toEqual(["spec2", "spec3", "spec1"]);
+      expect(actions).toEqual(['spec2', 'spec3', 'spec1']);
       done();
     });
   });
 
-  it("refuses to re-enter suites with a beforeAll", function() {
+  it('refuses to re-enter suites with a beforeAll', function() {
     var actions = [],
-        spec1, spec2, spec3;
+      spec1,
+      spec2,
+      spec3;
 
-    env.describe("top", function() {
+    env.describe('top', function() {
       env.beforeAll(function() {});
 
-      spec1 = env.it("spec1", function() {
+      spec1 = env.it('spec1', function() {
-        actions.push("spec1");
+        actions.push('spec1');
       });
 
-      spec2 = env.it("spec2", function() {
+      spec2 = env.it('spec2', function() {
-        actions.push("spec2");
+        actions.push('spec2');
       });
     });
 
-    spec3 = env.it("spec3", function() {
+    spec3 = env.it('spec3', function() {
-      actions.push("spec3");
+      actions.push('spec3');
     });
 
     expect(function() {
@@ -650,24 +664,26 @@ describe("spec running", function () {
     expect(actions).toEqual([]);
   });
 
-  it("refuses to re-enter suites with a afterAll", function() {
+  it('refuses to re-enter suites with a afterAll', function() {
     var actions = [],
-        spec1, spec2, spec3;
+      spec1,
+      spec2,
+      spec3;
 
-    env.describe("top", function() {
+    env.describe('top', function() {
       env.afterAll(function() {});
 
-      spec1 = env.it("spec1", function() {
+      spec1 = env.it('spec1', function() {
-        actions.push("spec1");
+        actions.push('spec1');
       });
 
-      spec2 = env.it("spec2", function() {
+      spec2 = env.it('spec2', function() {
-        actions.push("spec2");
+        actions.push('spec2');
       });
     });
 
-    spec3 = env.it("spec3", function() {
+    spec3 = env.it('spec3', function() {
-      actions.push("spec3");
+      actions.push('spec3');
     });
 
     expect(function() {
@@ -676,15 +692,15 @@ describe("spec running", function () {
     expect(actions).toEqual([]);
   });
 
-  it("should run the tests in a consistent order when a seed is supplied", function(done) {
+  it('should run the tests in a consistent order when a seed is supplied', function(done) {
     var actions = [];
-    env.configure({random: true, seed: '123456'});
+    env.configure({ random: true, seed: '123456' });
 
-    env.beforeEach(function () {
+    env.beforeEach(function() {
       actions.push('topSuite beforeEach');
     });
 
-    env.afterEach(function () {
+    env.afterEach(function() {
       actions.push('topSuite afterEach');
     });
 
@@ -769,14 +785,14 @@ describe("spec running", function () {
     });
   });
 
-  describe("When throwOnExpectationFailure is set", function() {
+  describe('When throwOnExpectationFailure is set', function() {
-    it("skips to cleanup functions after an error", function(done) {
+    it('skips to cleanup functions after an error', function(done) {
       var actions = [];
 
       env.describe('Something', function() {
         env.beforeEach(function() {
           actions.push('outer beforeEach');
-          throw new Error("error");
+          throw new Error('error');
         });
 
         env.afterEach(function() {
@@ -792,13 +808,13 @@ describe("spec running", function () {
             actions.push('inner afterEach');
           });
 
-          env.it('does it' , function() {
+          env.it('does it', function() {
             actions.push('inner it');
           });
         });
       });
 
-      env.configure({oneFailurePerSpec: true});
+      env.configure({ oneFailurePerSpec: true });
 
       env.execute(null, function() {
         expect(actions).toEqual([
@@ -810,7 +826,7 @@ describe("spec running", function () {
       });
     });
 
-    it("skips to cleanup functions after done.fail is called", function(done) {
+    it('skips to cleanup functions after done.fail is called', function(done) {
       var actions = [];
 
       env.describe('Something', function() {
@@ -824,23 +840,20 @@ describe("spec running", function () {
           actions.push('afterEach');
         });
 
-        env.it('does it' , function() {
+        env.it('does it', function() {
           actions.push('it');
         });
       });
 
-      env.configure({oneFailurePerSpec: true});
+      env.configure({ oneFailurePerSpec: true });
 
       env.execute(null, function() {
-        expect(actions).toEqual([
+        expect(actions).toEqual(['beforeEach', 'afterEach']);
-          'beforeEach',
-          'afterEach'
-        ]);
         done();
       });
     });
 
-    it("skips to cleanup functions when an async function times out", function(done) {
+    it('skips to cleanup functions when an async function times out', function(done) {
       var actions = [];
 
       env.describe('Something', function() {
@@ -852,23 +865,20 @@ describe("spec running", function () {
           actions.push('afterEach');
         });
 
-        env.it('does it' , function() {
+        env.it('does it', function() {
           actions.push('it');
         });
       });
 
-      env.configure({oneFailurePerSpec: true});
+      env.configure({ oneFailurePerSpec: true });
 
       env.execute(null, function() {
-        expect(actions).toEqual([
+        expect(actions).toEqual(['beforeEach', 'afterEach']);
-          'beforeEach',
-          'afterEach'
-        ]);
         done();
       });
     });
 
-    it("skips to cleanup functions after an error with deprecations", function(done) {
+    it('skips to cleanup functions after an error with deprecations', function(done) {
       var actions = [];
 
       spyOn(env, 'deprecated');
@@ -876,7 +886,7 @@ describe("spec running", function () {
       env.describe('Something', function() {
         env.beforeEach(function() {
           actions.push('outer beforeEach');
-          throw new Error("error");
+          throw new Error('error');
         });
 
         env.afterEach(function() {
@@ -892,7 +902,7 @@ describe("spec running", function () {
             actions.push('inner afterEach');
           });
 
-          env.it('does it' , function() {
+          env.it('does it', function() {
             actions.push('inner it');
           });
         });
@@ -911,7 +921,7 @@ describe("spec running", function () {
       });
     });
 
-    it("skips to cleanup functions after done.fail is called with deprecations", function(done) {
+    it('skips to cleanup functions after done.fail is called with deprecations', function(done) {
       var actions = [];
 
       spyOn(env, 'deprecated');
@@ -927,7 +937,7 @@ describe("spec running", function () {
           actions.push('afterEach');
         });
 
-        env.it('does it' , function() {
+        env.it('does it', function() {
           actions.push('it');
         });
       });
@@ -935,16 +945,13 @@ describe("spec running", function () {
       env.throwOnExpectationFailure(true);
 
       env.execute(null, function() {
-        expect(actions).toEqual([
+        expect(actions).toEqual(['beforeEach', 'afterEach']);
-          'beforeEach',
-          'afterEach'
-        ]);
         expect(env.deprecated).toHaveBeenCalled();
         done();
       });
     });
 
-    it("skips to cleanup functions when an async function times out with deprecations", function(done) {
+    it('skips to cleanup functions when an async function times out with deprecations', function(done) {
       var actions = [];
 
       spyOn(env, 'deprecated');
@@ -958,7 +965,7 @@ describe("spec running", function () {
           actions.push('afterEach');
         });
 
-        env.it('does it' , function() {
+        env.it('does it', function() {
           actions.push('it');
         });
       });
@@ -966,18 +973,15 @@ describe("spec running", function () {
       env.throwOnExpectationFailure(true);
 
       env.execute(null, function() {
-        expect(actions).toEqual([
+        expect(actions).toEqual(['beforeEach', 'afterEach']);
-          'beforeEach',
-          'afterEach'
-        ]);
         expect(env.deprecated).toHaveBeenCalled();
         done();
       });
     });
   });
 
-  describe("when stopOnSpecFailure is on", function() {
+  describe('when stopOnSpecFailure is on', function() {
-    it("does not run further specs when one fails", function(done) {
+    it('does not run further specs when one fails', function(done) {
       var actions = [];
 
       env.describe('wrapper', function() {
@@ -993,7 +997,7 @@ describe("spec running", function () {
         });
       });
 
-      env.configure({random: false, failFast: true});
+      env.configure({ random: false, failFast: true });
 
       env.execute(null, function() {
         expect(actions).toEqual(['fails']);
@@ -1001,7 +1005,7 @@ describe("spec running", function () {
       });
     });
 
-    it("does not run further specs when one fails when configured with deprecated option", function(done) {
+    it('does not run further specs when one fails when configured with deprecated option', function(done) {
       var actions = [];
 
       spyOn(env, 'deprecated');
@@ -1019,7 +1023,7 @@ describe("spec running", function () {
         });
       });
 
-      env.configure({random: false});
+      env.configure({ random: false });
       env.stopOnSpecFailure(true);
 
       env.execute(null, function() {

spec/core/matchers/DiffBuilderSpec.js

@@ -1,132 +1,159 @@
-describe("DiffBuilder", function () {
+describe('DiffBuilder', function() {
-  it("records the actual and expected objects", function () {
+  it('records the actual and expected objects', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
-    diffBuilder.setRoots({x: 'actual'}, {x: 'expected'});
+    diffBuilder.setRoots({ x: 'actual' }, { x: 'expected' });
     diffBuilder.recordMismatch();
 
-    expect(diffBuilder.getMessage()).toEqual("Expected Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
+    expect(diffBuilder.getMessage()).toEqual(
+      "Expected Object({ x: 'actual' }) to equal Object({ x: 'expected' })."
+    );
   });
 
-  it("prints the path at which the difference was found", function () {
+  it('prints the path at which the difference was found', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
-    diffBuilder.setRoots({foo: {x: 'actual'}}, {foo: {x: 'expected'}});
+    diffBuilder.setRoots({ foo: { x: 'actual' } }, { foo: { x: 'expected' } });
 
-    diffBuilder.withPath('foo', function () {
+    diffBuilder.withPath('foo', function() {
       diffBuilder.recordMismatch();
     });
 
-    expect(diffBuilder.getMessage()).toEqual("Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
+    expect(diffBuilder.getMessage()).toEqual(
+      "Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' })."
+    );
   });
 
-  it("prints multiple messages, separated by newlines", function () {
+  it('prints multiple messages, separated by newlines', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
-    diffBuilder.setRoots({foo: 1, bar: 3}, {foo: 2, bar: 4});
+    diffBuilder.setRoots({ foo: 1, bar: 3 }, { foo: 2, bar: 4 });
 
-    diffBuilder.withPath('foo', function () {
+    diffBuilder.withPath('foo', function() {
       diffBuilder.recordMismatch();
     });
-    diffBuilder.withPath('bar', function () {
+    diffBuilder.withPath('bar', function() {
       diffBuilder.recordMismatch();
     });
 
     var message =
-      "Expected $.foo = 1 to equal 2.\n" +
+      'Expected $.foo = 1 to equal 2.\n' + 'Expected $.bar = 3 to equal 4.';
-      "Expected $.bar = 3 to equal 4.";
 
     expect(diffBuilder.getMessage()).toEqual(message);
   });
 
-  it("allows customization of the message", function () {
+  it('allows customization of the message', function() {
     var diffBuilder = jasmineUnderTest.DiffBuilder();
-    diffBuilder.setRoots({x: 'bar'}, {x: 'foo'});
+    diffBuilder.setRoots({ x: 'bar' }, { x: 'foo' });
 
     function darthVaderFormatter(actual, expected, path) {
-      return "I find your lack of " + expected + " disturbing. (was " + actual + ", at " + path + ")"
+      return (
+        'I find your lack of ' +
+        expected +
+        ' disturbing. (was ' +
+        actual +
+        ', at ' +
+        path +
+        ')'
+      );
     }
 
-    diffBuilder.withPath('x', function () {
+    diffBuilder.withPath('x', function() {
       diffBuilder.recordMismatch(darthVaderFormatter);
     });
 
-    expect(diffBuilder.getMessage()).toEqual("I find your lack of foo disturbing. (was bar, at $.x)");
+    expect(diffBuilder.getMessage()).toEqual(
+      'I find your lack of foo disturbing. (was bar, at $.x)'
+    );
   });
 
-  it("uses the injected pretty-printer", function () {
+  it('uses the injected pretty-printer', function() {
-    var prettyPrinter = function (val) {
+    var prettyPrinter = function(val) {
         return '|' + val + '|';
       },
-      diffBuilder = jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
+      diffBuilder = jasmineUnderTest.DiffBuilder({
-    prettyPrinter.customFormat_ = function () {
+        prettyPrinter: prettyPrinter
-    };
+      });
+    prettyPrinter.customFormat_ = function() {};
 
-    diffBuilder.setRoots({foo: 'actual'}, {foo: 'expected'});
+    diffBuilder.setRoots({ foo: 'actual' }, { foo: 'expected' });
-    diffBuilder.withPath('foo', function () {
+    diffBuilder.withPath('foo', function() {
       diffBuilder.recordMismatch();
     });
 
-    expect(diffBuilder.getMessage()).toEqual("Expected $.foo = |actual| to equal |expected|.");
+    expect(diffBuilder.getMessage()).toEqual(
+      'Expected $.foo = |actual| to equal |expected|.'
+    );
   });
 
-  it("passes the injected pretty-printer to the diff formatter", function () {
+  it('passes the injected pretty-printer to the diff formatter', function() {
     var diffFormatter = jasmine.createSpy('diffFormatter'),
-      prettyPrinter = function () {
+      prettyPrinter = function() {},
-      },
+      diffBuilder = jasmineUnderTest.DiffBuilder({
-      diffBuilder = jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
+        prettyPrinter: prettyPrinter
-    prettyPrinter.customFormat_ = function () {
+      });
-    };
+    prettyPrinter.customFormat_ = function() {};
 
-    diffBuilder.setRoots({x: 'bar'}, {x: 'foo'});
+    diffBuilder.setRoots({ x: 'bar' }, { x: 'foo' });
-    diffBuilder.withPath('x', function () {
+    diffBuilder.withPath('x', function() {
       diffBuilder.recordMismatch(diffFormatter);
     });
 
     diffBuilder.getMessage();
 
-    expect(diffFormatter).toHaveBeenCalledWith('bar', 'foo', jasmine.anything(), prettyPrinter);
+    expect(diffFormatter).toHaveBeenCalledWith(
+      'bar',
+      'foo',
+      jasmine.anything(),
+      prettyPrinter
+    );
   });
 
-  it("uses custom object formatters on leaf nodes", function() {
+  it('uses custom object formatters on leaf nodes', function() {
     var formatter = function(x) {
       if (typeof x === 'number') {
         return '[number:' + x + ']';
       }
     };
     prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
-    var diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
+    var diffBuilder = new jasmineUnderTest.DiffBuilder({
+      prettyPrinter: prettyPrinter
+    });
 
     diffBuilder.setRoots(5, 4);
     diffBuilder.recordMismatch();
 
-    expect(diffBuilder.getMessage()).toEqual('Expected [number:5] to equal [number:4].');
+    expect(diffBuilder.getMessage()).toEqual(
+      'Expected [number:5] to equal [number:4].'
+    );
   });
 
-
+  it('uses custom object formatters on non leaf nodes', function() {
-  it("uses custom object formatters on non leaf nodes", function () {
+    var formatter = function(x) {
-    var formatter = function (x) {
       if (x.hasOwnProperty('a')) {
         return '[thing with a=' + x.a + ', b=' + JSON.stringify(x.b) + ']';
       }
     };
     prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]);
-    var diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter});
+    var diffBuilder = new jasmineUnderTest.DiffBuilder({
-    var expectedMsg = 'Expected $[0].foo = [thing with a=1, b={"x":42}] to equal [thing with a=1, b={"x":43}].\n' +
+      prettyPrinter: prettyPrinter
+    });
+    var expectedMsg =
+      'Expected $[0].foo = [thing with a=1, b={"x":42}] to equal [thing with a=1, b={"x":43}].\n' +
       "Expected $[0].bar = 'yes' to equal 'no'.";
 
     diffBuilder.setRoots(
-      [{foo: {a: 1, b: {x: 42}}, bar: 'yes'}],
+      [{ foo: { a: 1, b: { x: 42 } }, bar: 'yes' }],
-      [{foo: {a: 1, b: {x: 43}}, bar: 'no'}]
+      [{ foo: { a: 1, b: { x: 43 } }, bar: 'no' }]
     );
 
-    diffBuilder.withPath(0, function () {
+    diffBuilder.withPath(0, function() {
-      diffBuilder.withPath('foo', function () {
+      diffBuilder.withPath('foo', function() {
-        diffBuilder.withPath('b', function () {
+        diffBuilder.withPath('b', function() {
-          diffBuilder.withPath('x', function () {
+          diffBuilder.withPath('x', function() {
             diffBuilder.recordMismatch();
           });
         });
       });
 
-      diffBuilder.withPath('bar', function () {
+      diffBuilder.withPath('bar', function() {
         diffBuilder.recordMismatch();
       });
     });
@@ -136,14 +163,16 @@ describe("DiffBuilder", function () {
 
   it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ at the root', function() {
     var prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
-      diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter}),
+      diffBuilder = new jasmineUnderTest.DiffBuilder({
-      expectedMsg = 'Expected $.foo = 1 to equal 2.\n' +
+        prettyPrinter: prettyPrinter
-      "Expected $.baz = undefined to equal 3.";
+      }),
-
+      expectedMsg =
+        'Expected $.foo = 1 to equal 2.\n' +
+        'Expected $.baz = undefined to equal 3.';
 
     diffBuilder.setRoots(
-      {foo: 1, bar: 2},
+      { foo: 1, bar: 2 },
-      jasmine.objectContaining({foo: 2, baz: 3})
+      jasmine.objectContaining({ foo: 2, baz: 3 })
     );
 
     diffBuilder.withPath('foo', function() {
@@ -158,21 +187,23 @@ describe("DiffBuilder", function () {
 
   it('builds diffs involving asymmetric equality testers that implement valuesForDiff_ below the root', function() {
     var prettyPrinter = jasmineUnderTest.makePrettyPrinter([]),
-      diffBuilder = new jasmineUnderTest.DiffBuilder({prettyPrinter: prettyPrinter}),
+      diffBuilder = new jasmineUnderTest.DiffBuilder({
-      expectedMsg = 'Expected $.x.foo = 1 to equal 2.\n' +
+        prettyPrinter: prettyPrinter
-        "Expected $.x.baz = undefined to equal 3.";
+      }),
-
+      expectedMsg =
+        'Expected $.x.foo = 1 to equal 2.\n' +
+        'Expected $.x.baz = undefined to equal 3.';
 
     diffBuilder.setRoots(
-      {x: {foo: 1, bar: 2}},
+      { x: { foo: 1, bar: 2 } },
-      {x: jasmine.objectContaining({foo: 2, baz: 3})}
+      { x: jasmine.objectContaining({ foo: 2, baz: 3 }) }
     );
 
     diffBuilder.withPath('x', function() {
-      diffBuilder.withPath('foo', function () {
+      diffBuilder.withPath('foo', function() {
         diffBuilder.recordMismatch();
       });
-      diffBuilder.withPath('baz', function () {
+      diffBuilder.withPath('baz', function() {
         diffBuilder.recordMismatch();
       });
     });

spec/core/matchers/MismatchTreeSpec.js

@@ -1,15 +1,15 @@
-describe('MismatchTree', function () {
+describe('MismatchTree', function() {
-  describe('#add', function () {
+  describe('#add', function() {
-    describe('When the path is empty', function () {
+    describe('When the path is empty', function() {
-      it('flags the root node as mismatched', function () {
+      it('flags the root node as mismatched', function() {
         var tree = new jasmineUnderTest.MismatchTree();
         tree.add(new jasmineUnderTest.ObjectPath([]));
         expect(tree.isMismatch).toBe(true);
       });
     });
 
-    describe('When the path is not empty', function () {
+    describe('When the path is not empty', function() {
-      it('flags the node as mismatched', function () {
+      it('flags the node as mismatched', function() {
         var tree = new jasmineUnderTest.MismatchTree();
 
         tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
@@ -17,7 +17,7 @@ describe('MismatchTree', function () {
         expect(tree.child('a').child('b').isMismatch).toBe(true);
       });
 
-      it('does not flag ancestors as mismatched', function () {
+      it('does not flag ancestors as mismatched', function() {
         var tree = new jasmineUnderTest.MismatchTree();
 
         tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
@@ -27,7 +27,7 @@ describe('MismatchTree', function () {
       });
     });
 
-    it('stores the formatter on only the target node', function () {
+    it('stores the formatter on only the target node', function() {
       var tree = new jasmineUnderTest.MismatchTree();
 
       tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
@@ -37,7 +37,7 @@ describe('MismatchTree', function () {
       expect(tree.child('a').child('b').formatter).toBe(formatter);
     });
 
-    it('stores the path to the node', function () {
+    it('stores the path to the node', function() {
       var tree = new jasmineUnderTest.MismatchTree();
 
       tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
@@ -46,8 +46,8 @@ describe('MismatchTree', function () {
     });
   });
 
-  describe('#traverse', function () {
+  describe('#traverse', function() {
-    it('calls the callback for all nodes that are or contain mismatches', function () {
+    it('calls the callback for all nodes that are or contain mismatches', function() {
       var tree = new jasmineUnderTest.MismatchTree();
       tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']), formatter);
       tree.add(new jasmineUnderTest.ObjectPath(['c']));
@@ -56,20 +56,28 @@ describe('MismatchTree', function () {
       tree.traverse(visit);
 
       expect(visit).toHaveBeenCalledWith(
-        new jasmineUnderTest.ObjectPath([]), false, undefined
+        new jasmineUnderTest.ObjectPath([]),
+        false,
+        undefined
       );
       expect(visit).toHaveBeenCalledWith(
-        new jasmineUnderTest.ObjectPath(['a']), false, undefined
+        new jasmineUnderTest.ObjectPath(['a']),
+        false,
+        undefined
       );
       expect(visit).toHaveBeenCalledWith(
-        new jasmineUnderTest.ObjectPath(['a', 'b']), true, formatter
+        new jasmineUnderTest.ObjectPath(['a', 'b']),
+        true,
+        formatter
       );
       expect(visit).toHaveBeenCalledWith(
-        new jasmineUnderTest.ObjectPath(['c']), true, undefined
+        new jasmineUnderTest.ObjectPath(['c']),
+        true,
+        undefined
       );
     });
 
-    it('does not call the callback if there are no mismatches', function () {
+    it('does not call the callback if there are no mismatches', function() {
       var tree = new jasmineUnderTest.MismatchTree();
       var visit = jasmine.createSpy('visit');
 
@@ -78,12 +86,12 @@ describe('MismatchTree', function () {
       expect(visit).not.toHaveBeenCalled();
     });
 
-    it('visits parents before children', function () {
+    it('visits parents before children', function() {
       var tree = new jasmineUnderTest.MismatchTree();
       tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
       var visited = [];
 
-      tree.traverse(function (path) {
+      tree.traverse(function(path) {
         visited.push(path);
         return true;
       });
@@ -101,7 +109,7 @@ describe('MismatchTree', function () {
       tree.add(new jasmineUnderTest.ObjectPath([1]));
       var visited = [];
 
-      tree.traverse(function (path) {
+      tree.traverse(function(path) {
         visited.push(path);
         return true;
       });
@@ -118,7 +126,7 @@ describe('MismatchTree', function () {
       tree.add(new jasmineUnderTest.ObjectPath(['a', 'b']));
       var visited = [];
 
-      tree.traverse(function (path) {
+      tree.traverse(function(path) {
         visited.push(path);
         return path.depth() === 0;
       });
@@ -130,7 +138,5 @@ describe('MismatchTree', function () {
     });
   });
 
-  function formatter() {
+  function formatter() {}
-  }
-
 });

spec/core/matchers/NullDiffBuilderSpec.js

@@ -1,8 +1,7 @@
-describe('NullDiffBuilder', function () {
+describe('NullDiffBuilder', function() {
-  it('responds to withPath() by calling the passed function', function () {
+  it('responds to withPath() by calling the passed function', function() {
     var spy = jasmine.createSpy('callback');
     jasmineUnderTest.NullDiffBuilder().withPath('does not matter', spy);
     expect(spy).toHaveBeenCalled();
   });
-
 });

spec/core/matchers/async/toBePendingSpec.js

@@ -8,7 +8,7 @@ describe('toBePending', function() {
       actual = new Promise(function() {});
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
@@ -20,7 +20,7 @@ describe('toBePending', function() {
       actual = Promise.resolve();
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
@@ -32,21 +32,19 @@ describe('toBePending', function() {
       actual = Promise.reject(new Error('promise was rejected'));
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
   it('fails if actual is not a promise', function() {
     var matchersUtil = new jasmineUnderTest.MatchersUtil(),
-    matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
+      matcher = jasmineUnderTest.asyncMatchers.toBePending(matchersUtil),
-    actual = 'not a promise';
+      actual = 'not a promise';
 
     function f() {
       return matcher.compare(actual);
     }
 
-    expect(f).toThrowError(
+    expect(f).toThrowError('Expected toBePending to be called on a promise.');
-      'Expected toBePending to be called on a promise.'
-    );
   });
 });

spec/core/matchers/async/toBeRejectedSpec.js

@@ -8,7 +8,7 @@ describe('toBeRejected', function() {
       actual = Promise.reject('AsyncExpectationSpec rejection');
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
@@ -20,7 +20,7 @@ describe('toBeRejected', function() {
       actual = Promise.resolve();
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
@@ -33,8 +33,6 @@ describe('toBeRejected', function() {
       return matcher.compare(actual);
     }
 
-    expect(f).toThrowError(
+    expect(f).toThrowError('Expected toBeRejected to be called on a promise.');
-      'Expected toBeRejected to be called on a promise.'
-    );
   });
 });

spec/core/matchers/async/toBeRejectedWithErrorSpec.js

@@ -1,174 +1,253 @@
 /* eslint-disable compat/compat */
-describe('#toBeRejectedWithError', function () {
+describe('#toBeRejectedWithError', function() {
-  it('passes when Error type matches', function () {
+  it('passes when Error type matches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new TypeError('foo'));
 
-    return matcher.compare(actual, TypeError).then(function (result) {
+    return matcher.compare(actual, TypeError).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with TypeError, but it was.'
+          pass: true,
-      }));
+          message:
+            'Expected a promise not to be rejected with TypeError, but it was.'
+        })
+      );
     });
   });
 
-  it('passes when Error type and message matches', function () {
+  it('passes when Error type and message matches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new TypeError('foo'));
 
-    return matcher.compare(actual, TypeError, 'foo').then(function (result) {
+    return matcher.compare(actual, TypeError, 'foo').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with TypeError: \'foo\', but it was.'
+          pass: true,
-      }));
+          message:
+            "Expected a promise not to be rejected with TypeError: 'foo', but it was."
+        })
+      );
     });
   });
 
   it('passes when Error matches and is exactly Error', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error());
 
-    return matcher.compare(actual, Error).then(function (result) {
+    return matcher.compare(actual, Error).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with Error, but it was.'
+          pass: true,
-      }));
+          message:
+            'Expected a promise not to be rejected with Error, but it was.'
+        })
+      );
     });
-
   });
 
-  it('passes when Error message matches a string', function () {
+  it('passes when Error message matches a string', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, 'foo').then(function (result) {
+    return matcher.compare(actual, 'foo').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with Error: \'foo\', but it was.'
+          pass: true,
-      }));
+          message:
+            "Expected a promise not to be rejected with Error: 'foo', but it was."
+        })
+      );
     });
   });
 
-  it('passes when Error message matches a RegExp', function () {
+  it('passes when Error message matches a RegExp', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, /foo/).then(function (result) {
+    return matcher.compare(actual, /foo/).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with Error: /foo/, but it was.'
+          pass: true,
-      }));
+          message:
+            'Expected a promise not to be rejected with Error: /foo/, but it was.'
+        })
+      );
     });
   });
 
-  it('passes when Error message is empty', function () {
+  it('passes when Error message is empty', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error());
 
-    return matcher.compare(actual, '').then(function (result) {
+    return matcher.compare(actual, '').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with Error: \'\', but it was.'
+          pass: true,
-      }));
+          message:
+            "Expected a promise not to be rejected with Error: '', but it was."
+        })
+      );
     });
   });
 
-  it('passes when no arguments', function () {
+  it('passes when no arguments', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error());
 
-    return matcher.compare(actual, void 0).then(function (result) {
+    return matcher.compare(actual, void 0).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with Error, but it was.'
+          pass: true,
-      }));
+          message:
+            'Expected a promise not to be rejected with Error, but it was.'
+        })
+      );
     });
   });
 
-  it('fails when resolved', function () {
+  it('fails when resolved', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.resolve(new Error('foo'));
 
-    return matcher.compare(actual, 'foo').then(function (result) {
+    return matcher.compare(actual, 'foo').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: 'Expected a promise to be rejected but it was resolved.'
+          pass: false,
-      }));
+          message: 'Expected a promise to be rejected but it was resolved.'
+        })
+      );
     });
   });
 
-  it('fails when rejected with non Error type', function () {
+  it('fails when rejected with non Error type', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject('foo');
 
-    return matcher.compare(actual, 'foo').then(function (result) {
+    return matcher.compare(actual, 'foo').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: 'Expected a promise to be rejected with Error: \'foo\' but it was rejected with \'foo\'.'
+          pass: false,
-      }));
+          message:
+            "Expected a promise to be rejected with Error: 'foo' but it was rejected with 'foo'."
+        })
+      );
     });
   });
 
-  it('fails when Error type mismatches', function () {
+  it('fails when Error type mismatches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, TypeError, 'foo').then(function (result) {
+    return matcher.compare(actual, TypeError, 'foo').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: 'Expected a promise to be rejected with TypeError: \'foo\' but it was rejected with type Error.'
+          pass: false,
-      }));
+          message:
+            "Expected a promise to be rejected with TypeError: 'foo' but it was rejected with type Error."
+        })
+      );
     });
   });
 
-  it('fails when Error message mismatches', function () {
+  it('fails when Error message mismatches', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = Promise.reject(new Error('foo'));
 
-    return matcher.compare(actual, 'bar').then(function (result) {
+    return matcher.compare(actual, 'bar').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: 'Expected a promise to be rejected with Error: \'bar\' but it was rejected with Error: foo.'
+          pass: false,
-      }));
+          message:
+            "Expected a promise to be rejected with Error: 'bar' but it was rejected with Error: foo."
+        })
+      );
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
+      matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWithError(
+        matchersUtil
+      ),
       actual = 'not a promise';
 
     function f() {

spec/core/matchers/async/toBeRejectedWithSpec.js

@@ -1,74 +1,91 @@
 /* eslint-disable compat/compat */
-describe('#toBeRejectedWith', function () {
+describe('#toBeRejectedWith', function() {
-  it('should return true if the promise is rejected with the expected value', function () {
+  it('should return true if the promise is rejected with the expected value', function() {
     jasmine.getEnv().requirePromises();
 
     var matchersUtil = new jasmineUnderTest.MatchersUtil(),
       matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
-      actual = Promise.reject({error: 'PEBCAK'});
+      actual = Promise.reject({ error: 'PEBCAK' });
 
-    return matcher.compare(actual, {error: 'PEBCAK'}).then(function (result) {
+    return matcher.compare(actual, { error: 'PEBCAK' }).then(function(result) {
       expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
-  it('should fail if the promise resolves', function () {
+  it('should fail if the promise resolves', function() {
     jasmine.getEnv().requirePromises();
 
     var matchersUtil = new jasmineUnderTest.MatchersUtil(),
       matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.resolve();
 
-    return matcher.compare(actual, '').then(function (result) {
+    return matcher.compare(actual, '').then(function(result) {
       expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
-  it('should fail if the promise is rejected with a different value', function () {
+  it('should fail if the promise is rejected with a different value', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.reject('A Bad Apple');
 
-    return matcher.compare(actual, 'Some Cool Thing').then(function (result) {
+    return matcher.compare(actual, 'Some Cool Thing').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'.",
+          pass: false,
-      }));
+          message:
+            "Expected a promise to be rejected with 'Some Cool Thing' but it was rejected with 'A Bad Apple'."
+        })
+      );
     });
   });
 
-  it('should build its error correctly when negated', function () {
+  it('should build its error correctly when negated', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.reject(true);
 
-    return matcher.compare(actual, true).then(function (result) {
+    return matcher.compare(actual, true).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be rejected with true.'
+          pass: true,
-      }));
+          message: 'Expected a promise not to be rejected with true.'
+        })
+      );
     });
   });
 
-  it('should support custom equality testers', function () {
+  it('should support custom equality testers', function() {
     jasmine.getEnv().requirePromises();
 
-    var customEqualityTesters = [function() { return true; }],
+    var customEqualityTesters = [
-      matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
+        function() {
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = Promise.reject('actual');
 
     return matcher.compare(actual, 'expected').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeRejectedWith(matchersUtil),
       actual = 'not a promise';
 

spec/core/matchers/async/toBeResolvedSpec.js

@@ -8,7 +8,7 @@ describe('toBeResolved', function() {
       actual = Promise.resolve();
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
@@ -20,7 +20,7 @@ describe('toBeResolved', function() {
       actual = Promise.reject('AsyncExpectationSpec rejection');
 
     return matcher.compare(actual).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: false}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: false }));
     });
   });
 
@@ -33,8 +33,6 @@ describe('toBeResolved', function() {
       return matcher.compare(actual);
     }
 
-    expect(f).toThrowError(
+    expect(f).toThrowError('Expected toBeResolved to be called on a promise.');
-      'Expected toBeResolved to be called on a promise.'
-    );
   });
 });

spec/core/matchers/async/toBeResolvedToSpec.js

@@ -5,62 +5,80 @@ describe('#toBeResolvedTo', function() {
 
     var matchersUtil = new jasmineUnderTest.MatchersUtil(),
       matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
-      actual = Promise.resolve({foo: 42});
+      actual = Promise.resolve({ foo: 42 });
 
-    return matcher.compare(actual, {foo: 42}).then(function(result) {
+    return matcher.compare(actual, { foo: 42 }).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if the promise is rejected', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = Promise.reject('AsyncExpectationSpec error');
 
     return matcher.compare(actual, '').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: "Expected a promise to be resolved to '' but it was rejected.",
+          pass: false,
-      }));
+          message:
+            "Expected a promise to be resolved to '' but it was rejected."
+        })
+      );
     });
   });
 
   it('fails if the promise is resolved to a different value', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
-      actual = Promise.resolve({foo: 17});
+      actual = Promise.resolve({ foo: 17 });
 
-    return matcher.compare(actual, {foo: 42}).then(function(result) {
+    return matcher.compare(actual, { foo: 42 }).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: false,
+        jasmine.objectContaining({
-        message: 'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).',
+          pass: false,
-      }));
+          message:
+            'Expected a promise to be resolved to Object({ foo: 42 }) but it was resolved to Object({ foo: 17 }).'
+        })
+      );
     });
   });
 
   it('builds its message correctly when negated', function() {
     jasmine.getEnv().requirePromises();
 
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = Promise.resolve(true);
 
     return matcher.compare(actual, true).then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({
+      expect(result).toEqual(
-        pass: true,
+        jasmine.objectContaining({
-        message: 'Expected a promise not to be resolved to true.'
+          pass: true,
-      }));
+          message: 'Expected a promise not to be resolved to true.'
+        })
+      );
     });
   });
 
   it('supports custom equality testers', function() {
     jasmine.getEnv().requirePromises();
 
-    var customEqualityTesters = [function() { return true; }],
+    var customEqualityTesters = [
+        function() {
+          return true;
+        }
+      ],
       matchersUtil = new jasmineUnderTest.MatchersUtil({
         customTesters: customEqualityTesters,
         pp: jasmineUnderTest.makePrettyPrinter()
@@ -69,12 +87,14 @@ describe('#toBeResolvedTo', function() {
       actual = Promise.resolve('actual');
 
     return matcher.compare(actual, 'expected').then(function(result) {
-      expect(result).toEqual(jasmine.objectContaining({pass: true}));
+      expect(result).toEqual(jasmine.objectContaining({ pass: true }));
     });
   });
 
   it('fails if actual is not a promise', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.asyncMatchers.toBeResolvedTo(matchersUtil),
       actual = 'not a promise';
 

spec/core/matchers/toBeCloseToSpec.js

@@ -1,5 +1,5 @@
-describe("toBeCloseTo", function() {
+describe('toBeCloseTo', function() {
-  it("passes when within two decimal places by default", function() {
+  it('passes when within two decimal places by default', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -13,7 +13,7 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when not within two decimal places by default", function() {
+  it('fails when not within two decimal places by default', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -24,7 +24,7 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("accepts an optional precision argument", function() {
+  it('accepts an optional precision argument', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -47,23 +47,29 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when one of the arguments is null", function() {
+  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).');
+    }).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).');
+    }).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).');
+    }).toThrowError(
+      'Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).'
+    );
   });
 
-  it("rounds expected values", function() {
+  it('rounds expected values', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
@@ -91,15 +97,15 @@ describe("toBeCloseTo", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("handles edge cases with rounding", function () {
+  it('handles edge cases with rounding', function() {
     var matcher = jasmineUnderTest.matchers.toBeCloseTo(),
       result;
 
-    // these cases resulted in false negatives in version of V8 
+    // these cases resulted in false negatives in version of V8
     // included in Node.js 12 and Chrome 74 (and Edge Chromium)
     result = matcher.compare(4.030904708957288, 4.0309, 5);
     expect(result.pass).toBe(true);
-    result = matcher.compare(4.82665525779431,4.82666, 5);
+    result = matcher.compare(4.82665525779431, 4.82666, 5);
     expect(result.pass).toBe(true);
     result = matcher.compare(-2.82665525779431, -2.82666, 5);
     expect(result.pass).toBe(true);

spec/core/matchers/toBeDefinedSpec.js

@@ -1,18 +1,17 @@
-describe("toBeDefined", function() {
+describe('toBeDefined', function() {
-  it("matches for defined values", 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() {
+  it('fails when matching undefined values', function() {
     var matcher = jasmineUnderTest.matchers.toBeDefined(),
       result;
 
     result = matcher.compare(void 0);
     expect(result.pass).toBe(false);
-  })
+  });
 });

spec/core/matchers/toBeFalseSpec.js

@@ -1,5 +1,5 @@
-describe("toBeFalse", function() {
+describe('toBeFalse', function() {
-  it("passes for false", function() {
+  it('passes for false', function() {
     var matcher = jasmineUnderTest.matchers.toBeFalse(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeFalse", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails for non-false", function() {
+  it('fails for non-false', function() {
     var matcher = jasmineUnderTest.matchers.toBeFalse(),
       result;
 
@@ -15,7 +15,7 @@ describe("toBeFalse", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("fails for falsy", function() {
+  it('fails for falsy', function() {
     var matcher = jasmineUnderTest.matchers.toBeFalse(),
       result;
 

spec/core/matchers/toBeFalsySpec.js

@@ -1,4 +1,4 @@
-describe("toBeFalsy", function() {
+describe('toBeFalsy', function() {
   it("passes for 'falsy' values", function() {
     var matcher = jasmineUnderTest.matchers.toBeFalsy(),
       result;
@@ -29,7 +29,7 @@ describe("toBeFalsy", function() {
     result = matcher.compare(1);
     expect(result.pass).toBe(false);
 
-    result = matcher.compare("foo");
+    result = matcher.compare('foo');
     expect(result.pass).toBe(false);
 
     result = matcher.compare({});

spec/core/matchers/toBeGreaterThanOrEqualSpec.js

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

spec/core/matchers/toBeGreaterThanSpec.js

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

spec/core/matchers/toBeInstanceOfSpec.js

@@ -92,13 +92,14 @@ describe('toBeInstanceOf', function() {
 
   describe('when expecting Function', function() {
     it('passes for a function', function() {
-      var fn = function() { };
+      var fn = function() {};
 
       var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
       var result = matcher.compare(fn, Function);
       expect(result).toEqual({
         pass: true,
-        message: 'Expected instance of Function not to be an instance of Function'
+        message:
+          'Expected instance of Function not to be an instance of Function'
       });
     });
 
@@ -111,13 +112,14 @@ describe('toBeInstanceOf', function() {
       var result = matcher.compare(fn, Function);
       expect(result).toEqual({
         pass: true,
-        message: 'Expected instance of AsyncFunction not to be an instance of Function'
+        message:
+          'Expected instance of AsyncFunction not to be an instance of Function'
       });
     });
   });
 
   describe('when expecting Object', function() {
-    function Animal() { }
+    function Animal() {}
 
     it('passes for any object', function() {
       var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
@@ -164,14 +166,15 @@ describe('toBeInstanceOf', function() {
       var result = matcher.compare(object, Object);
       expect(result).toEqual({
         pass: true,
-        message: 'Expected instance of null({  }) not to be an instance of Object'
+        message:
+          'Expected instance of null({  }) not to be an instance of Object'
       });
     });
   });
 
   describe('when expecting a user-defined class', function() {
     // Base class
-    function Animal() { }
+    function Animal() {}
 
     // Subclasses, defined using syntax that is as old as possible
     function Dog() {
@@ -218,8 +221,10 @@ describe('toBeInstanceOf', function() {
     var matcher = jasmineUnderTest.matchers.toBeInstanceOf();
     expect(function() {
       matcher.compare({}, 'Error');
-    }).toThrowError('<toBeInstanceOf> : Expected value is not a constructor function\n' +
+    }).toThrowError(
-        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)');
+      '<toBeInstanceOf> : Expected value is not a constructor function\n' +
+        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)'
+    );
   });
 
   it('raises an error if missing an expected value', function() {
@@ -228,7 +233,9 @@ describe('toBeInstanceOf', function() {
     });
     expect(function() {
       matcher.compare({}, undefined);
-    }).toThrowError('<toBeInstanceOf> : Expected value is not a constructor function\n' +
+    }).toThrowError(
-        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)');
+      '<toBeInstanceOf> : Expected value is not a constructor function\n' +
+        'Usage: expect(value).toBeInstanceOf(<ConstructorFunction>)'
+    );
   });
 });

spec/core/matchers/toBeLessThanOrEqualSpec.js

@@ -1,5 +1,5 @@
-describe("toBeLessThanOrEqual", function() {
+describe('toBeLessThanOrEqual', function() {
-  it("passes when actual <= expected", function() {
+  it('passes when actual <= expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
       result;
 
@@ -11,12 +11,12 @@ describe("toBeLessThanOrEqual", function() {
 
     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() {
+  it('fails when actual < expected', function() {
     var matcher = jasmineUnderTest.matchers.toBeLessThanOrEqual(),
       result;
 

spec/core/matchers/toBeLessThanSpec.js

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

spec/core/matchers/toBeNaNSpec.js

@@ -1,14 +1,14 @@
-describe("toBeNaN", function() {
+describe('toBeNaN', function() {
-  it("passes for NaN with a custom .not fail", 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.");
+    expect(result.message).toEqual('Expected actual not to be NaN.');
   });
 
-  it("fails for anything not a NaN", function() {
+  it('fails for anything not a NaN', function() {
     var matcher = jasmineUnderTest.matchers.toBeNaN(),
       result;
 
@@ -28,12 +28,12 @@ describe("toBeNaN", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("has a custom message on failure", function() {
+  it('has a custom message on failure', function() {
     var matcher = jasmineUnderTest.matchers.toBeNaN({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       result = matcher.compare(0);
 
-    expect(result.message()).toEqual("Expected 0 to be NaN.");
+    expect(result.message()).toEqual('Expected 0 to be NaN.');
   });
 });

spec/core/matchers/toBeNegativeInfinitySpec.js

@@ -1,4 +1,4 @@
-describe("toBeNegativeInfinity", function() {
+describe('toBeNegativeInfinity', function() {
   it("fails for anything that isn't -Infinity", function() {
     var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity(),
       result;
@@ -13,21 +13,20 @@ describe("toBeNegativeInfinity", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("has a custom message on failure", function() {
+  it('has a custom message on failure', function() {
     var matcher = jasmineUnderTest.matchers.toBeNegativeInfinity({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       result = matcher.compare(0);
 
-    expect(result.message()).toEqual("Expected 0 to be -Infinity.")
+    expect(result.message()).toEqual('Expected 0 to be -Infinity.');
   });
 
-  it("succeeds for -Infinity", function() {
+  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 not to be -Infinity.")
+    expect(result.message).toEqual('Expected actual not to be -Infinity.');
   });
-
 });

spec/core/matchers/toBeNullSpec.js

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

spec/core/matchers/toBePositiveInfinitySpec.js

@@ -1,4 +1,4 @@
-describe("toBePositiveInfinity", function() {
+describe('toBePositiveInfinity', function() {
   it("fails for anything that isn't Infinity", function() {
     var matcher = jasmineUnderTest.matchers.toBePositiveInfinity(),
       result;
@@ -13,21 +13,20 @@ describe("toBePositiveInfinity", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("has a custom message on failure", function() {
+  it('has a custom message on failure', function() {
     var matcher = jasmineUnderTest.matchers.toBePositiveInfinity({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       result = matcher.compare(0);
 
-    expect(result.message()).toEqual("Expected 0 to be Infinity.")
+    expect(result.message()).toEqual('Expected 0 to be Infinity.');
   });
 
-  it("succeeds for Infinity", function() {
+  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 not to be Infinity.")
+    expect(result.message).toEqual('Expected actual not to be Infinity.');
   });
-
 });

spec/core/matchers/toBeSpec.js

@@ -1,5 +1,5 @@
-describe("toBe", function() {
+describe('toBe', function() {
-  it("passes with no message when actual === expected", function() {
+  it('passes with no message when actual === expected', function() {
     var matchersUtil = new jasmineUnderTest.MatchersUtil(),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
@@ -8,29 +8,37 @@ describe("toBe", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("passes with a custom message when expected is an array", function() {
+  it('passes with a custom message when expected is an array', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result,
       array = [1];
 
     result = matcher.compare(array, array);
     expect(result.pass).toBe(true);
-    expect(result.message).toBe("Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      'Expected [ 1 ] not to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
+    );
   });
 
-  it("passes with a custom message when expected is an object", function() {
+  it('passes with a custom message when expected is an object', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result,
-      obj = {foo: "bar"};
+      obj = { foo: 'bar' };
 
     result = matcher.compare(obj, obj);
     expect(result.pass).toBe(true);
-    expect(result.message).toBe("Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      "Expected Object({ foo: 'bar' }) not to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe()."
+    );
   });
 
-  it("fails with no message when actual !== expected", function() {
+  it('fails with no message when actual !== expected', function() {
     var matchersUtil = new jasmineUnderTest.MatchersUtil(),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
@@ -40,35 +48,47 @@ describe("toBe", function() {
     expect(result.message).toBeUndefined();
   });
 
-  it("fails with a custom message when expected is an array", function() {
+  it('fails with a custom message when expected is an array', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
     result = matcher.compare([1], [1]);
     expect(result.pass).toBe(false);
-    expect(result.message).toBe("Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      'Expected [ 1 ] to be [ 1 ]. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
+    );
   });
 
-  it("fails with a custom message when expected is an object", function() {
+  it('fails with a custom message when expected is an object', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
+        pp: jasmineUnderTest.makePrettyPrinter()
+      }),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
-    result = matcher.compare({foo: "bar"}, {foo: "bar"});
+    result = matcher.compare({ foo: 'bar' }, { foo: 'bar' });
     expect(result.pass).toBe(false);
-    expect(result.message).toBe("Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      "Expected Object({ foo: 'bar' }) to be Object({ foo: 'bar' }). Tip: To check for deep equality, use .toEqual() instead of .toBe()."
+    );
   });
 
-  it("works with custom object formatters when expected is an object", function() {
+  it('works with custom object formatters when expected is an object', function() {
-    var formatter = function(x) { return '<' + x.foo + '>'; },
+    var formatter = function(x) {
+        return '<' + x.foo + '>';
+      },
       prettyPrinter = jasmineUnderTest.makePrettyPrinter([formatter]),
-      matchersUtil = new jasmineUnderTest.MatchersUtil({pp: prettyPrinter}),
+      matchersUtil = new jasmineUnderTest.MatchersUtil({ pp: prettyPrinter }),
       matcher = jasmineUnderTest.matchers.toBe(matchersUtil),
       result;
 
-    result = matcher.compare({foo: "bar"}, {foo: "bar"});
+    result = matcher.compare({ foo: 'bar' }, { foo: 'bar' });
     expect(result.pass).toBe(false);
-    expect(result.message).toBe("Expected <bar> to be <bar>. Tip: To check for deep equality, use .toEqual() instead of .toBe().")
+    expect(result.message).toBe(
+      'Expected <bar> to be <bar>. Tip: To check for deep equality, use .toEqual() instead of .toBe().'
+    );
   });
 });

spec/core/matchers/toBeTrueSpec.js

@@ -1,5 +1,5 @@
-describe("toBeTrue", function() {
+describe('toBeTrue', function() {
-  it("passes for true", function() {
+  it('passes for true', function() {
     var matcher = jasmineUnderTest.matchers.toBeTrue(),
       result;
 
@@ -7,7 +7,7 @@ describe("toBeTrue", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails for non-true", function() {
+  it('fails for non-true', function() {
     var matcher = jasmineUnderTest.matchers.toBeTrue(),
       result;
 

spec/core/matchers/toBeTruthySpec.js

@@ -1,4 +1,4 @@
-describe("toBeTruthy", function() {
+describe('toBeTruthy', function() {
   it("passes for 'truthy' values", function() {
     var matcher = jasmineUnderTest.matchers.toBeTruthy(),
       result;
@@ -9,7 +9,7 @@ describe("toBeTruthy", function() {
     result = matcher.compare(1);
     expect(result.pass).toBe(true);
 
-    result = matcher.compare("foo");
+    result = matcher.compare('foo');
     expect(result.pass).toBe(true);
 
     result = matcher.compare({});

spec/core/matchers/toBeUndefinedSpec.js

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

spec/core/matchers/toContainSpec.js

@@ -1,21 +1,23 @@
-describe("toContain", function() {
+describe('toContain', function() {
-  it("delegates to jasmineUnderTest.matchersUtil.contains", function() {
+  it('delegates to jasmineUnderTest.matchersUtil.contains', function() {
     var matchersUtil = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
       matcher = jasmineUnderTest.matchers.toContain(matchersUtil),
       result;
 
-    result = matcher.compare("ABC", "B");
+    result = matcher.compare('ABC', 'B');
-    expect(matchersUtil.contains).toHaveBeenCalledWith("ABC", "B");
+    expect(matchersUtil.contains).toHaveBeenCalledWith('ABC', 'B');
     expect(result.pass).toBe(true);
   });
 
-  it("works with custom equality testers", function() {
+  it('works with custom equality testers', function() {
-    var tester = function (a, b) {
+    var tester = function(a, b) {
         return a.toString() === b.toString();
       },
-      matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]}),
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: [tester]
+      }),
       matcher = jasmineUnderTest.matchers.toContain(matchersUtil),
       result;
 

spec/core/matchers/toHaveBeenCalledBeforeSpec.js

@@ -1,29 +1,29 @@
-describe("toHaveBeenCalledBefore", function() {
+describe('toHaveBeenCalledBefore', function() {
-  it("throws an exception when the actual is not a spy", function() {
+  it('throws an exception when the actual is not a spy', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore({
-          pp: jasmineUnderTest.makePrettyPrinter()
+        pp: jasmineUnderTest.makePrettyPrinter()
-        }),
+      }),
-        fn = function() {},
+      fn = function() {},
-        spy = new jasmineUnderTest.Env().createSpy('a spy');
+      spy = new jasmineUnderTest.Env().createSpy('a spy');
 
-    expect(function () {
+    expect(function() {
       matcher.compare(fn, spy);
     }).toThrowError(Error, /Expected a spy, but got Function./);
   });
 
-  it("throws an exception when the expected is not a spy", function() {
+  it('throws an exception when the expected is not a spy', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore({
-          pp: jasmineUnderTest.makePrettyPrinter()
+        pp: jasmineUnderTest.makePrettyPrinter()
-        }),
+      }),
-        spy = new jasmineUnderTest.Env().createSpy('a spy'),
+      spy = new jasmineUnderTest.Env().createSpy('a spy'),
-        fn = function() {};
+      fn = function() {};
 
-    expect(function () {
+    expect(function() {
       matcher.compare(spy, fn);
     }).toThrowError(Error, /Expected a spy, but got Function./);
   });
 
-  it("fails when the actual was not called", function () {
+  it('fails when the actual was not called', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
       firstSpy = new jasmineUnderTest.Spy('first spy'),
       secondSpy = new jasmineUnderTest.Spy('second spy');
@@ -32,10 +32,12 @@ describe("toHaveBeenCalledBefore", function() {
 
     result = matcher.compare(firstSpy, secondSpy);
     expect(result.pass).toBe(false);
-    expect(result.message).toMatch(/Expected spy first spy to have been called./);
+    expect(result.message).toMatch(
+      /Expected spy first spy to have been called./
+    );
   });
 
-  it("fails when the expected was not called", function () {
+  it('fails when the expected was not called', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
       firstSpy = new jasmineUnderTest.Spy('first spy'),
       secondSpy = new jasmineUnderTest.Spy('second spy');
@@ -44,10 +46,12 @@ describe("toHaveBeenCalledBefore", function() {
 
     result = matcher.compare(firstSpy, secondSpy);
     expect(result.pass).toBe(false);
-    expect(result.message).toMatch(/Expected spy second spy to have been called./);
+    expect(result.message).toMatch(
+      /Expected spy second spy to have been called./
+    );
   });
 
-  it("fails when the actual is called after the expected", function () {
+  it('fails when the actual is called after the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
       firstSpy = new jasmineUnderTest.Spy('first spy'),
       secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -58,10 +62,12 @@ describe("toHaveBeenCalledBefore", function() {
 
     result = matcher.compare(firstSpy, secondSpy);
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual('Expected spy first spy to have been called before spy second spy');
+    expect(result.message).toEqual(
+      'Expected spy first spy to have been called before spy second spy'
+    );
   });
 
-  it("fails when the actual is called before and after the expected", function () {
+  it('fails when the actual is called before and after the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
       firstSpy = new jasmineUnderTest.Spy('first spy'),
       secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -73,10 +79,12 @@ describe("toHaveBeenCalledBefore", function() {
 
     result = matcher.compare(firstSpy, secondSpy);
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual('Expected latest call to spy first spy to have been called before first call to spy second spy (no interleaved calls)');
+    expect(result.message).toEqual(
+      'Expected latest call to spy first spy to have been called before first call to spy second spy (no interleaved calls)'
+    );
   });
 
-  it("fails when the expected is called before and after the actual", function () {
+  it('fails when the expected is called before and after the actual', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
       firstSpy = new jasmineUnderTest.Spy('first spy'),
       secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -88,10 +96,12 @@ describe("toHaveBeenCalledBefore", function() {
 
     result = matcher.compare(firstSpy, secondSpy);
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual('Expected first call to spy second spy to have been called after latest call to spy first spy (no interleaved calls)');
+    expect(result.message).toEqual(
+      'Expected first call to spy second spy to have been called after latest call to spy first spy (no interleaved calls)'
+    );
   });
 
-  it("passes when the actual is called before the expected", function () {
+  it('passes when the actual is called before the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
       firstSpy = new jasmineUnderTest.Spy('first spy'),
       secondSpy = new jasmineUnderTest.Spy('second spy'),
@@ -102,6 +112,8 @@ describe("toHaveBeenCalledBefore", function() {
 
     result = matcher.compare(firstSpy, secondSpy);
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual('Expected spy first spy to not have been called before spy second spy, but it was');
+    expect(result.message).toEqual(
+      'Expected spy first spy to not have been called before spy second spy, but it was'
+    );
   });
 });

spec/core/matchers/toHaveBeenCalledOnceWithSpec.js

@@ -1,6 +1,5 @@
-describe("toHaveBeenCalledOnceWith", function () {
+describe('toHaveBeenCalledOnceWith', function() {
-
+  it('passes when the actual was called only once and with matching parameters', function() {
-  it("passes when the actual was called only once and with matching parameters", function () {
     var pp = jasmineUnderTest.makePrettyPrinter(),
       util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -11,13 +10,23 @@ describe("toHaveBeenCalledOnceWith", function () {
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected spy called-spy to have been called 0 times, multiple times, or once, but with arguments different from:\n  [ 'a', 'b' ]\nBut the actual call was:\n  [ 'a', 'b' ].\n\n");
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called 0 times, multiple times, or once, but with arguments different from:\n  [ 'a', 'b' ]\nBut the actual call was:\n  [ 'a', 'b' ].\n\n"
+    );
   });
 
-  it("supports custom equality testers", function () {
+  it('supports custom equality testers', function() {
-    var customEqualityTesters = [function() { return true; }],
+    var customEqualityTesters = [
-      matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
+        function() {
-      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(matchersUtil),
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters
+      }),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(
+        matchersUtil
+      ),
       calledSpy = new jasmineUnderTest.Spy('called-spy'),
       result;
 
@@ -27,7 +36,7 @@ describe("toHaveBeenCalledOnceWith", function () {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when the actual was never called", function () {
+  it('fails when the actual was never called', function() {
     var pp = jasmineUnderTest.makePrettyPrinter(),
       util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -37,10 +46,12 @@ describe("toHaveBeenCalledOnceWith", function () {
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut it was never called.\n\n");
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut it was never called.\n\n"
+    );
   });
 
-  it("fails when the actual was called once with different parameters", function () {
+  it('fails when the actual was called once with different parameters', function() {
     var pp = jasmineUnderTest.makePrettyPrinter(),
       util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -51,10 +62,12 @@ describe("toHaveBeenCalledOnceWith", function () {
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual call was:\n  [ 'a', 'c' ].\nExpected $[1] = 'c' to equal 'b'.\n\n");
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual call was:\n  [ 'a', 'c' ].\nExpected $[1] = 'c' to equal 'b'.\n\n"
+    );
   });
 
-  it("fails when the actual was called multiple times with expected parameters", function () {
+  it('fails when the actual was called multiple times with expected parameters', function() {
     var pp = jasmineUnderTest.makePrettyPrinter(),
       util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -66,10 +79,12 @@ describe("toHaveBeenCalledOnceWith", function () {
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual calls were:\n  [ 'a', 'b' ],\n  [ 'a', 'b' ].\n\n");
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual calls were:\n  [ 'a', 'b' ],\n  [ 'a', 'b' ].\n\n"
+    );
   });
 
-  it("fails when the actual was called multiple times (one of them - with expected parameters)", function () {
+  it('fails when the actual was called multiple times (one of them - with expected parameters)', function() {
     var pp = jasmineUnderTest.makePrettyPrinter(),
       util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
@@ -81,15 +96,19 @@ describe("toHaveBeenCalledOnceWith", function () {
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual calls were:\n  [ 'a', 'b' ],\n  [ 'a', 'c' ].\n\n");
+    expect(result.message).toEqual(
+      "Expected spy called-spy to have been called only once, and with given args:\n  [ 'a', 'b' ]\nBut the actual calls were:\n  [ 'a', 'b' ],\n  [ 'a', 'c' ].\n\n"
+    );
   });
 
-  it("throws an exception when the actual is not a spy", function () {
+  it('throws an exception when the actual is not a spy', function() {
     var pp = jasmineUnderTest.makePrettyPrinter(),
       util = new jasmineUnderTest.MatchersUtil({ pp: pp }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledOnceWith(util),
-      fn = function () { };
+      fn = function() {};
 
-    expect(function () { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(fn);
+    }).toThrowError(/Expected a spy, but got Function./);
   });
 });

spec/core/matchers/toHaveBeenCalledSpec.js

@@ -1,5 +1,5 @@
-describe("toHaveBeenCalled", function() {
+describe('toHaveBeenCalled', function() {
-  it("passes when the actual was called, with a custom .not fail message", function() {
+  it('passes when the actual was called, with a custom .not fail message', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
       calledSpy = new jasmineUnderTest.Spy('called-spy'),
       result;
@@ -8,10 +8,12 @@ describe("toHaveBeenCalled", function() {
 
     result = matcher.compare(calledSpy);
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected spy called-spy not to have been called.");
+    expect(result.message).toEqual(
+      'Expected spy called-spy not to have been called.'
+    );
   });
 
-  it("fails when the actual was not called", function() {
+  it('fails when the actual was not called', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
       uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
       result;
@@ -20,30 +22,35 @@ describe("toHaveBeenCalled", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("throws an exception when the actual is not a spy", function() {
+  it('throws an exception when the actual is not a spy', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       fn = function() {};
 
-    expect(function() { matcher.compare(fn) }).toThrowError(Error, /Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(fn);
+    }).toThrowError(Error, /Expected a spy, but got Function./);
   });
 
-  it("throws an exception when invoked with any arguments", function() {
+  it('throws an exception when invoked with any arguments', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
       spy = new jasmineUnderTest.Spy('sample spy');
 
-    expect(function() { matcher.compare(spy, 'foo') }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
+    expect(function() {
+      matcher.compare(spy, 'foo');
+    }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
   });
 
-  it("has a custom message on failure", function() {
+  it('has a custom message on failure', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
       spy = new jasmineUnderTest.Spy('sample-spy'),
       result;
 
     result = matcher.compare(spy);
 
-    expect(result.message).toEqual("Expected spy sample-spy to have been called.");
+    expect(result.message).toEqual(
+      'Expected spy sample-spy to have been called.'
+    );
   });
 });
-

spec/core/matchers/toHaveBeenCalledTimesSpec.js

@@ -1,12 +1,12 @@
-describe("toHaveBeenCalledTimes", function() {
+describe('toHaveBeenCalledTimes', function() {
-  it("passes when the actual 0 matches the expected 0 ", function () {
+  it('passes when the actual 0 matches the expected 0 ', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-        calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
-        result;
+      result;
     result = matcher.compare(calledSpy, 0);
     expect(result.pass).toBeTruthy();
   });
-  it("passes when the actual matches the expected", function() {
+  it('passes when the actual matches the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       calledSpy = new jasmineUnderTest.Spy('called-spy'),
       result;
@@ -16,18 +16,20 @@ describe("toHaveBeenCalledTimes", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when expected numbers is not supplied", function(){
+  it('fails when expected numbers is not supplied', function() {
-     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       spy = new jasmineUnderTest.Spy('spy'),
       result;
 
     spy();
-     expect(function() {
+    expect(function() {
-       matcher.compare(spy);
+      matcher.compare(spy);
-     }).toThrowError(/The expected times failed is a required argument and must be a number./);
+    }).toThrowError(
+      /The expected times failed is a required argument and must be a number./
+    );
   });
 
-  it("fails when the actual was called less than the expected", function() {
+  it('fails when the actual was called less than the expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
       result;
@@ -36,7 +38,7 @@ describe("toHaveBeenCalledTimes", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("fails when the actual was called more than expected", function() {
+  it('fails when the actual was called more than expected', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
       result;
@@ -48,7 +50,7 @@ describe("toHaveBeenCalledTimes", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("throws an exception when the actual is not a spy", function() {
+  it('throws an exception when the actual is not a spy', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
@@ -59,7 +61,7 @@ describe("toHaveBeenCalledTimes", function() {
     }).toThrowError(/Expected a spy, but got Function./);
   });
 
-  it("has a custom message on failure that tells it was called only once", function() {
+  it('has a custom message on failure that tells it was called only once', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       spy = new jasmineUnderTest.Spy('sample-spy'),
       result;
@@ -69,10 +71,14 @@ describe("toHaveBeenCalledTimes", function() {
     spy();
 
     result = matcher.compare(spy, 1);
-    expect(result.message).toEqual('Expected spy sample-spy to have been called once. It was called ' +  4 + ' times.');
+    expect(result.message).toEqual(
+      'Expected spy sample-spy to have been called once. It was called ' +
+        4 +
+        ' times.'
+    );
   });
 
-  it("has a custom message on failure that tells how many times it was called", function() {
+  it('has a custom message on failure that tells how many times it was called', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
       spy = new jasmineUnderTest.Spy('sample-spy'),
       result;
@@ -82,7 +88,10 @@ describe("toHaveBeenCalledTimes", function() {
     spy();
 
     result = matcher.compare(spy, 2);
-    expect(result.message).toEqual('Expected spy sample-spy to have been called 2 times. It was called ' +  4 + ' times.');
+    expect(result.message).toEqual(
+      'Expected spy sample-spy to have been called 2 times. It was called ' +
+        4 +
+        ' times.'
+    );
   });
 });
-

spec/core/matchers/toHaveBeenCalledWithSpec.js

@@ -1,24 +1,31 @@
-describe("toHaveBeenCalledWith", function() {
+describe('toHaveBeenCalledWith', function() {
-
+  it('passes when the actual was called with matching parameters', function() {
-  it("passes when the actual was called with matching parameters", function() {
     var matchersUtil = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
+        contains: jasmine.createSpy('delegated-contains').and.returnValue(true),
-          pp: jasmineUnderTest.makePrettyPrinter()
+        pp: jasmineUnderTest.makePrettyPrinter()
-        },
+      },
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
-        calledSpy = new jasmineUnderTest.Spy('called-spy'),
+      calledSpy = new jasmineUnderTest.Spy('called-spy'),
-        result;
+      result;
 
     calledSpy('a', 'b');
     result = matcher.compare(calledSpy, 'a', 'b');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected spy called-spy not to have been called with:\n  [ 'a', 'b' ]\nbut it was.");
+    expect(result.message()).toEqual(
+      "Expected spy called-spy not to have been called with:\n  [ 'a', 'b' ]\nbut it was."
+    );
   });
 
-  it("supports custom equality testers", function() {
+  it('supports custom equality testers', function() {
-    var customEqualityTesters = [function() { return true; }],
+    var customEqualityTesters = [
-      matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: customEqualityTesters}),
+        function() {
+          return true;
+        }
+      ],
+      matchersUtil = new jasmineUnderTest.MatchersUtil({
+        customTesters: customEqualityTesters
+      }),
       matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
       calledSpy = new jasmineUnderTest.Spy('called-spy'),
       result;
@@ -28,25 +35,31 @@ describe("toHaveBeenCalledWith", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when the actual was not called", function() {
+  it('fails when the actual was not called', function() {
     var matchersUtil = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(false),
+        contains: jasmine
-          pp: jasmineUnderTest.makePrettyPrinter()
+          .createSpy('delegated-contains')
-        },
+          .and.returnValue(false),
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
-        uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
+      },
-        result;
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      uncalledSpy = new jasmineUnderTest.Spy('uncalled spy'),
+      result;
 
     result = matcher.compare(uncalledSpy);
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected spy uncalled spy to have been called with:\n  [  ]\nbut it was never called.");
+    expect(result.message()).toEqual(
+      'Expected spy uncalled spy to have been called with:\n  [  ]\nbut it was never called.'
+    );
   });
 
-  it("fails when the actual was called with different parameters", function() {
+  it('fails when the actual was called with different parameters', function() {
-    var matchersUtil = new jasmineUnderTest.MatchersUtil({pp: jasmineUnderTest.makePrettyPrinter()}),
+    var matchersUtil = new jasmineUnderTest.MatchersUtil({
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+        pp: jasmineUnderTest.makePrettyPrinter()
-        calledSpy = new jasmineUnderTest.Spy('called spy'),
+      }),
-        result;
+      matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(matchersUtil),
+      calledSpy = new jasmineUnderTest.Spy('called spy'),
+      result;
 
     calledSpy('a');
     calledSpy('c', 'd');
@@ -55,30 +68,32 @@ describe("toHaveBeenCalledWith", function() {
 
     expect(result.pass).toBe(false);
     expect(result.message()).toEqual(
-      "Expected spy called spy to have been called with:\n" +
+      'Expected spy called spy to have been called with:\n' +
-      "  [ 'a', 'b' ]\n" +
+        "  [ 'a', 'b' ]\n" +
-      "but actual calls were:\n" +
+        'but actual calls were:\n' +
-      "  [ 'a' ],\n" +
+        "  [ 'a' ],\n" +
-      "  [ 'c', 'd' ],\n" +
+        "  [ 'c', 'd' ],\n" +
-      "  [ 'a', 'b', 'c' ].\n\n" +
+        "  [ 'a', 'b', 'c' ].\n\n" +
-      "Call 0:\n" +
+        'Call 0:\n' +
-      "  Expected $.length = 1 to equal 2.\n" +
+        '  Expected $.length = 1 to equal 2.\n' +
-      "  Expected $[1] = undefined to equal 'b'.\n" +
+        "  Expected $[1] = undefined to equal 'b'.\n" +
-      "Call 1:\n" +
+        'Call 1:\n' +
-      "  Expected $[0] = 'c' to equal 'a'.\n" +
+        "  Expected $[0] = 'c' to equal 'a'.\n" +
-      "  Expected $[1] = 'd' to equal 'b'.\n" +
+        "  Expected $[1] = 'd' to equal 'b'.\n" +
-      "Call 2:\n" +
+        'Call 2:\n' +
-      "  Expected $.length = 3 to equal 2.\n" +
+        '  Expected $.length = 3 to equal 2.\n' +
-      "  Unexpected $[2] = 'c' in array.");
+        "  Unexpected $[2] = 'c' in array."
+    );
   });
 
-  it("throws an exception when the actual is not a spy", function() {
+  it('throws an exception when the actual is not a spy', function() {
     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
-      fn = function () {
+      fn = function() {};
-      };
 
-    expect(function() { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
+    expect(function() {
+      matcher.compare(fn);
+    }).toThrowError(/Expected a spy, but got Function./);
   });
 });

spec/core/matchers/toHaveClassSpec.js

@@ -5,7 +5,10 @@ describe('toHaveClass', function() {
 
   it('fails for a DOM element that lacks the expected class', function() {
     var matcher = jasmineUnderTest.matchers.toHaveClass(),
-      result = matcher.compare(this.domHelpers.createElementWithClassName(''), 'foo');
+      result = matcher.compare(
+        this.domHelpers.createElementWithClassName(''),
+        'foo'
+      );
 
     expect(result.pass).toBe(false);
   });
@@ -41,11 +44,11 @@ describe('toHaveClass', function() {
 
     var textNode = this.domHelpers.document.createTextNode('');
     expect(function() {
-      matcher.compare(textNode, 'foo')
+      matcher.compare(textNode, 'foo');
     }).toThrowError('HTMLNode is not a DOM element');
 
     expect(function() {
-      matcher.compare({classList: ''}, 'foo');
+      matcher.compare({ classList: '' }, 'foo');
     }).toThrowError("Object({ classList: '' }) is not a DOM element");
   });
 });

spec/core/matchers/toHaveSizeSpec.js

@@ -18,28 +18,28 @@ describe('toHaveSize', function() {
 
   it('passes for an object with the proper number of keys', function() {
     var matcher = jasmineUnderTest.matchers.toHaveSize(),
-      result = matcher.compare({a: 1, b: 2}, 2);
+      result = matcher.compare({ a: 1, b: 2 }, 2);
 
     expect(result.pass).toBe(true);
   });
 
   it('fails for an object with a different number of keys', function() {
     var matcher = jasmineUnderTest.matchers.toHaveSize(),
-      result = matcher.compare({a: 1, b: 2}, 1);
+      result = matcher.compare({ a: 1, b: 2 }, 1);
 
     expect(result.pass).toBe(false);
   });
 
   it('passes for an object with an explicit `length` property that matches', function() {
     var matcher = jasmineUnderTest.matchers.toHaveSize(),
-      result = matcher.compare({a: 1, b: 2, length: 5}, 5);
+      result = matcher.compare({ a: 1, b: 2, length: 5 }, 5);
 
     expect(result.pass).toBe(true);
   });
 
   it('fails for an object with an explicit `length` property that does not match', function() {
     var matcher = jasmineUnderTest.matchers.toHaveSize(),
-      result = matcher.compare({a: 1, b: 2, length: 5}, 1);
+      result = matcher.compare({ a: 1, b: 2, length: 5 }, 1);
 
     expect(result.pass).toBe(false);
   });
@@ -62,8 +62,8 @@ describe('toHaveSize', function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var map = new Map();
-    map.set('a',1);
+    map.set('a', 1);
-    map.set('b',2);
+    map.set('b', 2);
 
     var matcher = jasmineUnderTest.matchers.toHaveSize(),
       result = matcher.compare(map, 2);
@@ -75,8 +75,8 @@ describe('toHaveSize', function() {
     jasmine.getEnv().requireFunctioningMaps();
 
     var map = new Map();
-    map.set('a',1);
+    map.set('a', 1);
-    map.set('b',2);
+    map.set('b', 2);
 
     var matcher = jasmineUnderTest.matchers.toHaveSize(),
       result = matcher.compare(map, 1);

spec/core/matchers/toMatchSpec.js

@@ -1,6 +1,5 @@
-describe("toMatch", function() {
+describe('toMatch', function() {
-
+  it('passes when RegExps are equivalent', function() {
-  it("passes when RegExps are equivalent", function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -8,7 +7,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when RegExps are not equivalent", function() {
+  it('fails when RegExps are not equivalent', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -16,7 +15,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("passes when the actual matches the expected string as a pattern", function() {
+  it('passes when the actual matches the expected string as a pattern', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -24,7 +23,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(true);
   });
 
-  it("fails when the actual matches the expected string as a pattern", function() {
+  it('fails when the actual matches the expected string as a pattern', function() {
     var matcher = jasmineUnderTest.matchers.toMatch(),
       result;
 
@@ -32,7 +31,7 @@ describe("toMatch", function() {
     expect(result.pass).toBe(false);
   });
 
-  it("throws an Error when the expected is not a String or RegExp", function() {
+  it('throws an Error when the expected is not a String or RegExp', function() {
     var matcher = jasmineUnderTest.matchers.toMatch();
 
     expect(function() {
@@ -40,4 +39,3 @@ describe("toMatch", function() {
     }).toThrowError(/Expected is not a String or a RegExp/);
   });
 });
-

spec/core/matchers/toThrowErrorSpec.js

@@ -1,5 +1,5 @@
-describe("toThrowError", function() {
+describe('toThrowError', function() {
-  it("throws an error when the actual is not a function", function() {
+  it('throws an error when the actual is not a function', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError();
 
     expect(function() {
@@ -7,10 +7,10 @@ describe("toThrowError", function() {
     }).toThrowError(/Actual is not a Function/);
   });
 
-  it("throws an error when the expected is not an Error, string, or RegExp", function() {
+  it('throws an error when the expected is not an Error, string, or RegExp', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
@@ -18,21 +18,21 @@ describe("toThrowError", function() {
     }).toThrowError(/Expected is not an Error, string, or RegExp./);
   });
 
-  it("throws an error when the expected error type is not an Error", function() {
+  it('throws an error when the expected error type is not an Error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
-      matcher.compare(fn, void 0, "foo");
+      matcher.compare(fn, void 0, 'foo');
     }).toThrowError(/Expected error type is not an Error./);
   });
 
-  it("throws an error when the expected error message is not a string or RegExp", function() {
+  it('throws an error when the expected error message is not a string or RegExp', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
@@ -40,7 +40,7 @@ describe("toThrowError", function() {
     }).toThrowError(/Expected error message is not a string or RegExp./);
   });
 
-  it("fails if actual does not throw at all", function() {
+  it('fails if actual does not throw at all', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         return true;
@@ -50,10 +50,10 @@ describe("toThrowError", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an Error.");
+    expect(result.message).toEqual('Expected function to throw an Error.');
   });
 
-  it("fails if thrown is not an instanceof Error", function() {
+  it('fails if thrown is not an instanceof Error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
@@ -64,12 +64,14 @@ describe("toThrowError", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an Error, but it threw 4.");
+    expect(result.message()).toEqual(
+      'Expected function to throw an Error, but it threw 4.'
+    );
   });
 
-  describe("when error is from another frame", function() {
+  describe('when error is from another frame', function() {
     function isNotRunningInBrowser() {
-      return typeof document === 'undefined'
+      return typeof document === 'undefined';
     }
 
     var iframe = null;
@@ -80,31 +82,36 @@ describe("toThrowError", function() {
       }
     });
 
-    it("passes if thrown is an instanceof Error regardless of global that contains its constructor", function() {
+    it('passes if thrown is an instanceof Error regardless of global that contains its constructor', function() {
       if (isNotRunningInBrowser()) {
         return;
       }
 
       var matcher = jasmineUnderTest.matchers.toThrowError();
-      iframe = document.body.appendChild(document.createElement("iframe"));
+      iframe = document.body.appendChild(document.createElement('iframe'));
-      iframe.src = "about:blank";
+      iframe.src = 'about:blank';
       var iframeDocument = iframe.contentWindow.document;
 
       if (iframeDocument.body) {
-        iframeDocument.body.appendChild(iframeDocument.createElement("script"))
+        iframeDocument.body.appendChild(
-        .textContent = "function method() { throw new Error('foo'); }";
+          iframeDocument.createElement('script')
+        ).textContent = "function method() { throw new Error('foo'); }";
       } else {
         // IE 10 and older
-        iframeDocument.write("<html><head><script>function method() { throw new Error('foo'); }</script></head></html>");
+        iframeDocument.write(
+          "<html><head><script>function method() { throw new Error('foo'); }</script></head></html>"
+        );
       }
 
       var result = matcher.compare(iframe.contentWindow.method);
       expect(result.pass).toBe(true);
-      expect(result.message).toEqual("Expected function not to throw an Error, but it threw Error.");
+      expect(result.message).toEqual(
+        'Expected function not to throw an Error, but it threw Error.'
+      );
     });
   });
 
-  it("fails with the correct message if thrown is a falsy value", function() {
+  it('fails with the correct message if thrown is a falsy value', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
@@ -115,10 +122,12 @@ describe("toThrowError", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an Error, but it threw undefined.");
+    expect(result.message()).toEqual(
+      'Expected function to throw an Error, but it threw undefined.'
+    );
   });
 
-  it("passes if thrown is a type of Error, but there is no expected error", function() {
+  it('passes if thrown is a type of Error, but there is no expected error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new TypeError();
@@ -128,70 +137,80 @@ describe("toThrowError", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw an Error, but it threw TypeError.");
+    expect(result.message).toEqual(
+      'Expected function not to throw an Error, but it threw TypeError.'
+    );
   });
 
-  it("passes if thrown is an Error and the expected is the same message", function() {
+  it('passes if thrown is an Error and the expected is the same message', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       },
       result;
 
-    result = matcher.compare(fn, "foo");
+    result = matcher.compare(fn, 'foo');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function not to throw an exception with message 'foo'."
+    );
   });
 
-  it("fails if thrown is an Error and the expected is not the same message", function() {
+  it('fails if thrown is an Error and the expected is not the same message', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       },
       result;
 
-    result = matcher.compare(fn, "bar");
+    result = matcher.compare(fn, 'bar');
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'."
+    );
   });
 
-  it("passes if thrown is an Error and the expected is a RegExp that matches the message", function() {
+  it('passes if thrown is an Error and the expected is a RegExp that matches the message', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       fn = function() {
-        throw new Error("a long message");
+        throw new Error('a long message');
       },
       result;
 
     result = matcher.compare(fn, /long/);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception with a message matching /long/.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw an exception with a message matching /long/.'
+    );
   });
 
-  it("fails if thrown is an Error and the expected is a RegExp that does not match the message", function() {
+  it('fails if thrown is an Error and the expected is a RegExp that does not match the message', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
       fn = function() {
-        throw new Error("a long message");
+        throw new Error('a long message');
       },
       result;
 
     result = matcher.compare(fn, /foo/);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'."
+    );
   });
 
-  it("passes if thrown is an Error and the expected the same Error", function() {
+  it('passes if thrown is an Error and the expected the same Error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error();
@@ -201,12 +220,14 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, Error);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw Error.");
+    expect(result.message()).toEqual('Expected function not to throw Error.');
   });
 
-  it("passes if thrown is a custom error that takes arguments and the expected is the same error", function() {
+  it('passes if thrown is a custom error that takes arguments and the expected is the same error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
-      CustomError = function CustomError(arg) { arg.x },
+      CustomError = function CustomError(arg) {
+        arg.x;
+      },
       fn = function() {
         throw new CustomError({ x: 1 });
       },
@@ -217,10 +238,12 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, CustomError);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw CustomError.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw CustomError.'
+    );
   });
 
-  it("fails if thrown is an Error and the expected is a different Error", function() {
+  it('fails if thrown is an Error and the expected is a different Error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {
         throw new Error();
@@ -230,94 +253,108 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, TypeError);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError, but it threw Error.");
+    expect(result.message()).toEqual(
+      'Expected function to throw TypeError, but it threw Error.'
+    );
   });
 
-  it("passes if thrown is a type of Error and it is equal to the expected Error and message", function() {
+  it('passes if thrown is a type of Error and it is equal to the expected Error and message', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
         pp: jasmineUnderTest.makePrettyPrinter()
       },
       matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
-    result = matcher.compare(fn, TypeError, "foo");
+    result = matcher.compare(fn, TypeError, 'foo');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw TypeError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function not to throw TypeError with message 'foo'."
+    );
   });
 
-  it("passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message", function() {
+  it('passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
         pp: jasmineUnderTest.makePrettyPrinter()
       },
       matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
-      CustomError = function CustomError(arg) { this.message = arg.message; },
+      CustomError = function CustomError(arg) {
+        this.message = arg.message;
+      },
       fn = function() {
-        throw new CustomError({message: "foo"});
+        throw new CustomError({ message: 'foo' });
       },
       result;
 
     CustomError.prototype = new Error();
 
-    result = matcher.compare(fn, CustomError, "foo");
+    result = matcher.compare(fn, CustomError, 'foo');
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw CustomError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function not to throw CustomError with message 'foo'."
+    );
   });
 
-  it("fails if thrown is a type of Error and the expected is a different Error", function() {
+  it('fails if thrown is a type of Error and the expected is a different Error', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
         pp: jasmineUnderTest.makePrettyPrinter()
       },
       matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
-    result = matcher.compare(fn, TypeError, "bar");
+    result = matcher.compare(fn, TypeError, 'bar');
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'."
+    );
   });
 
-  it("passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message", function() {
+  it('passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
         pp: jasmineUnderTest.makePrettyPrinter()
       },
       matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
     result = matcher.compare(fn, TypeError, /foo/);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw TypeError with a message matching /foo/.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw TypeError with a message matching /foo/.'
+    );
   });
 
-  it("fails if thrown is a type of Error and the expected is a different Error", function() {
+  it('fails if thrown is a type of Error and the expected is a different Error', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
         pp: jasmineUnderTest.makePrettyPrinter()
       },
       matcher = jasmineUnderTest.matchers.toThrowError(matchersUtil),
       fn = function() {
-        throw new TypeError("foo");
+        throw new TypeError('foo');
       },
       result;
 
     result = matcher.compare(fn, TypeError, /bar/);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'."
+    );
   });
 });

spec/core/matchers/toThrowMatchingSpec.js

@@ -1,16 +1,18 @@
-describe("toThrowMatching", function() {
+describe('toThrowMatching', function() {
-  it("throws an error when the actual is not a function", function() {
+  it('throws an error when the actual is not a function', function() {
     var matcher = jasmineUnderTest.matchers.toThrowMatching();
 
     expect(function() {
-      matcher.compare({}, function() { return true; });
+      matcher.compare({}, function() {
+        return true;
+      });
     }).toThrowError(/Actual is not a Function/);
   });
 
-  it("throws an error when the expected is not a function", function() {
+  it('throws an error when the expected is not a function', function() {
     var matcher = jasmineUnderTest.matchers.toThrowMatching(),
       fn = function() {
-        throw new Error("foo");
+        throw new Error('foo');
       };
 
     expect(function() {
@@ -18,20 +20,22 @@ describe("toThrowMatching", function() {
     }).toThrowError(/Predicate is not a Function/);
   });
 
-  it("fails if actual does not throw at all", function() {
+  it('fails if actual does not throw at all', function() {
     var matcher = jasmineUnderTest.matchers.toThrowMatching(),
       fn = function() {
         return true;
       },
       result;
 
-    result = matcher.compare(fn, function() { return true; });
+    result = matcher.compare(fn, function() {
+      return true;
+    });
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an exception.");
+    expect(result.message).toEqual('Expected function to throw an exception.');
   });
 
-  it("fails with the correct message if thrown is a falsy value", function() {
+  it('fails with the correct message if thrown is a falsy value', function() {
     var matcher = jasmineUnderTest.matchers.toThrowMatching({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
@@ -40,38 +44,50 @@ describe("toThrowMatching", function() {
       },
       result;
 
-    result = matcher.compare(fn, function() { return false; });
+    result = matcher.compare(fn, function() {
+      return false;
+    });
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw undefined.");
+    expect(result.message()).toEqual(
+      'Expected function to throw an exception matching a predicate, but it threw undefined.'
+    );
   });
 
-  it("passes if the argument is a function that returns true when called with the error", function() {
+  it('passes if the argument is a function that returns true when called with the error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowMatching(),
-    predicate = function(e) { return e.message === "nope" },
+      predicate = function(e) {
+        return e.message === 'nope';
+      },
       fn = function() {
-        throw new TypeError("nope");
+        throw new TypeError('nope');
       },
       result;
 
     result = matcher.compare(fn, predicate);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw an exception matching a predicate.");
+    expect(result.message).toEqual(
+      'Expected function not to throw an exception matching a predicate.'
+    );
   });
 
-  it("fails if the argument is a function that returns false when called with the error", function() {
+  it('fails if the argument is a function that returns false when called with the error', function() {
     var matcher = jasmineUnderTest.matchers.toThrowMatching({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
-      predicate = function(e) { return e.message === "oh no" },
+      predicate = function(e) {
+        return e.message === 'oh no';
+      },
       fn = function() {
-        throw new TypeError("nope");
+        throw new TypeError('nope');
       },
       result;
 
     result = matcher.compare(fn, predicate);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'.");
+    expect(result.message()).toEqual(
+      "Expected function to throw an exception matching a predicate, but it threw TypeError with message 'nope'."
+    );
   });
 });

spec/core/matchers/toThrowSpec.js

@@ -1,6 +1,5 @@
-describe("toThrow", function() {
+describe('toThrow', function() {
-
+  it('throws an error when the actual is not a function', function() {
-  it("throws an error when the actual is not a function", function() {
     var matcher = jasmineUnderTest.matchers.toThrow();
 
     expect(function() {
@@ -9,7 +8,7 @@ describe("toThrow", function() {
     }).toThrowError(/Actual is not a Function/);
   });
 
-  it("fails if actual does not throw", function() {
+  it('fails if actual does not throw', function() {
     var matcher = jasmineUnderTest.matchers.toThrow(),
       fn = function() {
         return true;
@@ -19,10 +18,10 @@ describe("toThrow", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an exception.");
+    expect(result.message).toEqual('Expected function to throw an exception.');
   });
 
-  it("passes if it throws but there is no expected", function() {
+  it('passes if it throws but there is no expected', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
         pp: jasmineUnderTest.makePrettyPrinter()
@@ -36,10 +35,12 @@ describe("toThrow", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw, but it threw 5.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw, but it threw 5.'
+    );
   });
 
-  it("passes even if what is thrown is falsy", function() {
+  it('passes even if what is thrown is falsy', function() {
     var matcher = jasmineUnderTest.matchers.toThrow({
         pp: jasmineUnderTest.makePrettyPrinter()
       }),
@@ -50,10 +51,12 @@ describe("toThrow", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw, but it threw undefined.");
+    expect(result.message()).toEqual(
+      'Expected function not to throw, but it threw undefined.'
+    );
   });
 
-  it("passes if what is thrown is equivalent to what is expected", function() {
+  it('passes if what is thrown is equivalent to what is expected', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(true),
         pp: jasmineUnderTest.makePrettyPrinter()
@@ -67,10 +70,10 @@ describe("toThrow", function() {
     result = matcher.compare(fn, 5);
 
     expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw 5.");
+    expect(result.message()).toEqual('Expected function not to throw 5.');
   });
 
-  it("fails if what is thrown is not equivalent to what is expected", function() {
+  it('fails if what is thrown is not equivalent to what is expected', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
         pp: jasmineUnderTest.makePrettyPrinter()
@@ -81,13 +84,15 @@ describe("toThrow", function() {
       },
       result;
 
-    result = matcher.compare(fn, "foo");
+    result = matcher.compare(fn, 'foo');
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw 'foo', but it threw 5.");
+    expect(result.message()).toEqual(
+      "Expected function to throw 'foo', but it threw 5."
+    );
   });
 
-  it("fails if what is thrown is not equivalent to undefined", function() {
+  it('fails if what is thrown is not equivalent to undefined', function() {
     var matchersUtil = {
         equals: jasmine.createSpy('delegated-equal').and.returnValue(false),
         pp: jasmineUnderTest.makePrettyPrinter()
@@ -101,6 +106,8 @@ describe("toThrow", function() {
     result = matcher.compare(fn, void 0);
 
     expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw undefined, but it threw 5.");
+    expect(result.message()).toEqual(
+      'Expected function to throw undefined, but it threw 5.'
+    );
   });
 });

src/core/asymmetric_equality/Any.js

@@ -1,10 +1,9 @@
 getJasmineRequireObj().Any = function(j$) {
-
   function Any(expectedObject) {
     if (typeof expectedObject === 'undefined') {
       throw new TypeError(
         'jasmine.any() expects to be passed a constructor function. ' +
-        'Please pass one or use jasmine.anything() to match any object.'
+          'Please pass one or use jasmine.anything() to match any object.'
       );
     }
     this.expectedObject = expectedObject;

src/core/asymmetric_equality/Anything.js

@@ -1,5 +1,4 @@
 getJasmineRequireObj().Anything = function(j$) {
-
   function Anything() {}
 
   Anything.prototype.asymmetricMatch = function(other) {

src/core/asymmetric_equality/ArrayContaining.js

@@ -5,7 +5,11 @@ getJasmineRequireObj().ArrayContaining = function(j$) {
 
   ArrayContaining.prototype.asymmetricMatch = function(other, matchersUtil) {
     if (!j$.isArray_(this.sample)) {
-      throw new Error('You must provide an array to arrayContaining, not ' + j$.pp(this.sample) + '.');
+      throw new Error(
+        'You must provide an array to arrayContaining, not ' +
+          j$.pp(this.sample) +
+          '.'
+      );
     }
 
     // If the actual parameter is not an array, we can fail immediately, since it couldn't
@@ -25,8 +29,8 @@ getJasmineRequireObj().ArrayContaining = function(j$) {
     return true;
   };
 
-  ArrayContaining.prototype.jasmineToString = function (pp) {
+  ArrayContaining.prototype.jasmineToString = function(pp) {
-    return '<jasmine.arrayContaining(' + pp(this.sample) +')>';
+    return '<jasmine.arrayContaining(' + pp(this.sample) + ')>';
   };
 
   return ArrayContaining;

src/core/asymmetric_equality/ArrayWithExactContents.js

@@ -1,12 +1,18 @@
 getJasmineRequireObj().ArrayWithExactContents = function(j$) {
-
   function ArrayWithExactContents(sample) {
     this.sample = sample;
   }
 
-  ArrayWithExactContents.prototype.asymmetricMatch = function(other, matchersUtil) {
+  ArrayWithExactContents.prototype.asymmetricMatch = function(
+    other,
+    matchersUtil
+  ) {
     if (!j$.isArray_(this.sample)) {
-      throw new Error('You must provide an array to arrayWithExactContents, not ' + j$.pp(this.sample) + '.');
+      throw new Error(
+        'You must provide an array to arrayWithExactContents, not ' +
+          j$.pp(this.sample) +
+          '.'
+      );
     }
 
     if (this.sample.length !== other.length) {

src/core/asymmetric_equality/Empty.js

@@ -1,8 +1,7 @@
-getJasmineRequireObj().Empty = function (j$) {
+getJasmineRequireObj().Empty = function(j$) {
-
   function Empty() {}
 
-  Empty.prototype.asymmetricMatch = function (other) {
+  Empty.prototype.asymmetricMatch = function(other) {
     if (j$.isString_(other) || j$.isArray_(other) || j$.isTypedArray_(other)) {
       return other.length === 0;
     }
@@ -17,7 +16,7 @@ getJasmineRequireObj().Empty = function (j$) {
     return false;
   };
 
-  Empty.prototype.jasmineToString = function () {
+  Empty.prototype.jasmineToString = function() {
     return '<jasmine.empty>';
   };
 

src/core/asymmetric_equality/Falsy.js

@@ -1,5 +1,4 @@
 getJasmineRequireObj().Falsy = function(j$) {
-
   function Falsy() {}
 
   Falsy.prototype.asymmetricMatch = function(other) {

src/core/asymmetric_equality/MapContaining.js

@@ -1,7 +1,9 @@
 getJasmineRequireObj().MapContaining = function(j$) {
   function MapContaining(sample) {
     if (!j$.isMap(sample)) {
-      throw new Error('You must provide a map to `mapContaining`, not ' + j$.pp(sample));
+      throw new Error(
+        'You must provide a map to `mapContaining`, not ' + j$.pp(sample)
+      );
     }
 
     this.sample = sample;
@@ -17,8 +19,8 @@ getJasmineRequireObj().MapContaining = function(j$) {
       var hasMatch = false;
       j$.util.forEachBreakable(other, function(oBreakLoop, oValue, oKey) {
         if (
-          matchersUtil.equals(oKey, key)
+          matchersUtil.equals(oKey, key) &&
-          && matchersUtil.equals(oValue, value)
+          matchersUtil.equals(oValue, value)
         ) {
           hasMatch = true;
           oBreakLoop();

src/core/asymmetric_equality/NotEmpty.js

@@ -1,8 +1,7 @@
-getJasmineRequireObj().NotEmpty = function (j$) {
+getJasmineRequireObj().NotEmpty = function(j$) {
-
   function NotEmpty() {}
 
-  NotEmpty.prototype.asymmetricMatch = function (other) {
+  NotEmpty.prototype.asymmetricMatch = function(other) {
     if (j$.isString_(other) || j$.isArray_(other) || j$.isTypedArray_(other)) {
       return other.length !== 0;
     }
@@ -18,7 +17,7 @@ getJasmineRequireObj().NotEmpty = function (j$) {
     return false;
   };
 
-  NotEmpty.prototype.jasmineToString = function () {
+  NotEmpty.prototype.jasmineToString = function() {
     return '<jasmine.notEmpty>';
   };
 

src/core/asymmetric_equality/ObjectContaining.js

@@ -1,5 +1,4 @@
 getJasmineRequireObj().ObjectContaining = function(j$) {
-
   function ObjectContaining(sample) {
     this.sample = sample;
   }
@@ -17,7 +16,7 @@ getJasmineRequireObj().ObjectContaining = function(j$) {
   }
 
   function hasProperty(obj, property) {
-    if (!obj || typeof(obj) !== 'object') {
+    if (!obj || typeof obj !== 'object') {
       return false;
     }
 
@@ -29,12 +28,22 @@ getJasmineRequireObj().ObjectContaining = function(j$) {
   }
 
   ObjectContaining.prototype.asymmetricMatch = function(other, matchersUtil) {
-    if (typeof(this.sample) !== 'object') { throw new Error('You must provide an object to objectContaining, not \''+this.sample+'\'.'); }
+    if (typeof this.sample !== 'object') {
-    if (typeof(other) !== 'object') { return false; }
+      throw new Error(
+        "You must provide an object to objectContaining, not '" +
+          this.sample +
+          "'."
+      );
+    }
+    if (typeof other !== 'object') {
+      return false;
+    }
 
     for (var property in this.sample) {
-      if (!hasProperty(other, property) ||
+      if (
-          !matchersUtil.equals(this.sample[property], other[property])) {
+        !hasProperty(other, property) ||
+        !matchersUtil.equals(this.sample[property], other[property])
+      ) {
         return false;
       }
     }
@@ -51,7 +60,7 @@ getJasmineRequireObj().ObjectContaining = function(j$) {
     }
 
     var filteredOther = {};
-    Object.keys(this.sample).forEach(function (k) {
+    Object.keys(this.sample).forEach(function(k) {
       // eq short-circuits comparison of objects that have different key sets,
       // so include all keys even if undefined.
       filteredOther[k] = other[k];

src/core/asymmetric_equality/SetContaining.js

@@ -1,7 +1,9 @@
 getJasmineRequireObj().SetContaining = function(j$) {
   function SetContaining(sample) {
     if (!j$.isSet(sample)) {
-      throw new Error('You must provide a set to `setContaining`, not ' + j$.pp(sample));
+      throw new Error(
+        'You must provide a set to `setContaining`, not ' + j$.pp(sample)
+      );
     }
 
     this.sample = sample;

src/core/asymmetric_equality/StringMatching.js

@@ -1,5 +1,4 @@
 getJasmineRequireObj().StringMatching = function(j$) {
-
   function StringMatching(expected) {
     if (!j$.isString_(expected) && !j$.isA_('RegExp', expected)) {
       throw new Error('Expected is not a String or a RegExp');

src/core/asymmetric_equality/Truthy.js

@@ -1,5 +1,4 @@
 getJasmineRequireObj().Truthy = function(j$) {
-
   function Truthy() {}
 
   Truthy.prototype.asymmetricMatch = function(other) {

src/core/matchers/DiffBuilder.js

@@ -1,4 +1,4 @@
-getJasmineRequireObj().DiffBuilder = function (j$) {
+getJasmineRequireObj().DiffBuilder = function(j$) {
   return function DiffBuilder(config) {
     var prettyPrinter = (config || {}).prettyPrinter || j$.makePrettyPrinter(),
       mismatches = new j$.MismatchTree(),
@@ -7,21 +7,28 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
       expectedRoot = undefined;
 
     return {
-      setRoots: function (actual, expected) {
+      setRoots: function(actual, expected) {
         actualRoot = actual;
         expectedRoot = expected;
       },
 
-      recordMismatch: function (formatter) {
+      recordMismatch: function(formatter) {
         mismatches.add(path, formatter);
       },
 
-      getMessage: function () {
+      getMessage: function() {
         var messages = [];
 
-        mismatches.traverse(function (path, isLeaf, formatter) {
+        mismatches.traverse(function(path, isLeaf, formatter) {
-          var actualCustom, expectedCustom, useCustom,
+          var actualCustom,
-            derefResult = dereferencePath(path, actualRoot, expectedRoot, prettyPrinter),
+            expectedCustom,
+            useCustom,
+            derefResult = dereferencePath(
+              path,
+              actualRoot,
+              expectedRoot,
+              prettyPrinter
+            ),
             actual = derefResult.actual,
             expected = derefResult.expected;
 
@@ -32,15 +39,22 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
 
           actualCustom = prettyPrinter.customFormat_(actual);
           expectedCustom = prettyPrinter.customFormat_(expected);
-          useCustom = !(j$.util.isUndefined(actualCustom) && j$.util.isUndefined(expectedCustom));
+          useCustom = !(
+            j$.util.isUndefined(actualCustom) &&
+            j$.util.isUndefined(expectedCustom)
+          );
 
           if (useCustom) {
-            messages.push(wrapPrettyPrinted(actualCustom, expectedCustom, path));
+            messages.push(
+              wrapPrettyPrinted(actualCustom, expectedCustom, path)
+            );
             return false; // don't recurse further
           }
 
           if (isLeaf) {
-            messages.push(defaultFormatter(actual, expected, path, prettyPrinter));
+            messages.push(
+              defaultFormatter(actual, expected, path, prettyPrinter)
+            );
           }
 
           return true;
@@ -49,7 +63,7 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
         return messages.join('\n');
       },
 
-      withPath: function (pathComponent, block) {
+      withPath: function(pathComponent, block) {
         var oldPath = path;
         path = path.add(pathComponent);
         block();
@@ -58,22 +72,32 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
     };
 
     function defaultFormatter(actual, expected, path, prettyPrinter) {
-      return wrapPrettyPrinted(prettyPrinter(actual), prettyPrinter(expected), path);
+      return wrapPrettyPrinted(
+        prettyPrinter(actual),
+        prettyPrinter(expected),
+        path
+      );
     }
 
     function wrapPrettyPrinted(actual, expected, path) {
-      return 'Expected ' +
+      return (
-        path + (path.depth() ? ' = ' : '') +
+        'Expected ' +
+        path +
+        (path.depth() ? ' = ' : '') +
         actual +
         ' to equal ' +
         expected +
-        '.';
+        '.'
+      );
     }
   };
 
   function dereferencePath(objectPath, actual, expected, pp) {
     function handleAsymmetricExpected() {
-      if (j$.isAsymmetricEqualityTester_(expected) && j$.isFunction_(expected.valuesForDiff_)) {
+      if (
+        j$.isAsymmetricEqualityTester_(expected) &&
+        j$.isFunction_(expected.valuesForDiff_)
+      ) {
         var asymmetricResult = expected.valuesForDiff_(actual, pp);
         expected = asymmetricResult.self;
         actual = asymmetricResult.other;
@@ -89,7 +113,6 @@ getJasmineRequireObj().DiffBuilder = function (j$) {
       handleAsymmetricExpected();
     }
 
-    return {actual: actual, expected: expected};
+    return { actual: actual, expected: expected };
   }
-
 };

src/core/matchers/MismatchTree.js

@@ -1,5 +1,4 @@
-getJasmineRequireObj().MismatchTree = function (j$) {
+getJasmineRequireObj().MismatchTree = function(j$) {
-
   /*
     To be able to apply custom object formatters at all possible levels of an
     object graph, DiffBuilder needs to be able to know not just where the
@@ -14,7 +13,7 @@ getJasmineRequireObj().MismatchTree = function (j$) {
     this.isMismatch = false;
   }
 
-  MismatchTree.prototype.add = function (path, formatter) {
+  MismatchTree.prototype.add = function(path, formatter) {
     var key, child;
 
     if (path.depth() === 0) {
@@ -34,8 +33,9 @@ getJasmineRequireObj().MismatchTree = function (j$) {
     }
   };
 
-  MismatchTree.prototype.traverse = function (visit) {
+  MismatchTree.prototype.traverse = function(visit) {
-    var i, hasChildren = this.children.length > 0;
+    var i,
+      hasChildren = this.children.length > 0;
 
     if (this.isMismatch || hasChildren) {
       if (visit(this.path, !hasChildren, this.formatter)) {
@@ -59,4 +59,3 @@ getJasmineRequireObj().MismatchTree = function (j$) {
 
   return MismatchTree;
 };
-

src/core/matchers/ObjectPath.js

@@ -32,7 +32,7 @@ getJasmineRequireObj().ObjectPath = function(j$) {
       return '.' + prop;
     }
 
-    return '[\'' + prop + '\']';
+    return "['" + prop + "']";
   }
 
   function map(array, fn) {

src/core/matchers/async/toBePending.js

@@ -17,8 +17,12 @@ getJasmineRequireObj().toBePending = function(j$) {
         }
         var want = {};
         return Promise.race([actual, Promise.resolve(want)]).then(
-          function(got) { return {pass: want === got}; },
+          function(got) {
-          function() { return {pass: false}; }
+            return { pass: want === got };
+          },
+          function() {
+            return { pass: false };
+          }
         );
       }
     };

src/core/matchers/async/toBeRejected.js

@@ -17,8 +17,12 @@ getJasmineRequireObj().toBeRejected = function(j$) {
           throw new Error('Expected toBeRejected to be called on a promise.');
         }
         return actual.then(
-          function() { return {pass: false}; },
+          function() {
-          function() { return {pass: true}; }
+            return { pass: false };
+          },
+          function() {
+            return { pass: true };
+          }
         );
       }
     };

src/core/matchers/async/toBeRejectedWith.js

@@ -15,35 +15,44 @@ getJasmineRequireObj().toBeRejectedWith = function(j$) {
     return {
       compare: function(actualPromise, expectedValue) {
         if (!j$.isPromiseLike(actualPromise)) {
-          throw new Error('Expected toBeRejectedWith to be called on a promise.');
+          throw new Error(
+            'Expected toBeRejectedWith to be called on a promise.'
+          );
         }
 
         function prefix(passed) {
-          return 'Expected a promise ' +
+          return (
+            'Expected a promise ' +
             (passed ? 'not ' : '') +
-            'to be rejected with ' + matchersUtil.pp(expectedValue);
+            'to be rejected with ' +
+            matchersUtil.pp(expectedValue)
+          );
         }
 
         return actualPromise.then(
           function() {
-          return {
-            pass: false,
-            message: prefix(false) + ' but it was resolved.'
-          };
-        },
-        function(actualValue) {
-          if (matchersUtil.equals(actualValue, expectedValue)) {
-            return {
-              pass: true,
-              message: prefix(true) + '.'
-            };
-          } else {
             return {
               pass: false,
-              message: prefix(false) + ' but it was rejected with ' + matchersUtil.pp(actualValue) + '.'
+              message: prefix(false) + ' but it was resolved.'
             };
+          },
+          function(actualValue) {
+            if (matchersUtil.equals(actualValue, expectedValue)) {
+              return {
+                pass: true,
+                message: prefix(true) + '.'
+              };
+            } else {
+              return {
+                pass: false,
+                message:
+                  prefix(false) +
+                  ' but it was rejected with ' +
+                  matchersUtil.pp(actualValue) +
+                  '.'
+              };
+            }
           }
-        }
         );
       }
     };

src/core/matchers/async/toBeRejectedWithError.js

@@ -18,7 +18,9 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
     return {
       compare: function(actualPromise, arg1, arg2) {
         if (!j$.isPromiseLike(actualPromise)) {
-          throw new Error('Expected toBeRejectedWithError to be called on a promise.');
+          throw new Error(
+            'Expected toBeRejectedWithError to be called on a promise.'
+          );
         }
 
         var expected = getExpectedFromArgs(arg1, arg2, matchersUtil);
@@ -30,7 +32,9 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
               message: 'Expected a promise to be rejected but it was resolved.'
             };
           },
-          function(actualValue) { return matchError(actualValue, expected, matchersUtil); }
+          function(actualValue) {
+            return matchError(actualValue, expected, matchersUtil);
+          }
         );
       }
     };
@@ -42,16 +46,25 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
     }
 
     if (!(actual instanceof expected.error)) {
-      return fail(expected, 'rejected with type ' + j$.fnNameFor(actual.constructor));
+      return fail(
+        expected,
+        'rejected with type ' + j$.fnNameFor(actual.constructor)
+      );
     }
 
     var actualMessage = actual.message;
 
-    if (actualMessage === expected.message || typeof expected.message === 'undefined') {
+    if (
+      actualMessage === expected.message ||
+      typeof expected.message === 'undefined'
+    ) {
       return pass(expected);
     }
 
-    if (expected.message instanceof RegExp && expected.message.test(actualMessage)) {
+    if (
+      expected.message instanceof RegExp &&
+      expected.message.test(actualMessage)
+    ) {
       return pass(expected);
     }
 
@@ -61,18 +74,25 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
   function pass(expected) {
     return {
       pass: true,
-      message: 'Expected a promise not to be rejected with ' + expected.printValue + ', but it was.'
+      message:
+        'Expected a promise not to be rejected with ' +
+        expected.printValue +
+        ', but it was.'
     };
   }
 
   function fail(expected, message) {
     return {
       pass: false,
-      message: 'Expected a promise to be rejected with ' + expected.printValue + ' but it was ' + message + '.'
+      message:
+        'Expected a promise to be rejected with ' +
+        expected.printValue +
+        ' but it was ' +
+        message +
+        '.'
     };
   }
 
-
   function getExpectedFromArgs(arg1, arg2, matchersUtil) {
     var error, message;
 
@@ -87,11 +107,16 @@ getJasmineRequireObj().toBeRejectedWithError = function(j$) {
     return {
       error: error,
       message: message,
-      printValue: j$.fnNameFor(error) + (typeof message === 'undefined' ? '' : ': ' + matchersUtil.pp(message))
+      printValue:
+        j$.fnNameFor(error) +
+        (typeof message === 'undefined' ? '' : ': ' + matchersUtil.pp(message))
     };
   }
 
   function isErrorConstructor(value) {
-    return typeof value === 'function' && (value === Error || j$.isError_(value.prototype));
+    return (
+      typeof value === 'function' &&
+      (value === Error || j$.isError_(value.prototype))
+    );
   }
 };

src/core/matchers/async/toBeResolved.js

@@ -18,8 +18,12 @@ getJasmineRequireObj().toBeResolved = function(j$) {
         }
 
         return actual.then(
-          function() { return {pass: true}; },
+          function() {
-          function() { return {pass: false}; }
+            return { pass: true };
+          },
+          function() {
+            return { pass: false };
+          }
         );
       }
     };

src/core/matchers/async/toBeResolvedTo.js

@@ -19,9 +19,12 @@ getJasmineRequireObj().toBeResolvedTo = function(j$) {
         }
 
         function prefix(passed) {
-          return 'Expected a promise ' +
+          return (
+            'Expected a promise ' +
             (passed ? 'not ' : '') +
-            'to be resolved to ' + matchersUtil.pp(expectedValue);
+            'to be resolved to ' +
+            matchersUtil.pp(expectedValue)
+          );
         }
 
         return actualPromise.then(
@@ -34,7 +37,11 @@ getJasmineRequireObj().toBeResolvedTo = function(j$) {
             } else {
               return {
                 pass: false,
-                message: prefix(false) + ' but it was resolved to ' + matchersUtil.pp(actualValue) + '.'
+                message:
+                  prefix(false) +
+                  ' but it was resolved to ' +
+                  matchersUtil.pp(actualValue) +
+                  '.'
               };
             }
           },

src/core/matchers/matchersUtil.js

@@ -21,7 +21,7 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
      * @return {string} The pretty-printed value
      */
     this.pp = options.pp || function() {};
-  };
+  }
 
   /**
    * Determines whether `haystack` contains `needle`, using the same comparison
@@ -39,9 +39,10 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       return haystack.has(needle);
     }
 
-    if ((Object.prototype.toString.apply(haystack) === '[object Array]') ||
+    if (
-      (!!haystack && !haystack.indexOf))
+      Object.prototype.toString.apply(haystack) === '[object Array]' ||
-    {
+      (!!haystack && !haystack.indexOf)
+    ) {
       for (var i = 0; i < haystack.length; i++) {
         if (this.equals(haystack[i], needle, customTesters)) {
           return true;
@@ -60,9 +61,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       isNot = args[1],
       actual = args[2],
       expected = args.slice(3),
-      englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) { return ' ' + s.toLowerCase(); });
+      englishyPredicate = matcherName.replace(/[A-Z]/g, function(s) {
+        return ' ' + s.toLowerCase();
+      });
 
-    var message = 'Expected ' +
+    var message =
+      'Expected ' +
       self.pp(actual) +
       (isNot ? ' not ' : ' ') +
       englishyPredicate;
@@ -79,20 +83,41 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
     return message + '.';
   };
 
-  MatchersUtil.prototype.asymmetricDiff_ = function(a, b, aStack, bStack, customTesters, diffBuilder) {
+  MatchersUtil.prototype.asymmetricDiff_ = function(
+    a,
+    b,
+    aStack,
+    bStack,
+    customTesters,
+    diffBuilder
+  ) {
     if (j$.isFunction_(b.valuesForDiff_)) {
       var values = b.valuesForDiff_(a, this.pp);
-      this.eq_(values.other, values.self, aStack, bStack, customTesters, diffBuilder);
+      this.eq_(
+        values.other,
+        values.self,
+        aStack,
+        bStack,
+        customTesters,
+        diffBuilder
+      );
     } else {
       diffBuilder.recordMismatch();
     }
   };
 
-  MatchersUtil.prototype.asymmetricMatch_ = function(a, b, aStack, bStack, customTesters, diffBuilder) {
+  MatchersUtil.prototype.asymmetricMatch_ = function(
+    a,
+    b,
+    aStack,
+    bStack,
+    customTesters,
+    diffBuilder
+  ) {
     var asymmetricA = j$.isAsymmetricEqualityTester_(a),
-        asymmetricB = j$.isAsymmetricEqualityTester_(b),
+      asymmetricB = j$.isAsymmetricEqualityTester_(b),
-        shim,
+      shim,
-        result;
+      result;
 
     if (asymmetricA === asymmetricB) {
       return undefined;
@@ -127,7 +152,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
    * @param [customTesters] An array of custom equality testers
    * @returns {boolean} True if the values are equal
    */
-  MatchersUtil.prototype.equals = function(a, b, customTestersOrDiffBuilder, diffBuilderOrNothing) {
+  MatchersUtil.prototype.equals = function(
+    a,
+    b,
+    customTestersOrDiffBuilder,
+    diffBuilderOrNothing
+  ) {
     var customTesters, diffBuilder;
 
     if (isDiffBuilder(customTestersOrDiffBuilder)) {
@@ -146,10 +176,26 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
 
   // Equality function lovingly adapted from isEqual in
   //   [Underscore](http://underscorejs.org)
-  MatchersUtil.prototype.eq_ = function(a, b, aStack, bStack, customTesters, diffBuilder) {
+  MatchersUtil.prototype.eq_ = function(
-    var result = true, self = this, i;
+    a,
+    b,
+    aStack,
+    bStack,
+    customTesters,
+    diffBuilder
+  ) {
+    var result = true,
+      self = this,
+      i;
 
-    var asymmetricResult = this.asymmetricMatch_(a, b, aStack, bStack, customTesters, diffBuilder);
+    var asymmetricResult = this.asymmetricMatch_(
+      a,
+      b,
+      aStack,
+      bStack,
+      customTesters,
+      diffBuilder
+    );
     if (!j$.util.isUndefined(asymmetricResult)) {
       return asymmetricResult;
     }
@@ -207,7 +253,8 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       case '[object Number]':
         // `NaN`s are equivalent, but non-reflexive. An `egal` comparison is performed for
         // other numeric values.
-        result = a != +a ? b != +b : (a === 0 && b === 0 ? 1 / a == 1 / b : a == +b);
+        result =
+          a != +a ? b != +b : a === 0 && b === 0 ? 1 / a == 1 / b : a == +b;
         if (!result) {
           diffBuilder.recordMismatch();
         }
@@ -224,10 +271,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
         return result;
       // RegExps are compared by their source patterns and flags.
       case '[object RegExp]':
-        return a.source == b.source &&
+        return (
+          a.source == b.source &&
           a.global == b.global &&
           a.multiline == b.multiline &&
-          a.ignoreCase == b.ignoreCase;
+          a.ignoreCase == b.ignoreCase
+        );
     }
     if (typeof a != 'object' || typeof b != 'object') {
       diffBuilder.recordMismatch();
@@ -261,7 +310,9 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
     while (length--) {
       // Linear search. Performance is inversely proportional to the number of
       // unique nested structures.
-      if (aStack[length] == a) { return bStack[length] == b; }
+      if (aStack[length] == a) {
+        return bStack[length] == b;
+      }
     }
     // Add the first object to the stack of traversed objects.
     aStack.push(a);
@@ -283,10 +334,20 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       for (i = 0; i < aLength || i < bLength; i++) {
         diffBuilder.withPath(i, function() {
           if (i >= bLength) {
-            diffBuilder.recordMismatch(actualArrayIsLongerFormatter.bind(null, self.pp));
+            diffBuilder.recordMismatch(
+              actualArrayIsLongerFormatter.bind(null, self.pp)
+            );
             result = false;
           } else {
-            result = self.eq_(i < aLength ? a[i] : void 0, i < bLength ? b[i] : void 0, aStack, bStack, customTesters, diffBuilder) && result;
+            result =
+              self.eq_(
+                i < aLength ? a[i] : void 0,
+                i < bLength ? b[i] : void 0,
+                aStack,
+                bStack,
+                customTesters,
+                diffBuilder
+              ) && result;
           }
         });
       }
@@ -301,11 +362,11 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
 
       var keysA = [];
       var keysB = [];
-      a.forEach( function( valueA, keyA ) {
+      a.forEach(function(valueA, keyA) {
-        keysA.push( keyA );
+        keysA.push(keyA);
       });
-      b.forEach( function( valueB, keyB ) {
+      b.forEach(function(valueB, keyB) {
-        keysB.push( keyB );
+        keysB.push(keyB);
       });
 
       // For both sets of keys, check they map to equal values in both maps.
@@ -326,13 +387,30 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
           // Only use the cmpKey when one of the keys is asymmetric and the corresponding key matches,
           // otherwise explicitly look up the mapKey in the other Map since we want keys with unique
           // obj identity (that are otherwise equal) to not match.
-          if (j$.isAsymmetricEqualityTester_(mapKey) || j$.isAsymmetricEqualityTester_(cmpKey) &&
+          if (
-              this.eq_(mapKey, cmpKey, aStack, bStack, customTesters, j$.NullDiffBuilder())) {
+            j$.isAsymmetricEqualityTester_(mapKey) ||
+            (j$.isAsymmetricEqualityTester_(cmpKey) &&
+              this.eq_(
+                mapKey,
+                cmpKey,
+                aStack,
+                bStack,
+                customTesters,
+                j$.NullDiffBuilder()
+              ))
+          ) {
             mapValueB = b.get(cmpKey);
           } else {
             mapValueB = b.get(mapKey);
           }
-          result = this.eq_(mapValueA, mapValueB, aStack, bStack, customTesters, j$.NullDiffBuilder());
+          result = this.eq_(
+            mapValueA,
+            mapValueB,
+            aStack,
+            bStack,
+            customTesters,
+            j$.NullDiffBuilder()
+          );
         }
       }
 
@@ -347,12 +425,12 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       }
 
       var valuesA = [];
-      a.forEach( function( valueA ) {
+      a.forEach(function(valueA) {
-        valuesA.push( valueA );
+        valuesA.push(valueA);
       });
       var valuesB = [];
-      b.forEach( function( valueB ) {
+      b.forEach(function(valueB) {
-        valuesB.push( valueB );
+        valuesB.push(valueB);
       });
 
       // For both sets, check they are all contained in the other set
@@ -376,7 +454,14 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
             otherValue = otherValues[l];
             prevStackSize = baseStack.length;
             // compare by value equality
-            found = this.eq_(baseValue, otherValue, baseStack, otherStack, customTesters, j$.NullDiffBuilder());
+            found = this.eq_(
+              baseValue,
+              otherValue,
+              baseStack,
+              otherStack,
+              customTesters,
+              j$.NullDiffBuilder()
+            );
             if (!found && prevStackSize !== baseStack.length) {
               baseStack.splice(prevStackSize);
               otherStack.splice(prevStackSize);
@@ -391,27 +476,35 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
         return false;
       }
     } else {
-
       // Objects with different constructors are not equivalent, but `Object`s
       // or `Array`s from different frames are.
-      var aCtor = a.constructor, bCtor = b.constructor;
+      var aCtor = a.constructor,
-      if (aCtor !== bCtor &&
+        bCtor = b.constructor;
-          isFunction(aCtor) && isFunction(bCtor) &&
+      if (
-          a instanceof aCtor && b instanceof bCtor &&
+        aCtor !== bCtor &&
-          !(aCtor instanceof aCtor && bCtor instanceof bCtor)) {
+        isFunction(aCtor) &&
-
+        isFunction(bCtor) &&
-        diffBuilder.recordMismatch(constructorsAreDifferentFormatter.bind(null, this.pp));
+        a instanceof aCtor &&
+        b instanceof bCtor &&
+        !(aCtor instanceof aCtor && bCtor instanceof bCtor)
+      ) {
+        diffBuilder.recordMismatch(
+          constructorsAreDifferentFormatter.bind(null, this.pp)
+        );
         return false;
       }
     }
 
     // Deep compare objects.
-    var aKeys = keys(a, className == '[object Array]'), key;
+    var aKeys = keys(a, className == '[object Array]'),
+      key;
     size = aKeys.length;
 
     // Ensure that both objects contain the same number of properties before comparing deep equality.
     if (keys(b, className == '[object Array]').length !== size) {
-      diffBuilder.recordMismatch(objectKeysAreDifferentFormatter.bind(null, this.pp));
+      diffBuilder.recordMismatch(
+        objectKeysAreDifferentFormatter.bind(null, this.pp)
+      );
       return false;
     }
 
@@ -419,13 +512,17 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       key = aKeys[i];
       // Deep compare each member
       if (!j$.util.has(b, key)) {
-        diffBuilder.recordMismatch(objectKeysAreDifferentFormatter.bind(null, this.pp));
+        diffBuilder.recordMismatch(
+          objectKeysAreDifferentFormatter.bind(null, this.pp)
+        );
         result = false;
         continue;
       }
 
       diffBuilder.withPath(key, function() {
-        if(!self.eq_(a[key], b[key], aStack, bStack, customTesters, diffBuilder)) {
+        if (
+          !self.eq_(a[key], b[key], aStack, bStack, customTesters, diffBuilder)
+        ) {
           result = false;
         }
       });
@@ -443,23 +540,24 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
   };
 
   function keys(obj, isArray) {
-    var allKeys = Object.keys ? Object.keys(obj) :
+    var allKeys = Object.keys
-      (function(o) {
+      ? Object.keys(obj)
+      : (function(o) {
           var keys = [];
           for (var key in o) {
-              if (j$.util.has(o, key)) {
+            if (j$.util.has(o, key)) {
-                  keys.push(key);
+              keys.push(key);
-              }
+            }
           }
           return keys;
-      })(obj);
+        })(obj);
 
     if (!isArray) {
       return allKeys;
     }
 
     if (allKeys.length === 0) {
-        return allKeys;
+      return allKeys;
     }
 
     var extraKeys = [];
@@ -478,21 +576,25 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
 
   function objectKeysAreDifferentFormatter(pp, actual, expected, path) {
     var missingProperties = j$.util.objectDifference(expected, actual),
-        extraProperties = j$.util.objectDifference(actual, expected),
+      extraProperties = j$.util.objectDifference(actual, expected),
-        missingPropertiesMessage = formatKeyValuePairs(pp, missingProperties),
+      missingPropertiesMessage = formatKeyValuePairs(pp, missingProperties),
-        extraPropertiesMessage = formatKeyValuePairs(pp, extraProperties),
+      extraPropertiesMessage = formatKeyValuePairs(pp, extraProperties),
-        messages = [];
+      messages = [];
 
     if (!path.depth()) {
       path = 'object';
     }
 
     if (missingPropertiesMessage.length) {
-      messages.push('Expected ' + path + ' to have properties' + missingPropertiesMessage);
+      messages.push(
+        'Expected ' + path + ' to have properties' + missingPropertiesMessage
+      );
     }
 
     if (extraPropertiesMessage.length) {
-      messages.push('Expected ' + path + ' not to have properties' + extraPropertiesMessage);
+      messages.push(
+        'Expected ' + path + ' not to have properties' + extraPropertiesMessage
+      );
     }
 
     return messages.join('\n');
@@ -503,17 +605,25 @@ getJasmineRequireObj().MatchersUtil = function(j$) {
       path = 'object';
     }
 
-    return 'Expected ' +
+    return (
-      path + ' to be a kind of ' +
+      'Expected ' +
+      path +
+      ' to be a kind of ' +
       j$.fnNameFor(expected.constructor) +
-      ', but was ' + pp(actual) + '.';
+      ', but was ' +
+      pp(actual) +
+      '.'
+    );
   }
 
   function actualArrayIsLongerFormatter(pp, actual, expected, path) {
-    return 'Unexpected ' +
+    return (
-      path + (path.depth() ? ' = ' : '') +
+      'Unexpected ' +
+      path +
+      (path.depth() ? ' = ' : '') +
       pp(actual) +
-      ' in array.';
+      ' in array.'
+    );
   }
 
   function formatKeyValuePairs(pp, obj) {

src/core/matchers/toBe.js

@@ -9,7 +9,8 @@ getJasmineRequireObj().toBe = function(j$) {
    * expect(thing).toBe(realThing);
    */
   function toBe(matchersUtil) {
-    var tip = ' Tip: To check for deep equality, use .toEqual() instead of .toBe().';
+    var tip =
+      ' Tip: To check for deep equality, use .toEqual() instead of .toBe().';
 
     return {
       compare: function(actual, expected) {
@@ -18,7 +19,13 @@ getJasmineRequireObj().toBe = function(j$) {
         };
 
         if (typeof expected === 'object') {
-          result.message = matchersUtil.buildFailureMessage('toBe', result.pass, actual, expected) + tip;
+          result.message =
+            matchersUtil.buildFailureMessage(
+              'toBe',
+              result.pass,
+              actual,
+              expected
+            ) + tip;
         }
 
         return result;

src/core/matchers/toBeCloseTo.js

@@ -17,8 +17,13 @@ getJasmineRequireObj().toBeCloseTo = function() {
         }
 
         if (expected === null || actual === null) {
-          throw new Error('Cannot use toBeCloseTo with null. Arguments evaluated to: ' +
+          throw new Error(
-            'expect(' + actual + ').toBeCloseTo(' + expected + ').'
+            'Cannot use toBeCloseTo with null. Arguments evaluated to: ' +
+              'expect(' +
+              actual +
+              ').toBeCloseTo(' +
+              expected +
+              ').'
           );
         }
 

src/core/matchers/toBeDefined.js

@@ -11,7 +11,7 @@ getJasmineRequireObj().toBeDefined = function() {
     return {
       compare: function(actual) {
         return {
-          pass: (void 0 !== actual)
+          pass: void 0 !== actual
         };
       }
     };

src/core/matchers/toBeGreaterThan.js

@@ -20,4 +20,3 @@ getJasmineRequireObj().toBeGreaterThan = function() {
 
   return toBeGreaterThan;
 };
-

src/core/matchers/toBeInstanceOf.js

@@ -1,5 +1,8 @@
 getJasmineRequireObj().toBeInstanceOf = function(j$) {
-  var usageError =  j$.formatErrorMsg('<toBeInstanceOf>', 'expect(value).toBeInstanceOf(<ConstructorFunction>)');
+  var usageError = j$.formatErrorMsg(
+    '<toBeInstanceOf>',
+    'expect(value).toBeInstanceOf(<ConstructorFunction>)'
+  );
 
   /**
    * {@link expect} the actual to be an instance of the expected class
@@ -15,27 +18,42 @@ getJasmineRequireObj().toBeInstanceOf = function(j$) {
   function toBeInstanceOf(matchersUtil) {
     return {
       compare: function(actual, expected) {
-        var actualType = actual && actual.constructor ? j$.fnNameFor(actual.constructor) : matchersUtil.pp(actual),
+        var actualType =
-            expectedType = expected ? j$.fnNameFor(expected) : matchersUtil.pp(expected),
+            actual && actual.constructor
-            expectedMatcher,
+              ? j$.fnNameFor(actual.constructor)
-            pass;
+              : matchersUtil.pp(actual),
+          expectedType = expected
+            ? j$.fnNameFor(expected)
+            : matchersUtil.pp(expected),
+          expectedMatcher,
+          pass;
 
         try {
-            expectedMatcher = new j$.Any(expected);
+          expectedMatcher = new j$.Any(expected);
-            pass = expectedMatcher.asymmetricMatch(actual);
+          pass = expectedMatcher.asymmetricMatch(actual);
         } catch (error) {
-            throw new Error(usageError('Expected value is not a constructor function'));
+          throw new Error(
+            usageError('Expected value is not a constructor function')
+          );
         }
 
         if (pass) {
           return {
             pass: true,
-            message: 'Expected instance of ' + actualType + ' not to be an instance of ' + expectedType
+            message:
+              'Expected instance of ' +
+              actualType +
+              ' not to be an instance of ' +
+              expectedType
           };
         } else {
           return {
             pass: false,
-            message: 'Expected instance of ' + actualType + ' to be an instance of ' + expectedType
+            message:
+              'Expected instance of ' +
+              actualType +
+              ' to be an instance of ' +
+              expectedType
           };
         }
       }

src/core/matchers/toBeLessThan.js

@@ -10,7 +10,6 @@ getJasmineRequireObj().toBeLessThan = function() {
    */
   function toBeLessThan() {
     return {
-
       compare: function(actual, expected) {
         return {
           pass: actual < expected

src/core/matchers/toBeLessThanOrEqual.js

@@ -10,7 +10,6 @@ getJasmineRequireObj().toBeLessThanOrEqual = function() {
    */
   function toBeLessThanOrEqual() {
     return {
-
       compare: function(actual, expected) {
         return {
           pass: actual <= expected

src/core/matchers/toBeNaN.js

@@ -11,13 +11,15 @@ getJasmineRequireObj().toBeNaN = function(j$) {
     return {
       compare: function(actual) {
         var result = {
-          pass: (actual !== actual)
+          pass: actual !== actual
         };
 
         if (result.pass) {
           result.message = 'Expected actual not to be NaN.';
         } else {
-          result.message = function() { return 'Expected ' + matchersUtil.pp(actual) + ' to be NaN.'; };
+          result.message = function() {
+            return 'Expected ' + matchersUtil.pp(actual) + ' to be NaN.';
+          };
         }
 
         return result;

src/core/matchers/toBeNegativeInfinity.js

@@ -11,13 +11,15 @@ getJasmineRequireObj().toBeNegativeInfinity = function(j$) {
     return {
       compare: function(actual) {
         var result = {
-          pass: (actual === Number.NEGATIVE_INFINITY)
+          pass: actual === Number.NEGATIVE_INFINITY
         };
 
         if (result.pass) {
           result.message = 'Expected actual not to be -Infinity.';
         } else {
-          result.message = function() { return 'Expected ' + matchersUtil.pp(actual) + ' to be -Infinity.'; };
+          result.message = function() {
+            return 'Expected ' + matchersUtil.pp(actual) + ' to be -Infinity.';
+          };
         }
 
         return result;

src/core/matchers/toBePositiveInfinity.js

@@ -11,13 +11,15 @@ getJasmineRequireObj().toBePositiveInfinity = function(j$) {
     return {
       compare: function(actual) {
         var result = {
-          pass: (actual === Number.POSITIVE_INFINITY)
+          pass: actual === Number.POSITIVE_INFINITY
         };
 
         if (result.pass) {
           result.message = 'Expected actual not to be Infinity.';
         } else {
-          result.message = function() { return 'Expected ' + matchersUtil.pp(actual) + ' to be Infinity.'; };
+          result.message = function() {
+            return 'Expected ' + matchersUtil.pp(actual) + ' to be Infinity.';
+          };
         }
 
         return result;

src/core/matchers/toContain.js

@@ -12,7 +12,6 @@ getJasmineRequireObj().toContain = function() {
   function toContain(matchersUtil) {
     return {
       compare: function(actual, expected) {
-
         return {
           pass: matchersUtil.contains(actual, expected)
         };

src/core/matchers/toEqual.js

@@ -14,7 +14,7 @@ getJasmineRequireObj().toEqual = function(j$) {
         var result = {
             pass: false
           },
-          diffBuilder = j$.DiffBuilder({prettyPrinter: matchersUtil.pp});
+          diffBuilder = j$.DiffBuilder({ prettyPrinter: matchersUtil.pp });
 
         result.pass = matchersUtil.equals(actual, expected, diffBuilder);
 

src/core/matchers/toHaveBeenCalled.js

@@ -1,6 +1,8 @@
 getJasmineRequireObj().toHaveBeenCalled = function(j$) {
-
+  var getErrorMsg = j$.formatErrorMsg(
-  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalled>', 'expect(<spyObj>).toHaveBeenCalled()');
+    '<toHaveBeenCalled>',
+    'expect(<spyObj>).toHaveBeenCalled()'
+  );
 
   /**
    * {@link expect} the actual (a {@link Spy}) to have been called.
@@ -17,18 +19,24 @@ getJasmineRequireObj().toHaveBeenCalled = function(j$) {
         var result = {};
 
         if (!j$.isSpy(actual)) {
-          throw new Error(getErrorMsg('Expected a spy, but got ' + matchersUtil.pp(actual) + '.'));
+          throw new Error(
+            getErrorMsg(
+              'Expected a spy, but got ' + matchersUtil.pp(actual) + '.'
+            )
+          );
         }
 
         if (arguments.length > 1) {
-          throw new Error(getErrorMsg('Does not take arguments, use toHaveBeenCalledWith'));
+          throw new Error(
+            getErrorMsg('Does not take arguments, use toHaveBeenCalledWith')
+          );
         }
 
         result.pass = actual.calls.any();
 
-        result.message = result.pass ?
+        result.message = result.pass
-          'Expected spy ' + actual.and.identity + ' not to have been called.' :
+          ? 'Expected spy ' + actual.and.identity + ' not to have been called.'
-          'Expected spy ' + actual.and.identity + ' to have been called.';
+          : 'Expected spy ' + actual.and.identity + ' to have been called.';
 
         return result;
       }

src/core/matchers/toHaveBeenCalledBefore.js

@@ -1,6 +1,8 @@
 getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
-
+  var getErrorMsg = j$.formatErrorMsg(
-  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledBefore>', 'expect(<spyObj>).toHaveBeenCalledBefore(<spyObj>)');
+    '<toHaveBeenCalledBefore>',
+    'expect(<spyObj>).toHaveBeenCalledBefore(<spyObj>)'
+  );
 
   /**
    * {@link expect} the actual value (a {@link Spy}) to have been called before another {@link Spy}.
@@ -15,20 +17,30 @@ getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
     return {
       compare: function(firstSpy, latterSpy) {
         if (!j$.isSpy(firstSpy)) {
-          throw new Error(getErrorMsg('Expected a spy, but got ' + matchersUtil.pp(firstSpy) + '.'));
+          throw new Error(
+            getErrorMsg(
+              'Expected a spy, but got ' + matchersUtil.pp(firstSpy) + '.'
+            )
+          );
         }
         if (!j$.isSpy(latterSpy)) {
-          throw new Error(getErrorMsg('Expected a spy, but got ' + matchersUtil.pp(latterSpy) + '.'));
+          throw new Error(
+            getErrorMsg(
+              'Expected a spy, but got ' + matchersUtil.pp(latterSpy) + '.'
+            )
+          );
         }
 
         var result = { pass: false };
 
         if (!firstSpy.calls.count()) {
-          result.message = 'Expected spy ' +  firstSpy.and.identity + ' to have been called.';
+          result.message =
+            'Expected spy ' + firstSpy.and.identity + ' to have been called.';
           return result;
         }
         if (!latterSpy.calls.count()) {
-          result.message = 'Expected spy ' +  latterSpy.and.identity + ' to have been called.';
+          result.message =
+            'Expected spy ' + latterSpy.and.identity + ' to have been called.';
           return result;
         }
 
@@ -38,17 +50,36 @@ getJasmineRequireObj().toHaveBeenCalledBefore = function(j$) {
         result.pass = latest1stSpyCall < first2ndSpyCall;
 
         if (result.pass) {
-          result.message = 'Expected spy ' + firstSpy.and.identity + ' to not have been called before spy ' + latterSpy.and.identity + ', but it was';
+          result.message =
+            'Expected spy ' +
+            firstSpy.and.identity +
+            ' to not have been called before spy ' +
+            latterSpy.and.identity +
+            ', but it was';
         } else {
           var first1stSpyCall = firstSpy.calls.first().invocationOrder;
           var latest2ndSpyCall = latterSpy.calls.mostRecent().invocationOrder;
 
-          if(first1stSpyCall < first2ndSpyCall) {
+          if (first1stSpyCall < first2ndSpyCall) {
-            result.message = 'Expected latest call to spy ' + firstSpy.and.identity + ' to have been called before first call to spy ' + latterSpy.and.identity + ' (no interleaved calls)';
+            result.message =
+              'Expected latest call to spy ' +
+              firstSpy.and.identity +
+              ' to have been called before first call to spy ' +
+              latterSpy.and.identity +
+              ' (no interleaved calls)';
           } else if (latest2ndSpyCall > latest1stSpyCall) {
-            result.message = 'Expected first call to spy ' + latterSpy.and.identity + ' to have been called after latest call to spy ' + firstSpy.and.identity + ' (no interleaved calls)';
+            result.message =
+              'Expected first call to spy ' +
+              latterSpy.and.identity +
+              ' to have been called after latest call to spy ' +
+              firstSpy.and.identity +
+              ' (no interleaved calls)';
           } else {
-            result.message = 'Expected spy ' + firstSpy.and.identity + ' to have been called before spy ' + latterSpy.and.identity;
+            result.message =
+              'Expected spy ' +
+              firstSpy.and.identity +
+              ' to have been called before spy ' +
+              latterSpy.and.identity;
           }
         }
 

src/core/matchers/toHaveBeenCalledOnceWith.js

@@ -1,6 +1,8 @@
-getJasmineRequireObj().toHaveBeenCalledOnceWith = function (j$) {
+getJasmineRequireObj().toHaveBeenCalledOnceWith = function(j$) {
-
+  var getErrorMsg = j$.formatErrorMsg(
-  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledOnceWith>', 'expect(<spyObj>).toHaveBeenCalledOnceWith(...arguments)');
+    '<toHaveBeenCalledOnceWith>',
+    'expect(<spyObj>).toHaveBeenCalledOnceWith(...arguments)'
+  );
 
   /**
    * {@link expect} the actual (a {@link Spy}) to have been called exactly once, and exactly with the particular arguments.
@@ -13,31 +15,44 @@ getJasmineRequireObj().toHaveBeenCalledOnceWith = function (j$) {
    */
   function toHaveBeenCalledOnceWith(util) {
     return {
-      compare: function () {
+      compare: function() {
         var args = Array.prototype.slice.call(arguments, 0),
           actual = args[0],
           expectedArgs = args.slice(1);
 
         if (!j$.isSpy(actual)) {
-          throw new Error(getErrorMsg('Expected a spy, but got ' + util.pp(actual) + '.'));
+          throw new Error(
+            getErrorMsg('Expected a spy, but got ' + util.pp(actual) + '.')
+          );
         }
 
-        var prettyPrintedCalls = actual.calls.allArgs().map(function (argsForCall) {
+        var prettyPrintedCalls = actual.calls
-          return '  ' + util.pp(argsForCall);
+          .allArgs()
-        });
+          .map(function(argsForCall) {
+            return '  ' + util.pp(argsForCall);
+          });
 
-        if (actual.calls.count() === 1 && util.contains(actual.calls.allArgs(), expectedArgs)) {
+        if (
+          actual.calls.count() === 1 &&
+          util.contains(actual.calls.allArgs(), expectedArgs)
+        ) {
           return {
             pass: true,
-            message: 'Expected spy ' + actual.and.identity + ' to have been called 0 times, multiple times, or once, but with arguments different from:\n'
+            message:
-              + '  ' + util.pp(expectedArgs) + '\n'
+              'Expected spy ' +
-              + 'But the actual call was:\n'
+              actual.and.identity +
-              + prettyPrintedCalls.join(',\n') + '.\n\n'
+              ' to have been called 0 times, multiple times, or once, but with arguments different from:\n' +
+              '  ' +
+              util.pp(expectedArgs) +
+              '\n' +
+              'But the actual call was:\n' +
+              prettyPrintedCalls.join(',\n') +
+              '.\n\n'
           };
         }
 
         function getDiffs() {
-          return actual.calls.allArgs().map(function (argsForCall, callIx) {
+          return actual.calls.allArgs().map(function(argsForCall, callIx) {
             var diffBuilder = new j$.DiffBuilder();
             util.equals(argsForCall, expectedArgs, diffBuilder);
             return diffBuilder.getMessage();
@@ -49,17 +64,32 @@ getJasmineRequireObj().toHaveBeenCalledOnceWith = function (j$) {
             case 0:
               return 'But it was never called.\n\n';
             case 1:
-              return 'But the actual call was:\n' + prettyPrintedCalls.join(',\n') + '.\n' + getDiffs().join('\n') + '\n\n';
+              return (
+                'But the actual call was:\n' +
+                prettyPrintedCalls.join(',\n') +
+                '.\n' +
+                getDiffs().join('\n') +
+                '\n\n'
+              );
             default:
-              return 'But the actual calls were:\n' + prettyPrintedCalls.join(',\n') + '.\n\n';
+              return (
+                'But the actual calls were:\n' +
+                prettyPrintedCalls.join(',\n') +
+                '.\n\n'
+              );
           }
         }
 
         return {
           pass: false,
-          message: 'Expected spy ' + actual.and.identity + ' to have been called only once, and with given args:\n'
+          message:
-            + '  ' + util.pp(expectedArgs) + '\n'
+            'Expected spy ' +
-            + butString()
+            actual.and.identity +
+            ' to have been called only once, and with given args:\n' +
+            '  ' +
+            util.pp(expectedArgs) +
+            '\n' +
+            butString()
         };
       }
     };