bb.run(() => {
    let timer = bb.scheduleOnce('action', fn);

    assert.equal(wasCalled, 0);

    bb.cancel(timer);
    bb.scheduleOnce('action', fn);

    assert.equal(wasCalled, 0);
  });

QUnit.test('We can use a custom next', function(assert) {
  assert.expect(1);
  let done = assert.async();

  let customNextWasUsed = false;
  let bb = new Backburner(['one'], {
    _buildPlatform(flush) {
      return {
        setTimeout() {
          throw new TypeError('NOT IMPLEMENTED');
        },
        clearTimeout(timer) {
          return clearTimeout(timer);
        },
        next() {
          // next is used for the autorun
          customNextWasUsed = true;
          return setTimeout(flush);
        },
        clearNext() { },
        now() { return Date.now(); },
        isFakePlatform: true
      };
    }
  });

  bb.scheduleOnce('one', () => {
    assert.ok(customNextWasUsed , 'custom later was used');
    done();
  });
});

 bb.run(() => {
   bb.scheduleOnce('one', {zomg: 'hi'}, function(a, b, c) {
     assert.equal(this.zomg, 'hi', 'the target was properly set');
     assert.equal(a, 1, 'the first arguments was passed in');
     assert.equal(b, 2, 'the second arguments was passed in');
     assert.equal(c, 3, 'the third arguments was passed in');
     functionWasCalled = true;
   }, 1, 2, 3);
 });

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');

});

 bb.run(() => {
   bb.scheduleOnce('errors', () => {
     throw new Error('QUnit.test error');
   });
 });

 bb.run(() => {
   bb.scheduleOnce('one', argObj, deferMethod, 1);
   bb.scheduleOnce('two', argObj, scheduleMethod);
 });

 function scheduleMethod() {
   bb.scheduleOnce('one', argObj, deferMethod, 2);
 }

 bb.run(() => {
   bb.scheduleOnce('one', () => {
     assert.ok(!functionWasCalled, 'function was not called');
     assert.ok(customClearTimeoutWasUsed, 'custom clearTimeout was used');
   });
 });