let bar = () => {
    assert.ok(true, 'bar called');
    let timer = foo();
    bb.cancel(timer);

    setTimeout(done, 10);
  };

  bb.run(() => {
    let timer = bb.scheduleOnce('one', () => functionWasCalled = true);

    assert.ok(timer, 'Timer object was returned');
    assert.ok(bb.cancel(timer), 'Cancel returned true');
    assert.ok(!functionWasCalled, 'function was not called');
  });

QUnit.test('setTimeout and creating a new later', function(assert) {
  assert.expect(7);
  let done = assert.async();
  let called = false;
  let bb = new Backburner(['one'], {
    onBegin() {
      called = true;
    }
  });
  let function1WasCalled = false;
  let function2WasCalled = false;

  let timer1 = bb.later(() => function1WasCalled = true, 0);

  assert.ok(timer1, 'Timer object 2 was returned');
  assert.ok(bb.cancel(timer1), 'Cancel for timer 1 returned true');

  let timer2 = bb.later(() => function2WasCalled = true, 1);

  assert.ok(timer2, 'Timer object 2 was returned');
  assert.ok(!called, 'onBegin was not called');

  setTimeout(() => {
    assert.ok(!function1WasCalled, 'function 1 was not called');
    assert.ok(function2WasCalled, 'function 2 was called');
    assert.ok(called, 'onBegin was called');
    done();
  }, 50);
});

QUnit.test('properly cancel items which are added during flush', function(assert) {
  let bb = new Backburner(['zomg'], {
    // This is just a place holder for now, but somehow the system needs to
    // know to when to stop
    mustYield() {
      return true; // yield after each step, for now.
    },

    _buildPlatform: buildFakePlatform
  });

  let fooCalled = 0;
  let barCalled = 0;

  let obj1 = {
    foo() {
      fooCalled++;
    }
  };

  let obj2 = {
    bar() {
      barCalled++;
    }
  };

  bb.scheduleOnce('zomg', obj1, 'foo');
  bb.scheduleOnce('zomg', obj1, 'foo');
  bb.scheduleOnce('zomg', obj2, 'bar');
  bb.scheduleOnce('zomg', obj2, 'bar');

  platform.flushSync();

  let timer1 = bb.scheduleOnce('zomg', obj1, 'foo');
  let timer2 = bb.scheduleOnce('zomg', obj2, 'bar');
  bb.cancel(timer1);
  bb.cancel(timer2);

  platform.flushSync();
  platform.flushSync();
  platform.flushSync();

  assert.equal(fooCalled, 1, 'fooCalled');
  assert.equal(barCalled, 1, 'barCalled');

});

  setTimeout(() => { // 10 millisecond delay
    assert.equal(1, calledCount, 'debounced method was called');
    assert.ok(bb.cancel(timer), 'debounced delay was cancelled');
    bb.debounce(null, debouncee, 1000, true);

    setTimeout(() => { // 10 millisecond delay
      assert.equal(2, calledCount, 'debounced method was called again immediately');
      done();
    }, 10);
  }, 10);

  setTimeout(() => {
    assert.ok(!wasCalled, 'attempt to call throttle again didn\'t happen');

    throttle = bb.throttle(null, throttler, 40);
    assert.ok(wasCalled, 'newly inserted throttle after timeout functioned');

    assert.ok(bb.cancel(throttle), 'wait time of throttle was cancelled');

    wasCalled = false;
    throttle2 = bb.throttle(null, throttler, 40);
    assert.notEqual(throttle, throttle2, 'the throttle is different');
    assert.ok(wasCalled, 'throttle was inserted and run immediately after cancel');
    done();
  }, 60);

QUnit.test('throttle returns timer information usable for cancelling', function(assert) {
  assert.expect(3);

  let done = assert.async();
  let bb = new Backburner(['batman']);
  let wasCalled = false;

  function throttler() {
    assert.ok(false, 'this method shouldn\'t be called');
    wasCalled = true;
  }

  let timer = bb.throttle(null, throttler, 1, false);

  assert.ok(bb.cancel(timer), 'the timer is cancelled');

  // should return false second time around
  assert.ok(!bb.cancel(timer), 'the timer no longer exists in the list');

  setTimeout(() => {
    assert.ok(!wasCalled, 'the timer wasn\'t called after waiting');
    done();
  }, 60);
});

  bb.schedule('ohai', null, () => {
    assert.ok(!bb.hasTimers(), 'Initially there are no timers');

    timer = bb.later('ohai', () => {});
    assert.ok(bb.hasTimers(), 'hasTimers checks timers');

    bb.cancel(timer);

    assert.ok(!bb.hasTimers(), 'Timers are cleared');

    timer = bb.debounce(target, 'fn', 200);
    assert.ok(bb.hasTimers(), 'hasTimers checks debouncees');

    bb.cancel(timer);
    assert.ok(!bb.hasTimers(), 'Timers are cleared');

    timer = bb.throttle(target, 'fn', 200);
    assert.ok(bb.hasTimers(), 'hasTimers checks throttlers');

    bb.cancel(timer);
    assert.ok(!bb.hasTimers(), 'Timers are cleared');

    done();
  });

QUnit.test('boundRunExpiredTimers is called once when first timer canceled', function(assert) {
  let done = assert.async(1);

  let bb = new Backburner(['one']);

  let timer = bb.later(function() {}, 500);
  bb.cancel(timer);

  let boundRunExpiredTimers = bb['_boundRunExpiredTimers'];
  bb['_boundRunExpiredTimers'] = function() {
    assert.ok(true);
    done();
    return boundRunExpiredTimers.apply(bb, arguments);
  };

  bb.later(function() {}, 800);
});