add prettier and eslint

spec/core/AsyncExpectationSpec.js

@@ -1,22 +1,30 @@
 describe('AsyncExpectation', function() {
   beforeEach(function() {
-    jasmineUnderTest.Expectation.addAsyncCoreMatchers(jasmineUnderTest.asyncMatchers);
+    jasmineUnderTest.Expectation.addAsyncCoreMatchers(
+      jasmineUnderTest.asyncMatchers
+    );
   });
 
   describe('Factory', function() {
     it('throws an Error if promises are not available', function() {
-      var thenable = {then: function() {}},
-        options = {global: {}, actual: thenable}
-      function f() { jasmineUnderTest.Expectation.asyncFactory(options); }
-      expect(f).toThrowError('expectAsync is unavailable because the environment does not support promises.');
+      var thenable = { then: function() {} },
+        options = { global: {}, actual: thenable };
+      function f() {
+        jasmineUnderTest.Expectation.asyncFactory(options);
+      }
+      expect(f).toThrowError(
+        'expectAsync is unavailable because the environment does not support promises.'
+      );
     });
 
     it('throws an Error if the argument is not a promise', function() {
       jasmine.getEnv().requirePromises();
       function f() {
-        jasmineUnderTest.Expectation.asyncFactory({actual: 'not a promise'});
+        jasmineUnderTest.Expectation.asyncFactory({ actual: 'not a promise' });
       }
-      expect(f).toThrowError('Expected expectAsync to be called with a promise.');
+      expect(f).toThrowError(
+        'Expected expectAsync to be called with a promise.'
+      );
     });
   });
 
@@ -33,7 +41,8 @@ describe('AsyncExpectation', function() {
         });
 
       return expectation.not.toBeResolved().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(false,
+        expect(addExpectationResult).toHaveBeenCalledWith(
+          false,
           jasmine.objectContaining({
             passed: false,
             message: 'Expected a promise not to be resolved.'
@@ -54,7 +63,8 @@ describe('AsyncExpectation', function() {
         });
 
       return expectation.not.toBeResolved().then(function() {
-        expect(addExpectationResult).toHaveBeenCalledWith(true,
+        expect(addExpectationResult).toHaveBeenCalledWith(
+          true,
           jasmine.objectContaining({
             passed: true,
             message: ''
@@ -68,7 +78,6 @@ describe('AsyncExpectation', function() {
     jasmine.getEnv().requirePromises();
     var error = new Error('ExpectationSpec failure');
 
-
     var addExpectationResult = jasmine.createSpy('addExpectationResult'),
       actual = dummyPromise(),
       expectation = jasmineUnderTest.Expectation.asyncFactory({
@@ -76,22 +85,26 @@ describe('AsyncExpectation', function() {
         addExpectationResult: addExpectationResult
       });
 
-    spyOn(expectation, 'toBeResolved')
-      .and.returnValue(Promise.reject(error));
+    spyOn(expectation, 'toBeResolved').and.returnValue(Promise.reject(error));
 
-    return expectation.toBeResolved()
-      .then(
-        function() { fail('Expected a rejection'); },
-        function(e) { expect(e).toBe(error); }
-      );
+    return expectation.toBeResolved().then(
+      function() {
+        fail('Expected a rejection');
+      },
+      function(e) {
+        expect(e).toBe(error);
+      }
+    );
   });
 
   describe('#withContext', function() {
-    it("prepends the context to the generated failure message", function() {
+    it('prepends the context to the generated failure message', function() {
       jasmine.getEnv().requirePromises();
 
       var util = {
-          buildFailureMessage: function() { return 'failure message'; }
+          buildFailureMessage: function() {
+            return 'failure message';
+          }
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.asyncFactory({
@@ -100,21 +113,26 @@ describe('AsyncExpectation', function() {
           util: util
         });
 
-      return expectation.withContext('Some context').toBeResolved()
-        .then(
-          function() {
-            expect(addExpectationResult).toHaveBeenCalledWith(false,
-              jasmine.objectContaining({
-                message: 'Some context: failure message'
-              }));
-          });
+      return expectation
+        .withContext('Some context')
+        .toBeResolved()
+        .then(function() {
+          expect(addExpectationResult).toHaveBeenCalledWith(
+            false,
+            jasmine.objectContaining({
+              message: 'Some context: failure message'
+            })
+          );
+        });
     });
 
-    it("prepends the context to a custom failure message", function() {
+    it('prepends the context to a custom failure message', function() {
       jasmine.getEnv().requirePromises();
 
       var util = {
-          buildFailureMessage: function() { return 'failure message'; }
+          buildFailureMessage: function() {
+            return 'failure message';
+          }
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.asyncFactory({
@@ -123,22 +141,28 @@ describe('AsyncExpectation', function() {
           util: util
         });
 
-      return expectation.withContext('Some context').toBeResolvedTo('a')
-        .then(
-          function() {
-            expect(addExpectationResult).toHaveBeenCalledWith(false,
-              jasmine.objectContaining({
-                message: "Some context: Expected a promise to be resolved to 'a' but it was rejected."
-              }));
-          });
+      return expectation
+        .withContext('Some context')
+        .toBeResolvedTo('a')
+        .then(function() {
+          expect(addExpectationResult).toHaveBeenCalledWith(
+            false,
+            jasmine.objectContaining({
+              message:
+                "Some context: Expected a promise to be resolved to 'a' but it was rejected."
+            })
+          );
+        });
     });
 
-    it("prepends the context to a custom failure message from a function", function() {
+    it('prepends the context to a custom failure message from a function', function() {
       pending('should actually work, but no custom matchers for async yet');
       jasmine.getEnv().requirePromises();
 
       var util = {
-          buildFailureMessage: function() { return 'failure message'; }
+          buildFailureMessage: function() {
+            return 'failure message';
+          }
         },
         addExpectationResult = jasmine.createSpy('addExpectationResult'),
         actual = Promise.reject(),
@@ -148,17 +172,20 @@ describe('AsyncExpectation', function() {
           util: util
         });
 
-      return expectation.withContext('Some context').toBeResolved()
-        .then(
-          function() {
-            expect(addExpectationResult).toHaveBeenCalledWith(false,
-              jasmine.objectContaining({
-                message: 'Some context: msg'
-              }));
-          });
+      return expectation
+        .withContext('Some context')
+        .toBeResolved()
+        .then(function() {
+          expect(addExpectationResult).toHaveBeenCalledWith(
+            false,
+            jasmine.objectContaining({
+              message: 'Some context: msg'
+            })
+          );
+        });
     });
 
-    it("works with #not", function() {
+    it('works with #not', function() {
       jasmine.getEnv().requirePromises();
 
       var addExpectationResult = jasmine.createSpy('addExpectationResult'),
@@ -169,17 +196,20 @@ describe('AsyncExpectation', function() {
           util: jasmineUnderTest.matchersUtil
         });
 
-      return expectation.withContext('Some context').not.toBeResolved()
-        .then(
-          function() {
-            expect(addExpectationResult).toHaveBeenCalledWith(false,
-              jasmine.objectContaining({
-                message: 'Some context: Expected a promise not to be resolved.'
-              }));
-          });
+      return expectation
+        .withContext('Some context')
+        .not.toBeResolved()
+        .then(function() {
+          expect(addExpectationResult).toHaveBeenCalledWith(
+            false,
+            jasmine.objectContaining({
+              message: 'Some context: Expected a promise not to be resolved.'
+            })
+          );
+        });
     });
 
-    it("works with #not and a custom message", function() {
+    it('works with #not and a custom message', function() {
       jasmine.getEnv().requirePromises();
 
       var addExpectationResult = jasmine.createSpy('addExpectationResult'),
@@ -190,19 +220,22 @@ describe('AsyncExpectation', function() {
           util: jasmineUnderTest.matchersUtil
         });
 
-      return expectation.withContext('Some context').not.toBeResolvedTo('a')
-        .then(
-          function() {
-            expect(addExpectationResult).toHaveBeenCalledWith(false,
-              jasmine.objectContaining({
-                message: "Some context: Expected a promise not to be resolved to 'a'."
-              }));
-          });
+      return expectation
+        .withContext('Some context')
+        .not.toBeResolvedTo('a')
+        .then(function() {
+          expect(addExpectationResult).toHaveBeenCalledWith(
+            false,
+            jasmine.objectContaining({
+              message:
+                "Some context: Expected a promise not to be resolved to 'a'."
+            })
+          );
+        });
     });
   });
 
   function dummyPromise() {
-    return new Promise(function(resolve, reject) {
-    });
+    return new Promise(function(resolve, reject) {});
   }
 });

spec/core/CallTrackerSpec.js

@@ -1,5 +1,5 @@
-describe("CallTracker", function() {
-  it("tracks that it was called when executed", function() {
+describe('CallTracker', function() {
+  it('tracks that it was called when executed', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.any()).toBe(false);
@@ -9,7 +9,7 @@ describe("CallTracker", function() {
     expect(callTracker.any()).toBe(true);
   });
 
-  it("tracks that number of times that it is executed", function() {
+  it('tracks that number of times that it is executed', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.count()).toEqual(0);
@@ -19,52 +19,52 @@ describe("CallTracker", function() {
     expect(callTracker.count()).toEqual(1);
   });
 
-  it("tracks the params from each execution", function() {
+  it('tracks the params from each execution', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
-    callTracker.track({object: void 0, args: []});
-    callTracker.track({object: {}, args: [0, "foo"]});
+    callTracker.track({ object: void 0, args: [] });
+    callTracker.track({ object: {}, args: [0, 'foo'] });
 
     expect(callTracker.argsFor(0)).toEqual([]);
 
-    expect(callTracker.argsFor(1)).toEqual([0, "foo"]);
+    expect(callTracker.argsFor(1)).toEqual([0, 'foo']);
   });
 
-  it("returns any empty array when there was no call", function() {
+  it('returns any empty array when there was no call', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
     expect(callTracker.argsFor(0)).toEqual([]);
   });
 
-  it("allows access for the arguments for all calls", function() {
+  it('allows access for the arguments for all calls', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
-    callTracker.track({object: {}, args: []});
-    callTracker.track({object: {}, args: [0, "foo"]});
+    callTracker.track({ object: {}, args: [] });
+    callTracker.track({ object: {}, args: [0, 'foo'] });
 
-    expect(callTracker.allArgs()).toEqual([[], [0, "foo"]]);
+    expect(callTracker.allArgs()).toEqual([[], [0, 'foo']]);
   });
 
-  it("tracks the context and arguments for each call", function() {
+  it('tracks the context and arguments for each call', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
-    callTracker.track({object: {}, args: []});
-    callTracker.track({object: {}, args: [0, "foo"]});
+    callTracker.track({ object: {}, args: [] });
+    callTracker.track({ object: {}, args: [0, 'foo'] });
 
-    expect(callTracker.all()[0]).toEqual({object: {}, args: []});
+    expect(callTracker.all()[0]).toEqual({ object: {}, args: [] });
 
-    expect(callTracker.all()[1]).toEqual({object: {}, args: [0, "foo"]});
+    expect(callTracker.all()[1]).toEqual({ object: {}, args: [0, 'foo'] });
   });
 
-  it("simplifies access to the arguments for the last (most recent) call", function() {
+  it('simplifies access to the arguments for the last (most recent) call', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track();
-    callTracker.track({object: {}, args: [0, "foo"]});
+    callTracker.track({ object: {}, args: [0, 'foo'] });
 
     expect(callTracker.mostRecent()).toEqual({
       object: {},
-      args: [0, "foo"]
+      args: [0, 'foo']
     });
   });
 
@@ -74,12 +74,12 @@ describe("CallTracker", function() {
     expect(callTracker.mostRecent()).toBeFalsy();
   });
 
-  it("simplifies access to the arguments for the first (oldest) call", function() {
+  it('simplifies access to the arguments for the first (oldest) call', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
-    callTracker.track({object: {}, args: [0, "foo"]});
+    callTracker.track({ object: {}, args: [0, 'foo'] });
 
-    expect(callTracker.first()).toEqual({object: {}, args: [0, "foo"]})
+    expect(callTracker.first()).toEqual({ object: {}, args: [0, 'foo'] });
   });
 
   it("returns a useful falsy value when there isn't a first (oldest) call", function() {
@@ -88,12 +88,11 @@ describe("CallTracker", function() {
     expect(callTracker.first()).toBeFalsy();
   });
 
-
-  it("allows the tracking to be reset", function() {
+  it('allows the tracking to be reset', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
 
     callTracker.track();
-    callTracker.track({object: {}, args: [0, "foo"]});
+    callTracker.track({ object: {}, args: [0, 'foo'] });
     callTracker.reset();
 
     expect(callTracker.any()).toBe(false);
@@ -103,14 +102,17 @@ describe("CallTracker", function() {
     expect(callTracker.mostRecent()).toBeFalsy();
   });
 
-  it("allows object arguments to be shallow cloned", function() {
+  it('allows object arguments to be shallow cloned', function() {
     var callTracker = new jasmineUnderTest.CallTracker();
     callTracker.saveArgumentsByValue();
 
-    var objectArg = {"foo": "bar"},
-        arrayArg = ["foo", "bar"];
+    var objectArg = { foo: 'bar' },
+      arrayArg = ['foo', 'bar'];
 
-    callTracker.track({object: {}, args: [objectArg, arrayArg, false, undefined, null, NaN, "", 0, 1.0]});
+    callTracker.track({
+      object: {},
+      args: [objectArg, arrayArg, false, undefined, null, NaN, '', 0, 1.0]
+    });
 
     expect(callTracker.mostRecent().args[0]).not.toBe(objectArg);
     expect(callTracker.mostRecent().args[0]).toEqual(objectArg);

spec/core/ClearStackSpec.js

@@ -1,17 +1,23 @@
-describe("ClearStack", function() {
-  it("works in an integrationy way", function(done) {
-    var clearStack = jasmineUnderTest.getClearStack(jasmineUnderTest.getGlobal());
+describe('ClearStack', function() {
+  it('works in an integrationy way', function(done) {
+    var clearStack = jasmineUnderTest.getClearStack(
+      jasmineUnderTest.getGlobal()
+    );
 
     clearStack(function() {
       done();
     });
   });
 
-  it("uses setImmediate when available", function() {
-    var setImmediate = jasmine.createSpy('setImmediate').and.callFake(function(fn) { fn() }),
-        global = { setImmediate: setImmediate },
-        clearStack = jasmineUnderTest.getClearStack(global),
-        called = false;
+  it('uses setImmediate when available', function() {
+    var setImmediate = jasmine
+        .createSpy('setImmediate')
+        .and.callFake(function(fn) {
+          fn();
+        }),
+      global = { setImmediate: setImmediate },
+      clearStack = jasmineUnderTest.getClearStack(global),
+      called = false;
 
     clearStack(function() {
       called = true;
@@ -21,42 +27,50 @@ describe("ClearStack", function() {
     expect(setImmediate).toHaveBeenCalled();
   });
 
-  it("uses setTimeout instead of setImmediate every 10 calls to make sure we release the CPU", function() {
+  it('uses setTimeout instead of setImmediate every 10 calls to make sure we release the CPU', function() {
     var setImmediate = jasmine.createSpy('setImmediate'),
-        setTimeout = jasmine.createSpy('setTimeout'),
-        global = { setImmediate: setImmediate, setTimeout: setTimeout },
-        clearStack = jasmineUnderTest.getClearStack(global);
+      setTimeout = jasmine.createSpy('setTimeout'),
+      global = { setImmediate: setImmediate, setTimeout: setTimeout },
+      clearStack = jasmineUnderTest.getClearStack(global);
 
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
 
     expect(setImmediate).toHaveBeenCalled();
     expect(setTimeout).not.toHaveBeenCalled();
 
-    clearStack(function() { });
+    clearStack(function() {});
     expect(setImmediate.calls.count()).toEqual(9);
     expect(setTimeout.calls.count()).toEqual(1);
 
-    clearStack(function() { });
+    clearStack(function() {});
     expect(setImmediate.calls.count()).toEqual(10);
     expect(setTimeout.calls.count()).toEqual(1);
   });
 
-  it("uses MessageChannels when available", function() {
+  it('uses MessageChannels when available', function() {
     var fakeChannel = {
-          port1: {},
-          port2: { postMessage: function() { fakeChannel.port1.onmessage(); } }
-        },
-        global = { MessageChannel: function() { return fakeChannel; } },
-        clearStack = jasmineUnderTest.getClearStack(global),
-        called = false;
+        port1: {},
+        port2: {
+          postMessage: function() {
+            fakeChannel.port1.onmessage();
+          }
+        }
+      },
+      global = {
+        MessageChannel: function() {
+          return fakeChannel;
+        }
+      },
+      clearStack = jasmineUnderTest.getClearStack(global),
+      called = false;
 
     clearStack(function() {
       called = true;
@@ -65,53 +79,66 @@ describe("ClearStack", function() {
     expect(called).toBe(true);
   });
 
-  it("uses setTimeout instead of MessageChannel every 10 calls to make sure we release the CPU", function() {
+  it('uses setTimeout instead of MessageChannel every 10 calls to make sure we release the CPU', function() {
     var fakeChannel = {
-          port1: {},
-          port2: {
-            postMessage: jasmine.createSpy('postMessage').and.callFake(function() {
+        port1: {},
+        port2: {
+          postMessage: jasmine
+            .createSpy('postMessage')
+            .and.callFake(function() {
               fakeChannel.port1.onmessage();
             })
-          }
+        }
+      },
+      setTimeout = jasmine.createSpy('setTimeout'),
+      global = {
+        MessageChannel: function() {
+          return fakeChannel;
         },
-        setTimeout = jasmine.createSpy('setTimeout'),
-        global = { MessageChannel: function() { return fakeChannel; }, setTimeout: setTimeout },
-        clearStack = jasmineUnderTest.getClearStack(global);
+        setTimeout: setTimeout
+      },
+      clearStack = jasmineUnderTest.getClearStack(global);
 
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
-    clearStack(function() { });
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
+    clearStack(function() {});
 
     expect(fakeChannel.port2.postMessage).toHaveBeenCalled();
     expect(setTimeout).not.toHaveBeenCalled();
 
-    clearStack(function() { });
+    clearStack(function() {});
     expect(fakeChannel.port2.postMessage.calls.count()).toEqual(9);
     expect(setTimeout.calls.count()).toEqual(1);
 
-    clearStack(function() { });
+    clearStack(function() {});
     expect(fakeChannel.port2.postMessage.calls.count()).toEqual(10);
     expect(setTimeout.calls.count()).toEqual(1);
   });
 
-  it("calls setTimeout when onmessage is called recursively", function() {
+  it('calls setTimeout when onmessage is called recursively', function() {
     var fakeChannel = {
-          port1: {},
-          port2: { postMessage: function() { fakeChannel.port1.onmessage(); } }
+        port1: {},
+        port2: {
+          postMessage: function() {
+            fakeChannel.port1.onmessage();
+          }
+        }
+      },
+      setTimeout = jasmine.createSpy('setTimeout'),
+      global = {
+        MessageChannel: function() {
+          return fakeChannel;
         },
-        setTimeout = jasmine.createSpy('setTimeout'),
-        global = {
-          MessageChannel: function() { return fakeChannel; },
-          setTimeout: setTimeout,
-        },
-        clearStack = jasmineUnderTest.getClearStack(global),
-        fn = jasmine.createSpy("second clearStack function");
+        setTimeout: setTimeout
+      },
+      clearStack = jasmineUnderTest.getClearStack(global),
+      fn = jasmine.createSpy('second clearStack function');
 
     clearStack(function() {
       clearStack(fn);
@@ -121,11 +148,13 @@ describe("ClearStack", function() {
     expect(setTimeout).toHaveBeenCalledWith(fn, 0);
   });
 
-  it("falls back to setTimeout", function() {
-    var setTimeout = jasmine.createSpy('setTimeout').and.callFake(function(fn) { fn() }),
-        global = { setTimeout: setTimeout },
-        clearStack = jasmineUnderTest.getClearStack(global),
-        called = false;
+  it('falls back to setTimeout', function() {
+    var setTimeout = jasmine.createSpy('setTimeout').and.callFake(function(fn) {
+        fn();
+      }),
+      global = { setTimeout: setTimeout },
+      clearStack = jasmineUnderTest.getClearStack(global),
+      called = false;
 
     clearStack(function() {
       called = true;

spec/core/DelayedFunctionSchedulerSpec.js

@@ -1,5 +1,5 @@
-describe("DelayedFunctionScheduler", function() {
-  it("schedules a function for later execution", function() {
+describe('DelayedFunctionScheduler', function() {
+  it('schedules a function for later execution', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
@@ -12,9 +12,9 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
   });
 
-  it("schedules a string for later execution", function() {
+  it('schedules a string for later execution', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
-      strfn = "horrible = true;";
+      strfn = 'horrible = true;';
 
     scheduler.scheduleFunction(strfn, 0);
 
@@ -23,7 +23,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(horrible).toEqual(true);
   });
 
-  it("#tick defaults to 0", function() {
+  it('#tick defaults to 0', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
@@ -36,7 +36,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
   });
 
-  it("defaults delay to 0", function() {
+  it('defaults delay to 0', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
@@ -49,7 +49,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
   });
 
-  it("optionally passes params to scheduled functions", function() {
+  it('optionally passes params to scheduled functions', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
@@ -62,7 +62,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalledWith('foo', 'bar');
   });
 
-  it("scheduled fns can optionally reoccur", function() {
+  it('scheduled fns can optionally reoccur', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn');
 
@@ -81,23 +81,20 @@ describe("DelayedFunctionScheduler", function() {
     scheduler.tick(21);
 
     expect(fn.calls.count()).toBe(4);
-
   });
 
-  it("increments scheduled fns ids unless one is passed", function() {
+  it('increments scheduled fns ids unless one is passed', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler();
 
-    expect(scheduler.scheduleFunction(function() {
-    }, 0)).toBe(1);
-    expect(scheduler.scheduleFunction(function() {
-    }, 0)).toBe(2);
-    expect(scheduler.scheduleFunction(function() {
-    }, 0, [], false, 123)).toBe(123);
-    expect(scheduler.scheduleFunction(function() {
-    }, 0)).toBe(3);
+    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(1);
+    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(2);
+    expect(scheduler.scheduleFunction(function() {}, 0, [], false, 123)).toBe(
+      123
+    );
+    expect(scheduler.scheduleFunction(function() {}, 0)).toBe(3);
   });
 
-  it("#removeFunctionWithId removes a previously scheduled function with a given id", function() {
+  it('#removeFunctionWithId removes a previously scheduled function with a given id', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       timeoutKey;
@@ -113,7 +110,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).not.toHaveBeenCalled();
   });
 
-  it("executes recurring functions interleaved with regular functions in the correct order", function() {
+  it('executes recurring functions interleaved with regular functions in the correct order', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       recurringCallCount = 0,
@@ -134,12 +131,12 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
   });
 
-  it("schedules a function for later execution during a tick", function () {
+  it('schedules a function for later execution during a tick', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10;
 
-    scheduler.scheduleFunction(function () {
+    scheduler.scheduleFunction(function() {
       scheduler.scheduleFunction(fn, fnDelay);
     }, 0);
 
@@ -150,13 +147,13 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
   });
 
-  it("#removeFunctionWithId removes a previously scheduled function with a given id during a tick", function () {
+  it('#removeFunctionWithId removes a previously scheduled function with a given id during a tick', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
 
-    scheduler.scheduleFunction(function () {
+    scheduler.scheduleFunction(function() {
       scheduler.removeFunctionWithId(timeoutKey);
     }, 0);
     timeoutKey = scheduler.scheduleFunction(fn, fnDelay);
@@ -168,7 +165,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).not.toHaveBeenCalled();
   });
 
-  it("executes recurring functions interleaved with regular functions and functions scheduled during a tick in the correct order", function () {
+  it('executes recurring functions interleaved with regular functions and functions scheduled during a tick in the correct order', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       recurringCallCount = 0,
@@ -185,7 +182,7 @@ describe("DelayedFunctionScheduler", function() {
       scheduling = jasmine.createSpy('scheduling').and.callFake(function() {
         expect(recurring.calls.count()).toBe(3);
         expect(fn).not.toHaveBeenCalled();
-        scheduler.scheduleFunction(innerFn, 10);  // 41ms absolute
+        scheduler.scheduleFunction(innerFn, 10); // 41ms absolute
       });
 
     scheduler.scheduleFunction(recurring, 10, [], true);
@@ -201,7 +198,7 @@ describe("DelayedFunctionScheduler", function() {
     expect(innerFn).toHaveBeenCalled();
   });
 
-  it("executes recurring functions after rescheduling them", function () {
+  it('executes recurring functions after rescheduling them', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       recurring = function() {
         expect(scheduler.scheduleFunction).toHaveBeenCalled();
@@ -209,12 +206,12 @@ describe("DelayedFunctionScheduler", function() {
 
     scheduler.scheduleFunction(recurring, 10, [], true);
 
-    spyOn(scheduler, "scheduleFunction");
+    spyOn(scheduler, 'scheduleFunction');
 
     scheduler.tick(10);
   });
 
-  it("removes functions during a tick that runs the function", function() {
+  it('removes functions during a tick that runs the function', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       spy = jasmine.createSpy('fn'),
       spyAndRemove = jasmine.createSpy('fn'),
@@ -235,14 +232,14 @@ describe("DelayedFunctionScheduler", function() {
     expect(spyAndRemove).toHaveBeenCalled();
   });
 
-  it("removes functions during the first tick that runs the function", function() {
+  it('removes functions during the first tick that runs the function', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
       fnDelay = 10,
       timeoutKey;
 
     timeoutKey = scheduler.scheduleFunction(fn, fnDelay, [], true);
-    scheduler.scheduleFunction(function () {
+    scheduler.scheduleFunction(function() {
       scheduler.removeFunctionWithId(timeoutKey);
     }, fnDelay);
 
@@ -257,8 +254,7 @@ describe("DelayedFunctionScheduler", function() {
   it("does not remove a function that hasn't been added yet", function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       fn = jasmine.createSpy('fn'),
-      fnDelay = 10,
-      timeoutKey;
+      fnDelay = 10;
 
     scheduler.removeFunctionWithId('foo');
     scheduler.scheduleFunction(fn, fnDelay, [], false, 'foo');
@@ -270,17 +266,16 @@ describe("DelayedFunctionScheduler", function() {
     expect(fn).toHaveBeenCalled();
   });
 
-  it("updates the mockDate per scheduled time", function () {
+  it('updates the mockDate per scheduled time', function() {
     var scheduler = new jasmineUnderTest.DelayedFunctionScheduler(),
       tickDate = jasmine.createSpy('tickDate');
 
-      scheduler.scheduleFunction(function() {});
-      scheduler.scheduleFunction(function() {}, 1);
+    scheduler.scheduleFunction(function() {});
+    scheduler.scheduleFunction(function() {}, 1);
 
-      scheduler.tick(1, tickDate);
+    scheduler.tick(1, tickDate);
 
-      expect(tickDate).toHaveBeenCalledWith(0);
-      expect(tickDate).toHaveBeenCalledWith(1);
-  })
+    expect(tickDate).toHaveBeenCalledWith(0);
+    expect(tickDate).toHaveBeenCalledWith(1);
+  });
 });
-

spec/core/EnvSpec.js

@@ -1,54 +1,63 @@
 // TODO: Fix these unit tests!
-describe("Env", function() {
+describe('Env', function() {
   var env;
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
   });
 
-  describe("#pending", function() {
-    it("throws the Pending Spec exception", function() {
+  describe('#pending', function() {
+    it('throws the Pending Spec exception', function() {
       expect(function() {
         env.pending();
       }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
     });
 
-    it("throws the Pending Spec exception with a custom message", function() {
+    it('throws the Pending Spec exception with a custom message', function() {
       expect(function() {
         env.pending('custom message');
-      }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message');
+      }).toThrow(
+        jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message'
+      );
     });
   });
 
-  describe("#topSuite", function() {
-    it("returns the Jasmine top suite for users to traverse the spec tree", function() {
+  describe('#topSuite', function() {
+    it('returns the Jasmine top suite for users to traverse the spec tree', function() {
       var suite = env.topSuite();
       expect(suite.description).toEqual('Jasmine__TopLevel__Suite');
     });
   });
 
   it('can configure specs to throw errors on expectation failures', function() {
-    env.configure({oneFailurePerSpec: true});
+    env.configure({ oneFailurePerSpec: true });
 
     spyOn(jasmineUnderTest, 'Spec');
     env.it('foo', function() {});
-    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(jasmine.objectContaining({
-      throwOnExpectationFailure: true
-    }));
+    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        throwOnExpectationFailure: true
+      })
+    );
   });
 
   it('can configure suites to throw errors on expectation failures', function() {
-    env.configure({oneFailurePerSpec: true});
+    env.configure({ oneFailurePerSpec: true });
 
     spyOn(jasmineUnderTest, 'Suite');
     env.describe('foo', function() {});
-    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(jasmine.objectContaining({
-      throwOnExpectationFailure: true
-    }));
+    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        throwOnExpectationFailure: true
+      })
+    );
   });
 
   describe('promise library', function() {
     it('can be configured with a custom library', function() {
-      var myLibrary = { resolve: jasmine.createSpy(), reject: jasmine.createSpy() };
+      var myLibrary = {
+        resolve: jasmine.createSpy(),
+        reject: jasmine.createSpy()
+      };
       env.configure({ Promise: myLibrary });
     });
 
@@ -57,28 +66,34 @@ describe("Env", function() {
 
       expect(function() {
         env.configure({ Promise: myLibrary });
-      }).toThrowError('Custom promise library missing `resolve`/`reject` functions');
+      }).toThrowError(
+        'Custom promise library missing `resolve`/`reject` functions'
+      );
     });
   });
 
   it('defaults to multiple failures for specs', function() {
     spyOn(jasmineUnderTest, 'Spec');
-      env.it('bar', function() {});
-    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(jasmine.objectContaining({
-      throwOnExpectationFailure: false
-    }));
+    env.it('bar', function() {});
+    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        throwOnExpectationFailure: false
+      })
+    );
   });
 
   it('defaults to multiple failures for suites', function() {
     spyOn(jasmineUnderTest, 'Suite');
     env.describe('foo', function() {});
-    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(jasmine.objectContaining({
-      throwOnExpectationFailure: false
-    }));
+    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        throwOnExpectationFailure: false
+      })
+    );
   });
 
-  describe('#describe', function () {
-    it("throws an error when given arguments", function() {
+  describe('#describe', function() {
+    it('throws an error when given arguments', function() {
       expect(function() {
         env.describe('done method', function(done) {});
       }).toThrowError('describe does not expect any arguments');
@@ -92,29 +107,41 @@ describe("Env", function() {
       // anything other than a function throws an error.
       expect(function() {
         env.describe('undefined arg', undefined);
-      }).toThrowError(/describe expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /describe expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
+      );
       expect(function() {
         env.describe('null arg', null);
-      }).toThrowError(/describe expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /describe expects a function argument; received \[object (Null|DOMWindow|Object)\]/
+      );
 
       expect(function() {
         env.describe('array arg', []);
-      }).toThrowError('describe expects a function argument; received [object Array]');
+      }).toThrowError(
+        'describe expects a function argument; received [object Array]'
+      );
       expect(function() {
         env.describe('object arg', {});
-      }).toThrowError('describe expects a function argument; received [object Object]');
+      }).toThrowError(
+        'describe expects a function argument; received [object Object]'
+      );
 
       expect(function() {
         env.describe('fn arg', function() {});
-      }).not.toThrowError('describe expects a function argument; received [object Function]');
+      }).not.toThrowError(
+        'describe expects a function argument; received [object Function]'
+      );
     });
   });
 
-  describe('#it', function () {
+  describe('#it', function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.it('undefined arg', null);
-      }).toThrowError(/it expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /it expects a function argument; received \[object (Null|DOMWindow|Object)\]/
+      );
     });
 
     it('does not throw when it is not given a fn argument', function() {
@@ -144,7 +171,9 @@ describe("Env", function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.xit('undefined arg', null);
-      }).toThrowError(/xit expects a function argument; received \[object (Null|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /xit expects a function argument; received \[object (Null|DOMWindow|Object)\]/
+      );
     });
 
     it('does not throw when it is not given a fn argument', function() {
@@ -161,19 +190,23 @@ describe("Env", function() {
     });
   });
 
-  describe('#fit', function () {
+  describe('#fit', function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.fit('undefined arg', undefined);
-      }).toThrowError(/fit expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /fit expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
+      );
     });
   });
 
-  describe('#beforeEach', function () {
+  describe('#beforeEach', function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.beforeEach(undefined);
-      }).toThrowError(/beforeEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /beforeEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
+      );
     });
 
     it('accepts an async function', function() {
@@ -184,11 +217,13 @@ describe("Env", function() {
     });
   });
 
-  describe('#beforeAll', function () {
+  describe('#beforeAll', function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.beforeAll(undefined);
-      }).toThrowError(/beforeAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /beforeAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
+      );
     });
 
     it('accepts an async function', function() {
@@ -199,11 +234,13 @@ describe("Env", function() {
     });
   });
 
-  describe('#afterEach', function () {
+  describe('#afterEach', function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.afterEach(undefined);
-      }).toThrowError(/afterEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /afterEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
+      );
     });
 
     it('accepts an async function', function() {
@@ -214,11 +251,13 @@ describe("Env", function() {
     });
   });
 
-  describe('#afterAll', function () {
+  describe('#afterAll', function() {
     it('throws an error when it receives a non-fn argument', function() {
       expect(function() {
         env.afterAll(undefined);
-      }).toThrowError(/afterAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/);
+      }).toThrowError(
+        /afterAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
+      );
     });
 
     it('accepts an async function', function() {
@@ -231,7 +270,11 @@ describe("Env", function() {
 
   describe('when not constructed with suppressLoadErrors: true', function() {
     it('installs a global error handler on construction', function() {
-      var globalErrors = jasmine.createSpyObj('globalErrors', ['install', 'pushListener', 'popListener']);
+      var globalErrors = jasmine.createSpyObj('globalErrors', [
+        'install',
+        'pushListener',
+        'popListener'
+      ]);
       spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
       new jasmineUnderTest.Env();
       expect(globalErrors.install).toHaveBeenCalled();
@@ -240,9 +283,13 @@ describe("Env", function() {
 
   describe('when constructed with suppressLoadErrors: true', function() {
     it('does not install a global error handler until execute is called', function() {
-      var globalErrors = jasmine.createSpyObj('globalErrors', ['install', 'pushListener', 'popListener']);
+      var globalErrors = jasmine.createSpyObj('globalErrors', [
+        'install',
+        'pushListener',
+        'popListener'
+      ]);
       spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
-      env = new jasmineUnderTest.Env({suppressLoadErrors: true});
+      env = new jasmineUnderTest.Env({ suppressLoadErrors: true });
       expect(globalErrors.install).not.toHaveBeenCalled();
       env.execute();
       expect(globalErrors.install).toHaveBeenCalled();

spec/core/ExceptionFormatterSpec.js

@@ -1,5 +1,5 @@
-describe("ExceptionFormatter", function() {
-  describe("#message", function() {
+describe('ExceptionFormatter', function() {
+  describe('#message', function() {
     it('formats Firefox exception messages', function() {
       var sampleFirefoxException = {
           fileName: 'foo.js',
@@ -10,7 +10,9 @@ describe("ExceptionFormatter", function() {
         exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
         message = exceptionFormatter.message(sampleFirefoxException);
 
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
+      expect(message).toEqual(
+        'A Classic Mistake: you got your foo in my bar in foo.js (line 1978)'
+      );
     });
 
     it('formats Webkit exception messages', function() {
@@ -23,7 +25,9 @@ describe("ExceptionFormatter", function() {
         exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
         message = exceptionFormatter.message(sampleWebkitException);
 
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
+      expect(message).toEqual(
+        'A Classic Mistake: you got your foo in my bar in foo.js (line 1978)'
+      );
     });
 
     it('formats V8 exception messages', function() {
@@ -38,10 +42,10 @@ describe("ExceptionFormatter", function() {
     });
 
     it('formats unnamed exceptions with message', function() {
-      var unnamedError = {message: 'This is an unnamed error message.'};
+      var unnamedError = { message: 'This is an unnamed error message.' };
 
       var exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-          message = exceptionFormatter.message(unnamedError);
+        message = exceptionFormatter.message(unnamedError);
 
       expect(message).toEqual('This is an unnamed error message.');
     });
@@ -54,32 +58,39 @@ describe("ExceptionFormatter", function() {
       var emptyError = new EmptyError();
 
       var exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-          message = exceptionFormatter.message(emptyError);
+        message = exceptionFormatter.message(emptyError);
 
       expect(message).toEqual('[EmptyError] thrown');
     });
 
     it("formats thrown exceptions that aren't errors", function() {
-      var thrown = "crazy error",
-          exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-          message = exceptionFormatter.message(thrown);
+      var thrown = 'crazy error',
+        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
+        message = exceptionFormatter.message(thrown);
 
-      expect(message).toEqual("crazy error thrown");
+      expect(message).toEqual('crazy error thrown');
     });
   });
 
-  describe("#stack", function() {
-    it("formats stack traces", function() {
+  describe('#stack', function() {
+    it('formats stack traces', function() {
       var error;
-      try { throw new Error("an error") } catch(e) { error = e; }
+      try {
+        throw new Error('an error');
+      } catch (e) {
+        error = e;
+      }
 
-      expect(new jasmineUnderTest.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
+      expect(new jasmineUnderTest.ExceptionFormatter().stack(error)).toMatch(
+        /ExceptionFormatterSpec\.js.*\d+/
+      );
     });
 
-    it("filters Jasmine stack frames from V8 style traces", function() {
+    it('filters Jasmine stack frames from V8 style traces', function() {
       var error = {
         message: 'nope',
-        stack: 'Error: nope\n' +
+        stack:
+          'Error: nope\n' +
           '    at fn1 (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
           '    at fn2 (http://localhost:8888/__jasmine__/jasmine.js:4320:20)\n' +
           '    at fn3 (http://localhost:8888/__jasmine__/jasmine.js:4320:20)\n' +
@@ -89,16 +100,18 @@ describe("ExceptionFormatter", function() {
         jasmineFile: 'http://localhost:8888/__jasmine__/jasmine.js'
       });
       var result = subject.stack(error);
-      expect(result).toEqual('Error: nope\n' +
+      expect(result).toEqual(
+        'Error: nope\n' +
           '    at fn1 (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
           '    at <Jasmine>\n' +
           '    at fn4 (http://localhost:8888/__spec__/core/UtilSpec.js:110:19)'
       );
     });
 
-    it("filters Jasmine stack frames from Webkit style traces", function() {
+    it('filters Jasmine stack frames from Webkit style traces', function() {
       var error = {
-        stack: 'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
+        stack:
+          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
           'fn1@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
           'fn2@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
           'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
@@ -114,9 +127,13 @@ describe("ExceptionFormatter", function() {
       );
     });
 
-    it("filters Jasmine stack frames in this environment", function() {
+    it('filters Jasmine stack frames in this environment', function() {
       var error, i;
-      try { throw new Error("an error"); } catch(e) { error = e; }
+      try {
+        throw new Error('an error');
+      } catch (e) {
+        error = e;
+      }
       var subject = new jasmineUnderTest.ExceptionFormatter({
         jasmineFile: jasmine.util.jasmineFile()
       });
@@ -136,9 +153,14 @@ describe("ExceptionFormatter", function() {
       }
     });
 
-    it("handles multiline error messages in this environment", function() {
-      var error, i, msg = "an error\nwith two lines";
-      try { throw new Error(msg); } catch(e) { error = e; }
+    it('handles multiline error messages in this environment', function() {
+      var error,
+        msg = 'an error\nwith two lines';
+      try {
+        throw new Error(msg);
+      } catch (e) {
+        error = e;
+      }
 
       if (error.stack.indexOf(msg) === -1) {
         pending("Stack traces don't have messages in this environment");
@@ -155,19 +177,22 @@ describe("ExceptionFormatter", function() {
       expect(lines[3]).toMatch(/<Jasmine>/);
     });
 
-    it("returns null if no Error provided", function() {
+    it('returns null if no Error provided', function() {
       expect(new jasmineUnderTest.ExceptionFormatter().stack()).toBeNull();
     });
 
-    it("includes error properties in stack", function() {
+    it('includes error properties in stack', function() {
       var error;
-      try { throw new Error("an error") } catch(e) { error = e; }
+      try {
+        throw new Error('an error');
+      } catch (e) {
+        error = e;
+      }
       error.someProperty = 'hello there';
 
       var result = new jasmineUnderTest.ExceptionFormatter().stack(error);
 
       expect(result).toMatch(/error properties:.*someProperty.*hello there/);
     });
-
   });
 });

spec/core/ExceptionsSpec.js

@@ -7,11 +7,17 @@ describe('Exceptions:', function() {
 
   it('should handle exceptions thrown, but continue', function(done) {
     var secondTest = jasmine.createSpy('second test');
-    env.describe('Suite for handles exceptions', function () {
-      env.it('should be a test that fails because it throws an exception', function() {
-        throw new Error();
-      });
-      env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
+    env.describe('Suite for handles exceptions', function() {
+      env.it(
+        'should be a test that fails because it throws an exception',
+        function() {
+          throw new Error();
+        }
+      );
+      env.it(
+        'should be a passing test that runs after exceptions are thrown from a async test',
+        secondTest
+      );
     });
 
     var expectations = function() {
@@ -23,14 +29,14 @@ describe('Exceptions:', function() {
     env.execute();
   });
 
-  it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
-    var secondDescribe = jasmine.createSpy("second describe");
-    env.describe("a suite that throws an exception", function () {
-      env.it("is a test that should pass", function () {
+  it('should handle exceptions thrown directly in top-level describe blocks and continue', function(done) {
+    var secondDescribe = jasmine.createSpy('second describe');
+    env.describe('a suite that throws an exception', function() {
+      env.it('is a test that should pass', function() {
         this.expect(true).toEqual(true);
       });
 
-      throw new Error("top level error");
+      throw new Error('top level error');
     });
     env.describe("a suite that doesn't throw an exception", secondDescribe);
 
@@ -43,4 +49,3 @@ describe('Exceptions:', function() {
     env.execute();
   });
 });
-

spec/core/ExpectationFilterChainSpec.js

@@ -6,7 +6,7 @@ describe('ExpectationFilterChain', function() {
         orig = new jasmineUnderTest.ExpectationFilterChain({
           modifyFailureMessage: first
         }),
-        added = orig.addFilter({selectComparisonFunc: second});
+        added = orig.addFilter({ selectComparisonFunc: second });
 
       added.modifyFailureMessage();
       expect(first).toHaveBeenCalled();
@@ -18,7 +18,7 @@ describe('ExpectationFilterChain', function() {
       var orig = new jasmineUnderTest.ExpectationFilterChain({}),
         f = jasmine.createSpy('f');
 
-      orig.addFilter({selectComparisonFunc: f});
+      orig.addFilter({ selectComparisonFunc: f });
 
       orig.selectComparisonFunc();
       expect(f).not.toHaveBeenCalled();
@@ -39,8 +39,8 @@ describe('ExpectationFilterChain', function() {
         var first = jasmine.createSpy('first').and.returnValue('first'),
           second = jasmine.createSpy('second').and.returnValue('second'),
           chain = new jasmineUnderTest.ExpectationFilterChain()
-            .addFilter({selectComparisonFunc: first})
-            .addFilter({selectComparisonFunc: second}),
+            .addFilter({ selectComparisonFunc: first })
+            .addFilter({ selectComparisonFunc: second }),
           matcher = {},
           result;
 
@@ -67,17 +67,27 @@ describe('ExpectationFilterChain', function() {
         var first = jasmine.createSpy('first').and.returnValue('first'),
           second = jasmine.createSpy('second').and.returnValue('second'),
           chain = new jasmineUnderTest.ExpectationFilterChain()
-            .addFilter({buildFailureMessage: first})
-            .addFilter({buildFailureMessage: second}),
-          matcherResult = {pass: false},
+            .addFilter({ buildFailureMessage: first })
+            .addFilter({ buildFailureMessage: second }),
+          matcherResult = { pass: false },
           matcherName = 'foo',
           args = [],
           util = {},
           result;
 
-        result = chain.buildFailureMessage(matcherResult, matcherName, args, util);
+        result = chain.buildFailureMessage(
+          matcherResult,
+          matcherName,
+          args,
+          util
+        );
 
-        expect(first).toHaveBeenCalledWith(matcherResult, matcherName, args, util);
+        expect(first).toHaveBeenCalledWith(
+          matcherResult,
+          matcherName,
+          args,
+          util
+        );
         expect(second).not.toHaveBeenCalled();
         expect(result).toEqual('first');
       });
@@ -98,8 +108,8 @@ describe('ExpectationFilterChain', function() {
         var first = jasmine.createSpy('first').and.returnValue('first'),
           second = jasmine.createSpy('second').and.returnValue('second'),
           chain = new jasmineUnderTest.ExpectationFilterChain()
-            .addFilter({modifyFailureMessage: first})
-            .addFilter({modifyFailureMessage: second}),
+            .addFilter({ modifyFailureMessage: first })
+            .addFilter({ modifyFailureMessage: second }),
           result;
 
         result = chain.modifyFailureMessage('original');

spec/core/ExpectationResultSpec.js

@@ -1,76 +1,93 @@
-describe("buildExpectationResult", function() {
-  it("defaults to passed", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: 'some-value'});
+describe('buildExpectationResult', function() {
+  it('defaults to passed', function() {
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: 'some-value'
+    });
     expect(result.passed).toBe('some-value');
   });
 
-  it("message defaults to Passed for passing specs", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: true, message: 'some-value'});
+  it('message defaults to Passed for passing specs', function() {
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: true,
+      message: 'some-value'
+    });
     expect(result.message).toBe('Passed.');
   });
 
-  it("message returns the message for failing expectations", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: false, message: 'some-value'});
+  it('message returns the message for failing expectations', function() {
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: false,
+      message: 'some-value'
+    });
     expect(result.message).toBe('some-value');
   });
 
-  it("delegates message formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {message: 'foo'},
-      messageFormatter = jasmine.createSpy("exception message formatter").and.returnValue(fakeError.message);
+  it('delegates message formatting to the provided formatter if there was an Error', function() {
+    var fakeError = { message: 'foo' },
+      messageFormatter = jasmine
+        .createSpy('exception message formatter')
+        .and.returnValue(fakeError.message);
 
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        messageFormatter: messageFormatter
-      });
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: false,
+      error: fakeError,
+      messageFormatter: messageFormatter
+    });
 
     expect(messageFormatter).toHaveBeenCalledWith(fakeError);
     expect(result.message).toEqual('foo');
   });
 
-  it("delegates stack formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {stack: 'foo'},
-      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
+  it('delegates stack formatting to the provided formatter if there was an Error', function() {
+    var fakeError = { stack: 'foo' },
+      stackFormatter = jasmine
+        .createSpy('stack formatter')
+        .and.returnValue(fakeError.stack);
 
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        stackFormatter: stackFormatter
-      });
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: false,
+      error: fakeError,
+      stackFormatter: stackFormatter
+    });
 
     expect(stackFormatter).toHaveBeenCalledWith(fakeError);
     expect(result.stack).toEqual('foo');
   });
 
-  it("delegates stack formatting to the provided formatter if there was a provided errorForStack", function() {
-    var fakeError = {stack: 'foo'},
-      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
+  it('delegates stack formatting to the provided formatter if there was a provided errorForStack', function() {
+    var fakeError = { stack: 'foo' },
+      stackFormatter = jasmine
+        .createSpy('stack formatter')
+        .and.returnValue(fakeError.stack);
 
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        errorForStack: fakeError,
-        stackFormatter: stackFormatter
-      });
+    var result = jasmineUnderTest.buildExpectationResult({
+      passed: false,
+      errorForStack: fakeError,
+      stackFormatter: stackFormatter
+    });
 
     expect(stackFormatter).toHaveBeenCalledWith(fakeError);
     expect(result.stack).toEqual('foo');
   });
 
-  it("matcherName returns passed matcherName", function() {
-    var result = jasmineUnderTest.buildExpectationResult({matcherName: 'some-value'});
+  it('matcherName returns passed matcherName', function() {
+    var result = jasmineUnderTest.buildExpectationResult({
+      matcherName: 'some-value'
+    });
     expect(result.matcherName).toBe('some-value');
   });
 
-  it("expected returns passed expected", function() {
-    var result = jasmineUnderTest.buildExpectationResult({expected: 'some-value'});
+  it('expected returns passed expected', function() {
+    var result = jasmineUnderTest.buildExpectationResult({
+      expected: 'some-value'
+    });
     expect(result.expected).toBe('some-value');
   });
 
-  it("actual returns passed actual", function() {
-    var result = jasmineUnderTest.buildExpectationResult({actual: 'some-value'});
+  it('actual returns passed actual', function() {
+    var result = jasmineUnderTest.buildExpectationResult({
+      actual: 'some-value'
+    });
     expect(result.actual).toBe('some-value');
   });
 });

spec/core/ExpectationSpec.js

@@ -1,5 +1,5 @@
-describe("Expectation", function() {
-  it("makes custom matchers available to this expectation", function() {
+describe('Expectation', function() {
+  it('makes custom matchers available to this expectation', function() {
     var matchers = {
         toFoo: function() {},
         toBar: function() {}
@@ -14,7 +14,7 @@ describe("Expectation", function() {
     expect(expectation.toBar).toBeDefined();
   });
 
-  it(".addCoreMatchers makes matchers available to any expectation", function() {
+  it('.addCoreMatchers makes matchers available to any expectation', function() {
     var coreMatchers = {
         toQuux: function() {}
       },
@@ -28,8 +28,12 @@ describe("Expectation", function() {
   });
 
   it("wraps matchers's compare functions, passing in matcher dependencies", function() {
-    var fakeCompare = function() { return { pass: true }; },
-      matcherFactory = jasmine.createSpy("matcher").and.returnValue({ compare: fakeCompare }),
+    var fakeCompare = function() {
+        return { pass: true };
+      },
+      matcherFactory = jasmine
+        .createSpy('matcher')
+        .and.returnValue({ compare: fakeCompare }),
       matchers = {
         toFoo: matcherFactory
       },
@@ -37,24 +41,26 @@ describe("Expectation", function() {
         buildFailureMessage: jasmine.createSpy('buildFailureMessage')
       },
       customEqualityTesters = ['a'],
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       util: util,
       customMatchers: matchers,
       customEqualityTesters: customEqualityTesters,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
-    expect(matcherFactory).toHaveBeenCalledWith(util, customEqualityTesters)
+    expect(matcherFactory).toHaveBeenCalledWith(util, customEqualityTesters);
   });
 
   it("wraps matchers's compare functions, passing the actual and expected", function() {
-    var fakeCompare = jasmine.createSpy('fake-compare').and.returnValue({pass: true}),
+    var fakeCompare = jasmine
+        .createSpy('fake-compare')
+        .and.returnValue({ pass: true }),
       matchers = {
         toFoo: function() {
           return {
@@ -65,259 +71,270 @@ describe("Expectation", function() {
       util = {
         buildFailureMessage: jasmine.createSpy('buildFailureMessage')
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       util: util,
       customMatchers: matchers,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
-    expect(fakeCompare).toHaveBeenCalledWith("an actual", "hello");
+    expect(fakeCompare).toHaveBeenCalledWith('an actual', 'hello');
   });
 
-  it("reports a passing result to the spec when the comparison passes", function() {
+  it('reports a passing result to the spec when the comparison passes', function() {
     var matchers = {
         toFoo: function() {
           return {
-            compare: function() { return { pass: true }; }
+            compare: function() {
+              return { pass: true };
+            }
           };
         }
       },
       util = {
         buildFailureMessage: jasmine.createSpy('buildFailureMessage')
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
       util: util,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: true,
-      message: "",
+      message: '',
       error: undefined,
-      expected: "hello",
-      actual: "an actual",
+      expected: 'hello',
+      actual: 'an actual',
       errorForStack: undefined
     });
   });
 
-  it("reports a failing result to the spec when the comparison fails", function() {
+  it('reports a failing result to the spec when the comparison fails', function() {
     var matchers = {
         toFoo: function() {
           return {
-            compare: function() { return { pass: false }; }
+            compare: function() {
+              return { pass: false };
+            }
           };
         }
       },
       util = {
-        buildFailureMessage: function() { return ""; }
+        buildFailureMessage: function() {
+          return '';
+        }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
       util: util,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "",
+      expected: 'hello',
+      actual: 'an actual',
+      message: '',
       error: undefined,
       errorForStack: undefined
     });
   });
 
-  it("reports a failing result and a custom fail message to the spec when the comparison fails", function() {
+  it('reports a failing result and a custom fail message to the spec when the comparison fails', function() {
     var matchers = {
         toFoo: function() {
           return {
             compare: function() {
               return {
                 pass: false,
-                message: "I am a custom message"
+                message: 'I am a custom message'
               };
             }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
-      actual: "an actual",
+      actual: 'an actual',
       customMatchers: matchers,
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
+      expected: 'hello',
+      actual: 'an actual',
+      message: 'I am a custom message',
       error: undefined,
       errorForStack: undefined
     });
   });
 
-  it("reports a failing result with a custom fail message function to the spec when the comparison fails", function() {
+  it('reports a failing result with a custom fail message function to the spec when the comparison fails', function() {
     var matchers = {
         toFoo: function() {
           return {
             compare: function() {
               return {
                 pass: false,
-                message: function() { return "I am a custom message"; }
+                message: function() {
+                  return 'I am a custom message';
+                }
               };
             }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
+      expected: 'hello',
+      actual: 'an actual',
+      message: 'I am a custom message',
       error: undefined,
       errorForStack: undefined
     });
   });
 
-  it("reports a passing result to the spec when the comparison fails for a negative expectation", function() {
+  it('reports a passing result to the spec when the comparison fails for a negative expectation', function() {
     var matchers = {
         toFoo: function() {
           return {
-            compare: function() { return { pass: false }; }
+            compare: function() {
+              return { pass: false };
+            }
           };
         }
       },
-      util = {
-        buildFailureMessage: function() { return ""; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
+      actual = 'an actual',
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: true,
-      message: "",
+      message: '',
       error: undefined,
-      expected: "hello",
+      expected: 'hello',
       actual: actual,
       errorForStack: undefined
     });
   });
 
-  it("reports a failing result to the spec when the comparison passes for a negative expectation", function() {
+  it('reports a failing result to the spec when the comparison passes for a negative expectation', function() {
     var matchers = {
         toFoo: function() {
           return {
-            compare: function() { return { pass: true }; }
+            compare: function() {
+              return { pass: true };
+            }
           };
         }
       },
       util = {
-        buildFailureMessage: function() { return "default message"; }
+        buildFailureMessage: function() {
+          return 'default message';
+        }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
+      actual = 'an actual',
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      actual: "an actual",
+      actual: 'an actual',
       util: util,
-      addExpectationResult: addExpectationResult,
+      addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
+      expected: 'hello',
       actual: actual,
-      message: "default message",
+      message: 'default message',
       error: undefined,
       errorForStack: undefined
     });
   });
 
-  it("reports a failing result and a custom fail message to the spec when the comparison passes for a negative expectation", function() {
+  it('reports a failing result and a custom fail message to the spec when the comparison passes for a negative expectation', function() {
     var matchers = {
         toFoo: function() {
           return {
             compare: function() {
               return {
                 pass: true,
-                message: "I am a custom message"
+                message: 'I am a custom message'
               };
             }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
+      actual = 'an actual',
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
+      expected: 'hello',
       actual: actual,
-      message: "I am a custom message",
+      message: 'I am a custom message',
       error: undefined,
       errorForStack: undefined
     });
@@ -327,29 +344,33 @@ describe("Expectation", function() {
     var matchers = {
         toFoo: function() {
           return {
-            compare: function() { return { pass: true }; },
-            negativeCompare: function() { return { pass: true }; }
+            compare: function() {
+              return { pass: true };
+            },
+            negativeCompare: function() {
+              return { pass: true };
+            }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
+      actual = 'an actual',
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      actual: "an actual",
+      actual: 'an actual',
       addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: true,
-      expected: "hello",
+      expected: 'hello',
       actual: actual,
-      message: "",
+      message: '',
       error: undefined,
       errorForStack: undefined
     });
@@ -359,7 +380,9 @@ describe("Expectation", function() {
     var matchers = {
         toFoo: function() {
           return {
-            compare: function() { return { pass: true }; },
+            compare: function() {
+              return { pass: true };
+            },
             negativeCompare: function() {
               return {
                 pass: false,
@@ -369,22 +392,22 @@ describe("Expectation", function() {
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
+      actual = 'an actual',
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
       customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
+      actual: 'an actual',
+      addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
+      expected: 'hello',
       actual: actual,
       message: "I'm a custom message",
       error: undefined,
@@ -392,254 +415,272 @@ describe("Expectation", function() {
     });
   });
 
-  it("reports a custom error message to the spec", function() {
-    var customError = new Error("I am a custom error");
+  it('reports a custom error message to the spec', function() {
+    var customError = new Error('I am a custom error');
     var matchers = {
         toFoo: function() {
           return {
             compare: function() {
               return {
                 pass: false,
-                message: "I am a custom message",
+                message: 'I am a custom message',
                 error: customError
               };
             }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
-      actual: "an actual",
+      actual: 'an actual',
       customMatchers: matchers,
       addExpectationResult: addExpectationResult
     });
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
+      expected: 'hello',
+      actual: 'an actual',
+      message: 'I am a custom message',
       error: customError,
       errorForStack: undefined
     });
   });
 
   it("reports a custom message to the spec when a 'not' comparison fails", function() {
-    var customError = new Error("I am a custom error");
+    var customError = new Error('I am a custom error');
     var matchers = {
         toFoo: function() {
           return {
             compare: function() {
               return {
                 pass: true,
-                message: "I am a custom message",
+                message: 'I am a custom message',
                 error: customError
               };
             }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
-      actual: "an actual",
+      actual: 'an actual',
       customMatchers: matchers,
       addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
+      expected: 'hello',
+      actual: 'an actual',
+      message: 'I am a custom message',
       error: customError,
       errorForStack: undefined
     });
   });
 
   it("reports a custom message func to the spec when a 'not' comparison fails", function() {
-    var customError = new Error("I am a custom error");
+    var customError = new Error('I am a custom error');
     var matchers = {
         toFoo: function() {
           return {
             compare: function() {
               return {
                 pass: true,
-                message: function() { return "I am a custom message"; },
+                message: function() {
+                  return 'I am a custom message';
+                },
                 error: customError
               };
             }
           };
         }
       },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      addExpectationResult = jasmine.createSpy('addExpectationResult'),
       expectation;
 
     expectation = jasmineUnderTest.Expectation.factory({
-      actual: "an actual",
+      actual: 'an actual',
       customMatchers: matchers,
       addExpectationResult: addExpectationResult
     }).not;
 
-    expectation.toFoo("hello");
+    expectation.toFoo('hello');
 
     expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
+      matcherName: 'toFoo',
       passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
+      expected: 'hello',
+      actual: 'an actual',
+      message: 'I am a custom message',
       error: customError,
       errorForStack: undefined
     });
   });
 
-  describe("#withContext", function() {
-    it("prepends the context to the generated failure message", function() {
+  describe('#withContext', function() {
+    it('prepends the context to the generated failure message', function() {
       var matchers = {
           toFoo: function() {
             return {
-              compare: function() { return { pass: false }; }
+              compare: function() {
+                return { pass: false };
+              }
             };
           }
         },
         util = {
-          buildFailureMessage: function() { return "failure message"; }
+          buildFailureMessage: function() {
+            return 'failure message';
+          }
         },
-        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.factory({
           customMatchers: matchers,
           util: util,
-          actual: "an actual",
+          actual: 'an actual',
           addExpectationResult: addExpectationResult
         });
 
-      expectation.withContext("Some context").toFoo("hello");
+      expectation.withContext('Some context').toFoo('hello');
 
-      expect(addExpectationResult).toHaveBeenCalledWith(false,
+      expect(addExpectationResult).toHaveBeenCalledWith(
+        false,
         jasmine.objectContaining({
-          message: "Some context: failure message"
+          message: 'Some context: failure message'
         })
       );
     });
 
-    it("prepends the context to a custom failure message", function() {
+    it('prepends the context to a custom failure message', function() {
       var matchers = {
           toFoo: function() {
             return {
-              compare: function() { return { pass: false, message: "msg" }; }
+              compare: function() {
+                return { pass: false, message: 'msg' };
+              }
             };
           }
         },
-        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.factory({
           customMatchers: matchers,
-          actual: "an actual",
+          actual: 'an actual',
           addExpectationResult: addExpectationResult
         });
 
-      expectation.withContext("Some context").toFoo("hello");
+      expectation.withContext('Some context').toFoo('hello');
 
-      expect(addExpectationResult).toHaveBeenCalledWith(false,
+      expect(addExpectationResult).toHaveBeenCalledWith(
+        false,
         jasmine.objectContaining({
-          message: "Some context: msg"
+          message: 'Some context: msg'
         })
       );
     });
 
-    it("prepends the context to a custom failure message from a function", function() {
+    it('prepends the context to a custom failure message from a function', function() {
       var matchers = {
           toFoo: function() {
             return {
               compare: function() {
                 return {
                   pass: false,
-                  message: function() { return "msg"; }
+                  message: function() {
+                    return 'msg';
+                  }
                 };
               }
             };
           }
         },
-        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.factory({
           customMatchers: matchers,
-          actual: "an actual",
+          actual: 'an actual',
           addExpectationResult: addExpectationResult
         });
 
-      expectation.withContext("Some context").toFoo("hello");
+      expectation.withContext('Some context').toFoo('hello');
 
-      expect(addExpectationResult).toHaveBeenCalledWith(false,
+      expect(addExpectationResult).toHaveBeenCalledWith(
+        false,
         jasmine.objectContaining({
-          message: "Some context: msg"
+          message: 'Some context: msg'
         })
       );
     });
 
-    it("works with #not", function() {
+    it('works with #not', function() {
       var matchers = {
           toFoo: function() {
             return {
-              compare: function() { return { pass: true }; }
+              compare: function() {
+                return { pass: true };
+              }
             };
           }
         },
-        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.factory({
           customMatchers: matchers,
           util: jasmineUnderTest.matchersUtil,
-          actual: "an actual",
+          actual: 'an actual',
           addExpectationResult: addExpectationResult
         });
 
-      expectation.withContext("Some context").not.toFoo();
+      expectation.withContext('Some context').not.toFoo();
 
-      expect(addExpectationResult).toHaveBeenCalledWith(false,
+      expect(addExpectationResult).toHaveBeenCalledWith(
+        false,
         jasmine.objectContaining({
           message: "Some context: Expected 'an actual' not to foo."
         })
       );
     });
 
-    it("works with #not and a custom message", function() {
-      var customError = new Error("I am a custom error");
+    it('works with #not and a custom message', function() {
+      var customError = new Error('I am a custom error');
       var matchers = {
           toFoo: function() {
             return {
               compare: function() {
                 return {
                   pass: true,
-                  message: function() { return "I am a custom message"; },
+                  message: function() {
+                    return 'I am a custom message';
+                  },
                   error: customError
                 };
               }
             };
           }
         },
-        addExpectationResult = jasmine.createSpy("addExpectationResult"),
+        addExpectationResult = jasmine.createSpy('addExpectationResult'),
         expectation = jasmineUnderTest.Expectation.factory({
-          actual: "an actual",
+          actual: 'an actual',
           customMatchers: matchers,
           addExpectationResult: addExpectationResult
         });
 
-      expectation.withContext("Some context").not.toFoo("hello");
+      expectation.withContext('Some context').not.toFoo('hello');
 
-      expect(addExpectationResult).toHaveBeenCalledWith(false,
+      expect(addExpectationResult).toHaveBeenCalledWith(
+        false,
         jasmine.objectContaining({
-          message: "Some context: I am a custom message",
+          message: 'Some context: I am a custom message'
         })
       );
     });
   });
 });
-

spec/core/GlobalErrorsSpec.js

@@ -1,8 +1,8 @@
-describe("GlobalErrors", function() {
-  it("calls the added handler on error", function() {
+describe('GlobalErrors', function() {
+  it('calls the added handler on error', function() {
     var fakeGlobal = { onerror: null },
-        handler = jasmine.createSpy('errorHandler'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      handler = jasmine.createSpy('errorHandler'),
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
 
     errors.install();
     errors.pushListener(handler);
@@ -12,11 +12,11 @@ describe("GlobalErrors", function() {
     expect(handler).toHaveBeenCalledWith('foo');
   });
 
-  it("only calls the most recent handler", function() {
+  it('only calls the most recent handler', function() {
     var fakeGlobal = { onerror: null },
-        handler1 = jasmine.createSpy('errorHandler1'),
-        handler2 = jasmine.createSpy('errorHandler2'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      handler1 = jasmine.createSpy('errorHandler1'),
+      handler2 = jasmine.createSpy('errorHandler2'),
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
 
     errors.install();
     errors.pushListener(handler1);
@@ -28,11 +28,11 @@ describe("GlobalErrors", function() {
     expect(handler2).toHaveBeenCalledWith('foo');
   });
 
-  it("calls previous handlers when one is removed", function() {
+  it('calls previous handlers when one is removed', function() {
     var fakeGlobal = { onerror: null },
-        handler1 = jasmine.createSpy('errorHandler1'),
-        handler2 = jasmine.createSpy('errorHandler2'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      handler1 = jasmine.createSpy('errorHandler1'),
+      handler2 = jasmine.createSpy('errorHandler2'),
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
 
     errors.install();
     errors.pushListener(handler1);
@@ -46,10 +46,10 @@ describe("GlobalErrors", function() {
     expect(handler2).not.toHaveBeenCalled();
   });
 
-  it("uninstalls itself, putting back a previous callback", function() {
+  it('uninstalls itself, putting back a previous callback', function() {
     var originalCallback = jasmine.createSpy('error'),
-        fakeGlobal = { onerror: originalCallback },
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+      fakeGlobal = { onerror: originalCallback },
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
 
     expect(fakeGlobal.onerror).toBe(originalCallback);
 
@@ -62,10 +62,10 @@ describe("GlobalErrors", function() {
     expect(fakeGlobal.onerror).toBe(originalCallback);
   });
 
-  it("rethrows the original error when there is no handler", function() {
-    var fakeGlobal = { },
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal),
-        originalError = new Error('nope');
+  it('rethrows the original error when there is no handler', function() {
+    var fakeGlobal = {},
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal),
+      originalError = new Error('nope');
 
     errors.install();
 
@@ -78,22 +78,31 @@ describe("GlobalErrors", function() {
     errors.uninstall();
   });
 
-  it("reports uncaughtException in node.js", function() {
+  it('reports uncaughtException in node.js', function() {
     var fakeGlobal = {
-          process: {
-            on: jasmine.createSpy('process.on'),
-            removeListener: jasmine.createSpy('process.removeListener'),
-            listeners: jasmine.createSpy('process.listeners').and.returnValue(['foo']),
-            removeAllListeners: jasmine.createSpy('process.removeAllListeners')
-          }
-        },
-        handler = jasmine.createSpy('errorHandler'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+        process: {
+          on: jasmine.createSpy('process.on'),
+          removeListener: jasmine.createSpy('process.removeListener'),
+          listeners: jasmine
+            .createSpy('process.listeners')
+            .and.returnValue(['foo']),
+          removeAllListeners: jasmine.createSpy('process.removeAllListeners')
+        }
+      },
+      handler = jasmine.createSpy('errorHandler'),
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
 
     errors.install();
-    expect(fakeGlobal.process.on).toHaveBeenCalledWith('uncaughtException', jasmine.any(Function));
-    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith('uncaughtException');
-    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith('uncaughtException');
+    expect(fakeGlobal.process.on).toHaveBeenCalledWith(
+      'uncaughtException',
+      jasmine.any(Function)
+    );
+    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith(
+      'uncaughtException'
+    );
+    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith(
+      'uncaughtException'
+    );
 
     errors.pushListener(handler);
 
@@ -101,30 +110,47 @@ describe("GlobalErrors", function() {
     addedListener(new Error('bar'));
 
     expect(handler).toHaveBeenCalledWith(new Error('bar'));
-    expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe('Uncaught exception: Error: bar');
+    expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe(
+      'Uncaught exception: Error: bar'
+    );
 
     errors.uninstall();
 
-    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith('uncaughtException', addedListener);
-    expect(fakeGlobal.process.on).toHaveBeenCalledWith('uncaughtException', 'foo');
+    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith(
+      'uncaughtException',
+      addedListener
+    );
+    expect(fakeGlobal.process.on).toHaveBeenCalledWith(
+      'uncaughtException',
+      'foo'
+    );
   });
 
-  it("reports unhandledRejection in node.js", function() {
+  it('reports unhandledRejection in node.js', function() {
     var fakeGlobal = {
-          process: {
-            on: jasmine.createSpy('process.on'),
-            removeListener: jasmine.createSpy('process.removeListener'),
-            listeners: jasmine.createSpy('process.listeners').and.returnValue(['foo']),
-            removeAllListeners: jasmine.createSpy('process.removeAllListeners')
-          }
-        },
-        handler = jasmine.createSpy('errorHandler'),
-        errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
+        process: {
+          on: jasmine.createSpy('process.on'),
+          removeListener: jasmine.createSpy('process.removeListener'),
+          listeners: jasmine
+            .createSpy('process.listeners')
+            .and.returnValue(['foo']),
+          removeAllListeners: jasmine.createSpy('process.removeAllListeners')
+        }
+      },
+      handler = jasmine.createSpy('errorHandler'),
+      errors = new jasmineUnderTest.GlobalErrors(fakeGlobal);
 
     errors.install();
-    expect(fakeGlobal.process.on).toHaveBeenCalledWith('unhandledRejection', jasmine.any(Function));
-    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith('unhandledRejection');
-    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith('unhandledRejection');
+    expect(fakeGlobal.process.on).toHaveBeenCalledWith(
+      'unhandledRejection',
+      jasmine.any(Function)
+    );
+    expect(fakeGlobal.process.listeners).toHaveBeenCalledWith(
+      'unhandledRejection'
+    );
+    expect(fakeGlobal.process.removeAllListeners).toHaveBeenCalledWith(
+      'unhandledRejection'
+    );
 
     errors.pushListener(handler);
 
@@ -132,11 +158,19 @@ describe("GlobalErrors", function() {
     addedListener(new Error('bar'));
 
     expect(handler).toHaveBeenCalledWith(new Error('bar'));
-    expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe('Unhandled promise rejection: Error: bar');
+    expect(handler.calls.argsFor(0)[0].jasmineMessage).toBe(
+      'Unhandled promise rejection: Error: bar'
+    );
 
     errors.uninstall();
 
-    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith('unhandledRejection', addedListener);
-    expect(fakeGlobal.process.on).toHaveBeenCalledWith('unhandledRejection', 'foo');
+    expect(fakeGlobal.process.removeListener).toHaveBeenCalledWith(
+      'unhandledRejection',
+      addedListener
+    );
+    expect(fakeGlobal.process.on).toHaveBeenCalledWith(
+      'unhandledRejection',
+      'foo'
+    );
   });
 });

spec/core/JsApiReporterSpec.js

@@ -2,86 +2,81 @@ xdescribe('JsApiReporter (integration specs)', function() {
   describe('results', function() {
     var reporter, spec1, spec2;
     var env;
-    var suite, nestedSuite, nestedSpec;
 
     beforeEach(function() {
       env = new jasmineUnderTest.Env();
 
-      suite = env.describe("top-level suite", function() {
-        spec1 = env.it("spec 1", function() {
+      env.describe('top-level suite', function() {
+        spec1 = env.it('spec 1', function() {
           this.expect(true).toEqual(true);
-
         });
 
-        spec2 = env.it("spec 2", function() {
+        spec2 = env.it('spec 2', function() {
           this.expect(true).toEqual(false);
         });
 
-        nestedSuite = env.describe("nested suite", function() {
-          nestedSpec = env.it("nested spec", function() {
+        env.describe('nested suite', function() {
+          env.it('nested spec', function() {
             expect(true).toEqual(true);
           });
         });
-
       });
 
       reporter = new jasmineUnderTest.JsApiReporter({});
       env.addReporter(reporter);
 
       env.execute();
-
     });
 
     it('results() should return a hash of all results, indexed by spec id', function() {
-      var expectedSpec1Results = {
-          result: "passed"
-        },
-        expectedSpec2Results = {
-          result: "failed"
-        };
       expect(reporter.results()[spec1.id].result).toEqual('passed');
       expect(reporter.results()[spec2.id].result).toEqual('failed');
     });
 
-    it("should return nested suites as children of their parents", function() {
+    it('should return nested suites as children of their parents', function() {
       expect(reporter.suites()).toEqual([
-        { id: 0, name: 'top-level suite', type: 'suite',
+        {
+          id: 0,
+          name: 'top-level suite',
+          type: 'suite',
           children: [
-            { id: 0, name: 'spec 1', type: 'spec', children: [ ] },
-            { id: 1, name: 'spec 2', type: 'spec', children: [ ] },
-            { id: 1, name: 'nested suite', type: 'suite',
+            { id: 0, name: 'spec 1', type: 'spec', children: [] },
+            { id: 1, name: 'spec 2', type: 'spec', children: [] },
+            {
+              id: 1,
+              name: 'nested suite',
+              type: 'suite',
               children: [
-                { id: 2, name: 'nested spec', type: 'spec', children: [ ] }
+                { id: 2, name: 'nested spec', type: 'spec', children: [] }
               ]
-            },
+            }
           ]
         }
       ]);
     });
 
-    describe("#summarizeResult_", function() {
-      it("should summarize a passing result", function() {
+    describe('#summarizeResult_', function() {
+      it('should summarize a passing result', function() {
         var result = reporter.results()[spec1.id];
         var summarizedResult = reporter.summarizeResult_(result);
         expect(summarizedResult.result).toEqual('passed');
         expect(summarizedResult.messages.length).toEqual(0);
       });
 
-      it("should have a stack trace for failing specs", function() {
+      it('should have a stack trace for failing specs', function() {
         var result = reporter.results()[spec2.id];
         var summarizedResult = reporter.summarizeResult_(result);
         expect(summarizedResult.result).toEqual('failed');
-        expect(summarizedResult.messages[0].trace.stack).toEqual(result.messages[0].trace.stack);
+        expect(summarizedResult.messages[0].trace.stack).toEqual(
+          result.messages[0].trace.stack
+        );
       });
-
     });
   });
 });
 
-
-describe("JsApiReporter", function() {
-
-  it("knows when a full environment is started", function() {
+describe('JsApiReporter', function() {
+  it('knows when a full environment is started', function() {
     var reporter = new jasmineUnderTest.JsApiReporter({});
 
     expect(reporter.started).toBe(false);
@@ -93,7 +88,7 @@ describe("JsApiReporter", function() {
     expect(reporter.finished).toBe(false);
   });
 
-  it("knows when a full environment is done", function() {
+  it('knows when a full environment is done', function() {
     var reporter = new jasmineUnderTest.JsApiReporter({});
 
     expect(reporter.started).toBe(false);
@@ -127,58 +122,60 @@ describe("JsApiReporter", function() {
     expect(reporter.status()).toEqual('done');
   });
 
-  it("tracks a suite", function() {
+  it('tracks a suite', function() {
     var reporter = new jasmineUnderTest.JsApiReporter({});
 
     reporter.suiteStarted({
       id: 123,
-      description: "A suite"
+      description: 'A suite'
     });
 
     var suites = reporter.suites();
 
-    expect(suites).toEqual({123: {id: 123, description: "A suite"}});
+    expect(suites).toEqual({ 123: { id: 123, description: 'A suite' } });
 
     reporter.suiteDone({
       id: 123,
-      description: "A suite",
+      description: 'A suite',
       status: 'passed'
     });
 
-    expect(suites).toEqual({123: {id: 123, description: "A suite", status: 'passed'}});
+    expect(suites).toEqual({
+      123: { id: 123, description: 'A suite', status: 'passed' }
+    });
   });
 
-  describe("#specResults", function() {
+  describe('#specResults', function() {
     var reporter, specResult1, specResult2;
     beforeEach(function() {
       reporter = new jasmineUnderTest.JsApiReporter({});
       specResult1 = {
         id: 1,
-        description: "A spec"
+        description: 'A spec'
       };
       specResult2 = {
         id: 2,
-        description: "Another spec"
+        description: 'Another spec'
       };
 
       reporter.specDone(specResult1);
       reporter.specDone(specResult2);
     });
 
-    it("should return a slice of results", function() {
+    it('should return a slice of results', function() {
       expect(reporter.specResults(0, 1)).toEqual([specResult1]);
       expect(reporter.specResults(1, 1)).toEqual([specResult2]);
     });
 
-    describe("when the results do not exist", function() {
-      it("should return a slice of shorter length", function() {
+    describe('when the results do not exist', function() {
+      it('should return a slice of shorter length', function() {
         expect(reporter.specResults(0, 3)).toEqual([specResult1, specResult2]);
         expect(reporter.specResults(2, 3)).toEqual([]);
       });
     });
   });
 
-  describe("#suiteResults", function(){
+  describe('#suiteResults', function() {
     var reporter, suiteResult1, suiteResult2;
     beforeEach(function() {
       reporter = new jasmineUnderTest.JsApiReporter({});
@@ -200,37 +197,37 @@ describe("JsApiReporter", function() {
       reporter.suiteDone(suiteResult2);
     });
 
-    it('should not include suite starts', function(){
-      expect(reporter.suiteResults(0,3).length).toEqual(2);
+    it('should not include suite starts', function() {
+      expect(reporter.suiteResults(0, 3).length).toEqual(2);
     });
 
-    it("should return a slice of results", function() {
+    it('should return a slice of results', function() {
       expect(reporter.suiteResults(0, 1)).toEqual([suiteResult1]);
       expect(reporter.suiteResults(1, 1)).toEqual([suiteResult2]);
     });
 
-    it("returns nothing for out of bounds indices", function() {
+    it('returns nothing for out of bounds indices', function() {
       expect(reporter.suiteResults(0, 3)).toEqual([suiteResult1, suiteResult2]);
       expect(reporter.suiteResults(2, 3)).toEqual([]);
     });
   });
 
-  describe("#executionTime", function() {
-    it("should start the timer when jasmine starts", function() {
+  describe('#executionTime', function() {
+    it('should start the timer when jasmine starts', function() {
       var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-          reporter = new jasmineUnderTest.JsApiReporter({
-            timer: timerSpy
-          });
+        reporter = new jasmineUnderTest.JsApiReporter({
+          timer: timerSpy
+        });
 
       reporter.jasmineStarted();
       expect(timerSpy.start).toHaveBeenCalled();
     });
 
-    it("should return the time it took the specs to run, in ms", function() {
+    it('should return the time it took the specs to run, in ms', function() {
       var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-          reporter = new jasmineUnderTest.JsApiReporter({
-            timer: timerSpy
-          });
+        reporter = new jasmineUnderTest.JsApiReporter({
+          timer: timerSpy
+        });
 
       timerSpy.elapsed.and.returnValue(1000);
       reporter.jasmineDone();
@@ -238,11 +235,11 @@ describe("JsApiReporter", function() {
     });
 
     describe("when the specs haven't finished being run", function() {
-      it("should return undefined", function() {
+      it('should return undefined', function() {
         var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
-            reporter = new jasmineUnderTest.JsApiReporter({
-              timer: timerSpy
-            });
+          reporter = new jasmineUnderTest.JsApiReporter({
+            timer: timerSpy
+          });
 
         expect(reporter.executionTime()).toBeUndefined();
       });
@@ -252,8 +249,8 @@ describe("JsApiReporter", function() {
   describe('#runDetails', function() {
     it('should have details about the run', function() {
       var reporter = new jasmineUnderTest.JsApiReporter({});
-      reporter.jasmineDone({some: {run: 'details'}});
-      expect(reporter.runDetails).toEqual({some: {run: 'details'}});
+      reporter.jasmineDone({ some: { run: 'details' } });
+      expect(reporter.runDetails).toEqual({ some: { run: 'details' } });
     });
   });
 });

spec/core/MockDateSpec.js

@@ -1,5 +1,5 @@
-describe("FakeDate", function() {
-  it("does not fail if no global date is found", function() {
+describe('FakeDate', function() {
+  it('does not fail if no global date is found', function() {
     var fakeGlobal = {},
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
@@ -10,11 +10,11 @@ describe("FakeDate", function() {
     }).not.toThrow();
   });
 
-  it("replaces the global Date when it is installed", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+  it('replaces the global Date when it is installed', function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {}
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
@@ -25,11 +25,11 @@ describe("FakeDate", function() {
     expect(fakeGlobal.Date).not.toEqual(globalDate);
   });
 
-  it("replaces the global Date on uninstall", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+  it('replaces the global Date on uninstall', function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {}
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
@@ -40,13 +40,13 @@ describe("FakeDate", function() {
     expect(fakeGlobal.Date).toEqual(globalDate);
   });
 
-  it("takes the current time as the base when installing without parameters", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+  it('takes the current time as the base when installing without parameters', function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {
             return 1000;
           }
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
@@ -58,7 +58,7 @@ describe("FakeDate", function() {
     expect(globalDate).toHaveBeenCalledWith(1000);
   });
 
-  it("can accept a date as time base when installing", function() {
+  it('can accept a date as time base when installing', function() {
     var fakeGlobal = { Date: Date },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal),
       baseDate = new Date();
@@ -69,7 +69,7 @@ describe("FakeDate", function() {
     expect(new fakeGlobal.Date().getTime()).toEqual(123);
   });
 
-  it("makes real dates", function() {
+  it('makes real dates', function() {
     var fakeGlobal = { Date: Date },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
@@ -78,13 +78,13 @@ describe("FakeDate", function() {
     expect(new fakeGlobal.Date() instanceof fakeGlobal.Date).toBe(true);
   });
 
-  it("fakes current time when using Date.now()", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+  it('fakes current time when using Date.now()', function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {
             return 1000;
           }
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate };
 
@@ -97,28 +97,30 @@ describe("FakeDate", function() {
   });
 
   it("does not stub Date.now() if it doesn't already exist", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {
             return 1000;
           }
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
-    expect(fakeGlobal.Date.now).toThrowError("Browser does not support Date.now()");
+    expect(fakeGlobal.Date.now).toThrowError(
+      'Browser does not support Date.now()'
+    );
   });
 
-  it("makes time passes using tick", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+  it('makes time passes using tick', function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {
             return 1000;
           }
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate };
 
@@ -136,13 +138,13 @@ describe("FakeDate", function() {
     expect(fakeGlobal.Date.now()).toEqual(2100);
   });
 
-  it("allows to increase 0 milliseconds using tick", function() {
-    var globalDate = jasmine.createSpy("global Date").and.callFake(function() {
+  it('allows to increase 0 milliseconds using tick', function() {
+    var globalDate = jasmine.createSpy('global Date').and.callFake(function() {
         return {
           getTime: function() {
             return 1000;
           }
-        }
+        };
       }),
       fakeGlobal = { Date: globalDate };
 
@@ -158,14 +160,16 @@ describe("FakeDate", function() {
     expect(fakeGlobal.Date.now()).toEqual(1000);
   });
 
-  it("allows creation of a Date in a different time than the mocked time", function() {
+  it('allows creation of a Date in a different time than the mocked time', function() {
     var fakeGlobal = { Date: Date },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 
     mockDate.install();
 
     var otherDate = new fakeGlobal.Date(2013, 9, 23, 0, 0, 1, 0);
-    expect(otherDate.getTime()).toEqual(new Date(2013, 9, 23, 0, 0, 1, 0).getTime());
+    expect(otherDate.getTime()).toEqual(
+      new Date(2013, 9, 23, 0, 0, 1, 0).getTime()
+    );
   });
 
   it("allows creation of a Date that isn't fully specified", function() {
@@ -189,7 +193,7 @@ describe("FakeDate", function() {
     expect(otherDate.getTime()).toEqual(now);
   });
 
-  it("copies all Date properties to the mocked date", function() {
+  it('copies all Date properties to the mocked date', function() {
     var fakeGlobal = { Date: Date },
       mockDate = new jasmineUnderTest.MockDate(fakeGlobal);
 

spec/core/PrettyPrintSpec.js

@@ -1,29 +1,29 @@
-describe("jasmineUnderTest.pp", function () {
-  it("should wrap strings in single quotes", function() {
-    expect(jasmineUnderTest.pp("some string")).toEqual("'some string'");
+describe('jasmineUnderTest.pp', function() {
+  it('should wrap strings in single quotes', function() {
+    expect(jasmineUnderTest.pp('some string')).toEqual("'some string'");
     expect(jasmineUnderTest.pp("som' string")).toEqual("'som' string'");
   });
 
-  it("should stringify primitives properly", function() {
-    expect(jasmineUnderTest.pp(true)).toEqual("true");
-    expect(jasmineUnderTest.pp(false)).toEqual("false");
-    expect(jasmineUnderTest.pp(null)).toEqual("null");
-    expect(jasmineUnderTest.pp(jasmine.undefined)).toEqual("undefined");
-    expect(jasmineUnderTest.pp(3)).toEqual("3");
-    expect(jasmineUnderTest.pp(-3.14)).toEqual("-3.14");
-    expect(jasmineUnderTest.pp(-0)).toEqual("-0");
+  it('should stringify primitives properly', function() {
+    expect(jasmineUnderTest.pp(true)).toEqual('true');
+    expect(jasmineUnderTest.pp(false)).toEqual('false');
+    expect(jasmineUnderTest.pp(null)).toEqual('null');
+    expect(jasmineUnderTest.pp(jasmine.undefined)).toEqual('undefined');
+    expect(jasmineUnderTest.pp(3)).toEqual('3');
+    expect(jasmineUnderTest.pp(-3.14)).toEqual('-3.14');
+    expect(jasmineUnderTest.pp(-0)).toEqual('-0');
   });
 
   describe('stringify sets', function() {
-    it("should stringify sets properly", function() {
+    it('should stringify sets properly', function() {
       jasmine.getEnv().requireFunctioningSets();
       var set = new Set();
       set.add(1);
       set.add(2);
-      expect(jasmineUnderTest.pp(set)).toEqual("Set( 1, 2 )");
+      expect(jasmineUnderTest.pp(set)).toEqual('Set( 1, 2 )');
     });
 
-    it("should truncate sets with more elements than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
+    it('should truncate sets with more elements than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH', function() {
       jasmine.getEnv().requireFunctioningSets();
       var originalMaxSize = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
 
@@ -37,112 +37,137 @@ describe("jasmineUnderTest.pp", function () {
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
       }
-    })
+    });
   });
 
   describe('stringify maps', function() {
-    it("should stringify maps properly", function() {
+    it('should stringify maps properly', function() {
       jasmine.getEnv().requireFunctioningMaps();
       var map = new Map();
-      map.set(1,2);
-      expect(jasmineUnderTest.pp(map)).toEqual("Map( [ 1, 2 ] )");
+      map.set(1, 2);
+      expect(jasmineUnderTest.pp(map)).toEqual('Map( [ 1, 2 ] )');
     });
 
-    it("should truncate maps with more elements than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
+    it('should truncate maps with more elements than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH', function() {
       jasmine.getEnv().requireFunctioningMaps();
       var originalMaxSize = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
         var map = new Map();
-        map.set("a",1);
-        map.set("b",2);
-        map.set("c",3);
-        expect(jasmineUnderTest.pp(map)).toEqual("Map( [ 'a', 1 ], [ 'b', 2 ], ... )");
+        map.set('a', 1);
+        map.set('b', 2);
+        map.set('c', 3);
+        expect(jasmineUnderTest.pp(map)).toEqual(
+          "Map( [ 'a', 1 ], [ 'b', 2 ], ... )"
+        );
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxSize;
       }
-    })
+    });
   });
 
-
   describe('stringify arrays', function() {
-    it("should stringify arrays properly", function() {
-      expect(jasmineUnderTest.pp([1, 2])).toEqual("[ 1, 2 ]");
-      expect(jasmineUnderTest.pp([1, 'foo', {}, jasmine.undefined, null])).toEqual("[ 1, 'foo', Object({  }), undefined, null ]");
+    it('should stringify arrays properly', function() {
+      expect(jasmineUnderTest.pp([1, 2])).toEqual('[ 1, 2 ]');
+      expect(
+        jasmineUnderTest.pp([1, 'foo', {}, jasmine.undefined, null])
+      ).toEqual("[ 1, 'foo', Object({  }), undefined, null ]");
     });
 
-    it("should truncate arrays that are longer than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH", function() {
+    it('should truncate arrays that are longer than jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH', function() {
       var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
       var array = [1, 2, 3];
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(array)).toEqual("[ 1, 2, ... ]");
+        expect(jasmineUnderTest.pp(array)).toEqual('[ 1, 2, ... ]');
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
       }
     });
 
-    it("should stringify arrays with properties properly", function() {
+    it('should stringify arrays with properties properly', function() {
       var arr = [1, 2];
       arr.foo = 'bar';
       arr.baz = {};
-      expect(jasmineUnderTest.pp(arr)).toEqual("[ 1, 2, foo: 'bar', baz: Object({  }) ]");
+      expect(jasmineUnderTest.pp(arr)).toEqual(
+        "[ 1, 2, foo: 'bar', baz: Object({  }) ]"
+      );
     });
 
-    it("should stringify empty arrays with properties properly", function() {
+    it('should stringify empty arrays with properties properly', function() {
       var empty = [];
       empty.foo = 'bar';
       empty.baz = {};
-      expect(jasmineUnderTest.pp(empty)).toEqual("[ foo: 'bar', baz: Object({  }) ]");
+      expect(jasmineUnderTest.pp(empty)).toEqual(
+        "[ foo: 'bar', baz: Object({  }) ]"
+      );
     });
 
-    it("should stringify long arrays with properties properly", function() {
+    it('should stringify long arrays with properties properly', function() {
       var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
-      var long = [1,2,3];
+      var long = [1, 2, 3];
       long.foo = 'bar';
       long.baz = {};
 
       try {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-        expect(jasmineUnderTest.pp(long)).toEqual("[ 1, 2, ..., foo: 'bar', baz: Object({  }) ]");
+        expect(jasmineUnderTest.pp(long)).toEqual(
+          "[ 1, 2, ..., foo: 'bar', baz: Object({  }) ]"
+        );
       } finally {
         jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
       }
     });
 
-    it("should indicate circular array references", function() {
+    it('should indicate circular array references', function() {
       var array1 = [1, 2];
       var array2 = [array1];
       array1.push(array2);
-      expect(jasmineUnderTest.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
+      expect(jasmineUnderTest.pp(array1)).toEqual(
+        '[ 1, 2, [ <circular reference: Array> ] ]'
+      );
     });
 
-    it("should not indicate circular references incorrectly", function() {
-      var array = [ [1] ];
-      expect(jasmineUnderTest.pp(array)).toEqual("[ [ 1 ] ]");
+    it('should not indicate circular references incorrectly', function() {
+      var array = [[1]];
+      expect(jasmineUnderTest.pp(array)).toEqual('[ [ 1 ] ]');
     });
   });
 
-  it("should stringify objects properly", function() {
-    expect(jasmineUnderTest.pp({foo: 'bar'})).toEqual("Object({ foo: 'bar' })");
-    expect(jasmineUnderTest.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("Object({ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined })");
-    expect(jasmineUnderTest.pp({foo: function () {
-    }, bar: [1, 2, 3]})).toEqual("Object({ foo: Function, bar: [ 1, 2, 3 ] })");
+  it('should stringify objects properly', function() {
+    expect(jasmineUnderTest.pp({ foo: 'bar' })).toEqual(
+      "Object({ foo: 'bar' })"
+    );
+    expect(
+      jasmineUnderTest.pp({
+        foo: 'bar',
+        baz: 3,
+        nullValue: null,
+        undefinedValue: jasmine.undefined
+      })
+    ).toEqual(
+      "Object({ foo: 'bar', baz: 3, nullValue: null, undefinedValue: undefined })"
+    );
+    expect(jasmineUnderTest.pp({ foo: function() {}, bar: [1, 2, 3] })).toEqual(
+      'Object({ foo: Function, bar: [ 1, 2, 3 ] })'
+    );
   });
 
-  it("should stringify objects that almost look like DOM nodes", function() {
-    expect(jasmineUnderTest.pp({nodeType: 1})).toEqual("Object({ nodeType: 1 })");
+  it('should stringify objects that almost look like DOM nodes', function() {
+    expect(jasmineUnderTest.pp({ nodeType: 1 })).toEqual(
+      'Object({ nodeType: 1 })'
+    );
   });
 
-  it("should truncate objects with too many keys", function () {
+  it('should truncate objects with too many keys', function() {
     var originalMaxLength = jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH;
-    var long = {a: 1, b: 2, c: 3};
+    var long = { a: 1, b: 2, c: 3 };
 
     try {
       jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = 2;
-      expect(jasmineUnderTest.pp(long)).toEqual("Object({ a: 1, b: 2, ... })");
+      expect(jasmineUnderTest.pp(long)).toEqual('Object({ a: 1, b: 2, ... })');
     } finally {
       jasmineUnderTest.MAX_PRETTY_PRINT_ARRAY_LENGTH = originalMaxLength;
     }
@@ -159,86 +184,119 @@ describe("jasmineUnderTest.pp", function () {
     }
   }
 
-  it("should truncate outputs that are too long", function() {
-    var big = [
-      { a: 1, b: "a long string" },
-      {}
-    ];
+  it('should truncate outputs that are too long', function() {
+    var big = [{ a: 1, b: 'a long string' }, {}];
 
     withMaxChars(34, function() {
-      expect(jasmineUnderTest.pp(big)).toEqual("[ Object({ a: 1, b: 'a long st ...");
+      expect(jasmineUnderTest.pp(big)).toEqual(
+        "[ Object({ a: 1, b: 'a long st ..."
+      );
     });
   });
 
-  it("should not serialize more objects after hitting MAX_PRETTY_PRINT_CHARS", function() {
-    var a = { jasmineToString: function() { return 'object a'; } },
-      b = { jasmineToString: function() { return 'object b'; } },
-      c = { jasmineToString: jasmine.createSpy('c jasmineToString').and.returnValue('') },
-      d = { jasmineToString: jasmine.createSpy('d jasmineToString').and.returnValue('') };
+  it('should not serialize more objects after hitting MAX_PRETTY_PRINT_CHARS', function() {
+    var a = {
+        jasmineToString: function() {
+          return 'object a';
+        }
+      },
+      b = {
+        jasmineToString: function() {
+          return 'object b';
+        }
+      },
+      c = {
+        jasmineToString: jasmine
+          .createSpy('c jasmineToString')
+          .and.returnValue('')
+      },
+      d = {
+        jasmineToString: jasmine
+          .createSpy('d jasmineToString')
+          .and.returnValue('')
+      };
 
     withMaxChars(30, function() {
-      jasmineUnderTest.pp([{a: a, b: b, c: c}, d]);
+      jasmineUnderTest.pp([{ a: a, b: b, c: c }, d]);
       expect(c.jasmineToString).not.toHaveBeenCalled();
       expect(d.jasmineToString).not.toHaveBeenCalled();
     });
   });
 
   it("should print 'null' as the constructor of an object with its own constructor property", function() {
-    expect(jasmineUnderTest.pp({constructor: function() {}})).toContain("null({");
-    expect(jasmineUnderTest.pp({constructor: 'foo'})).toContain("null({");
+    expect(jasmineUnderTest.pp({ constructor: function() {} })).toContain(
+      'null({'
+    );
+    expect(jasmineUnderTest.pp({ constructor: 'foo' })).toContain('null({');
   });
 
-  it("should not include inherited properties when stringifying an object", function() {
+  it('should not include inherited properties when stringifying an object', function() {
     var SomeClass = function SomeClass() {};
-    SomeClass.prototype.foo = "inherited foo";
+    SomeClass.prototype.foo = 'inherited foo';
     var instance = new SomeClass();
-    instance.bar = "my own bar";
-    expect(jasmineUnderTest.pp(instance)).toEqual("SomeClass({ bar: 'my own bar' })");
+    instance.bar = 'my own bar';
+    expect(jasmineUnderTest.pp(instance)).toEqual(
+      "SomeClass({ bar: 'my own bar' })"
+    );
   });
 
-  it("should not recurse objects and arrays more deeply than jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH", function() {
+  it('should not recurse objects and arrays more deeply than jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH', function() {
     var originalMaxDepth = jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH;
-    var nestedObject = { level1: { level2: { level3: { level4: "leaf" } } } };
-    var nestedArray  = [1, [2, [3, [4, "leaf"]]]];
+    var nestedObject = { level1: { level2: { level3: { level4: 'leaf' } } } };
+    var nestedArray = [1, [2, [3, [4, 'leaf']]]];
 
     try {
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 2;
-      expect(jasmineUnderTest.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object }) })");
-      expect(jasmineUnderTest.pp(nestedArray)).toEqual("[ 1, [ 2, Array ] ]");
+      expect(jasmineUnderTest.pp(nestedObject)).toEqual(
+        'Object({ level1: Object({ level2: Object }) })'
+      );
+      expect(jasmineUnderTest.pp(nestedArray)).toEqual('[ 1, [ 2, Array ] ]');
 
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 3;
-      expect(jasmineUnderTest.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object({ level3: Object }) }) })");
-      expect(jasmineUnderTest.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, Array ] ] ]");
+      expect(jasmineUnderTest.pp(nestedObject)).toEqual(
+        'Object({ level1: Object({ level2: Object({ level3: Object }) }) })'
+      );
+      expect(jasmineUnderTest.pp(nestedArray)).toEqual(
+        '[ 1, [ 2, [ 3, Array ] ] ]'
+      );
 
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = 4;
-      expect(jasmineUnderTest.pp(nestedObject)).toEqual("Object({ level1: Object({ level2: Object({ level3: Object({ level4: 'leaf' }) }) }) })");
-      expect(jasmineUnderTest.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
+      expect(jasmineUnderTest.pp(nestedObject)).toEqual(
+        "Object({ level1: Object({ level2: Object({ level3: Object({ level4: 'leaf' }) }) }) })"
+      );
+      expect(jasmineUnderTest.pp(nestedArray)).toEqual(
+        "[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]"
+      );
     } finally {
       jasmineUnderTest.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
     }
   });
 
-  it("should stringify immutable circular objects", function(){
-    if(Object.freeze){
-      var frozenObject = {foo: {bar: 'baz'}};
+  it('should stringify immutable circular objects', function() {
+    if (Object.freeze) {
+      var frozenObject = { foo: { bar: 'baz' } };
       frozenObject.circular = frozenObject;
       frozenObject = Object.freeze(frozenObject);
-      expect(jasmineUnderTest.pp(frozenObject)).toEqual("Object({ foo: Object({ bar: 'baz' }), circular: <circular reference: Object> })");
+      expect(jasmineUnderTest.pp(frozenObject)).toEqual(
+        "Object({ foo: Object({ bar: 'baz' }), circular: <circular reference: Object> })"
+      );
     }
   });
 
-  it("should stringify RegExp objects properly", function() {
-    expect(jasmineUnderTest.pp(/x|y|z/)).toEqual("/x|y|z/");
+  it('should stringify RegExp objects properly', function() {
+    expect(jasmineUnderTest.pp(/x|y|z/)).toEqual('/x|y|z/');
   });
 
-  it("should indicate circular object references", function() {
-    var sampleValue = {foo: 'hello'};
+  it('should indicate circular object references', function() {
+    var sampleValue = { foo: 'hello' };
     sampleValue.nested = sampleValue;
-    expect(jasmineUnderTest.pp(sampleValue)).toEqual("Object({ foo: 'hello', nested: <circular reference: Object> })");
+    expect(jasmineUnderTest.pp(sampleValue)).toEqual(
+      "Object({ foo: 'hello', nested: <circular reference: Object> })"
+    );
   });
 
-  it("should indicate getters on objects as such", function() {
-    var sampleValue = {id: 1};
+  it('should indicate getters on objects as such', function() {
+    var sampleValue = { id: 1 };
     if (sampleValue.__defineGetter__) {
       //not supported in IE!
       sampleValue.__defineGetter__('calculatedValue', function() {
@@ -246,53 +304,64 @@ describe("jasmineUnderTest.pp", function () {
       });
     }
     if (sampleValue.__defineGetter__) {
-      expect(jasmineUnderTest.pp(sampleValue)).toEqual("Object({ id: 1, calculatedValue: <getter> })");
-    }
-    else {
-      expect(jasmineUnderTest.pp(sampleValue)).toEqual("Object({ id: 1 })");
+      expect(jasmineUnderTest.pp(sampleValue)).toEqual(
+        'Object({ id: 1, calculatedValue: <getter> })'
+      );
+    } else {
+      expect(jasmineUnderTest.pp(sampleValue)).toEqual('Object({ id: 1 })');
     }
   });
 
   it('should not do HTML escaping of strings', function() {
-    expect(jasmineUnderTest.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
+    expect(jasmineUnderTest.pp('some <b>html string</b> &', false)).toEqual(
+      "'some <b>html string</b> &'"
+    );
   });
 
-  it("should abbreviate the global (usually window) object", function() {
-    expect(jasmineUnderTest.pp(jasmine.getGlobal())).toEqual("<global>");
+  it('should abbreviate the global (usually window) object', function() {
+    expect(jasmineUnderTest.pp(jasmine.getGlobal())).toEqual('<global>');
   });
 
-  it("should stringify Date objects properly", function() {
+  it('should stringify Date objects properly', function() {
     var now = new Date();
-    expect(jasmineUnderTest.pp(now)).toEqual("Date(" + now.toString() + ")");
+    expect(jasmineUnderTest.pp(now)).toEqual('Date(' + now.toString() + ')');
   });
 
-  it("should stringify spy objects properly", function() {
+  it('should stringify spy objects properly', function() {
     var TestObject = {
-      someFunction: function() {}
-    },
-    env = new jasmineUnderTest.Env();
+        someFunction: function() {}
+      },
+      env = new jasmineUnderTest.Env();
 
     var spyRegistry = new jasmineUnderTest.SpyRegistry({
-      currentSpies: function() {return [];},
+      currentSpies: function() {
+        return [];
+      },
       createSpy: function(name, originalFn) {
         return jasmineUnderTest.Spy(name, originalFn);
       }
     });
 
     spyRegistry.spyOn(TestObject, 'someFunction');
-    expect(jasmineUnderTest.pp(TestObject.someFunction)).toEqual("spy on someFunction");
+    expect(jasmineUnderTest.pp(TestObject.someFunction)).toEqual(
+      'spy on someFunction'
+    );
 
-    expect(jasmineUnderTest.pp(env.createSpy("something"))).toEqual("spy on something");
+    expect(jasmineUnderTest.pp(env.createSpy('something'))).toEqual(
+      'spy on something'
+    );
   });
 
-  it("should stringify spyOn toString properly", function() {
+  it('should stringify spyOn toString properly', function() {
     var TestObject = {
-      someFunction: function() {}
-    },
-    env = new jasmineUnderTest.Env();
+        someFunction: function() {}
+      },
+      env = new jasmineUnderTest.Env();
 
     var spyRegistry = new jasmineUnderTest.SpyRegistry({
-      currentSpies: function() {return [];},
+      currentSpies: function() {
+        return [];
+      },
       createSpy: function(name, originalFn) {
         return jasmineUnderTest.Spy(name, originalFn);
       }
@@ -301,59 +370,73 @@ describe("jasmineUnderTest.pp", function () {
     spyRegistry.spyOn(TestObject, 'toString');
     var testSpyObj = env.createSpyObj('TheClassName', ['toString']);
 
-    expect(jasmineUnderTest.pp(testSpyObj)).toEqual("spy on TheClassName.toString");
+    expect(jasmineUnderTest.pp(testSpyObj)).toEqual(
+      'spy on TheClassName.toString'
+    );
   });
 
-  it("should stringify objects that implement jasmineToString", function () {
+  it('should stringify objects that implement jasmineToString', function() {
     var obj = {
-      jasmineToString: function () { return "strung"; }
+      jasmineToString: function() {
+        return 'strung';
+      }
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual("strung");
+    expect(jasmineUnderTest.pp(obj)).toEqual('strung');
   });
 
-  it("should stringify objects that implement custom toString", function () {
+  it('should stringify objects that implement custom toString', function() {
     var obj = {
-      toString: function () { return "my toString"; }
+      toString: function() {
+        return 'my toString';
+      }
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual("my toString");
+    expect(jasmineUnderTest.pp(obj)).toEqual('my toString');
 
     // Simulate object from another global context (e.g. an iframe or Web Worker) that does not actually have a custom
     // toString despite obj.toString !== Object.prototype.toString
     var objFromOtherContext = {
       foo: 'bar',
-      toString: function () { return Object.prototype.toString.call(this); }
+      toString: function() {
+        return Object.prototype.toString.call(this);
+      }
     };
 
-    expect(jasmineUnderTest.pp(objFromOtherContext)).toEqual("Object({ foo: 'bar', toString: Function })");
+    expect(jasmineUnderTest.pp(objFromOtherContext)).toEqual(
+      "Object({ foo: 'bar', toString: Function })"
+    );
   });
 
   it("should stringify objects have have a toString that isn't a function", function() {
     var obj = {
-      toString: "foo"
+      toString: 'foo'
     };
 
     expect(jasmineUnderTest.pp(obj)).toEqual("Object({ toString: 'foo' })");
   });
 
-  it("should stringify objects from anonymous constructors with custom toString", function () {
-    var MyAnonymousConstructor = (function() { return function () {}; })();
-    MyAnonymousConstructor.toString = function () { return ''; };
+  it('should stringify objects from anonymous constructors with custom toString', function() {
+    var MyAnonymousConstructor = (function() {
+      return function() {};
+    })();
+    MyAnonymousConstructor.toString = function() {
+      return '';
+    };
 
     var a = new MyAnonymousConstructor();
 
-    expect(jasmineUnderTest.pp(a)).toEqual("<anonymous>({  })");
+    expect(jasmineUnderTest.pp(a)).toEqual('<anonymous>({  })');
   });
 
-  it("should handle objects with null prototype", function() {
+  it('should handle objects with null prototype', function() {
     var obj = Object.create(null);
     obj.foo = 'bar';
 
     expect(jasmineUnderTest.pp(obj)).toEqual("null({ foo: 'bar' })");
   });
 
-  it("should gracefully handle objects with invalid toString implementations", function () {
+  it('should gracefully handle objects with invalid toString implementations', function() {
     var obj = {
       foo: {
         toString: function() {
@@ -374,9 +457,11 @@ describe("jasmineUnderTest.pp", function () {
       // Valid: an actual number
       baz: 3,
       // Valid: an actual Error object
-      qux: new Error("bar")
+      qux: new Error('bar')
     };
 
-    expect(jasmineUnderTest.pp(obj)).toEqual("Object({ foo: [object Number], bar: [object Object], baz: 3, qux: Error: bar })");
+    expect(jasmineUnderTest.pp(obj)).toEqual(
+      'Object({ foo: [object Number], bar: [object Object], baz: 3, qux: Error: bar })'
+    );
   });
 });

spec/core/QueueRunnerSpec.js

@@ -1,5 +1,4 @@
-describe("QueueRunner", function() {
-
+describe('QueueRunner', function() {
   it("runs all the functions it's passed", function() {
     var calls = [],
       queueableFn1 = { fn: jasmine.createSpy('fn1') },
@@ -19,7 +18,7 @@ describe("QueueRunner", function() {
     expect(calls).toEqual(['fn1', 'fn2']);
   });
 
-  it("runs cleanup functions after the others", function() {
+  it('runs cleanup functions after the others', function() {
     var calls = [],
       queueableFn1 = { fn: jasmine.createSpy('fn1') },
       queueableFn2 = { fn: jasmine.createSpy('fn2') },
@@ -41,12 +40,17 @@ describe("QueueRunner", function() {
 
   it("calls each function with a consistent 'this'-- an empty object", function() {
     var queueableFn1 = { fn: jasmine.createSpy('fn1') },
-        queueableFn2 = { fn: jasmine.createSpy('fn2') },
-        queueableFn3 = { fn: function(done) { asyncContext = this; done(); } },
-        queueRunner = new jasmineUnderTest.QueueRunner({
-          queueableFns: [queueableFn1, queueableFn2, queueableFn3]
-        }),
-        asyncContext;
+      queueableFn2 = { fn: jasmine.createSpy('fn2') },
+      queueableFn3 = {
+        fn: function(done) {
+          asyncContext = this;
+          done();
+        }
+      },
+      queueRunner = new jasmineUnderTest.QueueRunner({
+        queueableFns: [queueableFn1, queueableFn2, queueableFn3]
+      }),
+      asyncContext;
 
     queueRunner.execute();
 
@@ -56,7 +60,7 @@ describe("QueueRunner", function() {
     expect(asyncContext).toBe(context);
   });
 
-  describe("with an asynchronous function", function() {
+  describe('with an asynchronous function', function() {
     beforeEach(function() {
       jasmine.clock().install();
     });
@@ -65,7 +69,7 @@ describe("QueueRunner", function() {
       jasmine.clock().uninstall();
     });
 
-    it("supports asynchronous functions, only advancing to next function after a done() callback", function() {
+    it('supports asynchronous functions, only advancing to next function after a done() callback', function() {
       //TODO: it would be nice if spy arity could match the fake, so we could do something like:
       //createSpy('asyncfn').and.callFake(function(done) {});
 
@@ -73,18 +77,24 @@ describe("QueueRunner", function() {
         beforeCallback = jasmine.createSpy('beforeCallback'),
         fnCallback = jasmine.createSpy('fnCallback'),
         afterCallback = jasmine.createSpy('afterCallback'),
-        queueableFn1 = { fn: function(done) {
-          beforeCallback();
-          setTimeout(done, 100);
-        } },
-        queueableFn2 = { fn: function(done) {
-          fnCallback();
-          setTimeout(done, 100);
-        } },
-        queueableFn3 = { fn: function(done) {
-          afterCallback();
-          setTimeout(done, 100);
-        } },
+        queueableFn1 = {
+          fn: function(done) {
+            beforeCallback();
+            setTimeout(done, 100);
+          }
+        },
+        queueableFn2 = {
+          fn: function(done) {
+            fnCallback();
+            setTimeout(done, 100);
+          }
+        },
+        queueableFn3 = {
+          fn: function(done) {
+            afterCallback();
+            setTimeout(done, 100);
+          }
+        },
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2, queueableFn3],
           onComplete: onComplete
@@ -113,10 +123,14 @@ describe("QueueRunner", function() {
       expect(onComplete).toHaveBeenCalled();
     });
 
-    it("explicitly fails an async function with a provided fail function and moves to the next function", function() {
-      var queueableFn1 = { fn: function(done) {
-          setTimeout(function() { done.fail('foo'); }, 100);
-        } },
+    it('explicitly fails an async function with a provided fail function and moves to the next function', function() {
+      var queueableFn1 = {
+          fn: function(done) {
+            setTimeout(function() {
+              done.fail('foo');
+            }, 100);
+          }
+        },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
         failFn = jasmine.createSpy('fail'),
         queueRunner = new jasmineUnderTest.QueueRunner({
@@ -135,11 +149,15 @@ describe("QueueRunner", function() {
       expect(queueableFn2.fn).toHaveBeenCalled();
     });
 
-    it("explicitly fails an async function when next is called with an Error and moves to the next function", function() {
+    it('explicitly fails an async function when next is called with an Error and moves to the next function', function() {
       var err = new Error('foo'),
-        queueableFn1 = { fn: function(done) {
-          setTimeout(function() { done(err); }, 100);
-        } },
+        queueableFn1 = {
+          fn: function(done) {
+            setTimeout(function() {
+              done(err);
+            }, 100);
+          }
+        },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
         failFn = jasmine.createSpy('fail'),
         queueRunner = new jasmineUnderTest.QueueRunner({
@@ -158,11 +176,15 @@ describe("QueueRunner", function() {
       expect(queueableFn2.fn).toHaveBeenCalled();
     });
 
-    it("does not cause an explicit fail if execution is being stopped", function() {
+    it('does not cause an explicit fail if execution is being stopped', function() {
       var err = new jasmineUnderTest.StopExecutionError('foo'),
-        queueableFn1 = { fn: function(done) {
-          setTimeout(function() { done(err); }, 100);
-        } },
+        queueableFn1 = {
+          fn: function(done) {
+            setTimeout(function() {
+              done(err);
+            }, 100);
+          }
+        },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
         failFn = jasmine.createSpy('fail'),
         queueRunner = new jasmineUnderTest.QueueRunner({
@@ -183,7 +205,7 @@ describe("QueueRunner", function() {
 
     it("sets a timeout if requested for asynchronous functions so they don't go on forever", function() {
       var timeout = 3,
-        beforeFn = { fn: function(done) { }, type: 'before', timeout: timeout },
+        beforeFn = { fn: function(done) {}, type: 'before', timeout: timeout },
         queueableFn = { fn: jasmine.createSpy('fn'), type: 'queueable' },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
@@ -203,15 +225,15 @@ describe("QueueRunner", function() {
       expect(onComplete).toHaveBeenCalled();
     });
 
-    it("by default does not set a timeout for asynchronous functions", function() {
-      var beforeFn = { fn: function(done) { } },
+    it('by default does not set a timeout for asynchronous functions', function() {
+      var beforeFn = { fn: function(done) {} },
         queueableFn = { fn: jasmine.createSpy('fn') },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [beforeFn, queueableFn],
           onComplete: onComplete,
-          onException: onException,
+          onException: onException
         });
 
       queueRunner.execute();
@@ -224,8 +246,12 @@ describe("QueueRunner", function() {
       expect(onComplete).not.toHaveBeenCalled();
     });
 
-    it("clears the timeout when an async function throws an exception, to prevent additional exception reporting", function() {
-       var queueableFn = { fn: function(done) { throw new Error("error!"); } },
+    it('clears the timeout when an async function throws an exception, to prevent additional exception reporting', function() {
+      var queueableFn = {
+          fn: function(done) {
+            throw new Error('error!');
+          }
+        },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new jasmineUnderTest.QueueRunner({
@@ -243,8 +269,12 @@ describe("QueueRunner", function() {
       expect(onException.calls.count()).toEqual(1);
     });
 
-    it("clears the timeout when the done callback is called", function() {
-      var queueableFn = { fn: function(done) { done(); } },
+    it('clears the timeout when the done callback is called', function() {
+      var queueableFn = {
+          fn: function(done) {
+            done();
+          }
+        },
         onComplete = jasmine.createSpy('onComplete'),
         onException = jasmine.createSpy('onException'),
         queueRunner = new jasmineUnderTest.QueueRunner({
@@ -262,8 +292,13 @@ describe("QueueRunner", function() {
       expect(onException).not.toHaveBeenCalled();
     });
 
-    it("only moves to the next spec the first time you call done", function() {
-      var queueableFn = { fn: function(done) {done(); done();} },
+    it('only moves to the next spec the first time you call done', function() {
+      var queueableFn = {
+          fn: function(done) {
+            done();
+            done();
+          }
+        },
         nextQueueableFn = { fn: jasmine.createSpy('nextFn') },
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn, nextQueueableFn]
@@ -274,27 +309,31 @@ describe("QueueRunner", function() {
       expect(nextQueueableFn.fn.calls.count()).toEqual(1);
     });
 
-    it("does not move to the next spec if done is called after an exception has ended the spec", function() {
-       var queueableFn = { fn: function(done) {
-         setTimeout(done, 1);
-         throw new Error('error!');
-       } },
-       nextQueueableFn = { fn: jasmine.createSpy('nextFn') },
-       queueRunner = new jasmineUnderTest.QueueRunner({
-         queueableFns: [queueableFn, nextQueueableFn]
-       });
+    it('does not move to the next spec if done is called after an exception has ended the spec', function() {
+      var queueableFn = {
+          fn: function(done) {
+            setTimeout(done, 1);
+            throw new Error('error!');
+          }
+        },
+        nextQueueableFn = { fn: jasmine.createSpy('nextFn') },
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn, nextQueueableFn]
+        });
 
       queueRunner.execute();
       jasmine.clock().tick(1);
       expect(nextQueueableFn.fn.calls.count()).toEqual(1);
     });
 
-    it("should return a null when you call done", function () {
+    it('should return a null when you call done', function() {
       // Some promises want handlers to return anything but undefined to help catch "forgotten returns".
       var doneReturn,
-        queueableFn = { fn: function(done) {
-          doneReturn = done();
-        } },
+        queueableFn = {
+          fn: function(done) {
+            doneReturn = done();
+          }
+        },
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn]
         });
@@ -303,24 +342,36 @@ describe("QueueRunner", function() {
       expect(doneReturn).toBe(null);
     });
 
-    it("continues running functions when an exception is thrown in async code without timing out", function() {
-      var queueableFn = { fn: function(done) { throwAsync(); }, timeout: 1 },
-        nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
+    it('continues running functions when an exception is thrown in async code without timing out', function() {
+      var queueableFn = {
+          fn: function(done) {
+            throwAsync();
+          },
+          timeout: 1
+        },
+        nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
         onException = jasmine.createSpy('onException'),
-        globalErrors = { pushListener: jasmine.createSpy('pushListener'), popListener: jasmine.createSpy('popListener') },
+        globalErrors = {
+          pushListener: jasmine.createSpy('pushListener'),
+          popListener: jasmine.createSpy('popListener')
+        },
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn, nextQueueableFn],
           onException: onException,
           globalErrors: globalErrors
         }),
         throwAsync = function() {
-          globalErrors.pushListener.calls.mostRecent().args[0](new Error('foo'));
+          globalErrors.pushListener.calls
+            .mostRecent()
+            .args[0](new Error('foo'));
           jasmine.clock().tick(2);
         };
 
       nextQueueableFn.fn.and.callFake(function() {
         // should remove the same function that was added
-        expect(globalErrors.popListener).toHaveBeenCalledWith(globalErrors.pushListener.calls.argsFor(1)[0]);
+        expect(globalErrors.popListener).toHaveBeenCalledWith(
+          globalErrors.pushListener.calls.argsFor(1)[0]
+        );
       });
 
       queueRunner.execute();
@@ -335,28 +386,37 @@ describe("QueueRunner", function() {
           }
         };
       }
-      expect(onException).not.toHaveBeenCalledWith(errorWithMessage(/DEFAULT_TIMEOUT_INTERVAL/));
+      expect(onException).not.toHaveBeenCalledWith(
+        errorWithMessage(/DEFAULT_TIMEOUT_INTERVAL/)
+      );
       expect(onException).toHaveBeenCalledWith(errorWithMessage(/^foo$/));
       expect(nextQueueableFn.fn).toHaveBeenCalled();
     });
 
-    it("handles exceptions thrown while waiting for the stack to clear", function() {
-      var queueableFn = { fn: function(done) { done() } },
-      global = {},
-      errorListeners = [],
-      globalErrors = {
-        pushListener: function(f) { errorListeners.push(f); },
-        popListener: function() { errorListeners.pop(); }
-      },
-      clearStack = jasmine.createSpy('clearStack'),
-      onException = jasmine.createSpy('onException'),
-      queueRunner = new jasmineUnderTest.QueueRunner({
-        queueableFns: [queueableFn],
-        globalErrors: globalErrors,
-        clearStack: clearStack,
-        onException: onException
-      }),
-      error = new Error('nope');
+    it('handles exceptions thrown while waiting for the stack to clear', function() {
+      var queueableFn = {
+          fn: function(done) {
+            done();
+          }
+        },
+        errorListeners = [],
+        globalErrors = {
+          pushListener: function(f) {
+            errorListeners.push(f);
+          },
+          popListener: function() {
+            errorListeners.pop();
+          }
+        },
+        clearStack = jasmine.createSpy('clearStack'),
+        onException = jasmine.createSpy('onException'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [queueableFn],
+          globalErrors: globalErrors,
+          clearStack: clearStack,
+          onException: onException
+        }),
+        error = new Error('nope');
 
       queueRunner.execute();
       jasmine.clock().tick();
@@ -368,7 +428,7 @@ describe("QueueRunner", function() {
     });
   });
 
-  describe("with a function that returns a promise", function() {
+  describe('with a function that returns a promise', function() {
     function StubPromise() {}
 
     StubPromise.prototype.then = function(resolve, reject) {
@@ -384,28 +444,32 @@ describe("QueueRunner", function() {
       jasmine.clock().uninstall();
     });
 
-    it("runs the function asynchronously, advancing once the promise is settled", function() {
+    it('runs the function asynchronously, advancing once the promise is settled', function() {
       var onComplete = jasmine.createSpy('onComplete'),
-        fnCallback =  jasmine.createSpy('fnCallback'),
+        fnCallback = jasmine.createSpy('fnCallback'),
         p1 = new StubPromise(),
         p2 = new StubPromise(),
-        queueableFn1 = { fn: function() {
-          setTimeout(function() {
-            p1.resolveHandler();
-          }, 100);
-          return p1;
-        } };
-        queueableFn2 = { fn: function() {
+        queueableFn1 = {
+          fn: function() {
+            setTimeout(function() {
+              p1.resolveHandler();
+            }, 100);
+            return p1;
+          }
+        };
+      (queueableFn2 = {
+        fn: function() {
           fnCallback();
           setTimeout(function() {
             p2.resolveHandler();
           }, 100);
           return p2;
-        } },
-        queueRunner = new jasmineUnderTest.QueueRunner({
+        }
+      }),
+        (queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2],
           onComplete: onComplete
-        });
+        }));
 
       queueRunner.execute();
       expect(fnCallback).not.toHaveBeenCalled();
@@ -421,16 +485,17 @@ describe("QueueRunner", function() {
       expect(onComplete).toHaveBeenCalled();
     });
 
-    it("handles a rejected promise like an unhandled exception", function() {
+    it('handles a rejected promise like an unhandled exception', function() {
       var promise = new StubPromise(),
-        queueableFn1 = { fn: function() {
-          setTimeout(function() {
-            promise.rejectHandler('foo')
-          }, 100);
-          return promise;
-        } },
+        queueableFn1 = {
+          fn: function() {
+            setTimeout(function() {
+              promise.rejectHandler('foo');
+            }, 100);
+            return promise;
+          }
+        },
         queueableFn2 = { fn: jasmine.createSpy('fn2') },
-        failFn = jasmine.createSpy('fail'),
         onExceptionCallback = jasmine.createSpy('on exception callback'),
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn1, queueableFn2],
@@ -449,11 +514,13 @@ describe("QueueRunner", function() {
     });
   });
 
-  it("calls exception handlers when an exception is thrown in a fn", function() {
-    var queueableFn = { type: 'queueable',
-      fn: function() {
-        throw new Error('fake error');
-      } },
+  it('calls exception handlers when an exception is thrown in a fn', function() {
+    var queueableFn = {
+        type: 'queueable',
+        fn: function() {
+          throw new Error('fake error');
+        }
+      },
       onExceptionCallback = jasmine.createSpy('on exception callback'),
       queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn],
@@ -465,9 +532,13 @@ describe("QueueRunner", function() {
     expect(onExceptionCallback).toHaveBeenCalledWith(jasmine.any(Error));
   });
 
-  it("continues running the functions even after an exception is thrown in an async spec", function() {
-    var queueableFn = { fn: function(done) { throw new Error("error"); } },
-      nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
+  it('continues running the functions even after an exception is thrown in an async spec', function() {
+    var queueableFn = {
+        fn: function(done) {
+          throw new Error('error');
+        }
+      },
+      nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
       queueRunner = new jasmineUnderTest.QueueRunner({
         queueableFns: [queueableFn, nextQueueableFn]
       });
@@ -476,12 +547,16 @@ describe("QueueRunner", function() {
     expect(nextQueueableFn.fn).toHaveBeenCalled();
   });
 
-  describe("When configured to complete on first error", function() {
-    it("skips to cleanup functions on the first exception", function() {
-      var queueableFn = { fn: function() { throw new Error("error"); } },
-        nextQueueableFn = { fn: jasmine.createSpy("nextFunction") },
-        cleanupFn = { fn: jasmine.createSpy("cleanup") },
-        onComplete = jasmine.createSpy("onComplete"),
+  describe('When configured to complete on first error', function() {
+    it('skips to cleanup functions on the first exception', function() {
+      var queueableFn = {
+          fn: function() {
+            throw new Error('error');
+          }
+        },
+        nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
+        cleanupFn = { fn: jasmine.createSpy('cleanup') },
+        onComplete = jasmine.createSpy('onComplete'),
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn, nextQueueableFn],
           cleanupFns: [cleanupFn],
@@ -492,13 +567,19 @@ describe("QueueRunner", function() {
       queueRunner.execute();
       expect(nextQueueableFn.fn).not.toHaveBeenCalled();
       expect(cleanupFn.fn).toHaveBeenCalled();
-      expect(onComplete).toHaveBeenCalledWith(jasmine.any(jasmineUnderTest.StopExecutionError));
+      expect(onComplete).toHaveBeenCalledWith(
+        jasmine.any(jasmineUnderTest.StopExecutionError)
+      );
     });
 
-    it("does not skip when a cleanup function throws", function() {
-      var queueableFn = { fn: function() { } },
-        cleanupFn1 = { fn: function() { throw new Error("error"); } },
-        cleanupFn2 = { fn: jasmine.createSpy("cleanupFn2") },
+    it('does not skip when a cleanup function throws', function() {
+      var queueableFn = { fn: function() {} },
+        cleanupFn1 = {
+          fn: function() {
+            throw new Error('error');
+          }
+        },
+        cleanupFn2 = { fn: jasmine.createSpy('cleanupFn2') },
         queueRunner = new jasmineUnderTest.QueueRunner({
           queueableFns: [queueableFn],
           cleanupFns: [cleanupFn1, cleanupFn2],
@@ -509,7 +590,7 @@ describe("QueueRunner", function() {
       expect(cleanupFn2.fn).toHaveBeenCalled();
     });
 
-    describe("with an asynchronous function", function() {
+    describe('with an asynchronous function', function() {
       beforeEach(function() {
         jasmine.clock().install();
       });
@@ -518,21 +599,24 @@ describe("QueueRunner", function() {
         jasmine.clock().uninstall();
       });
 
-
-      it("skips to cleanup functions on the first exception", function() {
+      it('skips to cleanup functions on the first exception', function() {
         var errorListeners = [],
           queueableFn = { fn: function(done) {} },
           nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
           cleanupFn = { fn: jasmine.createSpy('cleanup') },
           queueRunner = new jasmineUnderTest.QueueRunner({
             globalErrors: {
-              pushListener: function(f) { errorListeners.push(f); },
-              popListener: function() { errorListeners.pop(); },
+              pushListener: function(f) {
+                errorListeners.push(f);
+              },
+              popListener: function() {
+                errorListeners.pop();
+              }
             },
             queueableFns: [queueableFn, nextQueueableFn],
             cleanupFns: [cleanupFn],
-            completeOnFirstError: true,
-         });
+            completeOnFirstError: true
+          });
 
         queueRunner.execute();
         errorListeners[errorListeners.length - 1](new Error('error'));
@@ -540,17 +624,19 @@ describe("QueueRunner", function() {
         expect(cleanupFn.fn).toHaveBeenCalled();
       });
 
-      it("skips to cleanup functions when next.fail is called", function() {
-        var queueableFn = { fn: function(done) {
-            done.fail('nope');
-          } },
+      it('skips to cleanup functions when next.fail is called', function() {
+        var queueableFn = {
+            fn: function(done) {
+              done.fail('nope');
+            }
+          },
           nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
           cleanupFn = { fn: jasmine.createSpy('cleanup') },
           queueRunner = new jasmineUnderTest.QueueRunner({
             queueableFns: [queueableFn, nextQueueableFn],
             cleanupFns: [cleanupFn],
-            completeOnFirstError: true,
-         });
+            completeOnFirstError: true
+          });
 
         queueRunner.execute();
         jasmine.clock().tick();
@@ -558,17 +644,19 @@ describe("QueueRunner", function() {
         expect(cleanupFn.fn).toHaveBeenCalled();
       });
 
-      it("skips to cleanup functions when next is called with an Error", function() {
-        var queueableFn = { fn: function(done) {
-            done(new Error('nope'));
-          } },
+      it('skips to cleanup functions when next is called with an Error', function() {
+        var queueableFn = {
+            fn: function(done) {
+              done(new Error('nope'));
+            }
+          },
           nextQueueableFn = { fn: jasmine.createSpy('nextFunction') },
           cleanupFn = { fn: jasmine.createSpy('cleanup') },
           queueRunner = new jasmineUnderTest.QueueRunner({
             queueableFns: [queueableFn, nextQueueableFn],
             cleanupFns: [cleanupFn],
-            completeOnFirstError: true,
-         });
+            completeOnFirstError: true
+          });
 
         queueRunner.execute();
         jasmine.clock().tick();
@@ -578,7 +666,7 @@ describe("QueueRunner", function() {
     });
   });
 
-  it("calls a provided complete callback when done", function() {
+  it('calls a provided complete callback when done', function() {
     var queueableFn = { fn: jasmine.createSpy('fn') },
       completeCallback = jasmine.createSpy('completeCallback'),
       queueRunner = new jasmineUnderTest.QueueRunner({
@@ -591,7 +679,7 @@ describe("QueueRunner", function() {
     expect(completeCallback).toHaveBeenCalled();
   });
 
-  describe("clearing the stack", function() {
+  describe('clearing the stack', function() {
     beforeEach(function() {
       jasmine.clock().install();
     });
@@ -600,18 +688,24 @@ describe("QueueRunner", function() {
       jasmine.clock().uninstall();
     });
 
-    it("calls a provided stack clearing function when done", function() {
-      var asyncFn = { fn: function(done) { done() } },
-          afterFn = { fn: jasmine.createSpy('afterFn') },
-          completeCallback = jasmine.createSpy('completeCallback'),
-          clearStack = jasmine.createSpy('clearStack'),
-          queueRunner = new jasmineUnderTest.QueueRunner({
-            queueableFns: [asyncFn, afterFn],
-            clearStack: clearStack,
-            onComplete: completeCallback
-          });
+    it('calls a provided stack clearing function when done', function() {
+      var asyncFn = {
+          fn: function(done) {
+            done();
+          }
+        },
+        afterFn = { fn: jasmine.createSpy('afterFn') },
+        completeCallback = jasmine.createSpy('completeCallback'),
+        clearStack = jasmine.createSpy('clearStack'),
+        queueRunner = new jasmineUnderTest.QueueRunner({
+          queueableFns: [asyncFn, afterFn],
+          clearStack: clearStack,
+          onComplete: completeCallback
+        });
 
-      clearStack.and.callFake(function(fn) { fn(); });
+      clearStack.and.callFake(function(fn) {
+        fn();
+      });
 
       queueRunner.execute();
       jasmine.clock().tick();
@@ -633,9 +727,7 @@ describe("QueueRunner", function() {
     });
 
     it('runs the functions on the scope of a UserContext', function() {
-      var calls = [],
-          context;
-
+      var context;
       this.fn.and.callFake(function() {
         context = this;
       });
@@ -659,8 +751,7 @@ describe("QueueRunner", function() {
     });
 
     it('runs the functions on the scope of a UserContext', function() {
-      var calls = [],
-          context;
+      var context;
       this.fn.and.callFake(function() {
         context = this;
       });

spec/core/ReportDispatcherSpec.js

@@ -1,16 +1,22 @@
-describe("ReportDispatcher", function() {
-
-  it("builds an interface of requested methods", function() {
-    var dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar', 'baz']);
+describe('ReportDispatcher', function() {
+  it('builds an interface of requested methods', function() {
+    var dispatcher = new jasmineUnderTest.ReportDispatcher([
+      'foo',
+      'bar',
+      'baz'
+    ]);
 
     expect(dispatcher.foo).toBeDefined();
     expect(dispatcher.bar).toBeDefined();
     expect(dispatcher.baz).toBeDefined();
   });
 
-  it("dispatches requested methods to added reporters", function() {
+  it('dispatches requested methods to added reporters', function() {
     var queueRunnerFactory = jasmine.createSpy('queueRunner'),
-      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(
+        ['foo', 'bar'],
+        queueRunnerFactory
+      ),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       anotherReporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       completeCallback = jasmine.createSpy('complete');
@@ -20,10 +26,15 @@ describe("ReportDispatcher", function() {
 
     dispatcher.foo(123, 456, completeCallback);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}],
-      isReporter: true
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: [
+          { fn: jasmine.any(Function) },
+          { fn: jasmine.any(Function) }
+        ],
+        isReporter: true
+      })
+    );
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
@@ -38,10 +49,15 @@ describe("ReportDispatcher", function() {
 
     dispatcher.bar('a', 'b', completeCallback);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}, {fn: jasmine.any(Function)}],
-      isReporter: true
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: [
+          { fn: jasmine.any(Function) },
+          { fn: jasmine.any(Function) }
+        ],
+        isReporter: true
+      })
+    );
 
     fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
@@ -53,39 +69,52 @@ describe("ReportDispatcher", function() {
 
   it("does not dispatch to a reporter if the reporter doesn't accept the method", function() {
     var queueRunnerFactory = jasmine.createSpy('queueRunner'),
-      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo'], queueRunnerFactory),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(
+        ['foo'],
+        queueRunnerFactory
+      ),
       reporter = jasmine.createSpyObj('reporter', ['baz']);
 
     dispatcher.addReporter(reporter);
 
     dispatcher.foo(123, 456);
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: []
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: []
+      })
+    );
   });
 
   it("allows providing a fallback reporter in case there's no other reporter", function() {
     var queueRunnerFactory = jasmine.createSpy('queueRunner'),
-      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(
+        ['foo', 'bar'],
+        queueRunnerFactory
+      ),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       completeCallback = jasmine.createSpy('complete');
 
     dispatcher.provideFallbackReporter(reporter);
     dispatcher.foo(123, 456, completeCallback);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}],
-      isReporter: true
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        isReporter: true
+      })
+    );
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
     expect(reporter.foo).toHaveBeenCalledWith(123, 456);
   });
 
-  it("does not call fallback reporting methods when another reporter is provided", function() {
+  it('does not call fallback reporting methods when another reporter is provided', function() {
     var queueRunnerFactory = jasmine.createSpy('queueRunner'),
-      dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(
+        ['foo', 'bar'],
+        queueRunnerFactory
+      ),
       reporter = jasmine.createSpyObj('reporter', ['foo', 'bar']),
       fallbackReporter = jasmine.createSpyObj('otherReporter', ['foo', 'bar']),
       completeCallback = jasmine.createSpy('complete');
@@ -94,10 +123,12 @@ describe("ReportDispatcher", function() {
     dispatcher.addReporter(reporter);
     dispatcher.foo(123, 456, completeCallback);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}],
-      isReporter: true
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        isReporter: true
+      })
+    );
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
@@ -105,19 +136,24 @@ describe("ReportDispatcher", function() {
     expect(fallbackReporter.foo).not.toHaveBeenCalledWith(123, 456);
   });
 
-  it("allows registered reporters to be cleared", function() {
+  it('allows registered reporters to be cleared', function() {
     var queueRunnerFactory = jasmine.createSpy('queueRunner'),
-        dispatcher = new jasmineUnderTest.ReportDispatcher(['foo', 'bar'], queueRunnerFactory),
-        reporter1 = jasmine.createSpyObj('reporter1', ['foo', 'bar']),
-        reporter2 = jasmine.createSpyObj('reporter2', ['foo', 'bar']),
+      dispatcher = new jasmineUnderTest.ReportDispatcher(
+        ['foo', 'bar'],
+        queueRunnerFactory
+      ),
+      reporter1 = jasmine.createSpyObj('reporter1', ['foo', 'bar']),
+      reporter2 = jasmine.createSpyObj('reporter2', ['foo', 'bar']),
       completeCallback = jasmine.createSpy('complete');
 
     dispatcher.addReporter(reporter1);
     dispatcher.foo(123, completeCallback);
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}],
-      isReporter: true
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        isReporter: true
+      })
+    );
 
     var fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();
@@ -127,10 +163,12 @@ describe("ReportDispatcher", function() {
     dispatcher.addReporter(reporter2);
     dispatcher.bar(456, completeCallback);
 
-    expect(queueRunnerFactory).toHaveBeenCalledWith(jasmine.objectContaining({
-      queueableFns: [{fn: jasmine.any(Function)}],
-      isReporter: true
-    }));
+    expect(queueRunnerFactory).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        isReporter: true
+      })
+    );
 
     fns = queueRunnerFactory.calls.mostRecent().args[0].queueableFns;
     fns[0].fn();

spec/core/SpecSpec.js

@@ -1,25 +1,30 @@
-describe("Spec", function() {
-
-  it("#isPendingSpecException returns true for a pending spec exception", function() {
+describe('Spec', function() {
+  it('#isPendingSpecException returns true for a pending spec exception', function() {
     var e = new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
 
     expect(jasmineUnderTest.Spec.isPendingSpecException(e)).toBe(true);
   });
 
-  it("#isPendingSpecException returns true for a pending spec exception (even when FF bug is present)", function() {
+  it('#isPendingSpecException returns true for a pending spec exception (even when FF bug is present)', function() {
     var fakeError = {
-      toString: function() { return "Error: " + jasmineUnderTest.Spec.pendingSpecExceptionMessage; }
+      toString: function() {
+        return 'Error: ' + jasmineUnderTest.Spec.pendingSpecExceptionMessage;
+      }
     };
 
     expect(jasmineUnderTest.Spec.isPendingSpecException(fakeError)).toBe(true);
   });
 
-  it("#isPendingSpecException returns true for a pending spec exception with a custom message", function() {
-    expect(jasmineUnderTest.Spec.isPendingSpecException(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'foo')).toBe(true);
+  it('#isPendingSpecException returns true for a pending spec exception with a custom message', function() {
+    expect(
+      jasmineUnderTest.Spec.isPendingSpecException(
+        jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'foo'
+      )
+    ).toBe(true);
   });
 
-  it("#isPendingSpecException returns false for not a pending spec exception", function() {
-    var e = new Error("foo");
+  it('#isPendingSpecException returns false for not a pending spec exception', function() {
+    var e = new Error('foo');
 
     expect(jasmineUnderTest.Spec.isPendingSpecException(e)).toBe(false);
   });
@@ -28,7 +33,7 @@ describe("Spec", function() {
     expect(jasmineUnderTest.Spec.isPendingSpecException(void 0)).toBe(false);
   });
 
-  it("delegates execution to a QueueRunner", function() {
+  it('delegates execution to a QueueRunner', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       spec = new jasmineUnderTest.Spec({
         description: 'my test',
@@ -42,7 +47,7 @@ describe("Spec", function() {
     expect(fakeQueueRunner).toHaveBeenCalled();
   });
 
-  it("should call the start callback on execution", function() {
+  it('should call the start callback on execution', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       startCallback = jasmine.createSpy('startCallback'),
       spec = new jasmineUnderTest.Spec({
@@ -64,18 +69,22 @@ describe("Spec", function() {
     expect(startCallback.calls.first().object).toEqual(spec);
   });
 
-  it("should call the start callback on execution but before any befores are called", function() {
+  it('should call the start callback on execution but before any befores are called', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       beforesWereCalled = false,
-      startCallback = jasmine.createSpy('start-callback').and.callFake(function() {
-        expect(beforesWereCalled).toBe(false);
-      }),
+      startCallback = jasmine
+        .createSpy('start-callback')
+        .and.callFake(function() {
+          expect(beforesWereCalled).toBe(false);
+        }),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         beforeFns: function() {
-          return [function() {
-            beforesWereCalled = true
-          }]
+          return [
+            function() {
+              beforesWereCalled = true;
+            }
+          ];
         },
         onStart: startCallback,
         queueRunnerFactory: fakeQueueRunner
@@ -87,18 +96,20 @@ describe("Spec", function() {
     expect(startCallback).toHaveBeenCalled();
   });
 
-  it("provides all before fns and after fns to be run", function() {
+  it('provides all before fns and after fns to be run', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       before = jasmine.createSpy('before'),
       after = jasmine.createSpy('after'),
-      queueableFn = { fn: jasmine.createSpy('test body').and.callFake(function() {
-        expect(before).toHaveBeenCalled();
-        expect(after).not.toHaveBeenCalled();
-      }) },
+      queueableFn = {
+        fn: jasmine.createSpy('test body').and.callFake(function() {
+          expect(before).toHaveBeenCalled();
+          expect(after).not.toHaveBeenCalled();
+        })
+      },
       spec = new jasmineUnderTest.Spec({
         queueableFn: queueableFn,
         beforeAndAfterFns: function() {
-          return {befores: [before], afters: [after]}
+          return { befores: [before], afters: [after] };
         },
         queueRunnerFactory: fakeQueueRunner
       });
@@ -106,8 +117,12 @@ describe("Spec", function() {
     spec.execute();
 
     var options = fakeQueueRunner.calls.mostRecent().args[0];
-    expect(options.queueableFns).toEqual([{fn: jasmine.any(Function)}, before, queueableFn]);
-    expect(options.cleanupFns).toEqual([after, {fn: jasmine.any(Function)}]);
+    expect(options.queueableFns).toEqual([
+      { fn: jasmine.any(Function) },
+      before,
+      queueableFn
+    ]);
+    expect(options.cleanupFns).toEqual([after, { fn: jasmine.any(Function) }]);
   });
 
   it("tells the queue runner that it's a leaf node", function() {
@@ -115,21 +130,22 @@ describe("Spec", function() {
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
         beforeAndAfterFns: function() {
-          return {befores: [], afters: []}
+          return { befores: [], afters: [] };
         },
         queueRunnerFactory: fakeQueueRunner
       });
 
     spec.execute();
 
-    expect(fakeQueueRunner).toHaveBeenCalledWith(jasmine.objectContaining({
-      isLeaf: true
-    }));
+    expect(fakeQueueRunner).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        isLeaf: true
+      })
+    );
   });
 
-  it("is marked pending if created without a function body", function() {
+  it('is marked pending if created without a function body', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
-
       startCallback = jasmine.createSpy('startCallback'),
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
@@ -142,13 +158,13 @@ describe("Spec", function() {
     expect(spec.status()).toBe('pending');
   });
 
-  it("can be excluded at execution time by a parent", function() {
+  it('can be excluded at execution time by a parent', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       startCallback = jasmine.createSpy('startCallback'),
       specBody = jasmine.createSpy('specBody'),
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
-        onStart:startCallback,
+        onStart: startCallback,
         queueableFn: { fn: specBody },
         resultCallback: resultCallback,
         queueRunnerFactory: fakeQueueRunner
@@ -156,11 +172,13 @@ describe("Spec", function() {
 
     spec.execute('cally-back', true);
 
-    expect(fakeQueueRunner).toHaveBeenCalledWith(jasmine.objectContaining({
-      onComplete: jasmine.any(Function),
-      queueableFns: [{fn: jasmine.any(Function)}],
-      cleanupFns: [{fn: jasmine.any(Function)}]
-    }));
+    expect(fakeQueueRunner).toHaveBeenCalledWith(
+      jasmine.objectContaining({
+        onComplete: jasmine.any(Function),
+        queueableFns: [{ fn: jasmine.any(Function) }],
+        cleanupFns: [{ fn: jasmine.any(Function) }]
+      })
+    );
     expect(specBody).not.toHaveBeenCalled();
 
     var args = fakeQueueRunner.calls.mostRecent().args[0];
@@ -172,16 +190,16 @@ describe("Spec", function() {
     expect(spec.result.status).toBe('excluded');
   });
 
-  it("can be marked pending, but still calls callbacks when executed", function() {
+  it('can be marked pending, but still calls callbacks when executed', function() {
     var fakeQueueRunner = jasmine.createSpy('fakeQueueRunner'),
       startCallback = jasmine.createSpy('startCallback'),
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         onStart: startCallback,
         resultCallback: resultCallback,
-        description: "with a spec",
+        description: 'with a spec',
         getSpecName: function() {
-          return "a suite with a spec"
+          return 'a suite with a spec';
         },
         queueRunnerFactory: fakeQueueRunner,
         queueableFn: { fn: null }
@@ -199,26 +217,33 @@ describe("Spec", function() {
     args.queueableFns[0].fn();
     expect(startCallback).toHaveBeenCalled();
     args.cleanupFns[0].fn('things');
-    expect(resultCallback).toHaveBeenCalledWith({
-      id: spec.id,
-      status: 'pending',
-      description: 'with a spec',
-      fullName: 'a suite with a spec',
-      failedExpectations: [],
-      passedExpectations: [],
-      deprecationWarnings: [],
-      pendingReason: '',
-      duration: null,
-    }, 'things');
+    expect(resultCallback).toHaveBeenCalledWith(
+      {
+        id: spec.id,
+        status: 'pending',
+        description: 'with a spec',
+        fullName: 'a suite with a spec',
+        failedExpectations: [],
+        passedExpectations: [],
+        deprecationWarnings: [],
+        pendingReason: '',
+        duration: null
+      },
+      'things'
+    );
   });
 
-  it("should call the done callback on execution complete", function() {
+  it('should call the done callback on execution complete', function() {
     var done = jasmine.createSpy('done callback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
-        catchExceptions: function() { return false; },
+        catchExceptions: function() {
+          return false;
+        },
         resultCallback: function() {},
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); }
+        queueRunnerFactory: function(attrs) {
+          attrs.onComplete();
+        }
       });
 
     spec.execute(done);
@@ -226,11 +251,13 @@ describe("Spec", function() {
     expect(done).toHaveBeenCalled();
   });
 
-  it("should call the done callback with an error if the spec is failed", function() {
+  it('should call the done callback with an error if the spec is failed', function() {
     var done = jasmine.createSpy('done callback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
-        catchExceptions: function() { return false; },
+        catchExceptions: function() {
+          return false;
+        },
         resultCallback: function() {},
         queueRunnerFactory: function(attrs) {
           spec.result.status = 'failed';
@@ -240,49 +267,61 @@ describe("Spec", function() {
 
     spec.execute(done);
 
-    expect(done).toHaveBeenCalledWith(jasmine.any(jasmineUnderTest.StopExecutionError));
+    expect(done).toHaveBeenCalledWith(
+      jasmine.any(jasmineUnderTest.StopExecutionError)
+    );
   });
 
-  it("should report the duration of the test", function() {
+  it('should report the duration of the test', function() {
     var done = jasmine.createSpy('done callback'),
-      timer = jasmine.createSpyObj('timer', {'start': null, elapsed: 77000}),
+      timer = jasmine.createSpyObj('timer', { start: null, elapsed: 77000 }),
       spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: jasmine.createSpy("spec body")},
-        catchExceptions: function() { return false; },
+        queueableFn: { fn: jasmine.createSpy('spec body') },
+        catchExceptions: function() {
+          return false;
+        },
         resultCallback: function() {},
         queueRunnerFactory: function(attrs) {
           attrs.onComplete();
         },
-        timer: timer,
+        timer: timer
       });
     spec.execute(done);
     expect(spec.result.duration).toBe(77000);
   });
 
-  it("#status returns passing by default", function() {
-    var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
+  it('#status returns passing by default', function() {
+    var spec = new jasmineUnderTest.Spec({
+      queueableFn: { fn: jasmine.createSpy('spec body') }
+    });
     expect(spec.status()).toBe('passed');
   });
 
-  it("#status returns passed if all expectations in the spec have passed", function() {
-    var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body")} });
+  it('#status returns passed if all expectations in the spec have passed', function() {
+    var spec = new jasmineUnderTest.Spec({
+      queueableFn: { fn: jasmine.createSpy('spec body') }
+    });
     spec.addExpectationResult(true);
     expect(spec.status()).toBe('passed');
   });
 
-  it("#status returns failed if any expectations in the spec have failed", function() {
-    var spec = new jasmineUnderTest.Spec({queueableFn: { fn: jasmine.createSpy("spec body") } });
+  it('#status returns failed if any expectations in the spec have failed', function() {
+    var spec = new jasmineUnderTest.Spec({
+      queueableFn: { fn: jasmine.createSpy('spec body') }
+    });
     spec.addExpectationResult(true);
     spec.addExpectationResult(false);
     expect(spec.status()).toBe('failed');
   });
 
-  it("keeps track of passed and failed expectations", function() {
+  it('keeps track of passed and failed expectations', function() {
     var fakeQueueRunner = jasmine.createSpy('queueRunner'),
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
-        queueableFn: { fn: jasmine.createSpy("spec body") },
-        expectationResultFactory: function (data) { return data; },
+        queueableFn: { fn: jasmine.createSpy('spec body') },
+        expectationResultFactory: function(data) {
+          return data;
+        },
         queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback
       });
@@ -292,8 +331,12 @@ describe("Spec", function() {
     spec.execute();
 
     fakeQueueRunner.calls.mostRecent().args[0].cleanupFns[0].fn();
-    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual(['expectation1']);
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual(['expectation2']);
+    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual([
+      'expectation1'
+    ]);
+    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([
+      'expectation2'
+    ]);
   });
 
   it("throws an ExpectationFailed error upon receiving a failed expectation when 'throwOnExpectationFailure' is set", function() {
@@ -301,7 +344,9 @@ describe("Spec", function() {
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
-        expectationResultFactory: function(data) { return data; },
+        expectationResultFactory: function(data) {
+          return data;
+        },
         queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback,
         throwOnExpectationFailure: true
@@ -309,22 +354,30 @@ describe("Spec", function() {
 
     spec.addExpectationResult(true, 'passed');
     expect(function() {
-      spec.addExpectationResult(false, 'failed')
+      spec.addExpectationResult(false, 'failed');
     }).toThrowError(jasmineUnderTest.errors.ExpectationFailed);
 
     spec.execute();
 
     fakeQueueRunner.calls.mostRecent().args[0].cleanupFns[0].fn();
-    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual(['passed']);
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual(['failed']);
+    expect(resultCallback.calls.first().args[0].passedExpectations).toEqual([
+      'passed'
+    ]);
+    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([
+      'failed'
+    ]);
   });
 
-  it("does not throw an ExpectationFailed error when handling an error", function() {
+  it('does not throw an ExpectationFailed error when handling an error', function() {
     var resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
-        expectationResultFactory: function(data) { return data; },
-        queueRunnerFactory: function(attrs) { attrs.onComplete(); },
+        expectationResultFactory: function(data) {
+          return data;
+        },
+        queueRunnerFactory: function(attrs) {
+          attrs.onComplete();
+        },
         resultCallback: resultCallback,
         throwOnExpectationFailure: true
       });
@@ -332,8 +385,10 @@ describe("Spec", function() {
     spec.onException('failing exception');
   });
 
-  it("can return its full name", function() {
-    var specNameSpy = jasmine.createSpy('specNameSpy').and.returnValue('expected val');
+  it('can return its full name', function() {
+    var specNameSpy = jasmine
+      .createSpy('specNameSpy')
+      .and.returnValue('expected val');
 
     var spec = new jasmineUnderTest.Spec({
       getSpecName: specNameSpy,
@@ -344,48 +399,57 @@ describe("Spec", function() {
     expect(specNameSpy.calls.mostRecent().args[0].id).toEqual(spec.id);
   });
 
-  describe("when a spec is marked pending during execution", function() {
-    it("should mark the spec as pending", function() {
+  describe('when a spec is marked pending during execution', function() {
+    it('should mark the spec as pending', function() {
       var fakeQueueRunner = function(opts) {
-          opts.onException(new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage));
+          opts.onException(
+            new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage)
+          );
         },
         spec = new jasmineUnderTest.Spec({
           description: 'my test',
           id: 'some-id',
-          queueableFn: { fn: function() { } },
+          queueableFn: { fn: function() {} },
           queueRunnerFactory: fakeQueueRunner
         });
 
       spec.execute();
 
-      expect(spec.status()).toEqual("pending");
+      expect(spec.status()).toEqual('pending');
       expect(spec.result.pendingReason).toEqual('');
     });
 
-    it("should set the pendingReason", function() {
+    it('should set the pendingReason', function() {
       var fakeQueueRunner = function(opts) {
-          opts.onException(new Error(jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message'));
+          opts.onException(
+            new Error(
+              jasmineUnderTest.Spec.pendingSpecExceptionMessage +
+                'custom message'
+            )
+          );
         },
         spec = new jasmineUnderTest.Spec({
           description: 'my test',
           id: 'some-id',
-          queueableFn: { fn: function() { } },
+          queueableFn: { fn: function() {} },
           queueRunnerFactory: fakeQueueRunner
         });
 
       spec.execute();
 
-      expect(spec.status()).toEqual("pending");
+      expect(spec.status()).toEqual('pending');
       expect(spec.result.pendingReason).toEqual('custom message');
     });
   });
 
-  it("should log a failure when handling an exception", function() {
+  it('should log a failure when handling an exception', function() {
     var fakeQueueRunner = jasmine.createSpy('queueRunner'),
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
-        expectationResultFactory: function(data) { return data; },
+        expectationResultFactory: function(data) {
+          return data;
+        },
         queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback
       });
@@ -395,21 +459,25 @@ describe("Spec", function() {
 
     var args = fakeQueueRunner.calls.mostRecent().args[0];
     args.cleanupFns[0].fn();
-    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([{
-      error: 'foo',
-      matcherName: '',
-      passed: false,
-      expected: '',
-      actual: ''
-    }]);
+    expect(resultCallback.calls.first().args[0].failedExpectations).toEqual([
+      {
+        error: 'foo',
+        matcherName: '',
+        passed: false,
+        expected: '',
+        actual: ''
+      }
+    ]);
   });
 
-  it("should not log an additional failure when handling an ExpectationFailed error", function() {
+  it('should not log an additional failure when handling an ExpectationFailed error', function() {
     var fakeQueueRunner = jasmine.createSpy('queueRunner'),
       resultCallback = jasmine.createSpy('resultCallback'),
       spec = new jasmineUnderTest.Spec({
         queueableFn: { fn: function() {} },
-        expectationResultFactory: function(data) { return data; },
+        expectationResultFactory: function(data) {
+          return data;
+        },
         queueRunnerFactory: fakeQueueRunner,
         resultCallback: resultCallback
       });

spec/core/SpyRegistrySpec.js

@@ -1,33 +1,35 @@
-describe("SpyRegistry", function() {
+describe('SpyRegistry', function() {
   function createSpy(name, originalFn) {
     return jasmineUnderTest.Spy(name, originalFn);
   }
 
-  describe("#spyOn", function() {
-    it("checks for the existence of the object", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy});
+  describe('#spyOn', function() {
+    it('checks for the existence of the object', function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+        createSpy: createSpy
+      });
       expect(function() {
         spyRegistry.spyOn(void 0, 'pants');
       }).toThrowError(/could not find an object/);
     });
 
-    it("checks that a method name was passed", function() {
+    it('checks that a method name was passed', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
-        expect(function() {
-          spyRegistry.spyOn(subject);
-        }).toThrowError(/No method name supplied/);
+      expect(function() {
+        spyRegistry.spyOn(subject);
+      }).toThrowError(/No method name supplied/);
     });
 
-    it("checks that the object is not `null`", function() {
+    it('checks that the object is not `null`', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry();
       expect(function() {
         spyRegistry.spyOn(null, 'pants');
       }).toThrowError(/could not find an object/);
     });
 
-    it("checks that the method name is not `null`", function() {
+    it('checks that the method name is not `null`', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
@@ -36,7 +38,7 @@ describe("SpyRegistry", function() {
       }).toThrowError(/No method name supplied/);
     });
 
-    it("checks for the existence of the method", function() {
+    it('checks for the existence of the method', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
@@ -45,10 +47,12 @@ describe("SpyRegistry", function() {
       }).toThrowError(/method does not exist/);
     });
 
-    it("checks if it has already been spied upon", function() {
+    it('checks if it has already been spied upon', function() {
       var spies = [],
         spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
+          currentSpies: function() {
+            return spies;
+          },
           createSpy: createSpy
         }),
         subject = { spiedFunc: function() {} };
@@ -60,7 +64,7 @@ describe("SpyRegistry", function() {
       }).toThrowError(/has already been spied upon/);
     });
 
-    it("checks if it can be spied upon", function() {
+    it('checks if it can be spied upon', function() {
       var scope = {};
 
       function myFunc() {
@@ -74,7 +78,11 @@ describe("SpyRegistry", function() {
       });
 
       var spies = [],
-        spyRegistry = new jasmineUnderTest.SpyRegistry({currentSpies: function() { return spies; }}),
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() {
+            return spies;
+          }
+        }),
         subject = { spiedFunc: scope.myFunc };
 
       expect(function() {
@@ -86,35 +94,43 @@ describe("SpyRegistry", function() {
       }).not.toThrowError(/is not declared writable or has no setter/);
     });
 
-    it("overrides the method on the object and returns the spy", function() {
+    it('overrides the method on the object and returns the spy', function() {
       var originalFunctionWasCalled = false,
-        spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
-        subject = { spiedFunc: function() { originalFunctionWasCalled = true; } };
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          createSpy: createSpy
+        }),
+        subject = {
+          spiedFunc: function() {
+            originalFunctionWasCalled = true;
+          }
+        };
 
       var spy = spyRegistry.spyOn(subject, 'spiedFunc');
 
       expect(subject.spiedFunc).toEqual(spy);
+      subject.spiedFunc();
+      expect(originalFunctionWasCalled).toBe(false);
     });
   });
 
-  describe("#spyOnProperty", function() {
-    it("checks for the existence of the object", function() {
+  describe('#spyOnProperty', function() {
+    it('checks for the existence of the object', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry();
       expect(function() {
         spyRegistry.spyOnProperty(void 0, 'pants');
       }).toThrowError(/could not find an object/);
     });
 
-    it("checks that a property name was passed", function() {
+    it('checks that a property name was passed', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
-        expect(function() {
-          spyRegistry.spyOnProperty(subject);
-        }).toThrowError(/No property name supplied/);
+      expect(function() {
+        spyRegistry.spyOnProperty(subject);
+      }).toThrowError(/No property name supplied/);
     });
 
-    it("checks for the existence of the method", function() {
+    it('checks for the existence of the method', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
@@ -123,12 +139,14 @@ describe("SpyRegistry", function() {
       }).toThrowError(/property does not exist/);
     });
 
-    it("checks for the existence of access type", function() {
+    it('checks for the existence of access type', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry(),
         subject = {};
 
       Object.defineProperty(subject, 'pants', {
-        get: function() { return 1; },
+        get: function() {
+          return 1;
+        },
         configurable: true
       });
 
@@ -137,7 +155,7 @@ describe("SpyRegistry", function() {
       }).toThrowError(/does not have access type/);
     });
 
-    it("checks if it can be spied upon", function() {
+    it('checks if it can be spied upon', function() {
       var subject = {};
 
       Object.defineProperty(subject, 'myProp', {
@@ -160,50 +178,64 @@ describe("SpyRegistry", function() {
       }).not.toThrowError(/is not declared configurable/);
     });
 
-    it("overrides the property getter on the object and returns the spy", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+    it('overrides the property getter on the object and returns the spy', function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+          createSpy: createSpy
+        }),
         subject = {},
         returnValue = 1;
 
       Object.defineProperty(subject, 'spiedProperty', {
-        get: function() { return returnValue; },
+        get: function() {
+          return returnValue;
+        },
         configurable: true
       });
 
       expect(subject.spiedProperty).toEqual(returnValue);
 
       var spy = spyRegistry.spyOnProperty(subject, 'spiedProperty');
-      var getter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty').get;
+      var getter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty')
+        .get;
 
       expect(getter).toEqual(spy);
       expect(subject.spiedProperty).toBeUndefined();
     });
 
-    it("overrides the property setter on the object and returns the spy", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+    it('overrides the property setter on the object and returns the spy', function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+          createSpy: createSpy
+        }),
         subject = {},
         returnValue = 1;
 
       Object.defineProperty(subject, 'spiedProperty', {
-        get: function() { return returnValue; },
+        get: function() {
+          return returnValue;
+        },
         set: function() {},
         configurable: true
       });
 
       var spy = spyRegistry.spyOnProperty(subject, 'spiedProperty', 'set');
-      var setter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty').set;
+      var setter = Object.getOwnPropertyDescriptor(subject, 'spiedProperty')
+        .set;
 
       expect(subject.spiedProperty).toEqual(returnValue);
       expect(setter).toEqual(spy);
     });
 
-    describe("when the property is already spied upon", function() {
-      it("throws an error if respy is not allowed", function() {
-        var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+    describe('when the property is already spied upon', function() {
+      it('throws an error if respy is not allowed', function() {
+        var spyRegistry = new jasmineUnderTest.SpyRegistry({
+            createSpy: createSpy
+          }),
           subject = {};
 
         Object.defineProperty(subject, 'spiedProp', {
-          get: function() { return 1; },
+          get: function() {
+            return 1;
+          },
           configurable: true
         });
 
@@ -214,37 +246,49 @@ describe("SpyRegistry", function() {
         }).toThrowError(/spiedProp#get has already been spied upon/);
       });
 
-      it("returns the original spy if respy is allowed", function() {
-        var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: createSpy}),
+      it('returns the original spy if respy is allowed', function() {
+        var spyRegistry = new jasmineUnderTest.SpyRegistry({
+            createSpy: createSpy
+          }),
           subject = {};
 
         spyRegistry.allowRespy(true);
 
         Object.defineProperty(subject, 'spiedProp', {
-          get: function() { return 1; },
+          get: function() {
+            return 1;
+          },
           configurable: true
         });
 
         var originalSpy = spyRegistry.spyOnProperty(subject, 'spiedProp');
 
-        expect(spyRegistry.spyOnProperty(subject, 'spiedProp')).toBe(originalSpy);
+        expect(spyRegistry.spyOnProperty(subject, 'spiedProp')).toBe(
+          originalSpy
+        );
       });
     });
   });
 
-  describe("#spyOnAllFunctions", function() {
-    it("checks for the existence of the object", function() {
+  describe('#spyOnAllFunctions', function() {
+    it('checks for the existence of the object', function() {
       var spyRegistry = new jasmineUnderTest.SpyRegistry();
       expect(function() {
         spyRegistry.spyOnAllFunctions(void 0);
       }).toThrowError(/spyOnAllFunctions could not find an object to spy upon/);
     });
 
-    it("overrides all writable and configurable functions of the object and its parents", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: function() {
-        return 'I am a spy';
-      }});
-      var createNoop = function() { return function() { /**/}; };
+    it('overrides all writable and configurable functions of the object and its parents', function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+        createSpy: function() {
+          return 'I am a spy';
+        }
+      });
+      var createNoop = function() {
+        return function() {
+          /**/
+        };
+      };
       var noop1 = createNoop();
       var noop2 = createNoop();
       var noop3 = createNoop();
@@ -270,7 +314,7 @@ describe("SpyRegistry", function() {
       var _spied3 = noop3;
       Object.defineProperty(subject, 'spied3', {
         configurable: true,
-        set: function (val) {
+        set: function(val) {
           _spied3 = val;
         },
         get: function() {
@@ -293,7 +337,9 @@ describe("SpyRegistry", function() {
       });
       Object.defineProperty(subject, 'notSpied4', {
         configurable: false,
-        set: function(val) { /**/ },
+        set: function(val) {
+          /**/
+        },
         get: function() {
           return noop4;
         },
@@ -322,13 +368,15 @@ describe("SpyRegistry", function() {
       expect(spiedObject).toBe(subject);
     });
 
-    it("overrides prototype methods on the object", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: function() {
-        return 'I am a spy';
-      }});
+    it('overrides prototype methods on the object', function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+        createSpy: function() {
+          return 'I am a spy';
+        }
+      });
 
-      var noop1 = function() { };
-      var noop2 = function() { };
+      var noop1 = function() {};
+      var noop2 = function() {};
 
       var MyClass = function() {
         this.spied1 = noop1;
@@ -343,12 +391,14 @@ describe("SpyRegistry", function() {
       expect(MyClass.prototype.spied2).toBe(noop2);
     });
 
-    it("does not override non-enumerable properties (like Object.prototype methods)", function() {
-      var spyRegistry = new jasmineUnderTest.SpyRegistry({createSpy: function() {
-        return 'I am a spy';
-      }});
+    it('does not override non-enumerable properties (like Object.prototype methods)', function() {
+      var spyRegistry = new jasmineUnderTest.SpyRegistry({
+        createSpy: function() {
+          return 'I am a spy';
+        }
+      });
       var subject = {
-        spied1: function() { }
+        spied1: function() {}
       };
 
       spyRegistry.spyOnAllFunctions(subject);
@@ -359,11 +409,13 @@ describe("SpyRegistry", function() {
     });
   });
 
-  describe("#clearSpies", function() {
-    it("restores the original functions on the spied-upon objects", function() {
+  describe('#clearSpies', function() {
+    it('restores the original functions on the spied-upon objects', function() {
       var spies = [],
         spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
+          currentSpies: function() {
+            return spies;
+          },
           createSpy: createSpy
         }),
         originalFunction = function() {},
@@ -375,10 +427,12 @@ describe("SpyRegistry", function() {
       expect(subject.spiedFunc).toBe(originalFunction);
     });
 
-    it("restores the original functions, even when that spy has been replace and re-spied upon", function() {
+    it('restores the original functions, even when that spy has been replace and re-spied upon', function() {
       var spies = [],
         spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
+          currentSpies: function() {
+            return spies;
+          },
           createSpy: createSpy
         }),
         originalFunction = function() {},
@@ -400,11 +454,13 @@ describe("SpyRegistry", function() {
     it("does not add a property that the spied-upon object didn't originally have", function() {
       var spies = [],
         spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
+          currentSpies: function() {
+            return spies;
+          },
           createSpy: createSpy
         }),
         originalFunction = function() {},
-        subjectParent = {spiedFunc: originalFunction};
+        subjectParent = { spiedFunc: originalFunction };
 
       var subject = Object.create(subjectParent);
 
@@ -417,14 +473,16 @@ describe("SpyRegistry", function() {
       expect(subject.spiedFunc).toBe(originalFunction);
     });
 
-    it("restores the original function when it\'s inherited and cannot be deleted", function() {
+    it("restores the original function when it's inherited and cannot be deleted", function() {
       var spies = [],
         spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
+          currentSpies: function() {
+            return spies;
+          },
           createSpy: createSpy
         }),
         originalFunction = function() {},
-        subjectParent = {spiedFunc: originalFunction};
+        subjectParent = { spiedFunc: originalFunction };
 
       var subject = Object.create(subjectParent);
 
@@ -440,15 +498,16 @@ describe("SpyRegistry", function() {
       expect(jasmineUnderTest.isSpy(subject.spiedFunc)).toBe(false);
     });
 
-    it("restores window.onerror by overwriting, not deleting", function() {
-      function FakeWindow() {
-      }
+    it('restores window.onerror by overwriting, not deleting', function() {
+      function FakeWindow() {}
       FakeWindow.prototype.onerror = function() {};
 
       var spies = [],
         global = new FakeWindow(),
         spyRegistry = new jasmineUnderTest.SpyRegistry({
-          currentSpies: function() { return spies; },
+          currentSpies: function() {
+            return spies;
+          },
           createSpy: createSpy,
           global: global
         });
@@ -460,50 +519,58 @@ describe("SpyRegistry", function() {
     });
   });
 
-    describe('spying on properties', function() {
-      it("restores the original properties on the spied-upon objects", function() {
-        var spies = [],
-          spyRegistry = new jasmineUnderTest.SpyRegistry({
-            currentSpies: function() { return spies; },
-            createSpy: createSpy
-          }),
-          originalReturn = 1,
-          subject = {};
+  describe('spying on properties', function() {
+    it('restores the original properties on the spied-upon objects', function() {
+      var spies = [],
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() {
+            return spies;
+          },
+          createSpy: createSpy
+        }),
+        originalReturn = 1,
+        subject = {};
 
-        Object.defineProperty(subject, 'spiedProp', {
-          get: function() { return originalReturn; },
-          configurable: true
-        });
-
-        spyRegistry.spyOnProperty(subject, 'spiedProp');
-        spyRegistry.clearSpies();
-
-        expect(subject.spiedProp).toBe(originalReturn);
+      Object.defineProperty(subject, 'spiedProp', {
+        get: function() {
+          return originalReturn;
+        },
+        configurable: true
       });
 
-      it("does not add a property that the spied-upon object didn't originally have", function() {
-        var spies = [],
-          spyRegistry = new jasmineUnderTest.SpyRegistry({
-            currentSpies: function() { return spies; },
-            createSpy: createSpy
-          }),
-          originalReturn = 1,
-          subjectParent = {};
+      spyRegistry.spyOnProperty(subject, 'spiedProp');
+      spyRegistry.clearSpies();
 
-        Object.defineProperty(subjectParent, 'spiedProp', {
-          get: function() { return originalReturn; },
-          configurable: true
-        });
-
-        var subject = Object.create(subjectParent);
-
-        expect(subject.hasOwnProperty('spiedProp')).toBe(false);
-
-        spyRegistry.spyOnProperty(subject, 'spiedProp');
-        spyRegistry.clearSpies();
-
-        expect(subject.hasOwnProperty('spiedProp')).toBe(false);
-        expect(subject.spiedProp).toBe(originalReturn);
-      });
+      expect(subject.spiedProp).toBe(originalReturn);
     });
+
+    it("does not add a property that the spied-upon object didn't originally have", function() {
+      var spies = [],
+        spyRegistry = new jasmineUnderTest.SpyRegistry({
+          currentSpies: function() {
+            return spies;
+          },
+          createSpy: createSpy
+        }),
+        originalReturn = 1,
+        subjectParent = {};
+
+      Object.defineProperty(subjectParent, 'spiedProp', {
+        get: function() {
+          return originalReturn;
+        },
+        configurable: true
+      });
+
+      var subject = Object.create(subjectParent);
+
+      expect(subject.hasOwnProperty('spiedProp')).toBe(false);
+
+      spyRegistry.spyOnProperty(subject, 'spiedProp');
+      spyRegistry.clearSpies();
+
+      expect(subject.hasOwnProperty('spiedProp')).toBe(false);
+      expect(subject.spiedProp).toBe(originalReturn);
+    });
+  });
 });

spec/core/SpySpec.js

@@ -1,64 +1,78 @@
-describe('Spies', function () {
+describe('Spies', function() {
   var env;
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
   });
 
-  describe("createSpy", function() {
+  describe('createSpy', function() {
     var TestClass;
 
     beforeEach(function() {
       TestClass = function() {};
       TestClass.prototype.someFunction = function() {};
-      TestClass.prototype.someFunction.bob = "test";
+      TestClass.prototype.someFunction.bob = 'test';
     });
 
-    it("preserves the properties of the spied function", function() {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+    it('preserves the properties of the spied function', function() {
+      var spy = env.createSpy(
+        TestClass.prototype,
+        TestClass.prototype.someFunction
+      );
 
-      expect(spy.bob).toEqual("test");
+      expect(spy.bob).toEqual('test');
     });
 
-    it("should allow you to omit the name argument and only pass the originalFn argument", function() {
+    it('should allow you to omit the name argument and only pass the originalFn argument', function() {
       var fn = function test() {};
       var spy = env.createSpy(fn);
 
       // IE doesn't do `.name`
-      if (fn.name === "test") {
-        expect(spy.and.identity).toEqual("test");
+      if (fn.name === 'test') {
+        expect(spy.and.identity).toEqual('test');
       } else {
-        expect(spy.and.identity).toEqual("unknown");
+        expect(spy.and.identity).toEqual('unknown');
       }
-    })
+    });
 
-    it("warns the user that we intend to overwrite an existing property", function() {
-      TestClass.prototype.someFunction.and = "turkey";
+    it('warns the user that we intend to overwrite an existing property', function() {
+      TestClass.prototype.someFunction.and = 'turkey';
 
       expect(function() {
         env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      }).toThrowError("Jasmine spies would overwrite the 'and' and 'calls' properties on the object being spied upon");
+      }).toThrowError(
+        "Jasmine spies would overwrite the 'and' and 'calls' properties on the object being spied upon"
+      );
     });
 
-    it("adds a spyStrategy and callTracker to the spy", function() {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
+    it('adds a spyStrategy and callTracker to the spy', function() {
+      var spy = env.createSpy(
+        TestClass.prototype,
+        TestClass.prototype.someFunction
+      );
 
       expect(spy.and).toEqual(jasmine.any(jasmineUnderTest.SpyStrategy));
       expect(spy.calls).toEqual(jasmine.any(jasmineUnderTest.CallTracker));
     });
 
-    it("tracks the argument of calls", function () {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
+    it('tracks the argument of calls', function() {
+      var spy = env.createSpy(
+        TestClass.prototype,
+        TestClass.prototype.someFunction
+      );
+      var trackSpy = spyOn(spy.calls, 'track');
 
-      spy("arg");
+      spy('arg');
 
-      expect(trackSpy.calls.mostRecent().args[0].args).toEqual(["arg"]);
+      expect(trackSpy.calls.mostRecent().args[0].args).toEqual(['arg']);
     });
 
-    it("tracks the context of calls", function () {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
+    it('tracks the context of calls', function() {
+      var spy = env.createSpy(
+        TestClass.prototype,
+        TestClass.prototype.someFunction
+      );
+      var trackSpy = spyOn(spy.calls, 'track');
 
       var contextObject = { spyMethod: spy };
       contextObject.spyMethod();
@@ -66,39 +80,47 @@ describe('Spies', function () {
       expect(trackSpy.calls.mostRecent().args[0].object).toEqual(contextObject);
     });
 
-    it("tracks the return value of calls", function () {
-      var spy = env.createSpy(TestClass.prototype, TestClass.prototype.someFunction);
-      var trackSpy = spyOn(spy.calls, "track");
+    it('tracks the return value of calls', function() {
+      var spy = env.createSpy(
+        TestClass.prototype,
+        TestClass.prototype.someFunction
+      );
+      var trackSpy = spyOn(spy.calls, 'track');
 
-      spy.and.returnValue("return value");
+      spy.and.returnValue('return value');
       spy();
 
-      expect(trackSpy.calls.mostRecent().args[0].returnValue).toEqual("return value");
+      expect(trackSpy.calls.mostRecent().args[0].returnValue).toEqual(
+        'return value'
+      );
     });
 
-    it("preserves arity of original function", function () {
+    it('preserves arity of original function', function() {
       var functions = [
-        function nullary () {},
-        function unary (arg) {},
-        function binary (arg1, arg2) {},
-        function ternary (arg1, arg2, arg3) {},
-        function quaternary (arg1, arg2, arg3, arg4) {},
-        function quinary (arg1, arg2, arg3, arg4, arg5) {},
-        function senary (arg1, arg2, arg3, arg4, arg5, arg6) {}
+        function nullary() {},
+        function unary(arg) {},
+        function binary(arg1, arg2) {},
+        function ternary(arg1, arg2, arg3) {},
+        function quaternary(arg1, arg2, arg3, arg4) {},
+        function quinary(arg1, arg2, arg3, arg4, arg5) {},
+        function senary(arg1, arg2, arg3, arg4, arg5, arg6) {}
       ];
 
       for (var arity = 0; arity < functions.length; arity++) {
         var someFunction = functions[arity],
-            spy = env.createSpy(someFunction.name, someFunction);
+          spy = env.createSpy(someFunction.name, someFunction);
 
         expect(spy.length).toEqual(arity);
       }
     });
   });
 
-  describe("createSpyObj", function() {
-    it("should create an object with spy methods and corresponding return values when you call jasmine.createSpyObj() with an object", function () {
-      var spyObj = env.createSpyObj('BaseName', {'method1': 42, 'method2': 'special sauce' });
+  describe('createSpyObj', function() {
+    it('should create an object with spy methods and corresponding return values when you call jasmine.createSpyObj() with an object', function() {
+      var spyObj = env.createSpyObj('BaseName', {
+        method1: 42,
+        method2: 'special sauce'
+      });
 
       expect(spyObj.method1()).toEqual(42);
       expect(spyObj.method1.and.identity).toEqual('BaseName.method1');
@@ -107,43 +129,54 @@ describe('Spies', function () {
       expect(spyObj.method2.and.identity).toEqual('BaseName.method2');
     });
 
-
-    it("should create an object with a bunch of spy methods when you call jasmine.createSpyObj()", function() {
+    it('should create an object with a bunch of spy methods when you call jasmine.createSpyObj()', function() {
       var spyObj = env.createSpyObj('BaseName', ['method1', 'method2']);
 
-      expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
+      expect(spyObj).toEqual({
+        method1: jasmine.any(Function),
+        method2: jasmine.any(Function)
+      });
       expect(spyObj.method1.and.identity).toEqual('BaseName.method1');
       expect(spyObj.method2.and.identity).toEqual('BaseName.method2');
     });
 
-    it("should allow you to omit the baseName", function() {
+    it('should allow you to omit the baseName', function() {
       var spyObj = env.createSpyObj(['method1', 'method2']);
 
-      expect(spyObj).toEqual({ method1: jasmine.any(Function), method2: jasmine.any(Function)});
+      expect(spyObj).toEqual({
+        method1: jasmine.any(Function),
+        method2: jasmine.any(Function)
+      });
       expect(spyObj.method1.and.identity).toEqual('unknown.method1');
       expect(spyObj.method2.and.identity).toEqual('unknown.method2');
     });
 
-    it("should throw if you do not pass an array or object argument", function() {
+    it('should throw if you do not pass an array or object argument', function() {
       expect(function() {
         env.createSpyObj('BaseName');
-      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
+      }).toThrow(
+        'createSpyObj requires a non-empty array or object of method names to create spies for'
+      );
     });
 
-    it("should throw if you pass an empty array argument", function() {
+    it('should throw if you pass an empty array argument', function() {
       expect(function() {
         env.createSpyObj('BaseName', []);
-      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
+      }).toThrow(
+        'createSpyObj requires a non-empty array or object of method names to create spies for'
+      );
     });
 
-    it("should throw if you pass an empty object argument", function() {
+    it('should throw if you pass an empty object argument', function() {
       expect(function() {
         env.createSpyObj('BaseName', {});
-      }).toThrow("createSpyObj requires a non-empty array or object of method names to create spies for");
+      }).toThrow(
+        'createSpyObj requires a non-empty array or object of method names to create spies for'
+      );
     });
   });
 
-  it("can use different strategies for different arguments", function() {
+  it('can use different strategies for different arguments', function() {
     var spy = env.createSpy('foo');
     spy.and.returnValue(42);
     spy.withArgs('baz', 'grault').and.returnValue(-1);
@@ -155,7 +188,7 @@ describe('Spies', function () {
     expect(spy('baz', 'grault', 'waldo')).toEqual(42);
   });
 
-  it("uses custom equality testers when selecting a strategy", function() {
+  it('uses custom equality testers when selecting a strategy', function() {
     var spy = env.createSpy('foo');
     spy.and.returnValue(42);
     spy.withArgs(jasmineUnderTest.any(String)).and.returnValue(-1);
@@ -164,7 +197,7 @@ describe('Spies', function () {
     expect(spy({})).toEqual(42);
   });
 
-  it("can reconfigure an argument-specific strategy", function() {
+  it('can reconfigure an argument-specific strategy', function() {
     var spy = env.createSpy('foo');
     spy.withArgs('foo').and.returnValue(42);
     spy.withArgs('foo').and.returnValue(17);
@@ -176,14 +209,19 @@ describe('Spies', function () {
       jasmine.getEnv().requirePromises();
 
       var spy = env.createSpy('foo').and.resolveWith(42);
-      spy().then(function(result) {
-        expect(result).toEqual(42);
-        done();
-      }).catch(done.fail);
+      spy()
+        .then(function(result) {
+          expect(result).toEqual(42);
+          done();
+        })
+        .catch(done.fail);
     });
 
     it('works with a custom Promise library', function() {
-      var customPromise = { resolve: jasmine.createSpy(), reject: jasmine.createSpy() };
+      var customPromise = {
+        resolve: jasmine.createSpy(),
+        reject: jasmine.createSpy()
+      };
       customPromise.resolve.and.returnValue('resolved');
       env.configure({ Promise: customPromise });
 
@@ -193,8 +231,8 @@ describe('Spies', function () {
     });
   });
 
-  describe("when withArgs is used without a base strategy", function() {
-    it("uses the matching strategy", function() {
+  describe('when withArgs is used without a base strategy', function() {
+    it('uses the matching strategy', function() {
       var spy = env.createSpy('foo');
       spy.withArgs('baz').and.returnValue(-1);
 
@@ -205,7 +243,11 @@ describe('Spies', function () {
       var spy = env.createSpy('foo');
       spy.withArgs('bar').and.returnValue(-1);
 
-      expect(function() { spy('baz', {qux: 42}); }).toThrowError('Spy \'foo\' received a call with arguments [ \'baz\', Object({ qux: 42 }) ] but all configured strategies specify other arguments.');
+      expect(function() {
+        spy('baz', { qux: 42 });
+      }).toThrowError(
+        "Spy 'foo' received a call with arguments [ 'baz', Object({ qux: 42 }) ] but all configured strategies specify other arguments."
+      );
     });
   });
 });

spec/core/SpyStrategySpec.js

@@ -1,20 +1,19 @@
-describe("SpyStrategy", function() {
-
-  it("defaults its name to unknown", function() {
+describe('SpyStrategy', function() {
+  it('defaults its name to unknown', function() {
     var spyStrategy = new jasmineUnderTest.SpyStrategy();
 
-    expect(spyStrategy.identity).toEqual("unknown");
+    expect(spyStrategy.identity).toEqual('unknown');
   });
 
-  it("takes a name", function() {
-    var spyStrategy = new jasmineUnderTest.SpyStrategy({name: "foo"});
+  it('takes a name', function() {
+    var spyStrategy = new jasmineUnderTest.SpyStrategy({ name: 'foo' });
 
-    expect(spyStrategy.identity).toEqual("foo");
+    expect(spyStrategy.identity).toEqual('foo');
   });
 
-  it("stubs an original function, if provided", function() {
-    var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+  it('stubs an original function, if provided', function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
     spyStrategy.exec();
 
@@ -22,22 +21,22 @@ describe("SpyStrategy", function() {
   });
 
   it("allows an original function to be called, passed through the params and returns it's value", function() {
-    var originalFn = jasmine.createSpy("original").and.returnValue(42),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
-        returnValue;
+    var originalFn = jasmine.createSpy('original').and.returnValue(42),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn }),
+      returnValue;
 
     spyStrategy.callThrough();
-    returnValue = spyStrategy.exec(null, ["foo"]);
+    returnValue = spyStrategy.exec(null, ['foo']);
 
     expect(originalFn).toHaveBeenCalled();
-    expect(originalFn.calls.mostRecent().args).toEqual(["foo"]);
+    expect(originalFn.calls.mostRecent().args).toEqual(['foo']);
     expect(returnValue).toEqual(42);
   });
 
-  it("can return a specified value when executed", function() {
-    var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
-        returnValue;
+  it('can return a specified value when executed', function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn }),
+      returnValue;
 
     spyStrategy.returnValue(17);
     returnValue = spyStrategy.exec();
@@ -46,9 +45,9 @@ describe("SpyStrategy", function() {
     expect(returnValue).toEqual(17);
   });
 
-  it("can return specified values in order specified when executed", function() {
-    var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+  it('can return specified values in order specified when executed', function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
     spyStrategy.returnValues('value1', 'value2', 'value3');
 
@@ -59,31 +58,35 @@ describe("SpyStrategy", function() {
     expect(originalFn).not.toHaveBeenCalled();
   });
 
-  it("allows an exception to be thrown when executed", function() {
-    var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+  it('allows an exception to be thrown when executed', function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
-    spyStrategy.throwError(new TypeError("bar"));
+    spyStrategy.throwError(new TypeError('bar'));
 
-    expect(function() { spyStrategy.exec(); }).toThrowError(TypeError, "bar");
+    expect(function() {
+      spyStrategy.exec();
+    }).toThrowError(TypeError, 'bar');
     expect(originalFn).not.toHaveBeenCalled();
   });
 
-  it("allows a non-Error to be thrown, wrapping it into an exception when executed", function() {
-    var originalFn = jasmine.createSpy("original"),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+  it('allows a non-Error to be thrown, wrapping it into an exception when executed', function() {
+    var originalFn = jasmine.createSpy('original'),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
-    spyStrategy.throwError("bar");
+    spyStrategy.throwError('bar');
 
-    expect(function() { spyStrategy.exec(); }).toThrowError(Error, "bar");
+    expect(function() {
+      spyStrategy.exec();
+    }).toThrowError(Error, 'bar');
     expect(originalFn).not.toHaveBeenCalled();
   });
 
-  it("allows a fake function to be called instead", function() {
-    var originalFn = jasmine.createSpy("original"),
-        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
-        returnValue;
+  it('allows a fake function to be called instead', function() {
+    var originalFn = jasmine.createSpy('original'),
+      fakeFn = jasmine.createSpy('fake').and.returnValue(67),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn }),
+      returnValue;
 
     spyStrategy.callFake(fakeFn);
     returnValue = spyStrategy.exec();
@@ -92,92 +95,128 @@ describe("SpyStrategy", function() {
     expect(returnValue).toEqual(67);
   });
 
-  it("allows a fake async function to be called instead", function(done) {
+  it('allows a fake async function to be called instead', function(done) {
     jasmine.getEnv().requireAsyncAwait();
-    var originalFn = jasmine.createSpy("original"),
-        fakeFn = jasmine.createSpy("fake").and.callFake(eval("async () => { return 67; }")),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
-        returnValue;
+    var originalFn = jasmine.createSpy('original'),
+      fakeFn = jasmine
+        .createSpy('fake')
+        .and.callFake(eval('async () => { return 67; }')),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
     spyStrategy.callFake(fakeFn);
-    spyStrategy.exec().then(function (returnValue) {
-      expect(originalFn).not.toHaveBeenCalled();
-      expect(fakeFn).toHaveBeenCalled();
-      expect(returnValue).toEqual(67);
-      done();
-    }).catch(function (err) {
-      done.fail(err);
-    })
+    spyStrategy
+      .exec()
+      .then(function(returnValue) {
+        expect(originalFn).not.toHaveBeenCalled();
+        expect(fakeFn).toHaveBeenCalled();
+        expect(returnValue).toEqual(67);
+        done();
+      })
+      .catch(function(err) {
+        done.fail(err);
+      });
   });
 
-  describe("#resolveWith", function() {
-    it("allows a resolved promise to be returned", function(done) {
+  describe('#resolveWith', function() {
+    it('allows a resolved promise to be returned', function(done) {
       jasmine.getEnv().requirePromises();
 
-      var originalFn = jasmine.createSpy("original"),
-          getPromise = function() { return Promise; },
-          spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn, getPromise: getPromise});
+      var originalFn = jasmine.createSpy('original'),
+        getPromise = function() {
+          return Promise;
+        },
+        spyStrategy = new jasmineUnderTest.SpyStrategy({
+          fn: originalFn,
+          getPromise: getPromise
+        });
 
       spyStrategy.resolveWith(37);
-      spyStrategy.exec().then(function (returnValue) {
-        expect(returnValue).toEqual(37);
-        done();
-      }).catch(done.fail);
+      spyStrategy
+        .exec()
+        .then(function(returnValue) {
+          expect(returnValue).toEqual(37);
+          done();
+        })
+        .catch(done.fail);
     });
 
-    it("fails if promises are not available", function() {
-      var originalFn = jasmine.createSpy("original"),
-          spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+    it('fails if promises are not available', function() {
+      var originalFn = jasmine.createSpy('original'),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
       expect(function() {
         spyStrategy.resolveWith(37);
-      }).toThrowError('resolveWith requires global Promise, or `Promise` configured with `jasmine.getEnv().configure()`');
+      }).toThrowError(
+        'resolveWith requires global Promise, or `Promise` configured with `jasmine.getEnv().configure()`'
+      );
     });
   });
 
-  describe("#rejectWith", function() {
-    it("allows a rejected promise to be returned", function(done) {
+  describe('#rejectWith', function() {
+    it('allows a rejected promise to be returned', function(done) {
       jasmine.getEnv().requirePromises();
 
-      var originalFn = jasmine.createSpy("original"),
-          getPromise = function() { return Promise; },
-          spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn, getPromise: getPromise});
+      var originalFn = jasmine.createSpy('original'),
+        getPromise = function() {
+          return Promise;
+        },
+        spyStrategy = new jasmineUnderTest.SpyStrategy({
+          fn: originalFn,
+          getPromise: getPromise
+        });
 
       spyStrategy.rejectWith(new Error('oops'));
-      spyStrategy.exec().then(done.fail).catch(function (error) {
-        expect(error).toEqual(new Error('oops'));
-        done();
-      }).catch(done.fail);
+      spyStrategy
+        .exec()
+        .then(done.fail)
+        .catch(function(error) {
+          expect(error).toEqual(new Error('oops'));
+          done();
+        })
+        .catch(done.fail);
     });
 
-    it("allows a non-Error to be rejected, wrapping it in an exception when executed", function(done) {
+    it('allows a non-Error to be rejected, wrapping it in an exception when executed', function(done) {
       jasmine.getEnv().requirePromises();
 
-      var originalFn = jasmine.createSpy("original"),
-          getPromise = function() { return Promise; },
-          spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn, getPromise: getPromise});
+      var originalFn = jasmine.createSpy('original'),
+        getPromise = function() {
+          return Promise;
+        },
+        spyStrategy = new jasmineUnderTest.SpyStrategy({
+          fn: originalFn,
+          getPromise: getPromise
+        });
 
       spyStrategy.rejectWith('oops');
-      spyStrategy.exec().then(done.fail).catch(function (error) {
-        expect(error).toEqual(new Error('oops'));
-        done();
-      }).catch(done.fail);
+      spyStrategy
+        .exec()
+        .then(done.fail)
+        .catch(function(error) {
+          expect(error).toEqual(new Error('oops'));
+          done();
+        })
+        .catch(done.fail);
     });
 
-    it("fails if promises are not available", function() {
-      var originalFn = jasmine.createSpy("original"),
-          spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn});
+    it('fails if promises are not available', function() {
+      var originalFn = jasmine.createSpy('original'),
+        spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
       expect(function() {
         spyStrategy.rejectWith(new Error('oops'));
-      }).toThrowError('rejectWith requires global Promise, or `Promise` configured with `jasmine.getEnv().configure()`');
+      }).toThrowError(
+        'rejectWith requires global Promise, or `Promise` configured with `jasmine.getEnv().configure()`'
+      );
     });
   });
 
-  it("allows a custom strategy to be used", function() {
-    var plan = jasmine.createSpy('custom strategy')
+  it('allows a custom strategy to be used', function() {
+    var plan = jasmine
+        .createSpy('custom strategy')
         .and.returnValue('custom strategy result'),
-      customStrategy = jasmine.createSpy('custom strategy')
+      customStrategy = jasmine
+        .createSpy('custom strategy')
         .and.returnValue(plan),
       originalFn = jasmine.createSpy('original'),
       spyStrategy = new jasmineUnderTest.SpyStrategy({
@@ -189,8 +228,9 @@ describe("SpyStrategy", function() {
 
     spyStrategy.doSomething(1, 2, 3);
     expect(customStrategy).toHaveBeenCalledWith(1, 2, 3);
-    expect(spyStrategy.exec(null, ['some', 'args']))
-      .toEqual('custom strategy result');
+    expect(spyStrategy.exec(null, ['some', 'args'])).toEqual(
+      'custom strategy result'
+    );
     expect(plan).toHaveBeenCalledWith('some', 'args');
   });
 
@@ -199,46 +239,49 @@ describe("SpyStrategy", function() {
       spyStrategy = new jasmineUnderTest.SpyStrategy({
         fn: originalFn,
         customStrategies: {
-          doSomething: function() { return 'not a function' }
+          doSomething: function() {
+            return 'not a function';
+          }
         }
       });
 
-    expect(function() { spyStrategy.doSomething(1, 2, 3) }).toThrowError('Spy strategy must return a function');
+    expect(function() {
+      spyStrategy.doSomething(1, 2, 3);
+    }).toThrowError('Spy strategy must return a function');
   });
 
-  it("does not allow custom strategies to overwrite existing methods", function() {
+  it('does not allow custom strategies to overwrite existing methods', function() {
     var spyStrategy = new jasmineUnderTest.SpyStrategy({
-        fn: function() {},
-        customStrategies: {
-          exec: function() {}
-        }
-       });
+      fn: function() {},
+      customStrategies: {
+        exec: function() {}
+      }
+    });
 
     expect(spyStrategy.exec).toBe(jasmineUnderTest.SpyStrategy.prototype.exec);
   });
 
   it('throws an error when a non-function is passed to callFake strategy', function() {
     var originalFn = jasmine.createSpy('original'),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
-        invalidFakes = [5, 'foo', {}, true, false, null, void 0, new Date(), /.*/];
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn });
 
     spyOn(jasmineUnderTest, 'isFunction_').and.returnValue(false);
     spyOn(jasmineUnderTest, 'isAsyncFunction_').and.returnValue(false);
 
-    expect(function () {
+    expect(function() {
       spyStrategy.callFake(function() {});
     }).toThrowError(/^Argument passed to callFake should be a function, got/);
 
-    expect(function () {
+    expect(function() {
       spyStrategy.callFake(function() {});
     }).toThrowError(/^Argument passed to callFake should be a function, got/);
   });
 
-  it("allows a return to plan stubbing after another strategy", function() {
-    var originalFn = jasmine.createSpy("original"),
-        fakeFn = jasmine.createSpy("fake").and.returnValue(67),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({fn: originalFn}),
-        returnValue;
+  it('allows a return to plan stubbing after another strategy', function() {
+    var originalFn = jasmine.createSpy('original'),
+      fakeFn = jasmine.createSpy('fake').and.returnValue(67),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ fn: originalFn }),
+      returnValue;
 
     spyStrategy.callFake(fakeFn);
     returnValue = spyStrategy.exec();
@@ -252,10 +295,10 @@ describe("SpyStrategy", function() {
     expect(returnValue).toEqual(void 0);
   });
 
-  it("returns the spy after changing the strategy", function(){
+  it('returns the spy after changing the strategy', function() {
     var spy = {},
-        spyFn = jasmine.createSpy('spyFn').and.returnValue(spy),
-        spyStrategy = new jasmineUnderTest.SpyStrategy({getSpy: spyFn});
+      spyFn = jasmine.createSpy('spyFn').and.returnValue(spy),
+      spyStrategy = new jasmineUnderTest.SpyStrategy({ getSpy: spyFn });
 
     expect(spyStrategy.callThrough()).toBe(spy);
     expect(spyStrategy.returnValue()).toBe(spy);

spec/core/StackTraceSpec.js

@@ -1,5 +1,5 @@
-describe("StackTrace", function() {
-  it("understands Chrome/IE/Edge style traces", function() {
+describe('StackTrace', function() {
+  it('understands Chrome/IE/Edge style traces', function() {
     var error = {
       message: 'nope',
       stack:
@@ -14,13 +14,15 @@ describe("StackTrace", function() {
     expect(result.style).toEqual('v8');
     expect(result.frames).toEqual([
       {
-        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        raw:
+          '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
         func: 'UserContext.<anonymous>',
         file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
         line: 115
       },
       {
-        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        raw:
+          '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
         func: 'QueueRunner.run',
         file: 'http://localhost:8888/__jasmine__/jasmine.js',
         line: 4320
@@ -28,7 +30,7 @@ describe("StackTrace", function() {
     ]);
   });
 
-  it("understands Chrome/IE/Edge style traces with multiline messages", function() {
+  it('understands Chrome/IE/Edge style traces with multiline messages', function() {
     var error = {
       message: 'line 1\nline 2',
       stack:
@@ -40,14 +42,16 @@ describe("StackTrace", function() {
     var result = new jasmineUnderTest.StackTrace(error);
 
     expect(result.message).toEqual('Error: line 1\nline 2');
-    var rawFrames = result.frames.map(function(f) { return f.raw; });
+    var rawFrames = result.frames.map(function(f) {
+      return f.raw;
+    });
     expect(rawFrames).toEqual([
       '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
-      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+      '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
     ]);
   });
 
-  it("understands Node style traces", function() {
+  it('understands Node style traces', function() {
     var error = {
       message: 'nope',
       stack:
@@ -69,13 +73,15 @@ describe("StackTrace", function() {
         line: 4255
       },
       {
-        raw: '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)',
+        raw:
+          '  at QueueRunner.complete [as onComplete] (/somewhere/jasmine/lib/jasmine-core/jasmine.js:579:9)',
         func: 'QueueRunner.complete [as onComplete]',
         file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
         line: 579
       },
       {
-        raw: '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)',
+        raw:
+          '  at Immediate.<anonymous> (/somewhere/jasmine/lib/jasmine-core/jasmine.js:4314:12)',
         func: 'Immediate.<anonymous>',
         file: '/somewhere/jasmine/lib/jasmine-core/jasmine.js',
         line: 4314
@@ -89,7 +95,7 @@ describe("StackTrace", function() {
     ]);
   });
 
-  it("understands Safari/Firefox/Phantom-OS X style traces", function() {
+  it('understands Safari/Firefox/Phantom-OS X style traces', function() {
     var error = {
       message: 'nope',
       stack:
@@ -116,22 +122,20 @@ describe("StackTrace", function() {
     ]);
   });
 
-  it("does not mistake gibberish for Safari/Firefox/Phantom-OS X style traces", function() {
+  it('does not mistake gibberish for Safari/Firefox/Phantom-OS X style traces', function() {
     var error = {
       message: 'nope',
       stack: 'randomcharsnotincludingwhitespace'
     };
     var result = new jasmineUnderTest.StackTrace(error);
     expect(result.style).toBeNull();
-    expect(result.frames).toEqual([
-      { raw: error.stack }
-    ]);
+    expect(result.frames).toEqual([{ raw: error.stack }]);
   });
 
-  it("understands Phantom-Linux style traces", function() {
+  it('understands Phantom-Linux style traces', function() {
     var error = {
       message: 'nope',
-      stack: 
+      stack:
         '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
         '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)'
     };
@@ -142,13 +146,15 @@ describe("StackTrace", function() {
     expect(result.style).toEqual('v8');
     expect(result.frames).toEqual([
       {
-        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        raw:
+          '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
         func: 'UserContext.<anonymous>',
         file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
         line: 115
       },
       {
-        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        raw:
+          '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
         func: 'QueueRunner.run',
         file: 'http://localhost:8888/__jasmine__/jasmine.js',
         line: 4320
@@ -156,7 +162,7 @@ describe("StackTrace", function() {
     ]);
   });
 
-  it("ignores blank lines", function() {
+  it('ignores blank lines', function() {
     var error = {
       message: 'nope',
       stack:
@@ -167,7 +173,8 @@ describe("StackTrace", function() {
 
     expect(result.frames).toEqual([
       {
-        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        raw:
+          '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
         func: 'UserContext.<anonymous>',
         file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
         line: 115
@@ -188,7 +195,8 @@ describe("StackTrace", function() {
     expect(result.style).toEqual('v8');
     expect(result.frames).toEqual([
       {
-        raw: '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
+        raw:
+          '    at UserContext.<anonymous> (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)',
         func: 'UserContext.<anonymous>',
         file: 'http://localhost:8888/__spec__/core/UtilSpec.js',
         line: 115
@@ -197,7 +205,8 @@ describe("StackTrace", function() {
         raw: '    but this is quite unexpected'
       },
       {
-        raw: '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
+        raw:
+          '    at QueueRunner.run (http://localhost:8888/__jasmine__/jasmine.js:4320:20)',
         func: 'QueueRunner.run',
         file: 'http://localhost:8888/__jasmine__/jasmine.js',
         line: 4320

spec/core/SuiteSpec.js

@@ -1,47 +1,46 @@
-describe("Suite", function() {
-
-  it("keeps its id", function() {
+describe('Suite', function() {
+  it('keeps its id', function() {
     var env = new jasmineUnderTest.Env(),
       suite = new jasmineUnderTest.Suite({
         env: env,
         id: 456,
-        description: "I am a suite"
+        description: 'I am a suite'
       });
 
     expect(suite.id).toEqual(456);
   });
 
-  it("returns blank full name for top level suite", function() {
+  it('returns blank full name for top level suite', function() {
     var env = new jasmineUnderTest.Env(),
       suite = new jasmineUnderTest.Suite({
         env: env,
-        description: "I am a suite"
+        description: 'I am a suite'
       });
 
-    expect(suite.getFullName()).toEqual("");
+    expect(suite.getFullName()).toEqual('');
   });
 
-  it("returns its full name when it has parent suites", function() {
+  it('returns its full name when it has parent suites', function() {
     var env = new jasmineUnderTest.Env(),
       parentSuite = new jasmineUnderTest.Suite({
         env: env,
-        description: "I am a parent suite",
+        description: 'I am a parent suite',
         parentSuite: jasmine.createSpy('pretend top level suite')
       }),
       suite = new jasmineUnderTest.Suite({
         env: env,
-        description: "I am a suite",
+        description: 'I am a suite',
         parentSuite: parentSuite
       });
 
-    expect(suite.getFullName()).toEqual("I am a parent suite I am a suite");
+    expect(suite.getFullName()).toEqual('I am a parent suite I am a suite');
   });
 
-  it("adds before functions in order of needed execution", function() {
+  it('adds before functions in order of needed execution', function() {
     var env = new jasmineUnderTest.Env(),
       suite = new jasmineUnderTest.Suite({
         env: env,
-        description: "I am a suite"
+        description: 'I am a suite'
       }),
       outerBefore = jasmine.createSpy('outerBeforeEach'),
       innerBefore = jasmine.createSpy('insideBeforeEach');
@@ -52,11 +51,11 @@ describe("Suite", function() {
     expect(suite.beforeFns).toEqual([innerBefore, outerBefore]);
   });
 
-  it("adds after functions in order of needed execution", function() {
+  it('adds after functions in order of needed execution', function() {
     var env = new jasmineUnderTest.Env(),
       suite = new jasmineUnderTest.Suite({
         env: env,
-        description: "I am a suite"
+        description: 'I am a suite'
       }),
       outerAfter = jasmine.createSpy('outerAfterEach'),
       innerAfter = jasmine.createSpy('insideAfterEach');
@@ -69,29 +68,33 @@ describe("Suite", function() {
 
   it('has a status of failed if any expectations have failed', function() {
     var suite = new jasmineUnderTest.Suite({
-      expectationResultFactory: function() { return 'hi'; }
+      expectationResultFactory: function() {
+        return 'hi';
+      }
     });
 
     suite.addExpectationResult(false);
     expect(suite.status()).toBe('failed');
   });
 
-  it("retrieves a result with updated status", function() {
+  it('retrieves a result with updated status', function() {
     var suite = new jasmineUnderTest.Suite({});
 
     expect(suite.getResult().status).toBe('passed');
   });
 
-  it("retrieves a result with pending status", function() {
+  it('retrieves a result with pending status', function() {
     var suite = new jasmineUnderTest.Suite({});
     suite.pend();
 
     expect(suite.getResult().status).toBe('pending');
   });
 
-  it("throws an ExpectationFailed when receiving a failed expectation when throwOnExpectationFailure is set", function() {
+  it('throws an ExpectationFailed when receiving a failed expectation when throwOnExpectationFailure is set', function() {
     var suite = new jasmineUnderTest.Suite({
-      expectationResultFactory: function(data) { return data; },
+      expectationResultFactory: function(data) {
+        return data;
+      },
       throwOnExpectationFailure: true
     });
 
@@ -103,7 +106,7 @@ describe("Suite", function() {
     expect(suite.result.failedExpectations).toEqual(['failed']);
   });
 
-  it("does not add an additional failure when an expectation fails", function(){
+  it('does not add an additional failure when an expectation fails', function() {
     var suite = new jasmineUnderTest.Suite({});
 
     suite.onException(new jasmineUnderTest.errors.ExpectationFailed());
@@ -111,17 +114,17 @@ describe("Suite", function() {
     expect(suite.getResult().failedExpectations).toEqual([]);
   });
 
-  it("calls timer to compute duration", function(){
-      var env = new jasmineUnderTest.Env(),
+  it('calls timer to compute duration', function() {
+    var env = new jasmineUnderTest.Env(),
       suite = new jasmineUnderTest.Suite({
         env: env,
         id: 456,
-        description: "I am a suite",
-        timer: jasmine.createSpyObj('timer', {'start': null, elapsed: 77000}),
+        description: 'I am a suite',
+        timer: jasmine.createSpyObj('timer', { start: null, elapsed: 77000 })
       });
-      suite.startTimer();
-      suite.endTimer();
-      expect(suite.getResult().duration).toEqual(77000);
+    suite.startTimer();
+    suite.endTimer();
+    expect(suite.getResult().duration).toEqual(77000);
   });
 
   describe('#sharedUserContext', function() {
@@ -130,7 +133,9 @@ describe("Suite", function() {
     });
 
     it('returns a UserContext', function() {
-      expect(this.suite.sharedUserContext().constructor).toBe(jasmineUnderTest.UserContext);
+      expect(this.suite.sharedUserContext().constructor).toBe(
+        jasmineUnderTest.UserContext
+      );
     });
   });
 });

spec/core/TimerSpec.js

@@ -1,7 +1,7 @@
-describe("Timer", function() {
-  it("reports the time elapsed", function() {
+describe('Timer', function() {
+  it('reports the time elapsed', function() {
     var fakeNow = jasmine.createSpy('fake Date.now'),
-        timer = new jasmineUnderTest.Timer({now: fakeNow});
+      timer = new jasmineUnderTest.Timer({ now: fakeNow });
 
     fakeNow.and.returnValue(100);
     timer.start();
@@ -11,7 +11,7 @@ describe("Timer", function() {
     expect(timer.elapsed()).toEqual(100);
   });
 
-  describe("when date is stubbed, perhaps by other testing helpers", function() {
+  describe('when date is stubbed, perhaps by other testing helpers', function() {
     var origDate = Date;
     beforeEach(function() {
       Date = jasmine.createSpy('date spy');
@@ -21,7 +21,7 @@ describe("Timer", function() {
       Date = origDate;
     });
 
-    it("does not throw even though Date was taken away", function() {
+    it('does not throw even though Date was taken away', function() {
       var timer = new jasmineUnderTest.Timer();
 
       expect(timer.start).not.toThrow();

spec/core/TreeProcessorSpec.js

@@ -1,5 +1,6 @@
-describe("TreeProcessor", function() {
-  var nodeNumber = 0, leafNumber = 0;
+describe('TreeProcessor', function() {
+  var nodeNumber = 0,
+    leafNumber = 0;
 
   function Node(attrs) {
     attrs = attrs || {};
@@ -15,7 +16,7 @@ describe("TreeProcessor", function() {
     this.getResult = jasmine.createSpy(this.id + '#execute');
     this.beforeAllFns = attrs.beforeAllFns || [];
     this.afterAllFns = attrs.afterAllFns || [];
-    this.cleanupBeforeAfter = function() { };
+    this.cleanupBeforeAfter = function() {};
   }
 
   function Leaf(attrs) {
@@ -25,10 +26,13 @@ describe("TreeProcessor", function() {
     this.execute = jasmine.createSpy(this.id + '#execute');
   }
 
-  it("processes a single leaf", function() {
+  it('processes a single leaf', function() {
     var leaf = new Leaf(),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
-        result = processor.processTree();
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: leaf,
+        runnableIds: [leaf.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -39,10 +43,13 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("processes a single pending leaf", function() {
+  it('processes a single pending leaf', function() {
     var leaf = new Leaf({ markedPending: true }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [leaf.id] }),
-        result = processor.processTree();
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: leaf,
+        runnableIds: [leaf.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -53,10 +60,13 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("processes a single non-specified leaf", function() {
+  it('processes a single non-specified leaf', function() {
     var leaf = new Leaf(),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: leaf, runnableIds: [] }),
-        result = processor.processTree();
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: leaf,
+        runnableIds: []
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -67,14 +77,16 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("processes a single excluded leaf", function() {
+  it('processes a single excluded leaf', function() {
     var leaf = new Leaf(),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: leaf,
-          runnableIds: [leaf.id],
-          excludeNode: function(node) { return true; }
-        }),
-        result = processor.processTree();
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: leaf,
+        runnableIds: [leaf.id],
+        excludeNode: function(node) {
+          return true;
+        }
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -85,11 +97,14 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("processes a tree with a single leaf with the root specified", function() {
+  it('processes a tree with a single leaf with the root specified', function() {
     var leaf = new Leaf(),
-        parent = new Node({ children: [leaf] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
-        result = processor.processTree();
+      parent = new Node({ children: [leaf] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: parent,
+        runnableIds: [parent.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -106,11 +121,14 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("processes a tree with a single pending leaf, with the root specified", function() {
+  it('processes a tree with a single pending leaf, with the root specified', function() {
     var leaf = new Leaf({ markedPending: true }),
-        parent = new Node({ children: [leaf] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: parent, runnableIds: [parent.id] }),
-        result = processor.processTree();
+      parent = new Node({ children: [leaf] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: parent,
+        runnableIds: [parent.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -127,17 +145,26 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("processes a complicated tree with the root specified", function() {
+  it('processes a complicated tree with the root specified', function() {
     var pendingLeaf = new Leaf({ markedPending: true }),
-        executableLeaf = new Leaf({ markedPending: false }),
-        parent = new Node({ children: [pendingLeaf, executableLeaf] }),
-        childless = new Node(),
-        childOfPending = new Leaf({ markedPending: true }),
-        pendingNode = new Node({ markedPending: true, children: [childOfPending] }),
-        parentOfPendings = new Node({ markedPending: false, children: [childless, pendingNode] }),
-        root = new Node({ children: [parent, parentOfPendings] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [root.id] }),
-        result = processor.processTree();
+      executableLeaf = new Leaf({ markedPending: false }),
+      parent = new Node({ children: [pendingLeaf, executableLeaf] }),
+      childless = new Node(),
+      childOfPending = new Leaf({ markedPending: true }),
+      pendingNode = new Node({
+        markedPending: true,
+        children: [childOfPending]
+      }),
+      parentOfPendings = new Node({
+        markedPending: false,
+        children: [childless, pendingNode]
+      }),
+      root = new Node({ children: [parent, parentOfPendings] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [root.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
 
@@ -190,58 +217,73 @@ describe("TreeProcessor", function() {
     });
   });
 
-  it("marks the run order invalid if it would re-enter a node that does not allow re-entry", function() {
+  it('marks the run order invalid if it would re-enter a node that does not allow re-entry', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        reentered = new Node({ noReenter: true, children: [leaf1, leaf2] }),
-        root = new Node({ children: [reentered, leaf3] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
-        result = processor.processTree();
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      reentered = new Node({ noReenter: true, children: [leaf1, leaf2] }),
+      root = new Node({ children: [reentered, leaf3] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [leaf1.id, leaf3.id, leaf2.id]
+      }),
+      result = processor.processTree();
 
     expect(result).toEqual({ valid: false });
   });
 
-  it("marks the run order valid if a node being re-entered allows re-entry", function() {
+  it('marks the run order valid if a node being re-entered allows re-entry', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        reentered = new Node({ children: [leaf1, leaf2] }),
-        root = new Node({ children: [reentered, leaf3] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [leaf1.id, leaf3.id, leaf2.id] }),
-        result = processor.processTree();
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      reentered = new Node({ children: [leaf1, leaf2] }),
+      root = new Node({ children: [reentered, leaf3] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [leaf1.id, leaf3.id, leaf2.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
   });
 
   it("marks the run order valid if a node which can't be re-entered is only entered once", function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        noReentry = new Node({ noReenter: true }),
-        root = new Node({ children: [noReentry] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [leaf2.id, leaf1.id, leaf3.id] }),
-        result = processor.processTree();
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      noReentry = new Node({ noReenter: true }),
+      root = new Node({ children: [noReentry] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [leaf2.id, leaf1.id, leaf3.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
   });
 
   it("marks the run order valid if a node which can't be re-entered is run directly", function() {
-    var leaf1 = new Leaf(),
-        noReentry = new Node({ noReenter: true }),
-        root = new Node({ children: [noReentry] }),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: root, runnableIds: [root.id] }),
-        result = processor.processTree();
+    var noReentry = new Node({ noReenter: true }),
+      root = new Node({ children: [noReentry] }),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [root.id]
+      }),
+      result = processor.processTree();
 
     expect(result.valid).toBe(true);
   });
 
-  it("runs a single leaf", function() {
+  it('runs a single leaf', function() {
     var leaf = new Leaf(),
-        node = new Node({ children: [leaf], userContext: { root: 'context' } }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({ tree: node, runnableIds: [leaf.id], queueRunnerFactory: queueRunner }),
-        treeComplete = jasmine.createSpy('treeComplete');
+      node = new Node({ children: [leaf], userContext: { root: 'context' } }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: node,
+        runnableIds: [leaf.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete');
 
     processor.execute(treeComplete);
 
@@ -257,21 +299,21 @@ describe("TreeProcessor", function() {
     expect(leaf.execute).toHaveBeenCalledWith('foo', false);
   });
 
-  it("runs a node with no children", function() {
+  it('runs a node with no children', function() {
     var node = new Node({ userContext: { node: 'context' } }),
-        root = new Node({ children: [node], userContext: { root: 'context' } }),
-        nodeStart = jasmine.createSpy('nodeStart'),
-        nodeComplete = jasmine.createSpy('nodeComplete'),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          nodeStart: nodeStart,
-          nodeComplete: nodeComplete,
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      root = new Node({ children: [node], userContext: { root: 'context' } }),
+      nodeStart = jasmine.createSpy('nodeStart'),
+      nodeComplete = jasmine.createSpy('nodeComplete'),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        nodeStart: nodeStart,
+        nodeComplete: nodeComplete,
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
 
@@ -297,22 +339,26 @@ describe("TreeProcessor", function() {
     node.getResult.and.returnValue({ my: 'result' });
 
     queueRunner.calls.mostRecent().args[0].onComplete();
-    expect(nodeComplete).toHaveBeenCalledWith(node, { my: 'result' }, jasmine.any(Function));
+    expect(nodeComplete).toHaveBeenCalledWith(
+      node,
+      { my: 'result' },
+      jasmine.any(Function)
+    );
   });
 
-  it("runs a node with children", function() {
+  it('runs a node with children', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        node = new Node({ children: [leaf1, leaf2] }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      leaf2 = new Leaf(),
+      node = new Node({ children: [leaf1, leaf2] }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -328,20 +374,20 @@ describe("TreeProcessor", function() {
     expect(leaf2.execute).toHaveBeenCalledWith('bar', false);
   });
 
-  it("cascades errors up the tree", function() {
+  it('cascades errors up the tree', function() {
     var leaf = new Leaf(),
-        node = new Node({ children: [leaf] }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        nodeComplete = jasmine.createSpy('nodeComplete'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          nodeComplete: nodeComplete,
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      node = new Node({ children: [leaf] }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      nodeComplete = jasmine.createSpy('nodeComplete'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        nodeComplete: nodeComplete,
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -359,22 +405,22 @@ describe("TreeProcessor", function() {
     expect(nodeDone).toHaveBeenCalledWith('things');
   });
 
-  it("runs an excluded node with leaf", function() {
+  it('runs an excluded node with leaf', function() {
     var leaf1 = new Leaf(),
-        node = new Node({ children: [leaf1] }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        nodeStart = jasmine.createSpy('nodeStart'),
-        nodeComplete = jasmine.createSpy('nodeComplete'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [],
-          queueRunnerFactory: queueRunner,
-          nodeStart: nodeStart,
-          nodeComplete: nodeComplete
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      node = new Node({ children: [leaf1] }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      nodeStart = jasmine.createSpy('nodeStart'),
+      nodeComplete = jasmine.createSpy('nodeComplete'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [],
+        queueRunnerFactory: queueRunner,
+        nodeStart: nodeStart,
+        nodeComplete: nodeComplete
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -392,24 +438,28 @@ describe("TreeProcessor", function() {
     node.getResult.and.returnValue({ im: 'disabled' });
 
     queueRunner.calls.mostRecent().args[0].onComplete();
-    expect(nodeComplete).toHaveBeenCalledWith(node, { im: 'disabled' }, jasmine.any(Function));
+    expect(nodeComplete).toHaveBeenCalledWith(
+      node,
+      { im: 'disabled' },
+      jasmine.any(Function)
+    );
   });
 
-  it("runs beforeAlls for a node with children", function() {
+  it('runs beforeAlls for a node with children', function() {
     var leaf = new Leaf(),
-        node = new Node({
-          children: [leaf],
-          beforeAllFns: ['beforeAll1', 'beforeAll2']
-        }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      node = new Node({
+        children: [leaf],
+        beforeAllFns: ['beforeAll1', 'beforeAll2']
+      }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -417,24 +467,29 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, 'beforeAll1', 'beforeAll2', { fn: jasmine.any(Function) }]);
+    expect(queueableFns).toEqual([
+      { fn: jasmine.any(Function) },
+      'beforeAll1',
+      'beforeAll2',
+      { fn: jasmine.any(Function) }
+    ]);
   });
 
-  it("runs afterAlls for a node with children", function() {
+  it('runs afterAlls for a node with children', function() {
     var leaf = new Leaf(),
-        node = new Node({
-          children: [leaf],
-          afterAllFns: ['afterAll1', 'afterAll2']
-        }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      node = new Node({
+        children: [leaf],
+        afterAllFns: ['afterAll1', 'afterAll2']
+      }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -442,23 +497,28 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, { fn: jasmine.any(Function) }, 'afterAll1', 'afterAll2']);
+    expect(queueableFns).toEqual([
+      { fn: jasmine.any(Function) },
+      { fn: jasmine.any(Function) },
+      'afterAll1',
+      'afterAll2'
+    ]);
   });
 
-  it("does not run beforeAlls or afterAlls for a node with no children", function() {
+  it('does not run beforeAlls or afterAlls for a node with no children', function() {
     var node = new Node({
-          beforeAllFns: ['before'],
-          afterAllFns: ['after']
-        }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+        beforeAllFns: ['before'],
+        afterAllFns: ['after']
+      }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -466,26 +526,26 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([{fn: jasmine.any(Function)}]);
+    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }]);
   });
 
-  it("does not run beforeAlls or afterAlls for a node with only pending children", function() {
+  it('does not run beforeAlls or afterAlls for a node with only pending children', function() {
     var leaf = new Leaf({ markedPending: true }),
-        node = new Node({
-          children: [leaf],
-          beforeAllFns: ['before'],
-          afterAllFns: ['after'],
-          markedPending: false
-        }),
-        root = new Node({ children: [node] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [node.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete'),
-        nodeDone = jasmine.createSpy('nodeDone');
+      node = new Node({
+        children: [leaf],
+        beforeAllFns: ['before'],
+        afterAllFns: ['after'],
+        markedPending: false
+      }),
+      root = new Node({ children: [node] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [node.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete'),
+      nodeDone = jasmine.createSpy('nodeDone');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -493,20 +553,23 @@ describe("TreeProcessor", function() {
 
     queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
 
-    expect(queueableFns).toEqual([{ fn: jasmine.any(Function) }, { fn: jasmine.any(Function) }]);
+    expect(queueableFns).toEqual([
+      { fn: jasmine.any(Function) },
+      { fn: jasmine.any(Function) }
+    ]);
   });
 
-  it("runs leaves in the order specified", function() {
+  it('runs leaves in the order specified', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        root = new Node({ children: [leaf1, leaf2] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [leaf2.id, leaf1.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete');
+      leaf2 = new Leaf(),
+      root = new Node({ children: [leaf1, leaf2] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [leaf2.id, leaf1.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -520,17 +583,17 @@ describe("TreeProcessor", function() {
     expect(leaf1.execute).toHaveBeenCalled();
   });
 
-  it("runs specified leaves before non-specified leaves within a parent node", function() {
+  it('runs specified leaves before non-specified leaves within a parent node', function() {
     var specified = new Leaf(),
-        nonSpecified = new Leaf(),
-        root = new Node({ children: [nonSpecified, specified] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [specified.id],
-          queueRunnerFactory: queueRunner
-        }),
-        treeComplete = jasmine.createSpy('treeComplete');
+      nonSpecified = new Leaf(),
+      root = new Node({ children: [nonSpecified, specified] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [specified.id],
+        queueRunnerFactory: queueRunner
+      }),
+      treeComplete = jasmine.createSpy('treeComplete');
 
     processor.execute(treeComplete);
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -544,17 +607,17 @@ describe("TreeProcessor", function() {
     expect(nonSpecified.execute).toHaveBeenCalledWith(undefined, true);
   });
 
-  it("runs nodes and leaves with a specified order", function() {
+  it('runs nodes and leaves with a specified order', function() {
     var specifiedLeaf = new Leaf(),
-        childLeaf = new Leaf(),
-        specifiedNode = new Node({ children: [childLeaf] }),
-        root = new Node({ children: [specifiedLeaf, specifiedNode] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [specifiedNode.id, specifiedLeaf.id],
-          queueRunnerFactory: queueRunner
-        });
+      childLeaf = new Leaf(),
+      specifiedNode = new Node({ children: [childLeaf] }),
+      root = new Node({ children: [specifiedLeaf, specifiedNode] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [specifiedNode.id, specifiedLeaf.id],
+        queueRunnerFactory: queueRunner
+      });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -571,20 +634,20 @@ describe("TreeProcessor", function() {
     expect(specifiedLeaf.execute).toHaveBeenCalled();
   });
 
-  it("runs a node multiple times if the order specified leaves and re-enters it", function() {
+  it('runs a node multiple times if the order specified leaves and re-enters it', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        leaf4 = new Leaf(),
-        leaf5 = new Leaf(),
-        reentered = new Node({ children: [leaf1, leaf2, leaf3] }),
-        root = new Node({ children: [reentered, leaf4, leaf5] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
-          queueRunnerFactory: queueRunner
-        });
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      leaf4 = new Leaf(),
+      leaf5 = new Leaf(),
+      reentered = new Node({ children: [leaf1, leaf2, leaf3] }),
+      root = new Node({ children: [reentered, leaf4, leaf5] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
+        queueRunnerFactory: queueRunner
+      });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -614,21 +677,21 @@ describe("TreeProcessor", function() {
     expect(leaf3.execute).toHaveBeenCalled();
   });
 
-  it("runs a parent of a node with segments correctly", function() {
+  it('runs a parent of a node with segments correctly', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        leaf4 = new Leaf(),
-        leaf5 = new Leaf(),
-        parent = new Node({ children: [leaf1, leaf2, leaf3] }),
-        grandparent = new Node({ children: [parent] }),
-        root = new Node({ children: [grandparent, leaf4, leaf5] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
-          queueRunnerFactory: queueRunner
-        });
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      leaf4 = new Leaf(),
+      leaf5 = new Leaf(),
+      parent = new Node({ children: [leaf1, leaf2, leaf3] }),
+      grandparent = new Node({ children: [parent] }),
+      root = new Node({ children: [grandparent, leaf4, leaf5] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [leaf1.id, leaf4.id, leaf2.id, leaf5.id, leaf3.id],
+        queueRunnerFactory: queueRunner
+      });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -671,18 +734,18 @@ describe("TreeProcessor", function() {
     expect(leaf3.execute).toHaveBeenCalled();
   });
 
-  it("runs nodes in the order they were declared", function() {
+  it('runs nodes in the order they were declared', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        parent = new Node({ children: [leaf2, leaf3] }),
-        root = new Node({ children: [leaf1, parent] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [root.id],
-          queueRunnerFactory: queueRunner
-        });
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      parent = new Node({ children: [leaf2, leaf3] }),
+      root = new Node({ children: [leaf1, parent] }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [root.id],
+        queueRunnerFactory: queueRunner
+      });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -702,25 +765,39 @@ describe("TreeProcessor", function() {
     expect(leaf3.execute).toHaveBeenCalled();
   });
 
-  it("runs large segments of nodes in the order they were declared", function() {
+  it('runs large segments of nodes in the order they were declared', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        leaf4 = new Leaf(),
-        leaf5 = new Leaf(),
-        leaf6 = new Leaf(),
-        leaf7 = new Leaf(),
-        leaf8 = new Leaf(),
-        leaf9 = new Leaf(),
-        leaf10 = new Leaf(),
-        leaf11 = new Leaf(),
-        root = new Node({ children: [leaf1, leaf2, leaf3, leaf4, leaf5, leaf6, leaf7, leaf8, leaf9, leaf10, leaf11] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [root.id],
-          queueRunnerFactory: queueRunner
-        });
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      leaf4 = new Leaf(),
+      leaf5 = new Leaf(),
+      leaf6 = new Leaf(),
+      leaf7 = new Leaf(),
+      leaf8 = new Leaf(),
+      leaf9 = new Leaf(),
+      leaf10 = new Leaf(),
+      leaf11 = new Leaf(),
+      root = new Node({
+        children: [
+          leaf1,
+          leaf2,
+          leaf3,
+          leaf4,
+          leaf5,
+          leaf6,
+          leaf7,
+          leaf8,
+          leaf9,
+          leaf10,
+          leaf11
+        ]
+      }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [root.id],
+        queueRunnerFactory: queueRunner
+      });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -760,29 +837,43 @@ describe("TreeProcessor", function() {
     expect(leaf11.execute).toHaveBeenCalled();
   });
 
-  it("runs nodes in a custom order when orderChildren is overridden", function() {
+  it('runs nodes in a custom order when orderChildren is overridden', function() {
     var leaf1 = new Leaf(),
-        leaf2 = new Leaf(),
-        leaf3 = new Leaf(),
-        leaf4 = new Leaf(),
-        leaf5 = new Leaf(),
-        leaf6 = new Leaf(),
-        leaf7 = new Leaf(),
-        leaf8 = new Leaf(),
-        leaf9 = new Leaf(),
-        leaf10 = new Leaf(),
-        leaf11 = new Leaf(),
-        root = new Node({ children: [leaf1, leaf2, leaf3, leaf4, leaf5, leaf6, leaf7, leaf8, leaf9, leaf10, leaf11] }),
-        queueRunner = jasmine.createSpy('queueRunner'),
-        processor = new jasmineUnderTest.TreeProcessor({
-          tree: root,
-          runnableIds: [root.id],
-          queueRunnerFactory: queueRunner,
-          orderChildren: function(node) {
-            var children = node.children.slice();
-            return children.reverse();
-          }
-        });
+      leaf2 = new Leaf(),
+      leaf3 = new Leaf(),
+      leaf4 = new Leaf(),
+      leaf5 = new Leaf(),
+      leaf6 = new Leaf(),
+      leaf7 = new Leaf(),
+      leaf8 = new Leaf(),
+      leaf9 = new Leaf(),
+      leaf10 = new Leaf(),
+      leaf11 = new Leaf(),
+      root = new Node({
+        children: [
+          leaf1,
+          leaf2,
+          leaf3,
+          leaf4,
+          leaf5,
+          leaf6,
+          leaf7,
+          leaf8,
+          leaf9,
+          leaf10,
+          leaf11
+        ]
+      }),
+      queueRunner = jasmine.createSpy('queueRunner'),
+      processor = new jasmineUnderTest.TreeProcessor({
+        tree: root,
+        runnableIds: [root.id],
+        queueRunnerFactory: queueRunner,
+        orderChildren: function(node) {
+          var children = node.children.slice();
+          return children.reverse();
+        }
+      });
 
     processor.execute();
     var queueableFns = queueRunner.calls.mostRecent().args[0].queueableFns;
@@ -820,6 +911,5 @@ describe("TreeProcessor", function() {
 
     queueableFns[10].fn();
     expect(leaf1.execute).toHaveBeenCalled();
-
   });
 });

spec/core/UserContextSpec.js

@@ -1,7 +1,7 @@
-describe("UserContext", function() {
-  it("Behaves just like an plain object", function() {
+describe('UserContext', function() {
+  it('Behaves just like an plain object', function() {
     var context = new jasmineUnderTest.UserContext(),
-        properties = [];
+      properties = [];
 
     for (var prop in context) {
       if (obj.hasOwnProperty(prop)) {
@@ -51,4 +51,3 @@ describe("UserContext", function() {
     });
   });
 });
-

spec/core/UtilSpec.js

@@ -1,11 +1,11 @@
-describe("jasmineUnderTest.util", function() {
-  describe("isArray_", function() {
-    it("should return true if the argument is an array", function() {
+describe('jasmineUnderTest.util', function() {
+  describe('isArray_', function() {
+    it('should return true if the argument is an array', function() {
       expect(jasmineUnderTest.isArray_([])).toBe(true);
       expect(jasmineUnderTest.isArray_(['a'])).toBe(true);
     });
 
-    it("should return false if the argument is not an array", function() {
+    it('should return false if the argument is not an array', function() {
       expect(jasmineUnderTest.isArray_(undefined)).toBe(false);
       expect(jasmineUnderTest.isArray_({})).toBe(false);
       expect(jasmineUnderTest.isArray_(function() {})).toBe(false);
@@ -15,13 +15,13 @@ describe("jasmineUnderTest.util", function() {
     });
   });
 
-  describe("isObject_", function() {
-    it("should return true if the argument is an object", function() {
+  describe('isObject_', function() {
+    it('should return true if the argument is an object', function() {
       expect(jasmineUnderTest.isObject_({})).toBe(true);
-      expect(jasmineUnderTest.isObject_({an: "object"})).toBe(true);
+      expect(jasmineUnderTest.isObject_({ an: 'object' })).toBe(true);
     });
 
-    it("should return false if the argument is not an object", function() {
+    it('should return false if the argument is not an object', function() {
       expect(jasmineUnderTest.isObject_(undefined)).toBe(false);
       expect(jasmineUnderTest.isObject_([])).toBe(false);
       expect(jasmineUnderTest.isObject_(function() {})).toBe(false);
@@ -31,128 +31,126 @@ describe("jasmineUnderTest.util", function() {
     });
   });
 
-  describe("promise utils", function () {
+  describe('promise utils', function() {
+    var mockNativePromise, mockPromiseLikeObject;
 
-    var mockNativePromise,
-      mockPromiseLikeObject;
+    var mockPromiseLike = function() {
+      this.then = function() {};
+    };
 
-    var mockPromiseLike = function () {this.then = function () {};};
-
-    beforeEach(function () {
+    beforeEach(function() {
       jasmine.getEnv().requirePromises();
-      mockNativePromise = new Promise(function (res, rej) {});
+      mockNativePromise = new Promise(function(res, rej) {});
       mockPromiseLikeObject = new mockPromiseLike();
     });
 
-    describe("isPromise", function () {
-
-      it("should return true when passed a native promise", function () {
+    describe('isPromise', function() {
+      it('should return true when passed a native promise', function() {
         expect(jasmineUnderTest.isPromise(mockNativePromise)).toBe(true);
       });
 
-      it("should return false for promise like objects", function () {
+      it('should return false for promise like objects', function() {
         expect(jasmineUnderTest.isPromise(mockPromiseLikeObject)).toBe(false);
       });
 
-      it("should return false for strings", function () {
-        expect(jasmineUnderTest.isPromise("hello")).toBe(false);
+      it('should return false for strings', function() {
+        expect(jasmineUnderTest.isPromise('hello')).toBe(false);
       });
 
-      it("should return false for numbers", function () {
+      it('should return false for numbers', function() {
         expect(jasmineUnderTest.isPromise(3)).toBe(false);
       });
 
-      it("should return false for null", function () {
+      it('should return false for null', function() {
         expect(jasmineUnderTest.isPromise(null)).toBe(false);
       });
 
-      it("should return false for undefined", function () {
+      it('should return false for undefined', function() {
         expect(jasmineUnderTest.isPromise(undefined)).toBe(false);
       });
 
-      it("should return false for arrays", function () {
+      it('should return false for arrays', function() {
         expect(jasmineUnderTest.isPromise([])).toBe(false);
       });
 
-      it("should return false for objects", function () {
+      it('should return false for objects', function() {
         expect(jasmineUnderTest.isPromise({})).toBe(false);
       });
 
-      it("should return false for boolean values", function () {
+      it('should return false for boolean values', function() {
         expect(jasmineUnderTest.isPromise(true)).toBe(false);
       });
-
     });
 
-    describe("isPromiseLike", function () {
-
-      it("should return true when passed a native promise", function () {
+    describe('isPromiseLike', function() {
+      it('should return true when passed a native promise', function() {
         expect(jasmineUnderTest.isPromiseLike(mockNativePromise)).toBe(true);
       });
 
-      it("should return  true for promise like objects", function () {
-        expect(jasmineUnderTest.isPromiseLike(mockPromiseLikeObject)).toBe(true);
+      it('should return  true for promise like objects', function() {
+        expect(jasmineUnderTest.isPromiseLike(mockPromiseLikeObject)).toBe(
+          true
+        );
       });
 
-      it("should return false if then is not a function", function () {
-        expect(jasmineUnderTest.isPromiseLike({then:{its:"Not a function :O"}})).toBe(false);
+      it('should return false if then is not a function', function() {
+        expect(
+          jasmineUnderTest.isPromiseLike({ then: { its: 'Not a function :O' } })
+        ).toBe(false);
       });
 
-      it("should return false for strings", function () {
-        expect(jasmineUnderTest.isPromiseLike("hello")).toBe(false);
+      it('should return false for strings', function() {
+        expect(jasmineUnderTest.isPromiseLike('hello')).toBe(false);
       });
 
-      it("should return false for numbers", function () {
+      it('should return false for numbers', function() {
         expect(jasmineUnderTest.isPromiseLike(3)).toBe(false);
       });
 
-      it("should return false for null", function () {
+      it('should return false for null', function() {
         expect(jasmineUnderTest.isPromiseLike(null)).toBe(false);
       });
 
-      it("should return false for undefined", function () {
+      it('should return false for undefined', function() {
         expect(jasmineUnderTest.isPromiseLike(undefined)).toBe(false);
       });
 
-      it("should return false for arrays", function () {
+      it('should return false for arrays', function() {
         expect(jasmineUnderTest.isPromiseLike([])).toBe(false);
       });
 
-      it("should return false for objects", function () {
+      it('should return false for objects', function() {
         expect(jasmineUnderTest.isPromiseLike({})).toBe(false);
       });
 
-      it("should return false for boolean values", function () {
+      it('should return false for boolean values', function() {
         expect(jasmineUnderTest.isPromiseLike(true)).toBe(false);
       });
-
     });
-
   });
 
-  describe("isUndefined", function() {
-    it("reports if a variable is defined", function() {
+  describe('isUndefined', function() {
+    it('reports if a variable is defined', function() {
       var a;
       expect(jasmineUnderTest.util.isUndefined(a)).toBe(true);
       expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(true);
 
-      var undefined = "diz be undefined yo";
+      var undefined = 'diz be undefined yo';
       expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(false);
     });
   });
 
-  describe("getPropertyDescriptor", function() {
-    it("get property descriptor from object", function() {
-      var obj = {prop: 1},
+  describe('getPropertyDescriptor', function() {
+    it('get property descriptor from object', function() {
+      var obj = { prop: 1 },
         actual = jasmineUnderTest.util.getPropertyDescriptor(obj, 'prop'),
         expected = Object.getOwnPropertyDescriptor(obj, 'prop');
 
       expect(actual).toEqual(expected);
     });
 
-    it("get property descriptor from object property", function() {
-      var proto = {prop: 1},
-        obj = Object.create(proto),
+    it('get property descriptor from object property', function() {
+      var proto = { prop: 1 },
         actual = jasmineUnderTest.util.getPropertyDescriptor(proto, 'prop'),
         expected = Object.getOwnPropertyDescriptor(proto, 'prop');
 
@@ -160,8 +158,8 @@ describe("jasmineUnderTest.util", function() {
     });
   });
 
-  describe("objectDifference", function() {
-    it("given two objects A and B, returns the properties in A not present in B", function() {
+  describe('objectDifference', function() {
+    it('given two objects A and B, returns the properties in A not present in B', function() {
       var a = {
         foo: 3,
         bar: 4,
@@ -173,10 +171,13 @@ describe("jasmineUnderTest.util", function() {
         quux: 7
       };
 
-      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({foo: 3, baz: 5})
+      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({
+        foo: 3,
+        baz: 5
+      });
     });
 
-    it("only looks at own properties of both objects", function() {
+    it('only looks at own properties of both objects', function() {
       function Foo() {}
 
       Foo.prototype.x = 1;
@@ -188,13 +189,13 @@ describe("jasmineUnderTest.util", function() {
       var b = new Foo();
       b.y = 2;
 
-      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({x: 1});
-      expect(jasmineUnderTest.util.objectDifference(b, a)).toEqual({y: 2});
+      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({ x: 1 });
+      expect(jasmineUnderTest.util.objectDifference(b, a)).toEqual({ y: 2 });
     });
   });
 
-  describe("jasmineFile", function() {
-    it("returns the file containing jasmine.util", function() {
+  describe('jasmineFile', function() {
+    it('returns the file containing jasmine.util', function() {
       // Chrome sometimes reports foo.js as foo.js/, so tolerate
       // a trailing slash if present.
       expect(jasmineUnderTest.util.jasmineFile()).toMatch(/util.js\/?$/);

spec/core/baseSpec.js

@@ -1,6 +1,6 @@
 describe('base helpers', function() {
   describe('isError_', function() {
-    it("correctly handles WebSocket events", function(done) {
+    it('correctly handles WebSocket events', function(done) {
       if (typeof jasmine.getGlobal().WebSocket === 'undefined') {
         done();
         return;
@@ -10,9 +10,11 @@ describe('base helpers', function() {
         var sock = new WebSocket('ws://localhost');
         var event;
         sock.onerror = function(e) {
-          event = e
+          event = e;
+        };
+        return function() {
+          return event;
         };
-        return function() { return event };
       })();
       var left = 20;
 
@@ -20,6 +22,7 @@ describe('base helpers', function() {
         if (obj() || left === 0) {
           var result = jasmineUnderTest.isError_(obj());
           expect(result).toBe(false);
+          clearInterval(int);
           done();
         } else {
           left--;

spec/core/formatErrorMsgSpec.js

@@ -1,4 +1,4 @@
-describe('formatErrorMsg', function () {
+describe('formatErrorMsg', function() {
   it('should format an error with a domain', function() {
     var formator = jasmineUnderTest.formatErrorMsg('api');
     expect(formator('message')).toBe('api : message');

spec/helpers/BrowserFlags.js

@@ -1,7 +1,9 @@
 (function(env) {
   function browserVersion(matchFn) {
     var userAgent = jasmine.getGlobal().navigator.userAgent;
-    if (!userAgent) { return void 0; }
+    if (!userAgent) {
+      return void 0;
+    }
 
     var match = matchFn(userAgent);
 
@@ -11,5 +13,4 @@
   env.firefoxVersion = browserVersion(function(userAgent) {
     return /Firefox\/([0-9]{0,})/.exec(userAgent);
   });
-
 })(jasmine.getEnv());

spec/helpers/asyncAwait.js

@@ -1,7 +1,7 @@
 (function(env) {
   function getAsyncCtor() {
     try {
-      eval("var func = async function(){};");
+      eval('var func = async function(){};');
     } catch (e) {
       return null;
     }
@@ -15,13 +15,12 @@
 
   env.makeAsyncAwaitFunction = function() {
     var AsyncFunction = getAsyncCtor();
-    return new AsyncFunction("");
+    return new AsyncFunction('');
   };
 
   env.requireAsyncAwait = function() {
     if (!hasAsyncAwaitSupport()) {
-      env.pending("Environment does not support async/await functions");
+      env.pending('Environment does not support async/await functions');
     }
   };
 })(jasmine.getEnv());
-

spec/helpers/checkForMap.js

@@ -1,37 +1,46 @@
 (function(env) {
   function hasFunctioningMaps() {
-    if (typeof Map === 'undefined') { return false; }
+    if (typeof Map === 'undefined') {
+      return false;
+    }
 
     try {
       var s = new Map();
-      s.set('a',1);
-      s.set('b',2);
+      s.set('a', 1);
+      s.set('b', 2);
 
-      if (s.size !== 2) { return false; }
-      if (s.has('a') !== true) { return false; }
+      if (s.size !== 2) {
+        return false;
+      }
+      if (s.has('a') !== true) {
+        return false;
+      }
 
       var iterations = 0;
       var ifForEachWorking = true;
       s.forEach(function(value, key, map) {
         ifForEachWorking = ifForEachWorking && map === s;
-        if (key==='a') {
-          ifForEachWorking = ifForEachWorking && value===1;
+        if (key === 'a') {
+          ifForEachWorking = ifForEachWorking && value === 1;
         }
         iterations++;
       });
-      if (iterations !== 2) { return false; }
-      if (ifForEachWorking !== true) { return false; }
+      if (iterations !== 2) {
+        return false;
+      }
+      if (ifForEachWorking !== true) {
+        return false;
+      }
 
       return true;
-    } catch(e) {
+    } catch (e) {
       return false;
     }
   }
 
   env.requireFunctioningMaps = function() {
     if (!hasFunctioningMaps()) {
-      env.pending("Browser has incomplete or missing support for Maps");
+      env.pending('Browser has incomplete or missing support for Maps');
     }
   };
-
 })(jasmine.getEnv());

spec/helpers/checkForSet.js

@@ -1,41 +1,50 @@
 (function(env) {
   function hasFunctioningSets() {
-    if (typeof Set === 'undefined') { return false; }
+    if (typeof Set === 'undefined') {
+      return false;
+    }
 
     try {
       var s = new Set();
       s.add(1);
       s.add(2);
 
-      if (s.size !== 2) { return false; }
-      if (s.has(1) !== true) { return false; }
+      if (s.size !== 2) {
+        return false;
+      }
+      if (s.has(1) !== true) {
+        return false;
+      }
 
       var iterations = 0;
       var isForEachWorking = true;
       s.forEach(function(value, key, set) {
         isForEachWorking = isForEachWorking && set === s;
 
-        if (iterations===0) {
-          isForEachWorking = isForEachWorking && (key===value) && value===1;
-        } else if (iterations===1) {
-          isForEachWorking = isForEachWorking && (key===value) && value===2;
+        if (iterations === 0) {
+          isForEachWorking = isForEachWorking && key === value && value === 1;
+        } else if (iterations === 1) {
+          isForEachWorking = isForEachWorking && key === value && value === 2;
         }
 
         iterations++;
       });
-      if (iterations !== 2) { return false; }
-      if (isForEachWorking !== true) { return false; }
+      if (iterations !== 2) {
+        return false;
+      }
+      if (isForEachWorking !== true) {
+        return false;
+      }
 
       return true;
-    } catch(e) {
+    } catch (e) {
       return false;
     }
   }
 
   env.requireFunctioningSets = function() {
     if (!hasFunctioningSets()) {
-      env.pending("Browser has incomplete or missing support for Sets");
+      env.pending('Browser has incomplete or missing support for Sets');
     }
   };
-
 })(jasmine.getEnv());

spec/helpers/checkForSymbol.js

@@ -21,8 +21,7 @@
 
   env.requireFunctioningSymbols = function() {
     if (!hasFunctioningSymbols()) {
-      env.pending("Browser has incomplete or missing support for Symbols");
+      env.pending('Browser has incomplete or missing support for Symbols');
     }
   };
-
 })(jasmine.getEnv());

spec/helpers/checkForTypedArrays.js

@@ -1,20 +1,23 @@
 (function(env) {
   function hasFunctioningTypedArrays() {
-    if (typeof Uint32Array === 'undefined') { return false; }
+    if (typeof Uint32Array === 'undefined') {
+      return false;
+    }
 
     try {
       var a = new Uint32Array([1, 2, 3]);
-      if (a.length !== 3) { return false; }
+      if (a.length !== 3) {
+        return false;
+      }
       return true;
-    } catch(e) {
+    } catch (e) {
       return false;
     }
   }
 
   env.requireFunctioningTypedArrays = function() {
     if (!hasFunctioningTypedArrays()) {
-      env.pending("Browser has incomplete or missing support for typed arrays");
+      env.pending('Browser has incomplete or missing support for typed arrays');
     }
   };
-  
 })(jasmine.getEnv());

spec/helpers/integrationMatchers.js

@@ -1,10 +1,15 @@
 (function(env) {
   env.registerIntegrationMatchers = function() {
     jasmine.addMatchers({
-      toHaveFailedExpectationsForRunnable: function (util, customeEqualityTesters) {
+      toHaveFailedExpectationsForRunnable: function(
+        util,
+        customeEqualityTesters
+      ) {
         return {
-          compare: function (actual, fullName, expectedFailures) {
-            var foundRunnable = false, expectations = true, foundFailures = [];
+          compare: function(actual, fullName, expectedFailures) {
+            var foundRunnable = false,
+              expectations = true,
+              foundFailures = [];
             for (var i = 0; i < actual.calls.count(); i++) {
               var args = actual.calls.argsFor(i)[0];
 
@@ -19,8 +24,12 @@
                   var failure = foundFailures[j];
                   var expectedFailure = expectedFailures[j];
 
-                  if (Object.prototype.toString.call(expectedFailure) === '[object RegExp]') {
-                    expectations = expectations && expectedFailure.test(failure);
+                  if (
+                    Object.prototype.toString.call(expectedFailure) ===
+                    '[object RegExp]'
+                  ) {
+                    expectations =
+                      expectations && expectedFailure.test(failure);
                   } else {
                     expectations = expectations && failure === expectedFailure;
                   }
@@ -31,8 +40,14 @@
 
             return {
               pass: foundRunnable && expectations,
-              message: !foundRunnable ? 'The runnable "' + fullName + '" never finished' :
-                'Expected runnable "' + fullName + '" to have failures ' + jasmine.pp(expectedFailures) + ' but it had ' + jasmine.pp(foundFailures)
+              message: !foundRunnable
+                ? 'The runnable "' + fullName + '" never finished'
+                : 'Expected runnable "' +
+                  fullName +
+                  '" to have failures ' +
+                  jasmine.pp(expectedFailures) +
+                  ' but it had ' +
+                  jasmine.pp(foundFailures)
             };
           }
         };
@@ -40,4 +55,3 @@
     });
   };
 })(jasmine.getEnv());
-

spec/helpers/nodeDefineJasmineUnderTest.js

@@ -1,21 +1,19 @@
 (function() {
-  var path = require("path"),
-      fg = require("fast-glob");
+  var path = require('path'),
+    fg = require('fast-glob');
 
-  var jasmineUnderTestRequire = require(path.join(__dirname, "../../src/core/requireCore.js"));
+  var jasmineUnderTestRequire = require(path.join(
+    __dirname,
+    '../../src/core/requireCore.js'
+  ));
 
-  global.getJasmineRequireObj = function () {
+  global.getJasmineRequireObj = function() {
     return jasmineUnderTestRequire;
   };
 
-  function extend(destination, source) {
-    for (var property in source) destination[property] = source[property];
-    return destination;
-  }
-
   function getSourceFiles() {
     var src_files = ['core/**/*.js', 'version.js'].map(function(file) {
-      return path.join(__dirname, "../../", 'src/', file);
+      return path.join(__dirname, '../../', 'src/', file);
     });
 
     fg.sync(src_files).forEach(function(resolvedFile) {
@@ -24,5 +22,7 @@
   }
 
   getSourceFiles();
-  global.jasmineUnderTest = jasmineUnderTestRequire.core(jasmineUnderTestRequire);
+  global.jasmineUnderTest = jasmineUnderTestRequire.core(
+    jasmineUnderTestRequire
+  );
 })();

spec/helpers/promises.js

@@ -1,8 +1,7 @@
 (function(env) {
   env.requirePromises = function() {
     if (typeof Promise !== 'function') {
-      env.pending("Environment does not support promises");
+      env.pending('Environment does not support promises');
     }
   };
 })(jasmine.getEnv());
-

spec/html/HtmlSpecFilterSpec.js

@@ -1,18 +1,19 @@
-describe("jasmineUnderTest.HtmlSpecFilter", function() {
-
-  it("should match when no string is provided", function() {
+describe('jasmineUnderTest.HtmlSpecFilter', function() {
+  it('should match when no string is provided', function() {
     var specFilter = new jasmineUnderTest.HtmlSpecFilter();
 
-    expect(specFilter.matches("foo")).toBe(true);
-    expect(specFilter.matches("*bar")).toBe(true);
+    expect(specFilter.matches('foo')).toBe(true);
+    expect(specFilter.matches('*bar')).toBe(true);
   });
 
-  it("should only match the provided string", function() {
+  it('should only match the provided string', function() {
     var specFilter = new jasmineUnderTest.HtmlSpecFilter({
-      filterString: function() { return "foo"; }
+      filterString: function() {
+        return 'foo';
+      }
     });
 
-    expect(specFilter.matches("foo")).toBe(true);
-    expect(specFilter.matches("bar")).toBe(false);
+    expect(specFilter.matches('foo')).toBe(true);
+    expect(specFilter.matches('bar')).toBe(false);
   });
 });

spec/html/MatchersHtmlSpec.js

@@ -1,12 +1,11 @@
-describe("MatchersSpec - HTML Dependent", function () {
+describe('MatchersSpec - HTML Dependent', function() {
   var env, spec;
 
   beforeEach(function() {
     env = new jasmineUnderTest.Env();
 
-    var suite = env.describe("suite", function() {
-      spec = env.it("spec", function() {
-      });
+    env.describe('suite', function() {
+      spec = env.it('spec', function() {});
     });
     spyOn(spec, 'addExpectationResult');
 
@@ -28,10 +27,10 @@ describe("MatchersSpec - HTML Dependent", function () {
     return spec.addExpectationResult.mostRecentCall.args[1];
   }
 
-  xit("toEqual with DOM nodes", function() {
+  xit('toEqual with DOM nodes', function() {
     var nodeA = document.createElement('div');
     var nodeB = document.createElement('div');
-    expect((match(nodeA).toEqual(nodeA))).toPass();
-    expect((match(nodeA).toEqual(nodeB))).toFail();
+    expect(match(nodeA).toEqual(nodeA)).toPass();
+    expect(match(nodeA).toEqual(nodeB)).toFail();
   });
 });

spec/html/PrettyPrintHtmlSpec.js

@@ -1,17 +1,19 @@
-describe("jasmineUnderTest.pp (HTML Dependent)", function () {
-  it("should stringify non-element HTML nodes properly", function() {
-    var sampleNode = document.createTextNode("");
-    expect(jasmineUnderTest.pp(sampleNode)).toEqual("HTMLNode");
-    expect(jasmineUnderTest.pp({foo: sampleNode})).toEqual("Object({ foo: HTMLNode })");
+describe('jasmineUnderTest.pp (HTML Dependent)', function() {
+  it('should stringify non-element HTML nodes properly', function() {
+    var sampleNode = document.createTextNode('');
+    expect(jasmineUnderTest.pp(sampleNode)).toEqual('HTMLNode');
+    expect(jasmineUnderTest.pp({ foo: sampleNode })).toEqual(
+      'Object({ foo: HTMLNode })'
+    );
   });
 
-  it("should stringify empty HTML elements as their opening tags", function () {
+  it('should stringify empty HTML elements as their opening tags', function() {
     var simple = document.createElement('div');
     simple.className = 'foo';
     expect(jasmineUnderTest.pp(simple)).toEqual('<div class="foo">');
   });
 
-  it("should stringify non-empty HTML elements as tags with placeholders", function() {
+  it('should stringify non-empty HTML elements as tags with placeholders', function() {
     var nonEmpty = document.createElement('div');
     nonEmpty.className = 'foo';
     nonEmpty.innerHTML = '<p>Irrelevant</p>';
@@ -19,14 +21,20 @@ describe("jasmineUnderTest.pp (HTML Dependent)", function () {
   });
 
   it("should print Firefox's wrapped native objects correctly", function() {
-    if(jasmine.getEnv().firefoxVersion) {
-      try { new CustomEvent(); } catch(e) { var err = e; };
+    if (jasmine.getEnv().firefoxVersion) {
+      try {
+        new CustomEvent();
+      } catch (e) {
+        var err = e;
+      }
       // Different versions of FF produce different error messages.
-      expect(jasmineUnderTest.pp(err)).toMatch(/Not enough arguments|CustomEvent requires at least 1 argument, but only 0 were passed/);
+      expect(jasmineUnderTest.pp(err)).toMatch(
+        /Not enough arguments|CustomEvent requires at least 1 argument, but only 0 were passed/
+      );
     }
   });
 
-  it("should stringify HTML element with text and attributes", function() {
+  it('should stringify HTML element with text and attributes', function() {
     var el = document.createElement('div');
     el.setAttribute('things', 'foo');
     el.innerHTML = 'foo';

spec/html/QueryStringSpec.js

@@ -1,28 +1,31 @@
-describe("QueryString", function() {
-
-  describe("#navigateWithNewParam", function() {
-    it("sets the query string to include the given key/value pair", function() {
+describe('QueryString', function() {
+  describe('#navigateWithNewParam', function() {
+    it('sets the query string to include the given key/value pair', function() {
       var windowLocation = {
-          search: ""
+          search: ''
         },
         queryString = new jasmineUnderTest.QueryString({
-          getWindowLocation: function() { return windowLocation }
+          getWindowLocation: function() {
+            return windowLocation;
+          }
         });
 
-      queryString.navigateWithNewParam("foo", "bar baz");
+      queryString.navigateWithNewParam('foo', 'bar baz');
 
       expect(windowLocation.search).toMatch(/foo=bar%20baz/);
     });
 
-    it("leaves existing params alone", function() {
+    it('leaves existing params alone', function() {
       var windowLocation = {
-        search: "?foo=bar"
-      },
-      queryString = new jasmineUnderTest.QueryString({
-        getWindowLocation: function() { return windowLocation }
-      });
+          search: '?foo=bar'
+        },
+        queryString = new jasmineUnderTest.QueryString({
+          getWindowLocation: function() {
+            return windowLocation;
+          }
+        });
 
-      queryString.navigateWithNewParam("baz", "quux");
+      queryString.navigateWithNewParam('baz', 'quux');
 
       expect(windowLocation.search).toMatch(/foo=bar/);
       expect(windowLocation.search).toMatch(/baz=quux/);
@@ -30,43 +33,48 @@ describe("QueryString", function() {
   });
 
   describe('#fullStringWithNewParam', function() {
-    it("gets the query string including the given key/value pair", function() {
+    it('gets the query string including the given key/value pair', function() {
       var windowLocation = {
-        search: "?foo=bar"
-      },
-      queryString = new jasmineUnderTest.QueryString({
-        getWindowLocation: function() { return windowLocation }
-      });
+          search: '?foo=bar'
+        },
+        queryString = new jasmineUnderTest.QueryString({
+          getWindowLocation: function() {
+            return windowLocation;
+          }
+        });
 
-      var result = queryString.fullStringWithNewParam("baz", "quux");
+      var result = queryString.fullStringWithNewParam('baz', 'quux');
 
       expect(result).toMatch(/foo=bar/);
       expect(result).toMatch(/baz=quux/);
     });
   });
 
-  describe("#getParam", function() {
-
-    it("returns the value of the requested key", function() {
+  describe('#getParam', function() {
+    it('returns the value of the requested key', function() {
       var windowLocation = {
-          search: "?baz=quux%20corge"
+          search: '?baz=quux%20corge'
         },
         queryString = new jasmineUnderTest.QueryString({
-          getWindowLocation: function() { return windowLocation }
+          getWindowLocation: function() {
+            return windowLocation;
+          }
         });
 
-      expect(queryString.getParam("baz")).toEqual("quux corge");
+      expect(queryString.getParam('baz')).toEqual('quux corge');
     });
 
-    it("returns null if the key is not present", function() {
+    it('returns null if the key is not present', function() {
       var windowLocation = {
-          search: ""
+          search: ''
         },
         queryString = new jasmineUnderTest.QueryString({
-          getWindowLocation: function() { return windowLocation }
+          getWindowLocation: function() {
+            return windowLocation;
+          }
         });
 
-      expect(queryString.getParam("baz")).toBeFalsy();
+      expect(queryString.getParam('baz')).toBeFalsy();
     });
   });
 });

spec/html/ResultsNodeSpec.js

@@ -1,61 +1,61 @@
-describe("ResultsNode", function() {
-  it("wraps a result", function() {
+describe('ResultsNode', function() {
+  it('wraps a result', function() {
     var fakeResult = {
         id: 123,
-        message: "foo"
+        message: 'foo'
       },
-      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, 'suite', null);
 
     expect(node.result).toBe(fakeResult);
-    expect(node.type).toEqual("suite");
+    expect(node.type).toEqual('suite');
   });
 
-  it("can add children with a type", function() {
+  it('can add children with a type', function() {
     var fakeResult = {
         id: 123,
-        message: "foo"
+        message: 'foo'
       },
       fakeChildResult = {
         id: 456,
-        message: "bar"
+        message: 'bar'
       },
-      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, 'suite', null);
 
-    node.addChild(fakeChildResult, "spec");
+    node.addChild(fakeChildResult, 'spec');
 
     expect(node.children.length).toEqual(1);
     expect(node.children[0].result).toEqual(fakeChildResult);
-    expect(node.children[0].type).toEqual("spec");
+    expect(node.children[0].type).toEqual('spec');
   });
 
-  it("has a pointer back to its parent ResultNode", function() {
+  it('has a pointer back to its parent ResultNode', function() {
     var fakeResult = {
         id: 123,
-        message: "foo"
+        message: 'foo'
       },
       fakeChildResult = {
         id: 456,
-        message: "bar"
+        message: 'bar'
       },
-      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, 'suite', null);
 
-    node.addChild(fakeChildResult, "spec");
+    node.addChild(fakeChildResult, 'spec');
 
     expect(node.children[0].parent).toBe(node);
   });
 
-  it("can provide the most recent child", function() {
+  it('can provide the most recent child', function() {
     var fakeResult = {
         id: 123,
-        message: "foo"
+        message: 'foo'
       },
       fakeChildResult = {
         id: 456,
-        message: "bar"
+        message: 'bar'
       },
-      node = new jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
+      node = new jasmineUnderTest.ResultsNode(fakeResult, 'suite', null);
 
-    node.addChild(fakeChildResult, "spec");
+    node.addChild(fakeChildResult, 'spec');
 
     expect(node.last()).toBe(node.children[node.children.length - 1]);
   });

spec/html/SpyRegistryHtmlSpec.js

@@ -8,7 +8,9 @@ describe('Spy Registry browser-specific behavior', function() {
 
     var spies = [],
       spyRegistry = new jasmineUnderTest.SpyRegistry({
-        currentSpies: function() { return spies; },
+        currentSpies: function() {
+          return spies;
+        },
         createSpy: createSpy,
         global: window
       }),
@@ -28,7 +30,7 @@ describe('Spy Registry browser-specific behavior', function() {
 
     try {
       descriptor = Object.getOwnPropertyDescriptor(window, 'onerror');
-    } catch(e) {
+    } catch (e) {
       // IE 8 doesn't support `definePropery` on non-DOM nodes
     }
 

spec/npmPackage/npmPackageSpec.js

@@ -1,19 +1,24 @@
 describe('npm package', function() {
   var path = require('path'),
-      temp = require('temp').track(),
-      fs = require('fs');
+    temp = require('temp').track(),
+    fs = require('fs');
 
   beforeAll(function() {
     var shell = require('shelljs'),
-        pack = shell.exec('npm pack', { silent: true});
+      pack = shell.exec('npm pack', { silent: true });
 
     this.tarball = pack.stdout.split('\n')[0];
     this.tmpDir = temp.mkdirSync(); // automatically deleted on exit
 
-    var untar = shell.exec('tar -xzf ' + this.tarball + ' -C ' + this.tmpDir, { silent: true });
+    var untar = shell.exec('tar -xzf ' + this.tarball + ' -C ' + this.tmpDir, {
+      silent: true
+    });
     expect(untar.code).toBe(0);
 
-    this.packagedCore = require(path.join(this.tmpDir, 'package/lib/jasmine-core.js'));
+    this.packagedCore = require(path.join(
+      this.tmpDir,
+      'package/lib/jasmine-core.js'
+    ));
   });
 
   beforeEach(function() {
@@ -32,25 +37,19 @@ describe('npm package', function() {
   });
 
   afterAll(function() {
-    var cleanup = function (parent, fileOrFolder) {
-      var fullPath = path.join(parent, fileOrFolder);
-      if (fs.statSync(fullPath).isFile()) {
-        fs.unlinkSync(fullPath);
-      } else {
-        fs.readdirSync(fullPath).forEach(cleanup.bind(null, fullPath));
-        fs.rmdirSync(fullPath);
-      }
-    };
-
     fs.unlinkSync(this.tarball);
   });
 
   it('has a root path', function() {
-    expect(this.packagedCore.files.path).toEqual(fs.realpathSync(path.resolve(this.tmpDir, 'package/lib/jasmine-core')));
+    expect(this.packagedCore.files.path).toEqual(
+      fs.realpathSync(path.resolve(this.tmpDir, 'package/lib/jasmine-core'))
+    );
   });
 
   it('has a bootDir', function() {
-    expect(this.packagedCore.files.bootDir).toEqual(fs.realpathSync(path.resolve(this.tmpDir, 'package/lib/jasmine-core')));
+    expect(this.packagedCore.files.bootDir).toEqual(
+      fs.realpathSync(path.resolve(this.tmpDir, 'package/lib/jasmine-core'))
+    );
   });
 
   it('has jsFiles', function() {
@@ -91,7 +90,9 @@ describe('npm package', function() {
   });
 
   it('has an imagesDir', function() {
-    expect(this.packagedCore.files.imagesDir).toEqual(fs.realpathSync(path.resolve(this.tmpDir, 'package/images')));
+    expect(this.packagedCore.files.imagesDir).toEqual(
+      fs.realpathSync(path.resolve(this.tmpDir, 'package/images'))
+    );
     var images = fs.readdirSync(path.resolve(this.tmpDir, 'package/images'));
 
     expect(images).toContain('jasmine-horizontal.png');

spec/performance/large_object_test.js

@@ -1,4 +1,4 @@
-describe('Printing a big object', function(){
+describe('Printing a big object', function() {
   var bigObject;
   function rand(upper) {
     return Math.round(upper * Math.random());
@@ -11,26 +11,24 @@ describe('Printing a big object', function(){
       var decide = rand(2);
       switch (decide) {
         case 0:
-          object["cycle" + i] = object;
-        break;
+          object['cycle' + i] = object;
+          break;
         case 1:
-          object["number" + i] = rand(100);
-        break;
+          object['number' + i] = rand(100);
+          break;
         case 2:
           if (level < 3) {
-          object["nesting" + i] = generateObject(level + 1);
-        }
-        break;
+            object['nesting' + i] = generateObject(level + 1);
+          }
+          break;
       }
-
     }
 
     return object;
   }
 
-  it('takes a reasonable amount of time', function(){
+  it('takes a reasonable amount of time', function() {
     bigObject = generateObject(0);
     expect(jasmineUnderTest.pp(bigObject)).toMatch(/cycle/);
   });
 });
-

spec/performance/performance_test.js

@@ -1,9 +1,9 @@
-describe("performance", function() {
+describe('performance', function() {
   for (var i = 0; i < 10000; i++) {
-    it("should pass", function() {
+    it('should pass', function() {
       expect(true).toBe(true);
     });
-    it("should fail", function() {
+    it('should fail', function() {
       expect(true).toBe(false);
     });
   }