.done((payload, textStatus, jqXHR) => {
          const response = this.handleResponse(
            jqXHR.status,
            parseResponseHeaders(jqXHR.getAllResponseHeaders()),
            payload,
            requestData
          );

          if (isAjaxError(response)) {
            const rejectionParam: RawErrorResponse = {
              payload,
              textStatus,
              jqXHR,
              response
            };
            run.join(null, reject, rejectionParam);
          } else {
            const resolutionParam: RawResponse = {
              payload,
              textStatus,
              jqXHR,
              response
            };
            run.join(null, resolve, resolutionParam);
          }
        })

function testThrottle() {
    function runIt() {
    }

    const myContext = { name: 'throttle' };

    run.throttle(runIt, 150);
    run.throttle(myContext, runIt, 150);
}

function testNext() {
    const myContext = {};
    run.next(myContext, () => {
        // code to be executed in the next run loop,
        // which will be scheduled after the current one
    });
}

 run(() => {
     // creates a new run-loop
     run.join(() => {
         // joins with the existing run-loop, and queues for invocation on
         // the existing run-loops action queue.
     });
 });

function testJoin() {
    run.join(() => {
        // creates a new run-loop
    });

    run(() => {
        // creates a new run-loop
        run.join(() => {
            // joins with the existing run-loop, and queues for invocation on
            // the existing run-loops action queue.
        });
    });

    run.later(() => {
        console.log({ msg: 'Hold Your Horses' });
    }, 3000);
}

function testOnce() {
    EmberObject.extend({
        init() {
            run.once(this, 'processFullName');
        },

        processFullName() {
        }
    });
}

function testSchedule() {
    EmberObject.extend({
        init() {
            run.schedule('sync', this, () => {
                // this will be executed in the first RunLoop queue, when bindings are synced
                console.log('scheduled on sync queue');
            });

            run.schedule('actions', this, () => {
                // this will be executed in the 'actions' queue, after bindings have synced.
                console.log('scheduled on actions queue');
            });
        }
    });

    run.schedule('actions', () => {
        // Do more things
    });
}

  cancelDestroy() {
    assert(
      `You cannot cancel the destruction of an InternalModel once it has already been destroyed`,
      !this.isDestroyed
    );

    this._doNotDestroy = true;
    this._isDematerializing = false;
    run.cancel(this._scheduledDestroy);
    this._scheduledDestroy = null;
  }

function testDebounce() {
    function runIt() {
    }

    const myContext = { name: 'debounce' };

    run.debounce(runIt, 150);
    run.debounce(myContext, runIt, 150);
    run.debounce(myContext, runIt, 150, true);

    EmberObject.extend({
        searchValue: 'test',
        fetchResults(value: string) {},

        actions: {
            handleTyping() {
                // the fetchResults function is passed into the component from its parent
                run.debounce(this, this.get('fetchResults'), this.get('searchValue'), 250);
            }
        }
    });
}

function testBind() {
    EmberObject.extend({
        init() {
            const bound = run.bind(this, this.setupEditor);
            bound();
        },

        editor: null as string | null,

        setupEditor(editor: string) {
            this.set('editor', editor);
        }
    });
}