define('dummy/app', ['exports', 'ember', 'ember/resolver', 'ember/load-initializers', 'dummy/config/environment'], function (exports, Ember, Resolver, loadInitializers, config) {

  'use strict';

  Ember['default'].MODEL_FACTORY_INJECTIONS = true;

  var App = Ember['default'].Application.extend({
    modulePrefix: config['default'].modulePrefix,
    podModulePrefix: config['default'].podModulePrefix,
    Resolver: Resolver['default']
  });

  loadInitializers['default'](App, config['default'].modulePrefix);

  exports['default'] = App;

});
define('dummy/components/validation-error-field', ['exports', 'ember', 'ember-cli-simple-validation/components/validation-error-field'], function (exports, Ember, ValidationErrorField) {

	'use strict';

	exports['default'] = ValidationErrorField['default'];

});
define('dummy/controllers/add', ['exports', 'ember', 'ember-cli-simple-validation/mixins/validate'], function (exports, Ember, validate) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(validate.ValidationMixin, {
        nameValidation: validate.validate("model.name"),
        zipcodeValidation: validate.validate("model.zipcode", /\d{5}/),
        emailValidation: validate.validate("model.email", /\S+@\S+\.\S+/),
        actions: {
            save: function () {
                this.set("submitted", true);
                if (this.get("valid")) {
                    this.transitionToRoute("success");
                }
            }
        }
    });

});
define('dummy/controllers/edit', ['exports', 'ember', 'ember-cli-simple-validation/mixins/validate'], function (exports, Ember, validate) {

    'use strict';

    exports['default'] = Ember['default'].Controller.extend(validate.ValidationMixin, {
        nameValidation: validate.validate("model.name"),
        zipcodeValidation: validate.validate("model.zipcode", /\d{5}/),
        emailValidation: validate.validate("model.email", /\S+@\S+\.\S+/),
        actions: {
            save: function () {
                this.set("submitted", true);
                if (this.get("valid")) {
                    this.transitionToRoute("success");
                }
            }
        }
    });

});
define('dummy/ember-cli-simple-store/tests/ember-cli-simple-store/initializers/ember-cli-simple-store.jshint', function () {

  'use strict';

  module("JSHint - ember-cli-simple-store/initializers");
  test("ember-cli-simple-store/initializers/ember-cli-simple-store.js should pass jshint", function () {
    ok(true, "ember-cli-simple-store/initializers/ember-cli-simple-store.js should pass jshint.");
  });

});
define('dummy/ember-cli-simple-store/tests/ember-cli-simple-store/model.jshint', function () {

  'use strict';

  module("JSHint - ember-cli-simple-store");
  test("ember-cli-simple-store/model.js should pass jshint", function () {
    ok(true, "ember-cli-simple-store/model.js should pass jshint.");
  });

});
define('dummy/ember-cli-simple-store/tests/ember-cli-simple-store/store.jshint', function () {

  'use strict';

  module("JSHint - ember-cli-simple-store");
  test("ember-cli-simple-store/store.js should pass jshint", function () {
    ok(true, "ember-cli-simple-store/store.js should pass jshint.");
  });

});
define('dummy/ember-cli-simple-validation/tests/ember-cli-simple-validation/components/validation-error-field.jshint', function () {

  'use strict';

  module("JSHint - ember-cli-simple-validation/components");
  test("ember-cli-simple-validation/components/validation-error-field.js should pass jshint", function () {
    ok(true, "ember-cli-simple-validation/components/validation-error-field.js should pass jshint.");
  });

});
define('dummy/ember-cli-simple-validation/tests/ember-cli-simple-validation/mixins/validate.jshint', function () {

  'use strict';

  module("JSHint - ember-cli-simple-validation/mixins");
  test("ember-cli-simple-validation/mixins/validate.js should pass jshint", function () {
    ok(true, "ember-cli-simple-validation/mixins/validate.js should pass jshint.");
  });

});
define('dummy/initializers/app-version', ['exports', 'dummy/config/environment', 'ember'], function (exports, config, Ember) {

  'use strict';

  var classify = Ember['default'].String.classify;

  exports['default'] = {
    name: "App Version",
    initialize: function (container, application) {
      var appName = classify(application.toString());
      Ember['default'].libraries.register(appName, config['default'].APP.version);
    }
  };

});
define('dummy/initializers/ember-cli-simple-store', ['exports', 'ember-cli-simple-store/initializers/ember-cli-simple-store'], function (exports, initializer) {

    'use strict';

    exports['default'] = {
        name: "store",
        initialize: initializer['default']
    };

});
define('dummy/initializers/export-application-global', ['exports', 'ember', 'dummy/config/environment'], function (exports, Ember, config) {

  'use strict';

  exports.initialize = initialize;

  function initialize(container, application) {
    var classifiedName = Ember['default'].String.classify(config['default'].modulePrefix);

    if (config['default'].exportApplicationGlobal) {
      window[classifiedName] = application;
    }
  };

  exports['default'] = {
    name: "export-application-global",

    initialize: initialize
  };

});
define('dummy/models/person', ['exports', 'ember-cli-simple-store/model'], function (exports, model) {

    'use strict';

    exports['default'] = model.Model.extend({
        name: model.attr(),
        zipcode: model.attr(),
        email: model.attr()
    });

});
define('dummy/router', ['exports', 'ember', 'dummy/config/environment'], function (exports, Ember, config) {

    'use strict';

    var Router = Ember['default'].Router.extend({
        location: config['default'].locationType
    });

    Router.map(function () {
        this.route("add", { path: "/" });
        this.route("edit", { path: "/edit" });
        this.route("success", { path: "/success" });
    });

    exports['default'] = Router;

});
define('dummy/routes/add', ['exports', 'ember', 'dummy/models/person'], function (exports, Ember, Person) {

    'use strict';

    exports['default'] = Ember['default'].Route.extend({
        model: function () {
            return Person['default'].create();
        }
    });

});
define('dummy/routes/edit', ['exports', 'ember', 'dummy/models/person'], function (exports, Ember, Person) {

    'use strict';

    exports['default'] = Ember['default'].Route.extend({
        model: function () {
            var store = this.get("store");
            store.push("person", {
                name: "toran",
                zipcode: "52601",
                email: "toranb@gmail.com"
            });
            return store.findOne("person");
        }
    });

});
define('dummy/templates/add', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].Handlebars.template(function anonymous(Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
  helpers = this.merge(helpers, Ember['default'].Handlebars.helpers); data = data || {};
    var buffer = '', stack1, helper, options, helperMissing=helpers.helperMissing, escapeExpression=this.escapeExpression, self=this;

  function program1(depth0,data) {
    
    
    data.buffer.push("invalid name");
    }

  function program3(depth0,data) {
    
    
    data.buffer.push("invalid zipcode");
    }

  function program5(depth0,data) {
    
    
    data.buffer.push("invalid email");
    }

    data.buffer.push("<div class=\"name-parent-div\">\n");
    data.buffer.push(escapeExpression((helper = helpers.input || (depth0 && depth0.input),options={hash:{
      'value': ("model.name"),
      'placeholder': ("name")
    },hashTypes:{'value': "ID",'placeholder': "STRING"},hashContexts:{'value': depth0,'placeholder': depth0},contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "input", options))));
    data.buffer.push("\n");
    stack1 = (helper = helpers['validation-error-field'] || (depth0 && depth0['validation-error-field']),options={hash:{
      'submitted': ("submitted"),
      'className': ("red"),
      'field': ("name"),
      'model': ("model"),
      'validation': ("nameValidation")
    },hashTypes:{'submitted': "ID",'className': "STRING",'field': "STRING",'model': "ID",'validation': "ID"},hashContexts:{'submitted': depth0,'className': depth0,'field': depth0,'model': depth0,'validation': depth0},inverse:self.noop,fn:self.program(1, program1, data),contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "validation-error-field", options));
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n</div>\n\n<div class=\"zipcode-parent-div\">\n");
    data.buffer.push(escapeExpression((helper = helpers.input || (depth0 && depth0.input),options={hash:{
      'value': ("model.zipcode"),
      'placeholder': ("zipcode")
    },hashTypes:{'value': "ID",'placeholder': "STRING"},hashContexts:{'value': depth0,'placeholder': depth0},contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "input", options))));
    data.buffer.push("\n");
    stack1 = (helper = helpers['validation-error-field'] || (depth0 && depth0['validation-error-field']),options={hash:{
      'submitted': ("submitted"),
      'field': ("zipcode"),
      'model': ("model"),
      'validation': ("zipcodeValidation")
    },hashTypes:{'submitted': "ID",'field': "STRING",'model': "ID",'validation': "ID"},hashContexts:{'submitted': depth0,'field': depth0,'model': depth0,'validation': depth0},inverse:self.noop,fn:self.program(3, program3, data),contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "validation-error-field", options));
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n</div>\n\n<div class=\"email-parent-div\">\n");
    data.buffer.push(escapeExpression((helper = helpers.input || (depth0 && depth0.input),options={hash:{
      'value': ("model.email"),
      'placeholder': ("email")
    },hashTypes:{'value': "ID",'placeholder': "STRING"},hashContexts:{'value': depth0,'placeholder': depth0},contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "input", options))));
    data.buffer.push("\n");
    stack1 = (helper = helpers['validation-error-field'] || (depth0 && depth0['validation-error-field']),options={hash:{
      'delayed': (true),
      'submitted': ("submitted"),
      'className': ("blue"),
      'field': ("email"),
      'model': ("model"),
      'validation': ("emailValidation")
    },hashTypes:{'delayed': "BOOLEAN",'submitted': "ID",'className': "STRING",'field': "STRING",'model': "ID",'validation': "ID"},hashContexts:{'delayed': depth0,'submitted': depth0,'className': depth0,'field': depth0,'model': depth0,'validation': depth0},inverse:self.noop,fn:self.program(5, program5, data),contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "validation-error-field", options));
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n</div>\n\n<button class=\"save\" ");
    data.buffer.push(escapeExpression(helpers.action.call(depth0, "save", {hash:{},hashTypes:{},hashContexts:{},contexts:[depth0],types:["STRING"],data:data})));
    data.buffer.push(">Save</button>\n");
    return buffer;
    
  });

});
define('dummy/templates/application', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].Handlebars.template(function anonymous(Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
  helpers = this.merge(helpers, Ember['default'].Handlebars.helpers); data = data || {};
    var buffer = '', stack1;


    data.buffer.push("<h2 id=\"title\">Welcome to Ember.js</h2>\n\n");
    stack1 = helpers._triageMustache.call(depth0, "outlet", {hash:{},hashTypes:{},hashContexts:{},contexts:[depth0],types:["ID"],data:data});
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n");
    return buffer;
    
  });

});
define('dummy/templates/edit', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].Handlebars.template(function anonymous(Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
  helpers = this.merge(helpers, Ember['default'].Handlebars.helpers); data = data || {};
    var buffer = '', stack1, helper, options, helperMissing=helpers.helperMissing, escapeExpression=this.escapeExpression, self=this;

  function program1(depth0,data) {
    
    
    data.buffer.push("invalid name");
    }

  function program3(depth0,data) {
    
    
    data.buffer.push("invalid zipcode");
    }

  function program5(depth0,data) {
    
    
    data.buffer.push("invalid email");
    }

    data.buffer.push("<div class=\"name-parent-div\">\n");
    data.buffer.push(escapeExpression((helper = helpers.input || (depth0 && depth0.input),options={hash:{
      'value': ("model.name"),
      'placeholder': ("name")
    },hashTypes:{'value': "ID",'placeholder': "STRING"},hashContexts:{'value': depth0,'placeholder': depth0},contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "input", options))));
    data.buffer.push("\n");
    stack1 = (helper = helpers['validation-error-field'] || (depth0 && depth0['validation-error-field']),options={hash:{
      'submitted': ("submitted"),
      'className': ("red"),
      'field': ("name"),
      'model': ("model"),
      'validation': ("nameValidation")
    },hashTypes:{'submitted': "ID",'className': "STRING",'field': "STRING",'model': "ID",'validation': "ID"},hashContexts:{'submitted': depth0,'className': depth0,'field': depth0,'model': depth0,'validation': depth0},inverse:self.noop,fn:self.program(1, program1, data),contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "validation-error-field", options));
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n</div>\n\n<div class=\"zipcode-parent-div\">\n");
    data.buffer.push(escapeExpression((helper = helpers.input || (depth0 && depth0.input),options={hash:{
      'value': ("model.zipcode"),
      'placeholder': ("zipcode")
    },hashTypes:{'value': "ID",'placeholder': "STRING"},hashContexts:{'value': depth0,'placeholder': depth0},contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "input", options))));
    data.buffer.push("\n");
    stack1 = (helper = helpers['validation-error-field'] || (depth0 && depth0['validation-error-field']),options={hash:{
      'submitted': ("submitted"),
      'field': ("zipcode"),
      'model': ("model"),
      'validation': ("zipcodeValidation")
    },hashTypes:{'submitted': "ID",'field': "STRING",'model': "ID",'validation': "ID"},hashContexts:{'submitted': depth0,'field': depth0,'model': depth0,'validation': depth0},inverse:self.noop,fn:self.program(3, program3, data),contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "validation-error-field", options));
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n</div>\n\n<div class=\"email-parent-div\">\n");
    data.buffer.push(escapeExpression((helper = helpers.input || (depth0 && depth0.input),options={hash:{
      'value': ("model.email"),
      'placeholder': ("email")
    },hashTypes:{'value': "ID",'placeholder': "STRING"},hashContexts:{'value': depth0,'placeholder': depth0},contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "input", options))));
    data.buffer.push("\n");
    stack1 = (helper = helpers['validation-error-field'] || (depth0 && depth0['validation-error-field']),options={hash:{
      'delayed': (true),
      'submitted': ("submitted"),
      'className': ("blue"),
      'field': ("email"),
      'model': ("model"),
      'validation': ("emailValidation")
    },hashTypes:{'delayed': "BOOLEAN",'submitted': "ID",'className': "STRING",'field': "STRING",'model': "ID",'validation': "ID"},hashContexts:{'delayed': depth0,'submitted': depth0,'className': depth0,'field': depth0,'model': depth0,'validation': depth0},inverse:self.noop,fn:self.program(5, program5, data),contexts:[],types:[],data:data},helper ? helper.call(depth0, options) : helperMissing.call(depth0, "validation-error-field", options));
    if(stack1 || stack1 === 0) { data.buffer.push(stack1); }
    data.buffer.push("\n</div>\n\n<button ");
    data.buffer.push(escapeExpression(helpers.action.call(depth0, "save", {hash:{},hashTypes:{},hashContexts:{},contexts:[depth0],types:["STRING"],data:data})));
    data.buffer.push(">Save</button>\n");
    return buffer;
    
  });

});
define('dummy/templates/success', ['exports', 'ember'], function (exports, Ember) {

  'use strict';

  exports['default'] = Ember['default'].Handlebars.template(function anonymous(Handlebars,depth0,helpers,partials,data) {
  this.compilerInfo = [4,'>= 1.0.0'];
  helpers = this.merge(helpers, Ember['default'].Handlebars.helpers); data = data || {};
    


    data.buffer.push("<div class=\"success\">valid form was submitted</div>\n");
    
  });

});
define('dummy/tests/acceptance/form-validation-test', ['ember', 'dummy/tests/helpers/start-app'], function (Ember, startApp) {

  'use strict';

  var application;

  var SAVE_BUTTON = "button.save";
  var NAME_ERROR_FIELD = ".name-parent-div span";
  var ZIPCODE_ERROR_FIELD = ".zipcode-parent-div span";
  var EMAIL_ERROR_FIELD = ".email-parent-div span";

  var NAME_INPUT = ".name-parent-div input";
  var ZIPCODE_INPUT = ".zipcode-parent-div input";
  var EMAIL_INPUT = ".email-parent-div input";

  var VALID_NAME = "x";
  var VALID_ZIPCODE = "52601";
  var VALID_EMAIL = "hi@hi.com";

  module("Acceptance: Form Validation", {
    setup: function () {
      application = startApp['default']();
    },
    teardown: function () {
      Ember['default'].run(application, "destroy");
    }
  });

  test("clicking save will transition to success when each field is valid", function () {
    visit("/");
    fillIn(NAME_INPUT, VALID_NAME);
    fillIn(ZIPCODE_INPUT, VALID_ZIPCODE);
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    click(SAVE_BUTTON);
    andThen(function () {
      equal(currentURL(), "/success");
    });
  });

  test("clicking save will not transition to success when only the last field is valid", function () {
    visit("/");
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    click(SAVE_BUTTON);
    andThen(function () {
      equal(currentURL(), "/");
    });
    fillIn(NAME_INPUT, VALID_NAME);
    fillIn(ZIPCODE_INPUT, VALID_ZIPCODE);
    click(SAVE_BUTTON);
    andThen(function () {
      equal(currentURL(), "/success");
    });
  });

  test("inputs with default validation will not accept empty string as valid", function () {
    visit("/");
    fillIn(NAME_INPUT, " ");
    fillIn(ZIPCODE_INPUT, VALID_ZIPCODE);
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    click(SAVE_BUTTON);
    andThen(function () {
      equal(currentURL(), "/");
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), false);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
  });

  test("clicking save will fire each validation", function () {
    visit("/");
    andThen(function () {
      equal(currentURL(), "/");
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
    click(SAVE_BUTTON);
    andThen(function () {
      equal(currentURL(), "/");
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), false);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), false);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), false);
    });
  });

  test("component will render with the correct text and css class", function () {
    visit("/");
    click(SAVE_BUTTON);
    andThen(function () {
      equal(currentURL(), "/");
      equal(find(NAME_ERROR_FIELD).hasClass("red"), true);
      equal(find(EMAIL_ERROR_FIELD).hasClass("blue"), true);
      equal(find(NAME_ERROR_FIELD).text(), "invalid name");
      equal(find(ZIPCODE_ERROR_FIELD).text(), "invalid zipcode");
      equal(find(EMAIL_ERROR_FIELD).text(), "invalid email");
    });
  });

  test("when inputs are showing errors they turn hidden when field is correctly entered", function () {
    visit("/");
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
    click(SAVE_BUTTON);
    fillIn(NAME_INPUT, VALID_NAME);
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), false);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(ZIPCODE_INPUT, VALID_ZIPCODE);
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
  });

  test("inputs with default validation start working without submit firing", function () {
    visit("/");
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(NAME_INPUT, VALID_NAME);
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(NAME_INPUT, "");
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(NAME_INPUT, VALID_NAME);
    andThen(function () {
      equal(find(NAME_ERROR_FIELD).hasClass("hidden"), true);
    });
  });

  test("inputs with regex validation start working without submit firing", function () {
    visit("/");
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(ZIPCODE_INPUT, VALID_ZIPCODE);
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(ZIPCODE_INPUT, "");
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(ZIPCODE_INPUT, VALID_ZIPCODE);
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
    });
  });

  test("inputs with regex validation will not work without submit when delay option set", function () {
    visit("/");
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(EMAIL_INPUT, "");
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
    click(SAVE_BUTTON);
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(EMAIL_INPUT, "hi");
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(EMAIL_INPUT, VALID_EMAIL);
    andThen(function () {
      equal(find(EMAIL_ERROR_FIELD).hasClass("hidden"), true);
    });
  });

  test("inputs with default validation will not trip validation when they are tabbed into", function () {
    visit("/");
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
    });
    triggerEvent(ZIPCODE_INPUT, "dblclick");
    triggerEvent(ZIPCODE_INPUT, "blur");
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
    });
    fillIn(ZIPCODE_INPUT, "5003");
    triggerEvent(ZIPCODE_INPUT, "blur");
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), false);
    });
    fillIn(ZIPCODE_INPUT, "12345");
    triggerEvent(ZIPCODE_INPUT, "blur");
    andThen(function () {
      equal(find(ZIPCODE_ERROR_FIELD).hasClass("hidden"), true);
    });
  });

});
define('dummy/tests/acceptance/form-validation-test.jshint', function () {

  'use strict';

  module('JSHint - acceptance');
  test('acceptance/form-validation-test.js should pass jshint', function() { 
    ok(true, 'acceptance/form-validation-test.js should pass jshint.'); 
  });

});
define('dummy/tests/app.jshint', function () {

  'use strict';

  module('JSHint - .');
  test('app.js should pass jshint', function() { 
    ok(true, 'app.js should pass jshint.'); 
  });

});
define('dummy/tests/controllers/add.jshint', function () {

  'use strict';

  module('JSHint - controllers');
  test('controllers/add.js should pass jshint', function() { 
    ok(true, 'controllers/add.js should pass jshint.'); 
  });

});
define('dummy/tests/controllers/edit.jshint', function () {

  'use strict';

  module('JSHint - controllers');
  test('controllers/edit.js should pass jshint', function() { 
    ok(true, 'controllers/edit.js should pass jshint.'); 
  });

});
define('dummy/tests/helpers/resolver', ['exports', 'ember/resolver', 'dummy/config/environment'], function (exports, Resolver, config) {

  'use strict';

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

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

  exports['default'] = resolver;

});
define('dummy/tests/helpers/resolver.jshint', function () {

  'use strict';

  module('JSHint - helpers');
  test('helpers/resolver.js should pass jshint', function() { 
    ok(true, 'helpers/resolver.js should pass jshint.'); 
  });

});
define('dummy/tests/helpers/start-app', ['exports', 'ember', 'dummy/app', 'dummy/router', 'dummy/config/environment'], function (exports, Ember, Application, Router, config) {

  'use strict';



  exports['default'] = startApp;
  function startApp(attrs) {
    var application;

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

    Ember['default'].run(function () {
      application = Application['default'].create(attributes);
      application.setupForTesting();
      application.injectTestHelpers();
    });

    return application;
  }

});
define('dummy/tests/helpers/start-app.jshint', function () {

  'use strict';

  module('JSHint - helpers');
  test('helpers/start-app.js should pass jshint', function() { 
    ok(true, 'helpers/start-app.js should pass jshint.'); 
  });

});
define('dummy/tests/models/person.jshint', function () {

  'use strict';

  module('JSHint - models');
  test('models/person.js should pass jshint', function() { 
    ok(true, 'models/person.js should pass jshint.'); 
  });

});
define('dummy/tests/router.jshint', function () {

  'use strict';

  module('JSHint - .');
  test('router.js should pass jshint', function() { 
    ok(true, 'router.js should pass jshint.'); 
  });

});
define('dummy/tests/routes/add.jshint', function () {

  'use strict';

  module('JSHint - routes');
  test('routes/add.js should pass jshint', function() { 
    ok(true, 'routes/add.js should pass jshint.'); 
  });

});
define('dummy/tests/routes/edit.jshint', function () {

  'use strict';

  module('JSHint - routes');
  test('routes/edit.js should pass jshint', function() { 
    ok(true, 'routes/edit.js should pass jshint.'); 
  });

});
define('dummy/tests/test-helper', ['dummy/tests/helpers/resolver', 'ember-qunit'], function (resolver, ember_qunit) {

	'use strict';

	ember_qunit.setResolver(resolver['default']);

});
define('dummy/tests/test-helper.jshint', function () {

  'use strict';

  module('JSHint - .');
  test('test-helper.js should pass jshint', function() { 
    ok(true, 'test-helper.js should pass jshint.'); 
  });

});
define('dummy/tests/unit/validation-mixin-test', ['ember', 'ember-cli-simple-store/model', 'ember-cli-simple-validation/mixins/validate'], function (Ember, ember_cli_simple_store__model, validate) {

    'use strict';

    var Person = ember_cli_simple_store__model.Model.extend({
        name: ember_cli_simple_store__model.attr(),
        email: ember_cli_simple_store__model.attr()
    });

    var controller,
        model = Person.create({ name: "x", email: "hi@hi.com" });

    var FakeController = Ember['default'].Controller.extend(validate.ValidationMixin, {
        nameValidation: validate.validate("model.name"),
        emailValidation: validate.validate("model.email", /\S+@\S+\.\S+/),
        model: model
    });

    module("Unit: Validation Mixin", {
        setup: function () {
            controller = new FakeController();
        },
        teardown: function () {
            controller = null;
        }
    });

    test("validation will fire when computed validation value is update", function () {
        equal(controller.get("nameValidation"), true);
        model.set("name", "");
        equal(controller.get("nameValidation"), false);
        model.set("name", "x");
        equal(controller.get("nameValidation"), true);
    });

    test("validate attr without regex option will trim the value by default", function () {
        equal(controller.get("nameValidation"), true);
        model.set("name", "");
        equal(controller.get("nameValidation"), false);
        model.set("name", " ");
        equal(controller.get("nameValidation"), false);
        model.set("name", "x");
        equal(controller.get("nameValidation"), true);
    });

    test("validate attr with regex will validate using the given pattern", function () {
        equal(controller.get("emailValidation"), true);
        model.set("email", "");
        equal(controller.get("emailValidation"), false);
        model.set("email", "hi@h");
        equal(controller.get("emailValidation"), false);
        model.set("email", "hi@hi.com");
        equal(controller.get("emailValidation"), true);
    });

    test("valid property defined on controller when mixin used", function () {
        equal(controller.get("emailValidation"), true);
        equal(controller.get("nameValidation"), true);
        equal(controller.get("valid"), true);
        model.set("email", "");
        equal(controller.get("valid"), false);
        model.set("email", "hi@hi.com");
        equal(controller.get("valid"), true);
        model.set("name", "");
        equal(controller.get("valid"), false);
        model.set("name", "x");
        equal(controller.get("valid"), true);
    });

});
define('dummy/tests/unit/validation-mixin-test.jshint', function () {

  'use strict';

  module('JSHint - unit');
  test('unit/validation-mixin-test.js should pass jshint', function() { 
    ok(true, 'unit/validation-mixin-test.js should pass jshint.'); 
  });

});
/* jshint ignore:start */

define('dummy/config/environment', ['ember'], function(Ember) {
  var prefix = 'dummy';
/* jshint ignore:start */

try {
  var metaName = prefix + '/config/environment';
  var rawConfig = Ember['default'].$('meta[name="' + metaName + '"]').attr('content');
  var config = JSON.parse(unescape(rawConfig));

  return { 'default': config };
}
catch(err) {
  throw new Error('Could not read config from meta tag with name "' + metaName + '".');
}

/* jshint ignore:end */

});

if (runningTests) {
  require("dummy/tests/test-helper");
} else {
  require("dummy/app")["default"].create({"LOG_ACTIVE_GENERATION":false,"LOG_VIEW_LOOKUPS":false,"rootElement":"#ember-testing","name":"ember-cli-simple-validation","version":"0.0.0.1c08e469"});
}

/* jshint ignore:end */
//# sourceMappingURL=dummy.map