function testThrottle() {
    function runIt() {
    }

    const myContext = { name: 'throttle' };

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

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

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

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

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

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

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

        processFullName() {
        }
    });
}

function testDebounce() {
    function runIt() {
    }

    const myContext = { name: 'debounce' };

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

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

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

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

        editor: null as string | null,

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

function testScheduleOnce() {
    function sayHi() {
        console.log('hi');
    }

    const myContext = {};
    Ember.run(() => {
        Ember.run.scheduleOnce('afterRender', myContext, sayHi);
        Ember.run.scheduleOnce('afterRender', myContext, sayHi);
        // sayHi will only be executed once, in the afterRender queue of the RunLoop
    });
    Ember.run.scheduleOnce('actions', myContext, () => {
        console.log('Closure');
    });
}

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

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

    new RSVP.Promise((resolve) => {
        Ember.run.later(() => {
            resolve({ msg: 'Hold Your Horses' });
        }, 3000);
    });
}

 promise.then(() => {
     Ember.run.schedule('afterRender', null, resolve);
     Ember.Test.adapter.asyncEnd();
 });