jasmine-core 2.0.0.rc2 → 2.0.0.rc3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1bd31139a1c91448e7da9a70a0d2305d03b2d0bc
+  data.tar.gz: 6f9500edfc06f08901eb9899ced10cf6fe331c70
+SHA512:
+  metadata.gz: 1abbaef73d3e0be63149fec07fba134017274b54aa7b7339b6422266b250387b947bf06ce4952d85a344f5cb85e21f527b90d1d505840c079fbed46b4a2020ac
+  data.tar.gz: 814477470ab35ce9d86a96c11f92a10d54600e88bbfa95de2e7527961ccb459371399374d9aa503b2dc3713857a9bcd1d90437b0cd45ec03b9ac07b4fdedc7b2

data/lib/jasmine-core/boot.js

@@ -69,10 +69,6 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
     },
 
     clock: env.clock,
-    setTimeout: env.clock.setTimeout,
-    clearTimeout: env.clock.clearTimeout,
-    setInterval: env.clock.setInterval,
-    clearInterval: env.clock.clearInterval,
     jsApiReporter: new jasmine.JsApiReporter({
       timer: new jasmine.Timer()
     })

data/lib/jasmine-core/boot/boot.js

@@ -47,10 +47,6 @@
     },
 
     clock: env.clock,
-    setTimeout: env.clock.setTimeout,
-    clearTimeout: env.clock.clearTimeout,
-    setInterval: env.clock.setInterval,
-    clearInterval: env.clock.clearInterval,
     jsApiReporter: new jasmine.JsApiReporter({
       timer: new jasmine.Timer()
     })

data/lib/jasmine-core/jasmine-html.js

@@ -109,7 +109,9 @@ jasmineRequire.HtmlReporter = function(j$) {
 
         var failure =
           createDom("div", {className: "spec-detail failed"},
-            createDom("a", {className: "description", title: result.fullName, href: specHref(result)}, result.fullName),
+            createDom("div", {className: "description"},
+              createDom("a", {title: result.fullName, href: specHref(result)}, result.fullName)
+            ),
             createDom("div", {className: "messages"})
           );
         var messages = failure.childNodes[1];

data/lib/jasmine-core/jasmine.css

@@ -11,7 +11,7 @@ body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
 .html-reporter .banner { margin-top: 14px; }
 .html-reporter .duration { color: #aaaaaa; float: right; }
 .html-reporter .symbol-summary { overflow: hidden; *zoom: 1; margin: 14px 0; }
-.html-reporter .symbol-summary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; }
+.html-reporter .symbol-summary li { display: inline-block; height: 8px; width: 14px; font-size: 16px; }
 .html-reporter .symbol-summary li.passed { font-size: 14px; }
 .html-reporter .symbol-summary li.passed:before { color: #5e7d00; content: "\02022"; }
 .html-reporter .symbol-summary li.failed { line-height: 9px; }
@@ -48,7 +48,8 @@ body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
 .html-reporter .suite { margin-top: 14px; }
 .html-reporter .suite a { color: #333333; }
 .html-reporter .failures .spec-detail { margin-bottom: 28px; }
-.html-reporter .failures .spec-detail .description { display: block; color: white; background-color: #b03911; }
+.html-reporter .failures .spec-detail .description { background-color: #b03911; }
+.html-reporter .failures .spec-detail .description a { color: white; }
 .html-reporter .result-message { padding-top: 14px; color: #333333; white-space: pre; }
 .html-reporter .result-message span.result { display: block; }
-.html-reporter .stack-trace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #dddddd; background: white; white-space: pre; }
+.html-reporter .stack-trace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }

data/lib/jasmine-core/jasmine.js

@@ -30,7 +30,7 @@ function getJasmineRequireObj() {
 }
 
 getJasmineRequireObj().core = function(jRequire) {
-  j$ = {};
+  var j$ = {};
 
   jRequire.base(j$);
   j$.util = jRequire.util();
@@ -48,7 +48,7 @@ getJasmineRequireObj().core = function(jRequire) {
   j$.pp = jRequire.pp(j$);
   j$.QueueRunner = jRequire.QueueRunner();
   j$.ReportDispatcher = jRequire.ReportDispatcher();
-  j$.Spec = jRequire.Spec();
+  j$.Spec = jRequire.Spec(j$);
   j$.SpyStrategy = jRequire.SpyStrategy();
   j$.Suite = jRequire.Suite();
   j$.Timer = jRequire.Timer();
@@ -94,7 +94,6 @@ getJasmineRequireObj().base = function(j$) {
     throw new Error("unimplemented method");
   };
 
-  j$.DEFAULT_UPDATE_INTERVAL = 250;
   j$.MAX_PRETTY_PRINT_DEPTH = 40;
   j$.DEFAULT_TIMEOUT_INTERVAL = 5000;
 
@@ -221,7 +220,7 @@ getJasmineRequireObj().util = function() {
   return util;
 };
 
-getJasmineRequireObj().Spec = function() {
+getJasmineRequireObj().Spec = function(j$) {
   function Spec(attrs) {
     this.encounteredExpectations = false;
     this.expectationFactory = attrs.expectationFactory;
@@ -281,14 +280,14 @@ getJasmineRequireObj().Spec = function() {
         var timeout = Function.prototype.apply.apply(self.timer.setTimeout, [j$.getGlobal(), [function() {
           onException(new Error('timeout'));
           done();
-        }, 10000]]);
+        }, j$.DEFAULT_TIMEOUT_INTERVAL]]);
 
         var callDone = function() {
           Function.prototype.apply.apply(self.timer.clearTimeout, [j$.getGlobal(), [timeout]]);
           done();
         };
 
-        fn(callDone); //TODO: do we care about more than 1 arg?
+        fn.call(this, callDone); //TODO: do we care about more than 1 arg?
       };
     }
 
@@ -382,6 +381,8 @@ getJasmineRequireObj().Env = function(j$) {
     var realClearTimeout = j$.getGlobal().clearTimeout;
     this.clock = new j$.Clock(global, new j$.DelayedFunctionScheduler());
 
+    var runnableLookupTable = {};
+
     var spies = [];
 
     this.currentSpec = null;
@@ -450,7 +451,7 @@ getJasmineRequireObj().Env = function(j$) {
     };
 
     var getSpecName = function(spec, currentSuite) {
-      return currentSuite.getFullName() + ' ' + spec.description + '.';
+      return currentSuite.getFullName() + ' ' + spec.description;
     };
 
     // TODO: we may just be able to pass in the fn instead of wrapping here
@@ -519,6 +520,8 @@ getJasmineRequireObj().Env = function(j$) {
         timer: {setTimeout: realSetTimeout, clearTimeout: realClearTimeout}
       });
 
+      runnableLookupTable[spec.id] = spec;
+
       if (!self.specFilter(spec)) {
         spec.disable();
       }
@@ -557,10 +560,11 @@ getJasmineRequireObj().Env = function(j$) {
       completeCallback: function() {}, // TODO - hook this up
       resultCallback: function() {} // TODO - hook this up
     });
+    runnableLookupTable[this.topSuite.id] = this.topSuite;
     this.currentSuite = this.topSuite;
 
     this.suiteFactory = function(description) {
-      return new suiteConstructor({
+      var suite = new suiteConstructor({
         env: self,
         id: self.nextSuiteId(),
         description: description,
@@ -571,13 +575,25 @@ getJasmineRequireObj().Env = function(j$) {
           self.reporter.suiteDone(attrs);
         }
       });
+
+      runnableLookupTable[suite.id] = suite;
+      return suite;
     };
 
-    this.execute = function() {
+    this.execute = function(runnablesToRun) {
+      runnablesToRun = runnablesToRun || [this.topSuite.id];
+
+      var allFns = [];
+      for(var i = 0; i < runnablesToRun.length; i++) {
+        var runnable = runnableLookupTable[runnablesToRun[i]];
+        allFns.push((function(runnable) { return function(done) { runnable.execute(done); }; })(runnable));
+      }
+
       this.reporter.jasmineStarted({
         totalSpecsDefined: totalSpecsDefined
       });
-      this.topSuite.execute(self.reporter.jasmineDone);
+
+      queueRunnerFactory({fns: allFns, onComplete: this.reporter.jasmineDone});
     };
 
     this.spyOn = function(obj, methodName) {
@@ -630,12 +646,12 @@ getJasmineRequireObj().Env = function(j$) {
 
   // TODO: move this to closure
   Env.prototype.nextSpecId = function() {
-    return this.nextSpecId_++;
+    return 'spec' + this.nextSpecId_++;
   };
 
   // TODO: move this to closure
   Env.prototype.nextSuiteId = function() {
-    return this.nextSuiteId_++;
+    return 'suite' + this.nextSuiteId_++;
   };
 
   // TODO: move this to closure
@@ -889,18 +905,19 @@ getJasmineRequireObj().Clock = function() {
         setInterval: setInterval,
         clearInterval: clearInterval
       },
-      timer = realTimingFunctions,
       installed = false;
 
     self.install = function() {
-      installed = true;
+      replace(global, fakeTimingFunctions);
       timer = fakeTimingFunctions;
+      installed = true;
     };
 
     self.uninstall = function() {
       delayedFunctionScheduler.reset();
-      installed = false;
+      replace(global, realTimingFunctions);
       timer = realTimingFunctions;
+      installed = false;
     };
 
     self.setTimeout = function(fn, delay, params) {
@@ -935,7 +952,7 @@ getJasmineRequireObj().Clock = function() {
       if (installed) {
         delayedFunctionScheduler.tick(millis);
       } else {
-        throw new Error("Mock clock is not installed, use jasmine.Clock.useMock()");
+        throw new Error("Mock clock is not installed, use jasmine.getEnv().clock.install()");
       }
     };
 
@@ -945,7 +962,13 @@ getJasmineRequireObj().Clock = function() {
       //if these methods are polyfilled, apply will be present
       //TODO: it may be difficult to load the polyfill before jasmine loads
       //(env should be new-ed inside of onload)
-      return !(global.setTimeout || global.setInterval).apply;
+      return !(realTimingFunctions.setTimeout || realTimingFunctions.setInterval).apply;
+    }
+
+    function replace(dest, source) {
+      for (var prop in source) {
+        dest[prop] = source[prop];
+      }
     }
 
     function setTimeout(fn, delay) {
@@ -981,8 +1004,8 @@ getJasmineRequireObj().DelayedFunctionScheduler = function() {
 
     self.tick = function(millis) {
       millis = millis || 0;
-      runFunctionsWithinRange(currentTime, currentTime + millis);
       currentTime = currentTime + millis;
+      runFunctionsWithinRange(currentTime - millis, currentTime);
     };
 
     self.scheduleFunction = function(funcToCall, millis, params, recurring, timeoutKey, runAtMillis) {
@@ -1323,7 +1346,7 @@ getJasmineRequireObj().pp = function(j$) {
         this.emitScalar('Date(' + value + ')');
       } else if (value.__Jasmine_been_here_before__) {
         this.emitScalar('<circular reference: ' + (j$.isArray_(value) ? 'Array' : 'Object') + '>');
-      } else if (j$.isArray_(value) || typeof value == 'object') {
+      } else if (j$.isArray_(value) || j$.isA_('Object', value)) {
         value.__Jasmine_been_here_before__ = true;
         if (j$.isArray_(value)) {
           this.emitArray(value);
@@ -1433,6 +1456,7 @@ getJasmineRequireObj().QueueRunner = function() {
     this.clearStack = attrs.clearStack || function(fn) {fn();};
     this.onException = attrs.onException || function() {};
     this.catchException = attrs.catchException || function() { return true; };
+    this.userContext = {};
   }
 
   QueueRunner.prototype.execute = function() {
@@ -1461,7 +1485,7 @@ getJasmineRequireObj().QueueRunner = function() {
 
     function attemptSync(fn) {
       try {
-        fn.call(self);
+        fn.call(self.userContext);
       } catch (e) {
         handleException(e);
       }
@@ -1471,7 +1495,7 @@ getJasmineRequireObj().QueueRunner = function() {
       var next = function () { self.run(fns, iterativeIndex + 1); };
 
       try {
-        fn.call(self, next);
+        fn.call(self.userContext, next);
       } catch (e) {
         handleException(e);
         next();
@@ -1550,16 +1574,17 @@ getJasmineRequireObj().SpyStrategy = function() {
       return getSpy();
     };
 
-    this.callReturn = function(value) {
+    this.returnValue = function(value) {
       plan = function() {
         return value;
       };
       return getSpy();
     };
 
-    this.callThrow = function(something) {
+    this.throwError = function(something) {
+      var error = (something instanceof Error) ? something : new Error(something);
       plan = function() {
-        throw something;
+        throw error;
       };
       return getSpy();
     };
@@ -2114,21 +2139,26 @@ getJasmineRequireObj().toHaveBeenCalledWith = function(j$) {
       compare: function() {
         var args = Array.prototype.slice.call(arguments, 0),
           actual = args[0],
-          expectedArgs = args.slice(1);
+          expectedArgs = args.slice(1),
+          result = { pass: false };
 
         if (!j$.isSpy(actual)) {
           throw new Error('Expected a spy, but got ' + j$.pp(actual) + '.');
         }
 
-        return {
-          pass: util.contains(actual.calls.allArgs(), expectedArgs)
-        };
-      },
-      message: function(actual) {
-        return {
-          affirmative: "Expected spy " + actual.and.identity() + " to have been called.",
-          negative: "Expected spy " + actual.and.identity() + " not to have been called."
-        };
+        if (!actual.calls.any()) {
+          result.message = "Expected spy " + actual.and.identity() + " to have been called with " + j$.pp(expectedArgs) + " but it was never called.";
+          return result;
+        }
+
+        if (util.contains(actual.calls.allArgs(), expectedArgs)) {
+          result.pass = true;
+          result.message = "Expected spy " + actual.and.identity() + " not to have been called with " + j$.pp(expectedArgs) + " but it was.";
+        } else {
+          result.message = "Expected spy " + actual.and.identity() + " to have been called with " + j$.pp(expectedArgs) + " but actual calls were " + j$.pp(actual.calls.allArgs()).replace(/^\[ | \]$/g, '') + ".";
+        }
+
+        return result;
       }
     };
   }

data/lib/jasmine-core/spec/console/ConsoleReporterSpec.js

@@ -90,7 +90,7 @@ describe("ConsoleReporter", function() {
     reporter.jasmineStarted();
     reporter.specDone({status: "passed"});
 
-    timerSpy.elapsed.and.callReturn(1000);
+    timerSpy.elapsed.and.returnValue(1000);
 
     out.clear();
     reporter.jasmineDone();
@@ -127,7 +127,7 @@ describe("ConsoleReporter", function() {
 
     out.clear();
 
-    timerSpy.elapsed.and.callReturn(100);
+    timerSpy.elapsed.and.returnValue(100);
 
     reporter.jasmineDone();
 

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

@@ -1,41 +1,141 @@
 describe("Clock", function() {
 
-  it("calls the global setTimeout directly if Clock is not installed", function() {
-    var setTimeout = jasmine.createSpy('setTimeout'),
-      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['scheduleFunction']),
-      global = { setTimeout: setTimeout },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
+  it("does not replace setTimeout until it is installed", function() {
+    var fakeSetTimeout = jasmine.createSpy("global setTimeout"),
+      fakeGlobal = { setTimeout: fakeSetTimeout },
+      delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction"]),
+      delayedFn = jasmine.createSpy("delayedFn"),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
 
-    clock.setTimeout(delayedFn, 0);
+    fakeGlobal.setTimeout(delayedFn, 0);
 
+    expect(fakeSetTimeout).toHaveBeenCalledWith(delayedFn, 0);
     expect(delayedFunctionScheduler.scheduleFunction).not.toHaveBeenCalled();
-    expect(setTimeout).toHaveBeenCalledWith(delayedFn, 0);
+
+    fakeSetTimeout.calls.reset();
+
+    clock.install();
+    fakeGlobal.setTimeout(delayedFn, 0);
+
+    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalled();
+    expect(fakeSetTimeout).not.toHaveBeenCalled();
   });
 
-  it("schedules the delayed function with the fake timer", function() {
-    var setTimeout = jasmine.createSpy('setTimeout'),
+  it("does not replace clearTimeout until it is installed", function() {
+    var fakeClearTimeout = jasmine.createSpy("global cleartimeout"),
+      fakeGlobal = { clearTimeout: fakeClearTimeout },
+      delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["removeFunctionWithId"]),
+      delayedFn = jasmine.createSpy("delayedFn"),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
+
+    fakeGlobal.clearTimeout("foo");
+
+    expect(fakeClearTimeout).toHaveBeenCalledWith("foo");
+    expect(delayedFunctionScheduler.removeFunctionWithId).not.toHaveBeenCalled();
+
+    fakeClearTimeout.calls.reset();
+
+    clock.install();
+    fakeGlobal.clearTimeout("foo");
+
+    expect(delayedFunctionScheduler.removeFunctionWithId).toHaveBeenCalled();
+    expect(fakeClearTimeout).not.toHaveBeenCalled();
+  });
+
+  it("does not replace setInterval until it is installed", function() {
+    var fakeSetInterval = jasmine.createSpy("global setInterval"),
+      fakeGlobal = { setInterval: fakeSetInterval },
+      delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction"]),
+      delayedFn = jasmine.createSpy("delayedFn"),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
+
+    fakeGlobal.setInterval(delayedFn, 0);
+
+    expect(fakeSetInterval).toHaveBeenCalledWith(delayedFn, 0);
+    expect(delayedFunctionScheduler.scheduleFunction).not.toHaveBeenCalled();
+
+    fakeSetInterval.calls.reset();
+
+    clock.install();
+    fakeGlobal.setInterval(delayedFn, 0);
+
+    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalled();
+    expect(fakeSetInterval).not.toHaveBeenCalled();
+  });
+
+  it("does not replace clearInterval until it is installed", function() {
+    var fakeClearInterval = jasmine.createSpy("global clearinterval"),
+      fakeGlobal = { clearInterval: fakeClearInterval },
+      delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["removeFunctionWithId"]),
+      delayedFn = jasmine.createSpy("delayedFn"),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
+
+    fakeGlobal.clearInterval("foo");
+
+    expect(fakeClearInterval).toHaveBeenCalledWith("foo");
+    expect(delayedFunctionScheduler.removeFunctionWithId).not.toHaveBeenCalled();
+
+    fakeClearInterval.calls.reset();
+
+    clock.install();
+    fakeGlobal.clearInterval("foo");
+
+    expect(delayedFunctionScheduler.removeFunctionWithId).toHaveBeenCalled();
+    expect(fakeClearInterval).not.toHaveBeenCalled();
+  });
+
+  it("replaces the global timer functions on uninstall", function() {
+    var fakeSetTimeout = jasmine.createSpy("global setTimeout"),
+      fakeClearTimeout = jasmine.createSpy("global clearTimeout"),
+      fakeSetInterval = jasmine.createSpy("global setInterval"),
+      fakeClearInterval = jasmine.createSpy("global clearInterval"),
+      fakeGlobal = {
+        setTimeout: fakeSetTimeout,
+        clearTimeout: fakeClearTimeout,
+        setInterval: fakeSetInterval,
+        clearInterval: fakeClearInterval
+      },
+      delayedFunctionScheduler = jasmine.createSpyObj("delayedFunctionScheduler", ["scheduleFunction", "reset"]),
+      delayedFn = jasmine.createSpy("delayedFn"),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
+
+    clock.install();
+    clock.uninstall();
+    fakeGlobal.setTimeout(delayedFn, 0);
+    fakeGlobal.clearTimeout("foo");
+    fakeGlobal.setInterval(delayedFn, 10);
+    fakeGlobal.clearInterval("bar");
+
+    expect(fakeSetTimeout).toHaveBeenCalledWith(delayedFn, 0);
+    expect(fakeClearTimeout).toHaveBeenCalledWith("foo");
+    expect(fakeSetInterval).toHaveBeenCalledWith(delayedFn, 10);
+    expect(fakeClearInterval).toHaveBeenCalledWith("bar");
+    expect(delayedFunctionScheduler.scheduleFunction).not.toHaveBeenCalled();
+  });
+
+  it("schedules the delayed function (via setTimeout) with the fake timer", function() {
+    var fakeSetTimeout = jasmine.createSpy('setTimeout'),
       scheduleFunction = jasmine.createSpy('scheduleFunction'),
-      delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
-      global = { setTimeout: setTimeout },
+      delayedFunctionScheduler = { scheduleFunction: scheduleFunction },
+      fakeGlobal = { setTimeout: fakeSetTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
 
     clock.install();
     clock.setTimeout(delayedFn, 0, 'a', 'b');
 
-    expect(setTimeout).not.toHaveBeenCalled();
+    expect(fakeSetTimeout).not.toHaveBeenCalled();
     expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b']);
   });
 
   it("returns an id for the delayed function", function() {
-    var setTimeout = jasmine.createSpy('setTimeout'),
+    var fakeSetTimeout = jasmine.createSpy('setTimeout'),
       scheduleId = 123,
-      scheduleFunction = jasmine.createSpy('scheduleFunction').and.callReturn(scheduleId),
+      scheduleFunction = jasmine.createSpy('scheduleFunction').and.returnValue(scheduleId),
       delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
-      global = { setTimeout: setTimeout },
+      fakeGlobal = { setTimeout: fakeSetTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler),
       timeoutId;
 
     clock.install();
@@ -44,67 +144,43 @@ describe("Clock", function() {
     expect(timeoutId).toEqual(123);
   });
 
-  it("calls the global clearTimeout directly if Clock is not installed", function() {
-    var clearTimeout = jasmine.createSpy('clearTimeout'),
-      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['clearTimeout']),
-      global = { clearTimeout: clearTimeout },
-      clock = new j$.Clock(global, delayedFunctionScheduler);
-
-    clock.clearTimeout(123);
-
-    expect(clearTimeout).toHaveBeenCalledWith(123);
-  });
-
   it("clears the scheduled function with the scheduler", function() {
-    var clearTimeout = jasmine.createSpy('clearTimeout'),
+    var fakeClearTimeout = jasmine.createSpy('clearTimeout'),
       delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['removeFunctionWithId']),
-      global = { setTimeout: clearTimeout },
+      fakeGlobal = { setTimeout: fakeClearTimeout },
       delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
 
     clock.install();
     clock.clearTimeout(123);
 
-    expect(clearTimeout).not.toHaveBeenCalled();
+    expect(fakeClearTimeout).not.toHaveBeenCalled();
     expect(delayedFunctionScheduler.removeFunctionWithId).toHaveBeenCalledWith(123);
   });
 
-  it("calls the global setInterval directly if Clock is not installed", function() {
-    var setInterval = jasmine.createSpy('setInterval'),
-      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['scheduleFunction']),
-      global = { setInterval: setInterval },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
-
-    clock.setInterval(delayedFn, 0);
-
-    expect(delayedFunctionScheduler.scheduleFunction).not.toHaveBeenCalled();
-    expect(setInterval).toHaveBeenCalledWith(delayedFn, 0);
-  });
-
   it("schedules the delayed function with the fake timer", function() {
-    var setInterval = jasmine.createSpy('setInterval'),
+    var fakeSetInterval = jasmine.createSpy('setInterval'),
       scheduleFunction = jasmine.createSpy('scheduleFunction'),
       delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
-      global = { setInterval: setInterval },
+      fakeGlobal = { setInterval: fakeSetInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
 
     clock.install();
     clock.setInterval(delayedFn, 0, 'a', 'b');
 
-    expect(setInterval).not.toHaveBeenCalled();
+    expect(fakeSetInterval).not.toHaveBeenCalled();
     expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b'], true);
   });
 
   it("returns an id for the delayed function", function() {
-    var setInterval = jasmine.createSpy('setInterval'),
+    var fakeSetInterval = jasmine.createSpy('setInterval'),
       scheduleId = 123,
-      scheduleFunction = jasmine.createSpy('scheduleFunction').and.callReturn(scheduleId),
+      scheduleFunction = jasmine.createSpy('scheduleFunction').and.returnValue(scheduleId),
       delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
-      global = { setInterval: setInterval },
+      fakeGlobal = { setInterval: fakeSetInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler),
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler),
       intervalId;
 
     clock.install();
@@ -113,23 +189,12 @@ describe("Clock", function() {
     expect(intervalId).toEqual(123);
   });
 
-  it("calls the global clearInterval directly if Clock is not installed", function() {
-    var clearInterval = jasmine.createSpy('clearInterval'),
-      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['clearInterval']),
-      global = { clearInterval: clearInterval },
-      clock = new j$.Clock(global, delayedFunctionScheduler);
-
-    clock.clearInterval(123);
-
-    expect(clearInterval).toHaveBeenCalledWith(123);
-  });
-
   it("clears the scheduled function with the scheduler", function() {
     var clearInterval = jasmine.createSpy('clearInterval'),
       delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['removeFunctionWithId']),
-      global = { setInterval: clearInterval },
+      fakeGlobal = { setInterval: clearInterval },
       delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
 
     clock.install();
     clock.clearInterval(123);
@@ -145,53 +210,20 @@ describe("Clock", function() {
     }).toThrow();
   });
 
-  it("can be uninstalled", function() {
-    var setTimeout = jasmine.createSpy('setTimeout'),
-      setInterval = jasmine.createSpy('setInterval'),
-      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['scheduleFunction', 'tick', 'reset']),
-      global = { setTimeout: setTimeout, setInterval: setInterval },
-      delayedFn = jasmine.createSpy('delayedFn'),
-      clock = new j$.Clock(global, delayedFunctionScheduler);
-
-    clock.install();
-    clock.setTimeout(delayedFn, 0);
-    expect(setTimeout).not.toHaveBeenCalled();
-
-    clock.setInterval(delayedFn, 0);
-    expect(setInterval).not.toHaveBeenCalled();
-
-    expect(function() {
-      clock.tick(0);
-    }).not.toThrow();
-
-    clock.uninstall();
-
-    expect(delayedFunctionScheduler.reset).toHaveBeenCalled();
-
-    clock.setTimeout(delayedFn, 0);
-
-    expect(setTimeout).toHaveBeenCalled();
-
-    clock.setInterval(delayedFn, 0);
-    expect(setInterval).toHaveBeenCalled();
-
-    expect(function() {
-      clock.tick(0);
-    }).toThrow();
-  });
-
-
   it("on IE < 9, fails if extra args are passed to fake clock", function() {
     //fail, because this would break in IE9.
-    var setTimeout = jasmine.createSpy('setTimeout'),
-    setInterval = jasmine.createSpy('setInterval'),
-    delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['scheduleFunction']),
-    fn = jasmine.createSpy('fn'),
-    global = { setTimeout: setTimeout, setInterval: setInterval },
-    clock = new j$.Clock(global, delayedFunctionScheduler);
+    var fakeSetTimeout = jasmine.createSpy('setTimeout'),
+      fakeSetInterval = jasmine.createSpy('setInterval'),
+      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['scheduleFunction']),
+      fn = jasmine.createSpy('fn'),
+      fakeGlobal = {
+        setTimeout: fakeSetTimeout,
+        setInterval: fakeSetInterval
+      },
+      clock = new j$.Clock(fakeGlobal, delayedFunctionScheduler);
 
-    setTimeout.apply = null;
-    setInterval.apply = null;
+    fakeSetTimeout.apply = null;
+    fakeSetInterval.apply = null;
 
     clock.install();
 
@@ -221,8 +253,8 @@ describe("Clock (acceptance)", function() {
 
     clock.install();
 
-    clock.setTimeout(delayedFn1, 0, 'some', 'arg');
-    var intervalId = clock.setInterval(recurring1, 50, 'some', 'other', 'args');
+    clock.setTimeout(delayedFn1, 0);
+    var intervalId = clock.setInterval(recurring1, 50);
     clock.setTimeout(delayedFn2, 100);
     clock.setTimeout(delayedFn3, 200);
 
@@ -232,13 +264,13 @@ describe("Clock (acceptance)", function() {
 
     clock.tick(0);
 
-    expect(delayedFn1).toHaveBeenCalledWith('some', 'arg');
+    expect(delayedFn1).toHaveBeenCalled();
     expect(delayedFn2).not.toHaveBeenCalled();
     expect(delayedFn3).not.toHaveBeenCalled();
 
     clock.tick(50);
 
-    expect(recurring1).toHaveBeenCalledWith('some', 'other', 'args');
+    expect(recurring1).toHaveBeenCalled();
     expect(recurring1.calls.count()).toBe(1);
     expect(delayedFn2).not.toHaveBeenCalled();
     expect(delayedFn3).not.toHaveBeenCalled();
@@ -280,7 +312,7 @@ describe("Clock (acceptance)", function() {
   it("correctly schedules functions after the Clock has advanced", function() {
     var delayedFn1 = jasmine.createSpy('delayedFn1'),
       delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
-      clock = new j$.Clock({setTimeout: function(){}}, delayedFunctionScheduler);
+      clock = new j$.Clock({setTimeout: function() {}}, delayedFunctionScheduler);
 
     clock.install();
 
@@ -292,7 +324,25 @@ describe("Clock (acceptance)", function() {
     expect(delayedFn1).toHaveBeenCalled();
   });
 
-  it("calls the global clearTimeout correctly when not installed", function () {
+  it("correctly schedules functions while the Clock is advancing", function() {
+    var delayedFn1 = jasmine.createSpy('delayedFn1'),
+        delayedFn2 = jasmine.createSpy('delayedFn2'),
+        delayedFunctionScheduler = new j$.DelayedFunctionScheduler(),
+        clock = new j$.Clock({setTimeout: function() {}}, delayedFunctionScheduler);
+
+    delayedFn1.and.callFake(function() { clock.setTimeout(delayedFn2, 0); });
+    clock.install();
+    clock.setTimeout(delayedFn1, 5);
+
+    clock.tick(5);
+    expect(delayedFn1).toHaveBeenCalled();
+    expect(delayedFn2).not.toHaveBeenCalled();
+
+    clock.tick();
+    expect(delayedFn2).toHaveBeenCalled();
+  });
+
+  it("calls the global clearTimeout correctly when not installed", function() {
     var delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['clearTimeout']),
       global = jasmine.getGlobal(),
       clock = new j$.Clock(global, delayedFunctionScheduler);
@@ -302,7 +352,7 @@ describe("Clock (acceptance)", function() {
     }).not.toThrow();
   });
 
-  it("calls the global clearTimeout correctly when not installed", function () {
+  it("calls the global clearTimeout correctly when not installed", function() {
     var delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['clearTimeout']),
       global = jasmine.getGlobal(),
       clock = new j$.Clock(global, delayedFunctionScheduler);