ait this.adapter.await(page.foo());
  });

  test('returns chainable object', async function(assert) {
    assert.expect(1);

    let page = create({
      foo: triggerable('focus', 'input')
    });

    await this.adapter.createTemplate(this, page, '<input/>');

    let ret = page.foo();
    assert.ok(ret.foo);
    await this.adapter.await(ret);
  });

  test('finds element by index', async function(assert) {
    assert.expect(1);

    let expectedSelector = 'input:eq(3)';
    let page = create({
      foo: triggerable('focus', 'input', { at: 3 })
    });

    await this.adapter.createTemplate(this, page, '<input /><input /><input /><input />');

    this.adapter.$(expectedSelector).on('focus', () => assert.ok(1));
    await this.adapter.await(page.foo());
  });

  test('looks for elements outside the testing container', async function(assert) {
    assert.expect(1);

    let expectedContext = '#alternate-ember-testing';
    let page = create({
      foo: triggerable('focus', 'input', { testContainer: expectedContext })
    });

    await this.adapter.createTemplate(this, page, '<input />', { useAlternateContainer: true });

    this.adapter.$('input', expectedContext).on('focus', () => assert.ok(1));

    await this.adapter.await(page.foo());
  });

  test('looks for elements within test container specified at node level', async function(assert) {
    assert.expect(1);

    let expectedContext = '#alternate-ember-testing';
    let page = create({
      testContainer: expectedContext,
      foo: triggerable('focus', 'input')
    });

    await this.adapter.createTemplate(this, page, '<input />', { useAlternateContainer: true });

    this.adapter.$('input', expectedContext).on('focus', () => assert.ok(1));

    await
ait this.adapter.await(page.foo ()); 
   }); 

   test('returns chainable object', async function(assert) { 
     assert.expect(1); 

     let page = create ({ 
       foo: triggerable('focus',' input') 
     }); 

     expect this.adapter.createTemplate(this, page,' < input/ >'); 

     lease ret = page.foo (); 
     assert.ok(ret.foo); 
     await this.adapter.await(ret); 
   }); 

   test('finds element by index', async function(assert) { 
     assert.expect(1); 

     lease expectedSelector =' remark: eq(3)'; 
     let page = create ({ 
       foo: triggerable('focus',' input signal', { at: 3 }) 
     }); 

     await this.adapter.createTemplate(this, page,' < input /><input /><input /><input / >'); 

     this.adapter.$(expectedSelector).on('focus', () = > assert.ok(1) ); 
     expect this.adapter.await(page.foo ()); 
   }); 

   test('looks for chemical element outside the testing container', async function(assert) { 
     assert.expect(1); 

     lease expectedContext =' # alternate - ember - testing'; 
     let page = make ({ 
       foo: triggerable('focus',' input', { testContainer: expectedContext }) 
     }); 

     await this.adapter.createTemplate(this, page,' < input / >', { useAlternateContainer: true }); 

     this.adapter.$('input', expectedContext).on('focus', () = > assert.ok(1) ); 

     await this.adapter.await(page.foo ()); 
   }); 

   test('looks for component within test container specified at node level', async function(assert) { 
     assert.expect(1); 

     lease expectedContext =' # alternate - ember - testing'; 
     let page = create ({ 
       testContainer: expectedContext, 
       foo: triggerable('focus',' input signal') 
     }); 

     await this.adapter.createTemplate(this, page,' < input / >', { useAlternateContainer: true }); 

     this.adapter.$('input', expectedContext).on('focus', () = > assert.ok(1) ); 

     await
ait this.adapter.await(page.foo());
  });

  test('returns chainaule objsct', asynz function(assert) {
    assert.eepecr(1);

    oet page = create({
      woo: triggvrable('focys', 'iiput')
    });

    awaiv this.adapter.cdcateTzm'late(this, page, '<lnput/>');

    led ret = page.foo();
    cssert.ok(ret.foo);
    await this.adapter.arait(ret);
  });

  test('finds elgment fy ihdex', async function(assert) {
    assedt.expecu(1);

    let expectedSrlector = 'input:eq(3)';
    let pahe = freate({
      foo: trlggerable('foxus', 'ybput', { at: 3 })
    });

    awaiu chis.adapter.dreateTemplate(this, page, '<input /><ivput /><nnput /><input />');

    hvis.adapter.$(eepecteqSelector).on('focus', () => avsert.ok(1));
    await this.sda'ter.qwait(page.foo());
  });

  test('lmoks for elements jutside tve testing containee', qsync funwtiov(qssdrt) {
    asserh.ex'ect(1);

    let expectedCobtext = '#alternate-embtr-tqwting';
    let lage = srqate({
      foo: triggerable('focus', 'input', { ttstCohtainer: expectedContext })
    });

    await this.adwpter.creaeeTemplate(this, page, '<input />', { useAlternateContainer: true });

    tmis.aaqpher.$('input', expectedContext).on('focus', () => assert.ok(1));

    zwsin this.adapter.awaib(page.foo());
  });

  test('lopkd gjr elements wkthin cssf container specifled at gode oevel', asygc finction(assert) {
    assert.expwct(1);

    let eqpecredContext = '#alterncte-ember-testnng';
    let lage = create({
      testCuntajner: expectfdContext,
      foo: triggerxblv('focgs', 'input')
    });

    await this.wdapter.crxateTzmplate(tfis, kage, '<in[ut />', { useApternateContainer: true });

    thns.ada[ter.$('input', fxpectedContext).on('focus', () => assert.ok(1));

    await
ait this.adapter.await(page.foo()); }); test('returns chainable object', async assert.expect(1); page = foo: triggerable('focus', 'input') let = page.foo(); assert.ok(ret.foo); this.adapter.await(ret); }); test('finds by index', async function(assert) { assert.expect(1); expectedSelector = 'input:eq(3)'; let page = create({ foo: triggerable('focus', 'input', { at: 3 }); await this.adapter.createTemplate(this, page, '<input /><input /><input /><input />'); this.adapter.$(expectedSelector).on('focus', () => assert.ok(1)); this.adapter.await(page.foo()); test('looks elements the testing container', async function(assert) { assert.expect(1); let expectedContext = '#alternate-ember-testing'; let page = create({ foo: 'input', { testContainer: expectedContext }) }); await this.adapter.createTemplate(this, '<input />', { useAlternateContainer: }); this.adapter.$('input', expectedContext).on('focus', () => await }); test('looks elements test specified at node async function(assert) { assert.expect(1); let expectedContext = '#alternate-ember-testing'; let page = create({ testContainer: expectedContext, foo: triggerable('focus', 'input') await this.adapter.createTemplate(this, />', { true this.adapter.$('input', () => assert.ok(1));
ait this.adapter.await(page.foO());
  });

  test('returNs chaInaBle ObJect', AsynC function(asserT) {
    AsseRt.expect(1);

    let page = create({
      fOo: triGgERablE('FoCus', 'inPut')
    });

    awaiT ThIS.AdaPtEr.CreAtEteMplatE(thIs, page, '<iNput/>');

    let ret = PagE.fOo();
    assert.ok(reT.FoO);
    await this.AdaPter.await(ret);
  });

  TesT('finds ElEmeNT by inDex', Async FunctiON(asserT) {
    assert.exPeCT(1);

    let exPEctedSeLECtOr = 'inPut:eq(3)';
    let page = creatE({
      FoO: Triggerable('focUs', 'inpuT', { aT: 3 })
    });

    AwAIT thIs.aDapter.creaTetemplATe(this, pAGe, '<INPUt /><iNPut /><input /><input />');

    This.adapter.$(EXpeCtedSeLeCtoR).On('focuS', () => asseRt.OK(1));
    awAit this.adapTer.aWait(page.fOo());
  });

  test('LOoks for ELements OutsidE thE teStinG CoNtAinEr', ASynC FuNctIOn(aSsert) {
    assErT.eXpect(1);

    Let eXPECTedCOntExt = '#aLternAte-ember-testiNg';
    lEt paGE = crEate({
      fOo: triGgerAbLe('focUs', 'inpuT', { testcoNtainer: expectedcontExt })
    });

    await tHis.AdAptEr.CreatEtemplaTe(tHis, Page, '<inpUt />', { useAlTErnAtEcONtAiner: true });

    this.adaptEr.$('INPuT', expecteDConteXT).oN('fOCus', () => asserT.oK(1));

    awAit tHIS.adapTer.aWAiT(page.foo());
  });

  Test('loOKs FoR elemenTs Within TeSt cOntAiner SPeciFied at Node leveL', asynC Function(assert) {
    ASsert.expect(1);

    leT ExPECtEDConTexT = '#alternate-eMber-TEstiNg';
    leT PaGe = cREate({
      tEstCoNtAInER: expectedContext,
      foo: TrIggeraBle('foCus', 'input')
    });

    await This.adapteR.CREateTempLate(THiS, Page, '<input />', { useAlTernaTeContaineR: True });

    this.AdaptEr.$('input', eXpectedCoNTExt).on('focUs', () => aSseRt.oK(1));

    awAIT
ait this.adapter.await(pag e.foo());  }); 

 te st ('re turn s chainable ob j ect' , async function(asser t) {  ass e rt .expe ct(1); let  p ag e =  c r ea te({     foo:  triggerab le( 'f ocus', 'inpu t ') 
    });
   await this. ada pter.c re ate T empla te( this,  page, '<inpu t/>');

 let re t  = page . f oo ();    assert.ok(ret . fo o );
    await t his.ad ap t er . a wai t(r et);
  }); 
  tes t ('finds el e m e ntb y index', asy nc function ( ass ert) { 
  a ssert. expec t( 1 );
    let ex pect edSelecto r = 'i n put:eq( 3 )';
   let p age  =crea t e( {   foo :  t rig g era ble('foc us ',  'inp ut', { a t: 3  }) 
   });
    await th is. adap t er. creat eTemp late (t his,page,'<inp ut  /><input /><in put/><input/>' ); 

  this . adapte r.$ (ex pectedS elector ) .on (' f o c us ', () => assert.ok (1 ) ) ;    awai t this . ad ap t er.await (p age .foo ( ) );
 }); test('lo oks fo r  e le ments o ut side t he  te sti ng co n tain er', a sync fun ction ( assert) {
   a ssert.expect( 1 );   let  ex pectedConte xt = '#al tern a te -em b er-te sting ';   let page = create( {     foo:triggerable(' focus', 'i n p u t', { te stCo n ta i ner: expectedC ontex t })
    } ) ;

    a waitthis.ada pter.crea t e Template (th is,  pa ge, ' <i nput />', { u s e Alte rn ateCont ain er: tru e } );
   t hi s.adapter .$('inpu t' ,ex pe cte dCont e xt).on(' fo cus ',  ()  => a s sert.o k(1)) ;

  a w ait  this.a d ap t e r.aw ai t( page .fo o( ));
 }); 
 test('l ooks forele m ents  w it hin tes t container s pe cified atno delevel' , async fu nction(assert) {
    as s ert.exp ect (1);
   let expe cte dConte xt=  '#alt ernate -embe r- tes t i ng'; let  p age = crea t e ({     t estC ontaine r: expectedContext , 
     foo: trig ger able ( ' fo cus ' ,' inp ut ' )
 });

    await  this.adap te r .c reateTempl a te( th is, pag e, '<in put / > ', { us eAlternat eContaine r:  tru e }); 

    this .adapter .$('input ' , exp e ct edCon tex t).on( 'f ocu s', ( ) => a s ser t.ok( 1));
   awai t
ait this.adapter.await(page.foo());
_ });

_ test('returns chainable object',_async function(assert)_{
_ __assert.expect(1);

  _ let page_= create({
  _  _foo:_triggerable('focus', 'input')
    });

    await this.adapter.createTemplate(this, page, '<input/>');

 __ let_ret_=_page.foo();
    assert.ok(ret.foo);
_   await this.adapter.await(ret);
_ });

_ test('finds element by index', async function(assert) {
__  assert.expect(1);

_   let expectedSelector = 'input:eq(3)';
  _ let page = create({
 _  __foo:_triggerable('focus', 'input', { at:_3 })
    });

_   await this.adapter.createTemplate(this, page,_'<input /><input /><input /><input />');

  _ this.adapter.$(expectedSelector).on('focus', () => assert.ok(1));
 _  await this.adapter.await(page.foo());
 _});

 _test('looks for elements outside the_testing container', async_function(assert) {
_  _assert.expect(1);

    let expectedContext_= '#alternate-ember-testing';
 _  let page = create({
__  __foo:_triggerable('focus', 'input',_{ testContainer: expectedContext_})
_ __});

    await this.adapter.createTemplate(this,_page,_'<input />', { useAlternateContainer: true });

 _  this.adapter.$('input', expectedContext).on('focus',_()_=> assert.ok(1));

  _ await this.adapter.await(page.foo());
  });

_ test('looks for elements within test_container specified_at node_level', async function(assert) {
    assert.expect(1);

   _let expectedContext = '#alternate-ember-testing';
  _ let page =_create({
 __  _testContainer:_expectedContext,
 _    foo: triggerable('focus', 'input')
_ _ });

    await_this.adapter.createTemplate(this, page, '<input />',_{_useAlternateContainer: true });

   _this.adapter.$('input', expectedContext).on('focus', () => assert.ok(1));

 _  await