discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-glimmer/tests/unit/outlet-test.js

@@ -1,48 +0,0 @@
-import { OutletView } from 'ember-glimmer';
-import { run, schedule } from '@ember/runloop';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Glimmer OutletView',
-  class extends AbstractTestCase {
-    ['@test render in the render queue'](assert) {
-      let didAppendOutletView = 0;
-      let expectedOutlet = '#foo.bar';
-
-      let renderer = {
-        appendOutletView(view, target) {
-          didAppendOutletView++;
-          assert.equal(view, outletView);
-          assert.equal(target, expectedOutlet);
-        },
-      };
-
-      let outletView = new OutletView({}, renderer);
-
-      run(() => {
-        assert.equal(
-          didAppendOutletView,
-          0,
-          'appendOutletView should not yet have been called (before appendTo)'
-        );
-        outletView.appendTo(expectedOutlet);
-        assert.equal(
-          didAppendOutletView,
-          0,
-          'appendOutletView should not yet have been called (sync after appendTo)'
-        );
-
-        schedule('actions', () =>
-          assert.equal(
-            didAppendOutletView,
-            0,
-            'appendOutletView should not yet have been called (in actions)'
-          )
-        );
-        schedule('render', () =>
-          assert.equal(didAppendOutletView, 1, 'appendOutletView should be invoked in render')
-        );
-      });
-    }
-  }
-);

data/dist/es/ember-glimmer/tests/unit/runtime-resolver-cache-test.js

@@ -1,263 +0,0 @@
-import { RenderingTest, moduleFor } from '../utils/test-case';
-import { Component } from '../utils/helpers';
-import { set } from 'ember-metal';
-import { runDestroy, runAppend } from 'internal-test-helpers';
-
-moduleFor(
-  'ember-glimmer runtime resolver cache',
-  class extends RenderingTest {
-    '@test a helper definition is only generated once'(assert) {
-      this.registerHelper('foo-bar', () => 'foo-bar helper!');
-      this.registerHelper('baz-qux', () => 'baz-qux helper!');
-
-      // assert precondition
-      let state = this.getCacheCounters();
-      assert.deepEqual(
-        state,
-        {
-          templateCacheHits: 0,
-          templateCacheMisses: 0,
-          componentDefinitionCount: 0,
-          helperDefinitionCount: 0,
-        },
-        'precondition'
-      );
-
-      this.render(
-        `
-          {{~#if cond~}}
-            {{foo-bar}}
-          {{~else~}}
-            {{baz-qux}}
-          {{~/if}}`,
-        {
-          cond: true,
-        }
-      );
-
-      this.assertText('foo-bar helper!');
-      state = this.expectCacheChanges(
-        { helperDefinitionCount: 1 },
-        state,
-        'calculate foo-bar helper only'
-      );
-
-      // show component-two for the first time
-      this.runTask(() => set(this.context, 'cond', false));
-
-      this.assertText('baz-qux helper!');
-      state = this.expectCacheChanges(
-        {
-          helperDefinitionCount: 1,
-        },
-        state,
-        'calculate baz-qux helper, misses cache'
-      );
-
-      // show foo-bar again
-      this.runTask(() => set(this.context, 'cond', true));
-
-      this.assertText('foo-bar helper!');
-      state = this.expectCacheChanges({}, state, 'toggle back to foo-bar cache hit');
-
-      // show baz-qux again
-      this.runTask(() => set(this.context, 'cond', false));
-
-      this.assertText('baz-qux helper!');
-      state = this.expectCacheChanges({}, state, 'toggle back to baz-qux cache hit');
-    }
-
-    '@test a component definition is only generated once'(assert) {
-      // static layout
-      this.registerComponent('component-one', { template: 'One' });
-      this.registerComponent('component-two', {
-        ComponentClass: Component.extend(),
-        template: 'Two',
-      });
-
-      // assert precondition
-      let state = this.getCacheCounters();
-      assert.deepEqual(
-        state,
-        {
-          templateCacheHits: 0,
-          templateCacheMisses: 0,
-          componentDefinitionCount: 0,
-          helperDefinitionCount: 0,
-        },
-        'precondition'
-      );
-
-      // show component-one for the first time
-      this.render(`{{component componentName}}`, {
-        componentName: 'component-one',
-      });
-
-      this.assertText('One');
-      state = this.expectCacheChanges(
-        { componentDefinitionCount: 1 },
-        state,
-        'test case component and component-one no change'
-      );
-
-      // show component-two for the first time
-      this.runTask(() => set(this.context, 'componentName', 'component-two'));
-
-      this.assertText('Two');
-      state = this.expectCacheChanges(
-        { componentDefinitionCount: 1 },
-        state,
-        'component-two first render'
-      );
-
-      // show component-one again
-      this.runTask(() => set(this.context, 'componentName', 'component-one'));
-
-      this.assertText('One');
-      state = this.expectCacheChanges({}, state, 'toggle back to component-one no change');
-
-      // show component-two again
-      this.runTask(() => set(this.context, 'componentName', 'component-two'));
-
-      this.assertText('Two');
-      state = this.expectCacheChanges({}, state, 'toggle back to component-two no change');
-    }
-
-    ['@test each template is only compiled once'](assert) {
-      // static layout
-      this.registerComponent('component-one', { template: 'One' });
-
-      // test directly import template factory onto late bound layout
-      let Two = Component.extend({
-        layout: this.compile('Two'),
-      });
-      this.registerComponent('component-two', { ComponentClass: Two });
-
-      // inject layout onto component, share layout with component-one
-      this.registerComponent('root-component', { ComponentClass: Component });
-      this.owner.inject('component:root-component', 'layout', 'template:components/component-one');
-
-      // template instance shared between to template managers
-      let rootFactory = this.owner.factoryFor('component:root-component');
-
-      // assert precondition
-      let state = this.getCacheCounters();
-      assert.deepEqual(
-        state,
-        {
-          templateCacheHits: 0,
-          templateCacheMisses: 0,
-          componentDefinitionCount: 0,
-          helperDefinitionCount: 0,
-        },
-        'precondition'
-      );
-
-      // show component-one for the first time
-      this.render(
-        `
-    {{~#if cond~}}
-      {{component-one}}
-    {{~else~}}
-      {{component-two}}
-    {{~/if}}`,
-        {
-          cond: true,
-        }
-      );
-
-      this.assertText('One');
-      state = this.expectCacheChanges(
-        { componentDefinitionCount: 1 },
-        state,
-        'test case component and component-one no change'
-      );
-
-      // show component-two for the first time
-      this.runTask(() => set(this.context, 'cond', false));
-
-      this.assertText('Two');
-      state = this.expectCacheChanges(
-        {
-          templateCacheMisses: 1,
-          componentDefinitionCount: 1,
-        },
-        state,
-        'component-two first render misses template cache'
-      );
-
-      // show component-one again
-      this.runTask(() => set(this.context, 'cond', true));
-
-      this.assertText('One');
-      state = this.expectCacheChanges({}, state, 'toggle back to component-one no change');
-
-      // show component-two again
-      this.runTask(() => set(this.context, 'cond', false));
-
-      this.assertText('Two');
-      state = this.expectCacheChanges(
-        {
-          templateCacheHits: 1,
-        },
-        state,
-        'toggle back to component-two hits template cache'
-      );
-
-      // render new root append
-      let root = rootFactory.create();
-      try {
-        runAppend(root);
-        this.assertText('TwoOne');
-        // roots have different capabilities so this will hit
-        state = this.expectCacheChanges({}, state, 'append root with component-one no change');
-
-        // render new root append
-        let root2 = rootFactory.create();
-        try {
-          runAppend(root2);
-          this.assertText('TwoOneOne');
-          state = this.expectCacheChanges({}, state, 'append another root no change');
-        } finally {
-          runDestroy(root2);
-        }
-      } finally {
-        runDestroy(root);
-      }
-    }
-
-    getCacheCounters() {
-      let {
-        templateCacheHits,
-        templateCacheMisses,
-        componentDefinitionCount,
-        helperDefinitionCount,
-      } = this.runtimeResolver;
-
-      return {
-        templateCacheHits,
-        templateCacheMisses,
-        componentDefinitionCount,
-        helperDefinitionCount,
-      };
-    }
-
-    expectCacheChanges(expected, lastState, message) {
-      let state = this.getCacheCounters();
-      let actual = diff(state, lastState);
-      this.assert.deepEqual(actual, expected, message);
-      return state;
-    }
-  }
-);
-
-function diff(state, lastState) {
-  let res = {};
-  Object.keys(state).forEach(key => {
-    let delta = state[key] - lastState[key];
-    if (delta !== 0) {
-      res[key] = state[key] - lastState[key];
-    }
-  });
-  return res;
-}

data/dist/es/ember-glimmer/tests/unit/template-factory-test.js

@@ -1,67 +0,0 @@
-import { precompile, compile } from 'ember-template-compiler';
-import { template } from 'ember-glimmer';
-import { RenderingTest, moduleFor } from '../utils/test-case';
-import { Component } from '../utils/helpers';
-
-moduleFor(
-  'Template factory test',
-  class extends RenderingTest {
-    ['@test the template factory returned from precompile is the same as compile'](assert) {
-      let { owner } = this;
-      let { runtimeResolver } = this;
-
-      let templateStr = 'Hello {{name}}';
-      let options = { moduleName: 'my-app/templates/some-module.hbs' };
-
-      let spec = precompile(templateStr, options);
-      let body = `exports.default = template(${spec});`;
-      let module = new Function('exports', 'template', body);
-      let exports = {};
-      module(exports, template);
-      let Precompiled = exports['default'];
-
-      let Compiled = compile(templateStr, options);
-
-      assert.equal(typeof Precompiled.create, 'function', 'precompiled is a factory');
-      assert.ok(Precompiled.id, 'precompiled has id');
-
-      assert.equal(typeof Compiled.create, 'function', 'compiled is a factory');
-      assert.ok(Compiled.id, 'compiled has id');
-
-      assert.equal(runtimeResolver.templateCacheMisses, 0, 'misses 0');
-      assert.equal(runtimeResolver.templateCacheHits, 0, 'hits 0');
-
-      let precompiled = runtimeResolver.createTemplate(Precompiled, owner);
-
-      assert.equal(runtimeResolver.templateCacheMisses, 1, 'misses 1');
-      assert.equal(runtimeResolver.templateCacheHits, 0, 'hits 0');
-
-      let compiled = runtimeResolver.createTemplate(Compiled, owner);
-
-      assert.equal(runtimeResolver.templateCacheMisses, 2, 'misses 2');
-      assert.equal(runtimeResolver.templateCacheHits, 0, 'hits 0');
-
-      assert.ok(typeof precompiled.spec !== 'string', 'Spec has been parsed');
-      assert.ok(typeof compiled.spec !== 'string', 'Spec has been parsed');
-
-      this.registerComponent('x-precompiled', {
-        ComponentClass: Component.extend({
-          layout: Precompiled,
-        }),
-      });
-
-      this.registerComponent('x-compiled', {
-        ComponentClass: Component.extend({
-          layout: Compiled,
-        }),
-      });
-
-      this.render('{{x-precompiled name="precompiled"}} {{x-compiled name="compiled"}}');
-
-      assert.equal(runtimeResolver.templateCacheMisses, 2, 'misses 2');
-      assert.equal(runtimeResolver.templateCacheHits, 2, 'hits 2');
-
-      this.assertText('Hello precompiled Hello compiled');
-    }
-  }
-);

data/dist/es/ember-glimmer/tests/unit/utils/debug-stack-test.js

@@ -1,38 +0,0 @@
-import { DebugStack } from 'ember-glimmer';
-import { DEBUG } from '@glimmer/env';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Glimmer DebugStack',
-  class extends AbstractTestCase {
-    ['@test pushing and popping'](assert) {
-      if (DEBUG) {
-        let stack = new DebugStack();
-
-        assert.equal(stack.peek(), undefined);
-
-        stack.push('template:application');
-
-        assert.equal(stack.peek(), '"template:application"');
-
-        stack.push('component:top-level-component');
-
-        assert.equal(stack.peek(), '"component:top-level-component"');
-
-        stack.pushEngine('engine:my-engine');
-        stack.push('component:component-in-engine');
-
-        assert.equal(stack.peek(), '"component:component-in-engine" (in "engine:my-engine")');
-
-        stack.pop();
-        stack.pop();
-        let item = stack.pop();
-
-        assert.equal(item, 'component:top-level-component');
-        assert.equal(stack.peek(), '"template:application"');
-      } else {
-        assert.expect(0);
-      }
-    }
-  }
-);

data/dist/es/ember-glimmer/tests/utils/abstract-test-case.js

@@ -1 +0,0 @@
-export { AbstractTestCase as TestCase, applyMixins, strip } from 'internal-test-helpers';

data/dist/es/ember-glimmer/tests/utils/helpers.js

@@ -1,15 +0,0 @@
-export { compile, precompile } from 'ember-template-compiler';
-
-export {
-  INVOKE,
-  Helper,
-  helper,
-  Component,
-  LinkComponent,
-  InteractiveRenderer,
-  InertRenderer,
-  htmlSafe,
-  SafeString,
-  DOMChanges,
-  isHTMLSafe,
-} from 'ember-glimmer';

data/dist/es/ember-glimmer/tests/utils/shared-conditional-tests.js

@@ -1,965 +0,0 @@
-import { assign } from '@ember/polyfills';
-import { applyMixins } from './abstract-test-case';
-import { RenderingTest } from './test-case';
-import { get, set } from 'ember-metal';
-import {
-  Object as EmberObject,
-  ObjectProxy,
-  A as emberA,
-  ArrayProxy,
-  removeAt,
-} from 'ember-runtime';
-import { Component } from './helpers';
-
-class AbstractConditionalsTest extends RenderingTest {
-  get truthyValue() {
-    return true;
-  }
-
-  get falsyValue() {
-    return false;
-  }
-
-  wrapperFor(templates) {
-    return templates.join('');
-  }
-
-  wrappedTemplateFor(options) {
-    return this.wrapperFor([this.templateFor(options)]);
-  }
-
-  /* abstract */
-  templateFor(/* { cond, truthy, falsy } */) {
-    // e.g. `{{#if ${cond}}}${truthy}{{else}}${falsy}{{/if}}`
-    throw new Error('Not implemented: `templateFor`');
-  }
-
-  /* abstract */
-  renderValues(/* ...values */) {
-    throw new Error('Not implemented: `renderValues`');
-  }
-}
-
-class AbstractGenerator {
-  constructor(cases) {
-    this.cases = cases;
-  }
-
-  /* abstract */
-  generate(/* value, idx */) {
-    throw new Error('Not implemented: `generate`');
-  }
-}
-
-/*
-  The test cases in this file generally follow the following pattern:
-
-  1. Render with [ truthy, ...(other truthy variations), falsy, ...(other falsy variations) ]
-  2. No-op rerender
-  3. Make all of them falsy (through interior mutation)
-  4. Make all of them truthy (through interior mutation, sometimes with some slight variations)
-  5. Reset them to their original values (through replacement)
-*/
-
-export class TruthyGenerator extends AbstractGenerator {
-  generate(value, idx) {
-    return {
-      [`@test it should consider ${JSON.stringify(value)} truthy [${idx}]`]() {
-        this.renderValues(value);
-
-        this.assertText('T1');
-
-        this.runTask(() => this.rerender());
-
-        this.assertText('T1');
-
-        this.runTask(() => set(this.context, 'cond1', this.falsyValue));
-
-        this.assertText('F1');
-
-        this.runTask(() => set(this.context, 'cond1', value));
-
-        this.assertText('T1');
-      },
-    };
-  }
-}
-
-export class FalsyGenerator extends AbstractGenerator {
-  generate(value, idx) {
-    return {
-      [`@test it should consider ${JSON.stringify(value)} falsy [${idx}]`]() {
-        this.renderValues(value);
-
-        this.assertText('F1');
-
-        this.runTask(() => this.rerender());
-
-        this.assertText('F1');
-
-        this.runTask(() => set(this.context, 'cond1', this.truthyValue));
-
-        this.assertText('T1');
-
-        this.runTask(() => set(this.context, 'cond1', value));
-
-        this.assertText('F1');
-      },
-    };
-  }
-}
-
-export class StableTruthyGenerator extends TruthyGenerator {
-  generate(value, idx) {
-    return assign(super.generate(value, idx), {
-      [`@test it maintains DOM stability when condition changes from ${value} to another truthy value and back [${idx}]`]() {
-        this.renderValues(value);
-
-        this.assertText('T1');
-
-        this.takeSnapshot();
-
-        this.runTask(() => set(this.context, 'cond1', this.truthyValue));
-
-        this.assertText('T1');
-
-        this.assertInvariants();
-
-        this.runTask(() => set(this.context, 'cond1', value));
-
-        this.assertText('T1');
-
-        this.assertInvariants();
-      },
-    });
-  }
-}
-
-export class StableFalsyGenerator extends FalsyGenerator {
-  generate(value, idx) {
-    return assign(super.generate(value), {
-      [`@test it maintains DOM stability when condition changes from ${value} to another falsy value and back [${idx}]`]() {
-        this.renderValues(value);
-
-        this.assertText('F1');
-
-        this.takeSnapshot();
-
-        this.runTask(() => set(this.context, 'cond1', this.falsyValue));
-
-        this.assertText('F1');
-
-        this.assertInvariants();
-
-        this.runTask(() => set(this.context, 'cond1', value));
-
-        this.assertText('F1');
-
-        this.assertInvariants();
-      },
-    });
-  }
-}
-
-class ObjectProxyGenerator extends AbstractGenerator {
-  generate(value, idx) {
-    // This is inconsistent with our usual to-bool policy, but the current proxy implementation
-    // simply uses !!content to determine truthiness
-    if (value) {
-      return {
-        [`@test it should consider an object proxy with \`${JSON.stringify(
-          value
-        )}\` truthy [${idx}]`]() {
-          this.renderValues(ObjectProxy.create({ content: value }));
-
-          this.assertText('T1');
-
-          this.runTask(() => this.rerender());
-
-          this.assertText('T1');
-
-          this.runTask(() => set(this.context, 'cond1.content', this.falsyValue));
-
-          this.assertText('F1');
-
-          this.runTask(() => set(this.context, 'cond1', ObjectProxy.create({ content: value })));
-
-          this.assertText('T1');
-        },
-      };
-    } else {
-      return {
-        [`@test it should consider an object proxy with \`${JSON.stringify(
-          value
-        )}\` falsy [${idx}]`]() {
-          this.renderValues(ObjectProxy.create({ content: value }));
-
-          this.assertText('F1');
-
-          this.runTask(() => this.rerender());
-
-          this.assertText('F1');
-
-          this.runTask(() => set(this.context, 'cond1.content', this.truthyValue));
-
-          this.assertText('T1');
-
-          this.runTask(() => set(this.context, 'cond1', ObjectProxy.create({ content: value })));
-
-          this.assertText('F1');
-        },
-      };
-    }
-  }
-}
-
-// Testing behaviors shared across all conditionals, i.e. {{#if}}, {{#unless}},
-// {{#with}}, {{#each}}, {{#each-in}}, (if) and (unless)
-export class BasicConditionalsTest extends AbstractConditionalsTest {
-  ['@test it renders the corresponding block based on the conditional']() {
-    this.renderValues(this.truthyValue, this.falsyValue);
-
-    this.assertText('T1F2');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => set(this.context, 'cond1', this.falsyValue));
-
-    this.assertText('F1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.truthyValue);
-    });
-
-    this.assertText('T1T2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.falsyValue);
-    });
-
-    this.assertText('T1F2');
-  }
-}
-
-// Testing behaviors related to ember objects, object proxies, etc
-export const ObjectTestCases = {
-  ['@test it considers object proxies without content falsy']() {
-    this.renderValues(
-      ObjectProxy.create({ content: {} }),
-      ObjectProxy.create({ content: EmberObject.create() }),
-      ObjectProxy.create({ content: null })
-    );
-
-    this.assertText('T1T2F3');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1T2F3');
-
-    this.runTask(() => {
-      set(this.context, 'cond1.content', null);
-      set(this.context, 'cond2.content', null);
-    });
-
-    this.assertText('F1F2F3');
-
-    this.runTask(() => {
-      set(this.context, 'cond1.content', EmberObject.create());
-      set(this.context, 'cond2.content', {});
-      set(this.context, 'cond3.content', { foo: 'bar' });
-    });
-
-    this.assertText('T1T2T3');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', ObjectProxy.create({ content: {} }));
-      set(this.context, 'cond2', ObjectProxy.create({ content: EmberObject.create() }));
-      set(this.context, 'cond3', ObjectProxy.create({ content: null }));
-    });
-
-    this.assertText('T1T2F3');
-  },
-};
-
-// Testing behaviors related to arrays and array proxies
-export const ArrayTestCases = {
-  ['@test it considers empty arrays falsy']() {
-    this.renderValues(emberA(['hello']), emberA());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => removeAt(get(this.context, 'cond1'), 0));
-
-    this.assertText('F1F2');
-
-    this.runTask(() => {
-      get(this.context, 'cond1').pushObject('hello');
-      get(this.context, 'cond2').pushObjects([1]);
-    });
-
-    this.assertText('T1T2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', emberA(['hello']));
-      set(this.context, 'cond2', emberA());
-    });
-
-    this.assertText('T1F2');
-  },
-
-  ['@test it considers array proxies without content falsy']() {
-    this.renderValues(
-      ArrayProxy.create({ content: emberA(['hello']) }),
-      ArrayProxy.create({ content: null })
-    );
-
-    this.assertText('T1F2');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1.content', null);
-      set(this.context, 'cond2.content', null);
-    });
-
-    this.assertText('F1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1.content', emberA(['hello']));
-      set(this.context, 'cond2.content', emberA([1]));
-    });
-
-    this.assertText('T1T2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', ArrayProxy.create({ content: emberA(['hello']) }));
-      set(this.context, 'cond2', ArrayProxy.create({ content: null }));
-    });
-
-    this.assertText('T1F2');
-  },
-
-  ['@test it considers array proxies with empty arrays falsy']() {
-    this.renderValues(
-      ArrayProxy.create({ content: emberA(['hello']) }),
-      ArrayProxy.create({ content: emberA() })
-    );
-
-    this.assertText('T1F2');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => removeAt(get(this.context, 'cond1.content'), 0));
-
-    this.assertText('F1F2');
-
-    this.runTask(() => {
-      get(this.context, 'cond1.content').pushObject('hello');
-      get(this.context, 'cond2.content').pushObjects([1]);
-    });
-
-    this.assertText('T1T2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', ArrayProxy.create({ content: emberA(['hello']) }));
-      set(this.context, 'cond2', ArrayProxy.create({ content: emberA() }));
-    });
-
-    this.assertText('T1F2');
-  },
-};
-
-const IfUnlessWithTestCases = [
-  new StableTruthyGenerator([
-    true,
-    ' ',
-    'hello',
-    'false',
-    'null',
-    'undefined',
-    1,
-    ['hello'],
-    emberA(['hello']),
-    {},
-    { foo: 'bar' },
-    EmberObject.create(),
-    EmberObject.create({ foo: 'bar' }),
-    ObjectProxy.create({ content: true }),
-    Object,
-    function() {},
-    /*jshint -W053 */
-    new String('hello'),
-    new String(''),
-    new Boolean(true),
-    new Boolean(false),
-    /*jshint +W053 */
-    new Date(),
-  ]),
-
-  new StableFalsyGenerator([
-    false,
-    null,
-    undefined,
-    '',
-    0,
-    [],
-    emberA(),
-    ObjectProxy.create({ content: undefined }),
-  ]),
-
-  new ObjectProxyGenerator([
-    true,
-    ' ',
-    'hello',
-    'false',
-    'null',
-    'undefined',
-    1,
-    ['hello'],
-    emberA(['hello']),
-    ArrayProxy.create({ content: ['hello'] }),
-    ArrayProxy.create({ content: [] }),
-    {},
-    { foo: 'bar' },
-    EmberObject.create(),
-    EmberObject.create({ foo: 'bar' }),
-    ObjectProxy.create({ content: true }),
-    ObjectProxy.create({ content: undefined }),
-    /*jshint -W053 */
-    new String('hello'),
-    new String(''),
-    new Boolean(true),
-    new Boolean(false),
-    /*jshint +W053 */
-    new Date(),
-    false,
-    null,
-    undefined,
-    '',
-    0,
-    [],
-    emberA(),
-  ]),
-
-  ObjectTestCases,
-
-  ArrayTestCases,
-];
-
-// Testing behaviors shared across the "toggling" conditionals, i.e. {{#if}},
-// {{#unless}}, {{#with}}, {{#each}}, {{#each-in}}, (if) and (unless)
-export class TogglingConditionalsTest extends BasicConditionalsTest {}
-
-// Testing behaviors shared across the (if) and (unless) helpers
-export class TogglingHelperConditionalsTest extends TogglingConditionalsTest {
-  renderValues(...values) {
-    let templates = [];
-    let context = {};
-
-    for (let i = 1; i <= values.length; i++) {
-      templates.push(this.templateFor({ cond: `cond${i}`, truthy: `t${i}`, falsy: `f${i}` }));
-      context[`t${i}`] = `T${i}`;
-      context[`f${i}`] = `F${i}`;
-      context[`cond${i}`] = values[i - 1];
-    }
-
-    let wrappedTemplate = this.wrapperFor(templates);
-    this.render(wrappedTemplate, context);
-  }
-
-  ['@test it has access to the outer scope from both templates']() {
-    let template = this.wrapperFor([
-      this.templateFor({ cond: 'cond1', truthy: 'truthy', falsy: 'falsy' }),
-      this.templateFor({ cond: 'cond2', truthy: 'truthy', falsy: 'falsy' }),
-    ]);
-
-    this.render(template, {
-      cond1: this.truthyValue,
-      cond2: this.falsyValue,
-      truthy: 'YES',
-      falsy: 'NO',
-    });
-
-    this.assertText('YESNO');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('YESNO');
-
-    this.runTask(() => {
-      set(this.context, 'truthy', 'YASS');
-      set(this.context, 'falsy', 'NOPE');
-    });
-
-    this.assertText('YASSNOPE');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.falsyValue);
-      set(this.context, 'cond2', this.truthyValue);
-    });
-
-    this.assertText('NOPEYASS');
-
-    this.runTask(() => {
-      set(this.context, 'truthy', 'YES');
-      set(this.context, 'falsy', 'NO');
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.falsyValue);
-    });
-
-    this.assertText('YESNO');
-  }
-
-  ['@test it does not update when the unbound helper is used']() {
-    let template = this.wrapperFor([
-      this.templateFor({
-        cond: '(unbound cond1)',
-        truthy: '"T1"',
-        falsy: '"F1"',
-      }),
-      this.templateFor({
-        cond: '(unbound cond2)',
-        truthy: '"T2"',
-        falsy: '"F2"',
-      }),
-    ]);
-
-    this.render(template, { cond1: this.truthyValue, cond2: this.falsyValue });
-
-    this.assertText('T1F2');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => set(this.context, 'cond1', this.falsyValue));
-
-    this.assertText('T1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.truthyValue);
-    });
-
-    this.assertText('T1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.falsyValue);
-    });
-
-    this.assertText('T1F2');
-  }
-
-  ['@test evaluation should be lazy'](assert) {
-    let truthyEvaluated;
-    let falsyEvaluated;
-
-    let withoutEvaluatingTruthy = callback => {
-      truthyEvaluated = false;
-      callback();
-      assert.ok(!truthyEvaluated, 'x-truthy is not evaluated');
-    };
-
-    let withoutEvaluatingFalsy = callback => {
-      falsyEvaluated = false;
-      callback();
-      assert.ok(!falsyEvaluated, 'x-falsy is not evaluated');
-    };
-
-    this.registerHelper('x-truthy', {
-      compute() {
-        truthyEvaluated = true;
-        return 'T';
-      },
-    });
-
-    this.registerHelper('x-falsy', {
-      compute() {
-        falsyEvaluated = true;
-        return 'F';
-      },
-    });
-
-    let template = this.wrappedTemplateFor({
-      cond: 'cond',
-      truthy: '(x-truthy)',
-      falsy: '(x-falsy)',
-    });
-
-    withoutEvaluatingFalsy(() => this.render(template, { cond: this.truthyValue }));
-
-    this.assertText('T');
-
-    withoutEvaluatingFalsy(() => this.runTask(() => this.rerender()));
-
-    this.assertText('T');
-
-    withoutEvaluatingTruthy(() => this.runTask(() => set(this.context, 'cond', this.falsyValue)));
-
-    this.assertText('F');
-
-    withoutEvaluatingTruthy(() => this.runTask(() => this.rerender()));
-
-    this.assertText('F');
-
-    withoutEvaluatingFalsy(() => this.runTask(() => set(this.context, 'cond', this.truthyValue)));
-
-    this.assertText('T');
-  }
-}
-
-export class IfUnlessHelperTest extends TogglingHelperConditionalsTest {}
-
-applyMixins(IfUnlessHelperTest, ...IfUnlessWithTestCases);
-
-// Testing behaviors shared across the "toggling" syntatical constructs,
-// i.e. {{#if}}, {{#unless}}, {{#with}}, {{#each}} and {{#each-in}}
-export class TogglingSyntaxConditionalsTest extends TogglingConditionalsTest {
-  renderValues(...values) {
-    let templates = [];
-    let context = {};
-
-    for (let i = 1; i <= values.length; i++) {
-      templates.push(
-        this.templateFor({
-          cond: `cond${i}`,
-          truthy: `{{t}}${i}`,
-          falsy: `{{f}}${i}`,
-        })
-      );
-      context[`cond${i}`] = values[i - 1];
-    }
-
-    let wrappedTemplate = this.wrapperFor(templates);
-    this.render(wrappedTemplate, assign({ t: 'T', f: 'F' }, context));
-  }
-
-  ['@test it does not update when the unbound helper is used']() {
-    let template = `${this.templateFor({
-      cond: '(unbound cond1)',
-      truthy: 'T1',
-      falsy: 'F1',
-    })}${this.templateFor({
-      cond: '(unbound cond2)',
-      truthy: 'T2',
-      falsy: 'F2',
-    })}`;
-
-    this.render(template, { cond1: this.truthyValue, cond2: this.falsyValue });
-
-    this.assertText('T1F2');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T1F2');
-
-    this.runTask(() => set(this.context, 'cond1', this.falsyValue));
-
-    this.assertText('T1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.truthyValue);
-    });
-
-    this.assertText('T1F2');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.falsyValue);
-    });
-
-    this.assertText('T1F2');
-  }
-
-  ['@test it has access to the outer scope from both templates']() {
-    let template = this.wrapperFor([
-      this.templateFor({
-        cond: 'cond1',
-        truthy: '{{truthy}}',
-        falsy: '{{falsy}}',
-      }),
-      this.templateFor({
-        cond: 'cond2',
-        truthy: '{{truthy}}',
-        falsy: '{{falsy}}',
-      }),
-    ]);
-
-    this.render(template, {
-      cond1: this.truthyValue,
-      cond2: this.falsyValue,
-      truthy: 'YES',
-      falsy: 'NO',
-    });
-
-    this.assertText('YESNO');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('YESNO');
-
-    this.runTask(() => {
-      set(this.context, 'truthy', 'YASS');
-      set(this.context, 'falsy', 'NOPE');
-    });
-
-    this.assertText('YASSNOPE');
-
-    this.runTask(() => {
-      set(this.context, 'cond1', this.falsyValue);
-      set(this.context, 'cond2', this.truthyValue);
-    });
-
-    this.assertText('NOPEYASS');
-
-    this.runTask(() => {
-      set(this.context, 'truthy', 'YES');
-      set(this.context, 'falsy', 'NO');
-      set(this.context, 'cond1', this.truthyValue);
-      set(this.context, 'cond2', this.falsyValue);
-    });
-
-    this.assertText('YESNO');
-  }
-
-  ['@test it updates correctly when enclosing another conditional']() {
-    // This tests whether the outer conditional tracks its bounds correctly as its inner bounds changes
-    let inner = this.templateFor({
-      cond: 'inner',
-      truthy: 'T-inner',
-      falsy: 'F-inner',
-    });
-    let template = this.wrappedTemplateFor({
-      cond: 'outer',
-      truthy: inner,
-      falsy: 'F-outer',
-    });
-
-    this.render(template, { outer: this.truthyValue, inner: this.truthyValue });
-
-    this.assertText('T-inner');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('T-inner');
-
-    // Changes the inner bounds
-    this.runTask(() => set(this.context, 'inner', this.falsyValue));
-
-    this.assertText('F-inner');
-
-    // Now rerender the outer conditional, which require first clearing its bounds
-    this.runTask(() => set(this.context, 'outer', this.falsyValue));
-
-    this.assertText('F-outer');
-  }
-
-  ['@test it updates correctly when enclosing #each']() {
-    // This tests whether the outer conditional tracks its bounds correctly as its inner bounds changes
-    let template = this.wrappedTemplateFor({
-      cond: 'outer',
-      truthy: '{{#each inner as |text|}}{{text}}{{/each}}',
-      falsy: 'F-outer',
-    });
-
-    this.render(template, {
-      outer: this.truthyValue,
-      inner: ['inner', '-', 'before'],
-    });
-
-    this.assertText('inner-before');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('inner-before');
-
-    // Changes the inner bounds
-    this.runTask(() => set(this.context, 'inner', ['inner-after']));
-
-    this.assertText('inner-after');
-
-    // Now rerender the outer conditional, which require first clearing its bounds
-    this.runTask(() => set(this.context, 'outer', this.falsyValue));
-
-    this.assertText('F-outer');
-
-    // Reset
-    this.runTask(() => {
-      set(this.context, 'inner', ['inner-again']);
-      set(this.context, 'outer', this.truthyValue);
-    });
-
-    this.assertText('inner-again');
-
-    // Now clear the inner bounds
-    this.runTask(() => set(this.context, 'inner', []));
-
-    this.assertText('');
-
-    // Now rerender the outer conditional, which require first clearing its bounds
-    this.runTask(() => set(this.context, 'outer', this.falsyValue));
-
-    this.assertText('F-outer');
-  }
-
-  ['@test it updates correctly when enclosing triple-curlies']() {
-    // This tests whether the outer conditional tracks its bounds correctly as its inner bounds changes
-    let template = this.wrappedTemplateFor({
-      cond: 'outer',
-      truthy: '{{{inner}}}',
-      falsy: 'F-outer',
-    });
-
-    this.render(template, {
-      outer: this.truthyValue,
-      inner: '<b>inner</b>-<b>before</b>',
-    });
-
-    this.assertText('inner-before');
-
-    this.runTask(() => this.rerender());
-
-    this.assertText('inner-before');
-
-    // Changes the inner bounds
-    this.runTask(() => set(this.context, 'inner', '<p>inner-after</p>'));
-
-    this.assertText('inner-after');
-
-    // Now rerender the outer conditional, which require first clearing its bounds
-    this.runTask(() => set(this.context, 'outer', this.falsyValue));
-
-    this.assertText('F-outer');
-  }
-
-  ['@test child conditional should not render children if parent conditional becomes false'](
-    assert
-  ) {
-    let childCreated = false;
-
-    this.registerComponent('foo-bar', {
-      template: 'foo-bar',
-      ComponentClass: Component.extend({
-        init() {
-          this._super(...arguments);
-          childCreated = true;
-        },
-      }),
-    });
-
-    let innerTemplate = this.templateFor({
-      cond: 'cond2',
-      truthy: '{{foo-bar}}',
-      falsy: '',
-    });
-    let wrappedTemplate = this.wrappedTemplateFor({
-      cond: 'cond1',
-      truthy: innerTemplate,
-      falsy: '',
-    });
-
-    this.render(wrappedTemplate, {
-      cond1: this.truthyValue,
-      cond2: this.falsyValue,
-    });
-
-    assert.ok(!childCreated);
-    this.assertText('');
-
-    this.runTask(() => this.rerender());
-
-    assert.ok(!childCreated);
-    this.assertText('');
-
-    this.runTask(() => {
-      set(this.context, 'cond2', this.truthyValue);
-      set(this.context, 'cond1', this.falsyValue);
-    });
-
-    assert.ok(!childCreated);
-    this.assertText('');
-
-    this.runTask(() => {
-      set(this.context, 'cond2', this.falsyValue);
-      set(this.context, 'cond1', this.truthyValue);
-    });
-
-    assert.ok(!childCreated);
-    this.assertText('');
-  }
-
-  ['@test evaluation should be lazy'](assert) {
-    let truthyEvaluated;
-    let falsyEvaluated;
-
-    let withoutEvaluatingTruthy = callback => {
-      truthyEvaluated = false;
-      callback();
-      assert.ok(!truthyEvaluated, 'x-truthy is not evaluated');
-    };
-
-    let withoutEvaluatingFalsy = callback => {
-      falsyEvaluated = false;
-      callback();
-      assert.ok(!falsyEvaluated, 'x-falsy is not evaluated');
-    };
-
-    this.registerHelper('x-truthy', {
-      compute() {
-        truthyEvaluated = true;
-        return 'T';
-      },
-    });
-
-    this.registerHelper('x-falsy', {
-      compute() {
-        falsyEvaluated = true;
-        return 'F';
-      },
-    });
-
-    let template = this.wrappedTemplateFor({
-      cond: 'cond',
-      truthy: '{{x-truthy}}',
-      falsy: '{{x-falsy}}',
-    });
-
-    withoutEvaluatingFalsy(() => this.render(template, { cond: this.truthyValue }));
-
-    this.assertText('T');
-
-    withoutEvaluatingFalsy(() => this.runTask(() => this.rerender()));
-
-    this.assertText('T');
-
-    withoutEvaluatingTruthy(() => this.runTask(() => set(this.context, 'cond', this.falsyValue)));
-
-    this.assertText('F');
-
-    withoutEvaluatingTruthy(() => this.runTask(() => this.rerender()));
-
-    this.assertText('F');
-
-    withoutEvaluatingFalsy(() => this.runTask(() => set(this.context, 'cond', this.truthyValue)));
-
-    this.assertText('T');
-  }
-}
-
-export class IfUnlessWithSyntaxTest extends TogglingSyntaxConditionalsTest {}
-
-applyMixins(IfUnlessWithSyntaxTest, ...IfUnlessWithTestCases);