'use strict';

define('ember-formulaic/tests/app.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | app');

  QUnit.test('adapters/application.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'adapters/application.js should pass ESLint\n\n');
  });

  QUnit.test('app.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'app.js should pass ESLint\n\n');
  });

  QUnit.test('components/base-sortable.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/base-sortable.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-checkbox-select-multiple.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-checkbox-select-multiple.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-checkbox.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-checkbox.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-email.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-email.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-full-name.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-full-name.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-hidden.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-hidden.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-integer.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-integer.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-phone-number.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-phone-number.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-radio-select.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-radio-select.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-select-multiple.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-select-multiple.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-select.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-select.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-text.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-text.js should pass ESLint\n\n');
  });

  QUnit.test('components/preview-textarea.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/preview-textarea.js should pass ESLint\n\n');
  });

  QUnit.test('components/rule-condition.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/rule-condition.js should pass ESLint\n\n');
  });

  QUnit.test('components/rule-result.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/rule-result.js should pass ESLint\n\n');
  });

  QUnit.test('components/sortable-field.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/sortable-field.js should pass ESLint\n\n');
  });

  QUnit.test('components/sortable-fields.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/sortable-fields.js should pass ESLint\n\n');
  });

  QUnit.test('components/sortable-rule.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/sortable-rule.js should pass ESLint\n\n');
  });

  QUnit.test('components/sortable-rules.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'components/sortable-rules.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields/basefield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields/basefield.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields/booleanfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields/booleanfield.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields/choicefield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields/choicefield.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields/hiddenfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields/hiddenfield.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields/index.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields/index.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/fields/textfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/fields/textfield.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/index.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/index.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/rules.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/rules.js should pass ESLint\n\n');
  });

  QUnit.test('controllers/form/submissions.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'controllers/form/submissions.js should pass ESLint\n\n');
  });

  QUnit.test('initializers/cookie-initializer.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'initializers/cookie-initializer.js should pass ESLint\n\n');
  });

  QUnit.test('models/basefield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/basefield.js should pass ESLint\n\n');
  });

  QUnit.test('models/booleanfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/booleanfield.js should pass ESLint\n\n');
  });

  QUnit.test('models/choicefield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/choicefield.js should pass ESLint\n\n');
  });

  QUnit.test('models/field.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/field.js should pass ESLint\n\n');
  });

  QUnit.test('models/form.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/form.js should pass ESLint\n\n');
  });

  QUnit.test('models/hiddenfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/hiddenfield.js should pass ESLint\n\n');
  });

  QUnit.test('models/option.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/option.js should pass ESLint\n\n');
  });

  QUnit.test('models/optiongroup.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/optiongroup.js should pass ESLint\n\n');
  });

  QUnit.test('models/optionlist.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/optionlist.js should pass ESLint\n\n');
  });

  QUnit.test('models/privacypolicy.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/privacypolicy.js should pass ESLint\n\n');
  });

  QUnit.test('models/rule.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/rule.js should pass ESLint\n\n');
  });

  QUnit.test('models/rulecondition.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/rulecondition.js should pass ESLint\n\n');
  });

  QUnit.test('models/ruleresult.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/ruleresult.js should pass ESLint\n\n');
  });

  QUnit.test('models/submission.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/submission.js should pass ESLint\n\n');
  });

  QUnit.test('models/submissionsource.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/submissionsource.js should pass ESLint\n\n');
  });

  QUnit.test('models/textfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'models/textfield.js should pass ESLint\n\n');
  });

  QUnit.test('resolver.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'resolver.js should pass ESLint\n\n');
  });

  QUnit.test('router.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'router.js should pass ESLint\n\n');
  });

  QUnit.test('routes/form.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'routes/form.js should pass ESLint\n\n');
  });

  QUnit.test('routes/form/fields.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'routes/form/fields.js should pass ESLint\n\n');
  });

  QUnit.test('routes/form/index.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'routes/form/index.js should pass ESLint\n\n');
  });

  QUnit.test('routes/form/rules.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'routes/form/rules.js should pass ESLint\n\n');
  });

  QUnit.test('routes/form/submissions.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'routes/form/submissions.js should pass ESLint\n\n');
  });

  QUnit.test('serializers/field.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'serializers/field.js should pass ESLint\n\n');
  });

  QUnit.test('serializers/optiongroup.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'serializers/optiongroup.js should pass ESLint\n\n');
  });

  QUnit.test('serializers/optionlist.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'serializers/optionlist.js should pass ESLint\n\n');
  });

  QUnit.test('serializers/rule.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'serializers/rule.js should pass ESLint\n\n');
  });

  QUnit.test('serializers/submissionsource.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'serializers/submissionsource.js should pass ESLint\n\n');
  });

  QUnit.test('transforms/json.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'transforms/json.js should pass ESLint\n\n');
  });

  QUnit.test('utils/fields.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'utils/fields.js should pass ESLint\n\n');
  });

  QUnit.test('utils/slug.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'utils/slug.js should pass ESLint\n\n');
  });

  QUnit.test('validators/factories.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/factories.js should pass ESLint\n\n');
  });

  QUnit.test('validators/fields/basefield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/fields/basefield.js should pass ESLint\n\n');
  });

  QUnit.test('validators/fields/booleanfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/fields/booleanfield.js should pass ESLint\n\n');
  });

  QUnit.test('validators/fields/choicefield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/fields/choicefield.js should pass ESLint\n\n');
  });

  QUnit.test('validators/fields/hiddenfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/fields/hiddenfield.js should pass ESLint\n\n');
  });

  QUnit.test('validators/fields/textfield.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/fields/textfield.js should pass ESLint\n\n');
  });

  QUnit.test('validators/rules/rule.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/rules/rule.js should pass ESLint\n\n');
  });

  QUnit.test('validators/rules/rulecondition.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/rules/rulecondition.js should pass ESLint\n\n');
  });

  QUnit.test('validators/rules/ruleresult.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'validators/rules/ruleresult.js should pass ESLint\n\n');
  });
});
define('ember-formulaic/tests/helpers/destroy-app', ['exports', 'ember'], function (exports, _ember) {
  exports['default'] = destroyApp;

  function destroyApp(application) {
    _ember['default'].run(application, 'destroy');
  }
});
define('ember-formulaic/tests/helpers/module-for-acceptance', ['exports', 'qunit', 'ember', 'ember-formulaic/tests/helpers/start-app', 'ember-formulaic/tests/helpers/destroy-app'], function (exports, _qunit, _ember, _emberFormulaicTestsHelpersStartApp, _emberFormulaicTestsHelpersDestroyApp) {
  var Promise = _ember['default'].RSVP.Promise;

  exports['default'] = function (name) {
    var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    (0, _qunit.module)(name, {
      beforeEach: function beforeEach() {
        this.application = (0, _emberFormulaicTestsHelpersStartApp['default'])();

        if (options.beforeEach) {
          return options.beforeEach.apply(this, arguments);
        }
      },

      afterEach: function afterEach() {
        var _this = this;

        var afterEach = options.afterEach && options.afterEach.apply(this, arguments);
        return Promise.resolve(afterEach).then(function () {
          return (0, _emberFormulaicTestsHelpersDestroyApp['default'])(_this.application);
        });
      }
    });
  };
});
define('ember-formulaic/tests/helpers/resolver', ['exports', 'ember-formulaic/resolver', 'ember-formulaic/config/environment'], function (exports, _emberFormulaicResolver, _emberFormulaicConfigEnvironment) {

  var resolver = _emberFormulaicResolver['default'].create();

  resolver.namespace = {
    modulePrefix: _emberFormulaicConfigEnvironment['default'].modulePrefix,
    podModulePrefix: _emberFormulaicConfigEnvironment['default'].podModulePrefix
  };

  exports['default'] = resolver;
});
define('ember-formulaic/tests/helpers/start-app', ['exports', 'ember', 'ember-formulaic/app', 'ember-formulaic/config/environment'], function (exports, _ember, _emberFormulaicApp, _emberFormulaicConfigEnvironment) {
  exports['default'] = startApp;

  function startApp(attrs) {
    var attributes = _ember['default'].merge({}, _emberFormulaicConfigEnvironment['default'].APP);
    attributes = _ember['default'].merge(attributes, attrs); // use defaults, but you can override;

    return _ember['default'].run(function () {
      var application = _emberFormulaicApp['default'].create(attributes);
      application.setupForTesting();
      application.injectTestHelpers();
      return application;
    });
  }
});
define('ember-formulaic/tests/helpers/x-select', ['exports', 'ember', 'jquery'], function (exports, _ember, _jquery) {
  exports.select = select;

  /**
   * Picks an option from the select and sets it to be `selected` in the DOM.
   *
   * @method select
   * @param {string|<jQuery>} selector - selector for the select to pick from.
   * @param {string} texts - text of the option you are picking
   */

  function select(selector) {
    for (var _len = arguments.length, texts = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      texts[_key - 1] = arguments[_key];
    }

    var $select = selector instanceof _jquery['default'] ? selector : _ember['default'].$(selector);
    var $options = $select.find('option');

    if (!$options.length) {
      throw 'No options found in ' + selector;
    }

    $options.each(function () {
      var _this = this;

      var $option = _ember['default'].$(this);

      _ember['default'].run(function () {
        _this.selected = texts.some(function (text) {
          // uppercase both texts so the helper isn't case sensastive.
          var optionText = $option.text().trim().toUpperCase();

          return optionText === text.toUpperCase();
        });

        if (_this.selected) {
          $option.prop('selected', true).trigger('change');
        }
      });
    });
  }
});
define('ember-formulaic/tests/integration/components/base-sortable-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('base-sortable', 'Integration | Component | base sortable', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'Lsckrow5',
      'block': '{"statements":[["append",["unknown",["base-sortable"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'f/ojrpjQ',
      'block': '{"statements":[["text","\\n"],["block",["base-sortable"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-checkbox-select-multiple-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-checkbox-select-multiple', 'Integration | Component | preview checkbox select multiple', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'o6v8Bv0Y',
      'block': '{"statements":[["append",["unknown",["preview-checkbox-select-multiple"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'MAYGYfmE',
      'block': '{"statements":[["text","\\n"],["block",["preview-checkbox-select-multiple"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-checkbox-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-checkbox', 'Integration | Component | preview checkbox', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': '8HzBPVlf',
      'block': '{"statements":[["append",["unknown",["preview-checkbox"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': '74AAaWTu',
      'block': '{"statements":[["text","\\n"],["block",["preview-checkbox"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-email-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-email', 'Integration | Component | preview email', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'vMpjlsAA',
      'block': '{"statements":[["append",["unknown",["preview-email"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'IvcVnMXA',
      'block': '{"statements":[["text","\\n"],["block",["preview-email"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-full-name-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-full-name', 'Integration | Component | preview full name', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': '8aN96x6Y',
      'block': '{"statements":[["append",["unknown",["preview-full-name"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'yrJHh9ga',
      'block': '{"statements":[["text","\\n"],["block",["preview-full-name"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-hidden-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-hidden', 'Integration | Component | preview hidden', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'f5qnGk8S',
      'block': '{"statements":[["append",["unknown",["preview-hidden"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'zN8/V25v',
      'block': '{"statements":[["text","\\n"],["block",["preview-hidden"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-integer-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-integer', 'Integration | Component | preview integer', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'b0yit+pm',
      'block': '{"statements":[["append",["unknown",["preview-integer"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'uo0zkjVE',
      'block': '{"statements":[["text","\\n"],["block",["preview-integer"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-phone-number-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-phone-number', 'Integration | Component | preview phone number', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'TSQpHmFM',
      'block': '{"statements":[["append",["unknown",["preview-phone-number"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': '90XVEd2z',
      'block': '{"statements":[["text","\\n"],["block",["preview-phone-number"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-radio-select-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-radio-select', 'Integration | Component | preview radio select', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'a4ODQ80Q',
      'block': '{"statements":[["append",["unknown",["preview-radio-select"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'NSc6TbOT',
      'block': '{"statements":[["text","\\n"],["block",["preview-radio-select"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-select-multiple-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-select-multiple', 'Integration | Component | preview select multiple', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'I1qAIObc',
      'block': '{"statements":[["append",["unknown",["preview-select-multiple"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 't/Lkoijm',
      'block': '{"statements":[["text","\\n"],["block",["preview-select-multiple"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-select-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-select', 'Integration | Component | preview select', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': '4BAjHkS8',
      'block': '{"statements":[["append",["unknown",["preview-select"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'r9VmPCoU',
      'block': '{"statements":[["text","\\n"],["block",["preview-select"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-text-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-text', 'Integration | Component | preview text', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'TXX0R9iG',
      'block': '{"statements":[["append",["unknown",["preview-text"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'XQJzDSvp',
      'block': '{"statements":[["text","\\n"],["block",["preview-text"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/preview-textarea-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('preview-textarea', 'Integration | Component | preview textarea', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'ZApZ2HFc',
      'block': '{"statements":[["append",["unknown",["preview-textarea"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'wfN/jop0',
      'block': '{"statements":[["text","\\n"],["block",["preview-textarea"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/integration/components/sortable-rules-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleForComponent)('sortable-rules', 'Integration | Component | sortable rules', {
    integration: true
  });

  (0, _emberQunit.test)('it renders', function (assert) {

    // Set any properties with this.set('myProperty', 'value');
    // Handle any actions with this.on('myAction', function(val) { ... });

    this.render(Ember.HTMLBars.template({
      'id': 'yqEzTjj8',
      'block': '{"statements":[["append",["unknown",["sortable-rules"]],false]],"locals":[],"named":[],"yields":[],"blocks":[],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), '');

    // Template block usage:
    this.render(Ember.HTMLBars.template({
      'id': 'hAhmTw7e',
      'block': '{"statements":[["text","\\n"],["block",["sortable-rules"],null,null,0],["text","  "]],"locals":[],"named":[],"yields":[],"blocks":[{"statements":[["text","      template block text\\n"]],"locals":[]}],"hasPartials":false}',
      'meta': {}
    }));

    assert.equal(this.$().text().trim(), 'template block text');
  });
});
define('ember-formulaic/tests/test-helper', ['exports', 'ember-formulaic/tests/helpers/resolver', 'ember-qunit'], function (exports, _emberFormulaicTestsHelpersResolver, _emberQunit) {

  (0, _emberQunit.setResolver)(_emberFormulaicTestsHelpersResolver['default']);
});
define('ember-formulaic/tests/tests.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | tests');

  QUnit.test('helpers/destroy-app.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'helpers/destroy-app.js should pass ESLint\n\n');
  });

  QUnit.test('helpers/module-for-acceptance.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'helpers/module-for-acceptance.js should pass ESLint\n\n');
  });

  QUnit.test('helpers/resolver.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'helpers/resolver.js should pass ESLint\n\n');
  });

  QUnit.test('helpers/start-app.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'helpers/start-app.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/base-sortable-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/base-sortable-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-checkbox-select-multiple-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-checkbox-select-multiple-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-checkbox-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-checkbox-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-email-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-email-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-full-name-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-full-name-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-hidden-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-hidden-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-integer-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-integer-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-phone-number-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-phone-number-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-radio-select-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-radio-select-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-select-multiple-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-select-multiple-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-select-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-select-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-text-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-text-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/preview-textarea-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/preview-textarea-test.js should pass ESLint\n\n');
  });

  QUnit.test('integration/components/sortable-rules-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'integration/components/sortable-rules-test.js should pass ESLint\n\n');
  });

  QUnit.test('test-helper.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'test-helper.js should pass ESLint\n\n');
  });

  QUnit.test('unit/initializers/cookie-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'unit/initializers/cookie-test.js should pass ESLint\n\n');
  });

  QUnit.test('unit/routes/form-test.js', function (assert) {
    assert.expect(1);
    assert.ok(true, 'unit/routes/form-test.js should pass ESLint\n\n');
  });
});
define('ember-formulaic/tests/unit/initializers/cookie-test', ['exports', 'ember', 'ember-formulaic/initializers/cookie', 'qunit', 'ember-formulaic/tests/helpers/destroy-app'], function (exports, _ember, _emberFormulaicInitializersCookie, _qunit, _emberFormulaicTestsHelpersDestroyApp) {

  (0, _qunit.module)('Unit | Initializer | cookie', {
    beforeEach: function beforeEach() {
      var _this = this;

      _ember['default'].run(function () {
        _this.application = _ember['default'].Application.create();
        _this.application.deferReadiness();
      });
    },
    afterEach: function afterEach() {
      (0, _emberFormulaicTestsHelpersDestroyApp['default'])(this.application);
    }
  });

  // Replace this with your real tests.
  (0, _qunit.test)('it works', function (assert) {
    (0, _emberFormulaicInitializersCookie.initialize)(this.application);

    // you would normally confirm the results of the initializer here
    assert.ok(true);
  });
});
define('ember-formulaic/tests/unit/routes/form-test', ['exports', 'ember-qunit'], function (exports, _emberQunit) {

  (0, _emberQunit.moduleFor)('route:form', 'Unit | Route | form', {
    // Specify the other units that are required for this test.
    // needs: ['controller:foo']
  });

  (0, _emberQunit.test)('it exists', function (assert) {
    var route = this.subject();
    assert.ok(route);
  });
});
require('ember-formulaic/tests/test-helper');
EmberENV.TESTS_FILE_LOADED = true;
//# sourceMappingURL=tests.map
