Re-add Mock Clock behavior as global 'clock'

- Use clock.install, clock.tick...
- Add unit coverage.
- Fixes old bug in function scheduler

spec/core/ClockSpec.js

@@ -0,0 +1,296 @@
+describe("Clock", function() {
+
+// TODO: fullName/SpecFilter is broken, so don't nest describes you want to filter
+
+  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 jasmine.Clock(global, delayedFunctionScheduler);
+
+    clock.setTimeout(delayedFn, 0);
+
+    expect(delayedFunctionScheduler.scheduleFunction).not.toHaveBeenCalled();
+    expect(setTimeout).toHaveBeenCalledWith(delayedFn, 0);
+  });
+
+  it("schedules the delayed function with the fake timer", function() {
+    var setTimeout = jasmine.createSpy('setTimeout'),
+      scheduleFunction = jasmine.createSpy('scheduleFunction'),
+      delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
+      global = { setTimeout: setTimeout },
+      delayedFn = jasmine.createSpy('delayedFn'),
+      clock = new jasmine.Clock(global, delayedFunctionScheduler);
+
+    clock.install();
+    clock.setTimeout(delayedFn, 0, 'a', 'b');
+
+    expect(setTimeout).not.toHaveBeenCalled();
+    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(delayedFn, 0, ['a', 'b']);
+  });
+
+  it("returns an id for the delayed function", function() {
+    var setTimeout = jasmine.createSpy('setTimeout'),
+      scheduleId = 123,
+      scheduleFunction = jasmine.createSpy('scheduleFunction').andReturn(scheduleId),
+      delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
+      global = { setTimeout: setTimeout },
+      delayedFn = jasmine.createSpy('delayedFn'),
+      clock = new jasmine.Clock(global, delayedFunctionScheduler),
+      timeoutId;
+
+    clock.install();
+    timeoutId = clock.setTimeout(delayedFn, 0);
+
+    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 jasmine.Clock(global, delayedFunctionScheduler);
+
+    clock.clearTimeout(123);
+
+    expect(clearTimeout).toHaveBeenCalledWith(123);
+  });
+
+  it("clears the scheduled function with the scheduler", function() {
+    var clearTimeout = jasmine.createSpy('clearTimeout'),
+      delayedFunctionScheduler = jasmine.createSpyObj('delayedFunctionScheduler', ['removeFunctionWithId']),
+      global = { setTimeout: clearTimeout },
+      delayedFn = jasmine.createSpy('delayedFn'),
+      clock = new jasmine.Clock(global, delayedFunctionScheduler);
+
+    clock.install();
+    clock.clearTimeout(123);
+
+    expect(clearTimeout).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 jasmine.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'),
+      scheduleFunction = jasmine.createSpy('scheduleFunction'),
+      delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
+      global = { setInterval: setInterval },
+      delayedFn = jasmine.createSpy('delayedFn'),
+      clock = new jasmine.Clock(global, delayedFunctionScheduler);
+
+    clock.install();
+    clock.setInterval(delayedFn, 0, 'a', 'b');
+
+    expect(setInterval).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'),
+      scheduleId = 123,
+      scheduleFunction = jasmine.createSpy('scheduleFunction').andReturn(scheduleId),
+      delayedFunctionScheduler = {scheduleFunction: scheduleFunction},
+      global = { setInterval: setInterval },
+      delayedFn = jasmine.createSpy('delayedFn'),
+      clock = new jasmine.Clock(global, delayedFunctionScheduler),
+      intervalId;
+
+    clock.install();
+    intervalId = clock.setInterval(delayedFn, 0);
+
+    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 jasmine.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 },
+      delayedFn = jasmine.createSpy('delayedFn'),
+      clock = new jasmine.Clock(global, delayedFunctionScheduler);
+
+    clock.install();
+    clock.clearInterval(123);
+
+    expect(clearInterval).not.toHaveBeenCalled();
+    expect(delayedFunctionScheduler.removeFunctionWithId).toHaveBeenCalledWith(123);
+  });
+
+  it("gives you a friendly reminder if the Clock is not installed and you tick", function() {
+    var clock = new jasmine.Clock({}, jasmine.createSpyObj('delayedFunctionScheduler', ['tick']));
+    expect(function() {
+      clock.tick(50);
+    }).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 jasmine.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 jasmine.Clock(global, delayedFunctionScheduler);
+
+    setTimeout.apply = null;
+    setInterval.apply = null;
+
+    clock.install();
+
+    clock.setTimeout(fn, 0);
+    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, []);
+    expect(function() {
+      clock.setTimeout(fn, 0, 'extra');
+    }).toThrow();
+
+    clock.setInterval(fn, 0);
+    expect(delayedFunctionScheduler.scheduleFunction).toHaveBeenCalledWith(fn, 0, [], true);
+    expect(function() {
+      clock.setInterval(fn, 0, 'extra');
+    }).toThrow();
+  });
+
+});
+
+describe("Clock (acceptance)", function() {
+  it("can run setTimeouts/setIntervals synchronously", function() {
+    var delayedFn1 = jasmine.createSpy('delayedFn1'),
+      delayedFn2 = jasmine.createSpy('delayedFn2'),
+      delayedFn3 = jasmine.createSpy('delayedFn3'),
+      recurring1 = jasmine.createSpy('recurring1'),
+      delayedFunctionScheduler = new jasmine.DelayedFunctionScheduler(),
+      clock = new jasmine.Clock({setTimeout: setTimeout}, delayedFunctionScheduler);
+
+    clock.install();
+
+    clock.setTimeout(delayedFn1, 0, 'some', 'arg');
+    var intervalId = clock.setInterval(recurring1, 50, 'some', 'other', 'args');
+    clock.setTimeout(delayedFn2, 100);
+    clock.setTimeout(delayedFn3, 200);
+
+    expect(delayedFn1).not.toHaveBeenCalled();
+    expect(delayedFn2).not.toHaveBeenCalled();
+    expect(delayedFn3).not.toHaveBeenCalled();
+
+    clock.tick(0);
+
+    expect(delayedFn1).toHaveBeenCalledWith('some', 'arg');
+    expect(delayedFn2).not.toHaveBeenCalled();
+    expect(delayedFn3).not.toHaveBeenCalled();
+
+    clock.tick(50);
+
+    expect(recurring1).toHaveBeenCalledWith('some', 'other', 'args');
+    expect(recurring1.callCount).toBe(1);
+    expect(delayedFn2).not.toHaveBeenCalled();
+    expect(delayedFn3).not.toHaveBeenCalled();
+
+    clock.tick(50);
+
+    expect(recurring1.callCount).toBe(2);
+    expect(delayedFn2).toHaveBeenCalled();
+    expect(delayedFn3).not.toHaveBeenCalled();
+
+    clock.tick(100);
+
+    expect(recurring1.callCount).toBe(4);
+    expect(delayedFn3).toHaveBeenCalled();
+
+    clock.clearInterval(intervalId);
+    clock.tick(50);
+
+    expect(recurring1.callCount).toBe(4);
+  });
+
+  it("can clear a previously set timeout", function() {
+    var clearedFn = jasmine.createSpy('clearedFn'),
+      delayedFunctionScheduler = new jasmine.DelayedFunctionScheduler(),
+      clock = new jasmine.Clock({setTimeout: function() {}}, delayedFunctionScheduler),
+      timeoutId;
+
+    clock.install();
+
+    timeoutId = clock.setTimeout(clearedFn, 100);
+    expect(clearedFn).not.toHaveBeenCalled();
+
+    clock.clearTimeout(timeoutId);
+    clock.tick(100);
+
+    expect(clearedFn).not.toHaveBeenCalled();
+  });
+
+  it("correctly schedules functions after the Clock has advanced", function() {
+    var delayedFn1 = jasmine.createSpy('delayedFn1'),
+      delayedFunctionScheduler = new jasmine.DelayedFunctionScheduler(),
+      clock = new jasmine.Clock({setTimeout: function(){}}, delayedFunctionScheduler);
+
+    clock.install();
+
+    clock.tick(100);
+    clock.setTimeout(delayedFn1, 10, ['some', 'arg']);
+    clock.tick(5);
+    expect(delayedFn1).not.toHaveBeenCalled();
+    clock.tick(5);
+    expect(delayedFn1).toHaveBeenCalled();
+  });
+});

spec/core/DelayedFunctionSchedulerSpec.js

@@ -0,0 +1,142 @@
+describe("DelayedFunctionScheduler", function() {
+  it("schedules a function for later execution", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn');
+
+    scheduler.scheduleFunction(fn, 0);
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.tick(0);
+
+    expect(fn).toHaveBeenCalled();
+  });
+
+  it("optionally passes params to scheduled functions", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn');
+
+    scheduler.scheduleFunction(fn, 0, ['foo', 'bar']);
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.tick(0);
+
+    expect(fn).toHaveBeenCalledWith('foo', 'bar');
+  });
+
+  it("scheduled fns can optionally reoccur", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn');
+
+    scheduler.scheduleFunction(fn, 20, [], true);
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.tick(20);
+
+    expect(fn.callCount).toBe(1);
+
+    scheduler.tick(40);
+
+    expect(fn.callCount).toBe(3);
+
+    scheduler.tick(21);
+
+    expect(fn.callCount).toBe(4);
+
+  });
+
+  it("increments scheduled fns ids unless one is passed", function() {
+    var scheduler = new jasmine.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);
+  });
+
+  it("#removeFunctionWithId removes a previously scheduled function with a given id", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn'),
+      timeoutKey;
+
+    timeoutKey = scheduler.scheduleFunction(fn, 0);
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.removeFunctionWithId(timeoutKey);
+
+    scheduler.tick(0);
+
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it("reset removes scheduled functions", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn');
+
+    scheduler.scheduleFunction(fn, 0);
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.reset();
+
+    scheduler.tick(0);
+
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it("reset resets the returned ids", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler();
+    expect(scheduler.scheduleFunction(function() { }, 0)).toBe(1);
+    expect(scheduler.scheduleFunction(function() { }, 0, [], false, 123)).toBe(123);
+
+    scheduler.reset();
+    expect(scheduler.scheduleFunction(function() { }, 0)).toBe(1);
+    expect(scheduler.scheduleFunction(function() { }, 0, [], false, 123)).toBe(123);
+  });
+
+  it("reset resets the current tick time", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn');
+
+    expect(fn).not.toHaveBeenCalled();
+
+    scheduler.tick(15);
+    scheduler.reset();
+
+    scheduler.scheduleFunction(fn, 20, [], false, 1, 20);
+
+    scheduler.tick(5);
+
+    expect(fn).not.toHaveBeenCalled();
+  });
+
+  it("executes recurring functions interleaved with regular functions in the correct order", function() {
+    var scheduler = new jasmine.DelayedFunctionScheduler(),
+      fn = jasmine.createSpy('fn'),
+      recurringCallCount = 0,
+      recurring = jasmine.createSpy('recurring').andCallFake(function() {
+        recurringCallCount++;
+        if (recurringCallCount < 5) {
+          expect(fn).not.toHaveBeenCalled();
+        }
+      });
+
+    scheduler.scheduleFunction(recurring, 10, [], true);
+    scheduler.scheduleFunction(fn, 50);
+
+    scheduler.tick(60);
+
+    expect(recurring).toHaveBeenCalled();
+    expect(recurring.callCount).toBe(6);
+    expect(fn).toHaveBeenCalled();
+  });
+
+});
+

spec/core/EnvSpec.js

@@ -157,3 +157,33 @@ describe("jasmine.Env", function() {
     });
   });
 });
+
+describe("jasmine Env", function() {
+
+  it("Mock clock can be installed and used in tests", function() {
+    var setTimeout = jasmine.createSpy('setTimeout'),
+    globalTimeoutFn = jasmine.createSpy('globalTimeoutFn'),
+    fakeTimeoutFn = jasmine.createSpy('fakeTimeoutFn'),
+    env = new jasmine.Env({global: { setTimeout: setTimeout }});
+
+    env.describe("tests", function() {
+      env.it("test with mock clock", function() {
+        env.clock.install();
+        env.clock.setTimeout(fakeTimeoutFn, 100);
+        env.clock.tick(100);
+      });
+      env.it("test without mock clock", function() {
+        env.clock.setTimeout(globalTimeoutFn, 100);
+      });
+    });
+
+    expect(setTimeout).not.toHaveBeenCalled();
+    expect(fakeTimeoutFn).not.toHaveBeenCalled();
+
+    env.execute();
+
+    expect(fakeTimeoutFn).toHaveBeenCalled();
+    expect(setTimeout).toHaveBeenCalledWith(globalTimeoutFn, 100);
+  });
+
+});

spec/core/MockClockSpec.js

@@ -1,40 +0,0 @@
-//// TODO: Disabling b/c this spec isn't testing what it thinks it is.
-////   Make a proper unit and intergration tests for this object
-//describe("MockClock", function () {
-//
-//  beforeEach(function() {
-//    jasmine.Clock.useMock();
-//  });
-//
-//  describe("setTimeout", function () {
-//    it("should mock the clock when useMock is in a beforeEach", function() {
-//      var expected = false;
-//      setTimeout(function() {
-//        expected = true;
-//      }, 30000);
-//      expect(expected).toBe(false);
-//      jasmine.Clock.tick(30001);
-//      expect(expected).toBe(true);
-//    });
-//  });
-//
-//  describe("setInterval", function () {
-//    it("should mock the clock when useMock is in a beforeEach", function() {
-//      var interval = 0;
-//      setInterval(function() {
-//        interval++;
-//      }, 30000);
-//      expect(interval).toEqual(0);
-//      jasmine.Clock.tick(30001);
-//      expect(interval).toEqual(1);
-//      jasmine.Clock.tick(30001);
-//      expect(interval).toEqual(2);
-//      jasmine.Clock.tick(1);
-//      expect(interval).toEqual(2);
-//    });
-//  });
-//
-//  it("shouldn't complain if you call jasmine.Clock.useMock() more than once", function() {
-//    jasmine.Clock.useMock();
-//  });
-//});

spec/core/RunnerSpec.js

@@ -5,12 +5,6 @@ describe('RunnerTest', function() {
   beforeEach(function() {
     env = new jasmine.Env();
     env.updateInterval = 0;
-
-    fakeTimer = new jasmine.FakeTimer();
-    env.setTimeout = fakeTimer.setTimeout;
-    env.clearTimeout = fakeTimer.clearTimeout;
-    env.setInterval = fakeTimer.setInterval;
-    env.clearInterval = fakeTimer.clearInterval;
   });
 
   describe('beforeEach', function() {

spec/core/SpecRunningSpec.js

@@ -5,12 +5,6 @@ describe("jasmine spec running", function () {
   beforeEach(function() {
     env = new jasmine.Env();
     env.updateInterval = 0;
-
-    fakeTimer = new originalJasmine.FakeTimer();
-    env.setTimeout = fakeTimer.setTimeout;
-    env.clearTimeout = fakeTimer.clearTimeout;
-    env.setInterval = fakeTimer.setInterval;
-    env.clearInterval = fakeTimer.clearInterval;
   });
 
   it('should assign spec ids sequentially', function() {

spec/core/SuiteSpec.js

@@ -1,16 +1,9 @@
 describe('Suite', function() {
-  var fakeTimer;
   var env;
 
   beforeEach(function() {
     env = new jasmine.Env();
     env.updateInterval = 0;
-
-    fakeTimer = new originalJasmine.FakeTimer();
-    env.setTimeout = fakeTimer.setTimeout;
-    env.clearTimeout = fakeTimer.clearTimeout;
-    env.setInterval = fakeTimer.setInterval;
-    env.clearInterval = fakeTimer.clearInterval;
   });
 
   describe('Specs', function () {
@@ -42,7 +35,7 @@ describe('Suite', function() {
         });
       });
     });
-    
+
     it('#specs should return all immediate children that are specs.', function () {
       var suiteSpecs = suite.specs();
       expect(suiteSpecs.length).toEqual(3);

spec/html/HTMLReporterSpec.js

@@ -71,12 +71,6 @@ describe("HtmlReporter", function() {
 
     var runner, spec, fakeTimer;
     beforeEach(function() {
-      fakeTimer = new jasmine.FakeTimer();
-      env.setTimeout = fakeTimer.setTimeout;
-      env.clearTimeout = fakeTimer.clearTimeout;
-      env.setInterval = fakeTimer.setInterval;
-      env.clearInterval = fakeTimer.clearInterval;
-      fakeDocument.location.search = "?";
       env.addReporter(htmlReporter);
     });
 
@@ -89,7 +83,6 @@ describe("HtmlReporter", function() {
         });
 
         env.execute();
-        fakeTimer.tick(0);
 
         var resultEl = getResultMessageDiv(body);
         expect(resultEl.innerHTML).toMatch(/foo/);

spec/jasmine.yml

@@ -11,7 +11,6 @@ src_files:
   - 'core/Env.js'
   - 'core/JsApiReporter.js'
   - 'core/Matchers.js'
-  - 'core/mock-timeout.js'
   - 'core/MultiReporter.js'
   - 'core/NestedResults.js'
   - 'core/PrettyPrinter.js'

spec/node_performance_suite.js

@@ -0,0 +1,176 @@
+var fs = require('fs');
+var util = require('util');
+var path = require('path');
+
+// yes, really keep this here to keep us honest, but only for jasmine's own runner! [xw]
+// undefined = "diz be undefined yo";
+
+
+var jasmineGlobals = require('../lib/jasmine-core/jasmine.js');
+for (var k in jasmineGlobals) {
+  global[k] = jasmineGlobals[k];
+}
+var env = jasmine.getEnv();
+
+var jasmineInterface = {
+  describe: function(description, specDefinitions) {
+    return env.describe(description, specDefinitions);
+  },
+
+  xdescribe: function(description, specDefinitions) {
+    return env.xdescribe(description, specDefinitions);
+  },
+
+  it: function(desc, func) {
+    return env.it(desc, func);
+  },
+
+  xit: function(desc, func) {
+    return env.xit(desc, func);
+  },
+
+  beforeEach: function(beforeEachFunction) {
+    return env.beforeEach(beforeEachFunction);
+  },
+
+  afterEach: function(afterEachFunction) {
+    return env.afterEach(afterEachFunction);
+  },
+
+  expect: function(actual) {
+    return env.expect(actual);
+  },
+
+  addMatchers: function(matchers) {
+    return env.addMatchers(matchers);
+  },
+
+  spyOn: function(obj, methodName) {
+    return env.spyOn(obj, methodName);
+  },
+
+
+  jsApiReporter: new jasmine.JsApiReporter(jasmine)
+};
+
+for (var k in jasmineInterface) {
+  global[k] = jasmineInterface[k];
+}
+
+require('../src/console/ConsoleReporter.js');
+
+/*
+ Pulling in code from jasmine-node.
+
+ We can't just depend on jasmine-node because it has its own jasmine that it uses.
+ */
+
+global.window = {
+  setTimeout: setTimeout,
+  clearTimeout: clearTimeout,
+  setInterval: setInterval,
+  clearInterval: clearInterval
+};
+
+delete global.window;
+
+function noop() {
+}
+
+jasmine.executeSpecs = function(specs, done, isVerbose, showColors) {
+  global.originalJasmine = jasmine;
+
+  for (var i = 0, len = specs.length; i < len; ++i) {
+    var filename = specs[i];
+    require(filename.replace(/\.\w+$/, ""));
+  }
+
+  var jasmineEnv = jasmine.getEnv();
+  var consoleReporter = new jasmine.ConsoleReporter(util.print, done, showColors);
+
+  jasmineEnv.addReporter(consoleReporter);
+  jasmineEnv.execute();
+};
+
+jasmine.getAllSpecFiles = function(dir, matcher) {
+  var specs = [];
+
+  if (fs.statSync(dir).isFile() && dir.match(matcher)) {
+    specs.push(dir);
+  } else {
+    var files = fs.readdirSync(dir);
+    for (var i = 0, len = files.length; i < len; ++i) {
+      var filename = dir + '/' + files[i];
+      if (fs.statSync(filename).isFile() && filename.match(matcher)) {
+        specs.push(filename);
+      } else if (fs.statSync(filename).isDirectory()) {
+        var subfiles = this.getAllSpecFiles(filename, matcher);
+        subfiles.forEach(function(result) {
+          specs.push(result);
+        });
+      }
+    }
+  }
+
+  return specs;
+};
+
+function now() {
+  return new Date().getTime();
+}
+
+jasmine.asyncSpecWait = function() {
+  var wait = jasmine.asyncSpecWait;
+  wait.start = now();
+  wait.done = false;
+  (function innerWait() {
+    waits(10);
+    runs(function() {
+      if (wait.start + wait.timeout < now()) {
+        expect('timeout waiting for spec').toBeNull();
+      } else if (wait.done) {
+        wait.done = false;
+      } else {
+        innerWait();
+      }
+    });
+  })();
+};
+jasmine.asyncSpecWait.timeout = 4 * 1000;
+jasmine.asyncSpecDone = function() {
+  jasmine.asyncSpecWait.done = true;
+};
+
+for (var key in jasmine) {
+  exports[key] = jasmine[key];
+}
+
+/*
+ End jasmine-node runner
+ */
+
+var isVerbose = false;
+var showColors = true;
+process.argv.forEach(function(arg) {
+  switch (arg) {
+    case '--color': showColors = true; break;
+    case '--noColor': showColors = false; break;
+    case '--verbose': isVerbose = true; break;
+  }
+});
+
+var specs = jasmine.getAllSpecFiles(__dirname + '/smoke/', new RegExp("test.js$"));
+var domIndependentSpecs = [];
+for (var i = 0; i < specs.length; i++) {
+  if (fs.readFileSync(specs[i], "utf8").indexOf("document.createElement") < 0) {
+    domIndependentSpecs.push(specs[i]);
+  }
+}
+
+jasmine.executeSpecs(domIndependentSpecs, function(passed) {
+  if (passed) {
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+}, isVerbose, showColors);

spec/runner.html

@@ -34,7 +34,8 @@
     <script type="text/javascript" src=".././spec/core/ExpectationResultSpec.js"></script>
     <script type="text/javascript" src=".././spec/core/JsApiReporterSpec.js"></script>
     <script type="text/javascript" src=".././spec/core/MatchersSpec.js"></script>
-    <script type="text/javascript" src=".././spec/core/MockClockSpec.js"></script>
+    <script type="text/javascript" src=".././spec/core/ClockSpec.js"></script>
+    <script type="text/javascript" src=".././spec/core/DelayedFunctionSchedulerSpec.js"></script>
     <script type="text/javascript" src=".././spec/core/MultiReporterSpec.js"></script>
     <script type="text/javascript" src=".././spec/core/NestedResultsSpec.js"></script>
     <script type="text/javascript" src=".././spec/core/PrettyPrintSpec.js"></script>