From 88d89f82b0bb006b9e95a0b263ced455f4552df0 Mon Sep 17 00:00:00 2001
From: Christian Lent <clent@getacceptd.com>
Date: Thu, 13 Mar 2014 11:37:52 -0400
Subject: [PATCH 1/5] Per-selector external validation

---
 jquery.h5validate.js    | 37 +++++++++++++++++++++++++++++++++
 test/index.html         |  8 +++++++
 test/test.h5validate.js | 46 +++++++++++++++++++++++++++++++++++++++++
 3 files changed, 91 insertions(+)

diff --git a/jquery.h5validate.js b/jquery.h5validate.js
index b151b06..0069ca9 100644
--- a/jquery.h5validate.js
+++ b/jquery.h5validate.js
@@ -92,6 +92,9 @@
 				// Callback stubs
 				invalidCallback: function () {},
 				validCallback: function () {},
+				
+				// Array of External Validator Functions. View the comment for addExternalValidator for more information.
+				externalValidators: [],
 
 				// Elements to validate with allValid (only validating visible elements)
 				allValidSelectors: ':input:visible:not(:button):not(:disabled):not(.novalidate)',
@@ -280,6 +283,19 @@
 						validity.valid = false;	
 						validity.tooLong = true;
 				}
+				
+				// Iterate through the external validators. If any fail, the field fails.
+				for (var i = 0;i<settings.externalValidators.length;i++) {
+					var validator = settings.externalValidators[i].validator;
+					var selector = settings.externalValidators[i].selector;
+					if ($(this).is(selector)) {
+						var boundValidator = validator.bind(this);
+						if (!boundValidator(value)) {
+							validity.valid = false;	
+							validity.failedExternalValidation = true;
+						}
+					}
+				}
 
 				if (required && !value) {
 					validity.valid = false;
@@ -523,6 +539,27 @@
 			}
 			re = new RegExp('^(?:' + pattern + ')$');
 			$(selector).data('regex', re);
+		},
+		/**
+		 * Takes a selector and a function that is used to do external validation of all fields.
+		 * This is useful for doing validation against a webservice
+		 * (e.g. 'http://example.com/is_value_valid/example_value')
+		 * Each validator will be matched using the corresponding selector against every field attached to h5Validate.
+		 * 
+		 * @param {Selector} selector - A jquery selector of the field on which to apply the external validator.
+		 *		example: [name="target-field"]
+		 * @param {Function} validator - An external validator function with the following definition:
+		 *		@param {String} value - The value of the input being validated.
+		 *		@return {Boolean} - the result of the validation (true = pass, false = fail)
+		 *		@this {DOM Element} - The dom element being validated. 
+		 */
+		addExternalValidator: function(selector, validator) {
+			if (!$.isFunction(validator)) {
+				console.log("External validators should be functions. You, on the other hand, tried to add the following as a validator:",validator);
+				return false;
+			}
+			defaults.externalValidators.push({selector: selector, validator: validator} );
+			return true;
 		}
 	};
 
diff --git a/test/index.html b/test/index.html
index dba376e..6436592 100644
--- a/test/index.html
+++ b/test/index.html
@@ -259,6 +259,14 @@ <h2>Bypassing Validation tests (via 'formnovalidate')</h2>
 				<input id="bypassSubmit" type="submit" formnovalidate="formnovalidate"/>
 			</form>
 		</section>
+		
+		<section>
+			<h2>External Form Validation Tests</h2>
+			<form id="externalValidationForm">
+				<input id="externalValidationFieldPass" type="text" />
+				<input id="externalValidationFieldFail" type="text" />
+			</form>
+		</section>
 
 
 		<script src="http://code.jquery.com/jquery.js"></script>
diff --git a/test/test.h5validate.js b/test/test.h5validate.js
index 8446eb4..a0b8a46 100644
--- a/test/test.h5validate.js
+++ b/test/test.h5validate.js
@@ -302,6 +302,52 @@
       $form.empty().remove();
     });	
 
+    test('Adding an external validator should fail for non functions',function () {
+	var result = $.h5Validate.addExternalValidator('[name="target-field"]',5);
+	equal(result, false, 'Should not be able to add an integer as an external validator.');
+
+	var result = $.h5Validate.addExternalValidator('[name="target-field"]','5');
+	equal(result, false, 'Should not be able to add a string as an external validator.');
+
+	var result = $.h5Validate.addExternalValidator('[name="target-field"]',null);
+	equal(result, false, 'Should not be able to add a null as an external validator.');
+
+	var result = $.h5Validate.addExternalValidator('[name="target-field"]',{});
+	equal(result, false, 'Should not be able to add an object as an external validator.');
+
+	var result = $.h5Validate.addExternalValidator('[name="target-field"]',[]);
+	equal(result, false, 'Should not be able to add an array as an external validator.');
+    });
+
+    test('Adding an external validator should succeed for functions',function () {
+	var result = $.h5Validate.addExternalValidator('[name="target-field"]',function(){return true;});
+	equal(result, true, 'Should be able to add a function as an external validator.');
+    });
+
+    test('Adding an external validator that returns true should not cause validation to fail.',function () {
+	var $form = $('#externalValidationForm'),
+		$field = $('#externalValidationFieldPass');
+	$.h5Validate.addExternalValidator($field,function(){return true;});
+	$form.h5Validate();
+	equal($field.h5Validate('isValid'), true, 'Adding an external validator that returns true should not cause validation to fail.');
+    });
+
+    test('Adding an external validator that returns false should cause validation to fail.',function () {
+	var $form = $('#externalValidationForm'),
+		$field = $('#externalValidationFieldFail');
+	$.h5Validate.addExternalValidator($field,function(){return false;});
+	$form.h5Validate();
+	equal($field.h5Validate('isValid'), false, 'Adding an external validator that returns false should cause validation to fail.');
+    });
+
+    test('Adding an external validator to a selector that does not exist should not cause validation to fail.',function () {
+	var $form = $('#externalValidationForm');
+	$.h5Validate.addExternalValidator('atagthatdoesntexistinhtml',function(){return false;});
+	$form.h5Validate();
+	equal($form.h5Validate('allValid'), true, 'Adding an external validator to a selector that does not exist should not cause validation to fail.');
+    });
+
+
   }
   exports.runTests = runTests;
 }((typeof exports !== 'undefined') ? exports : window));

From 709dcbd79724cdafad6255640e5a3fafd0efe5c9 Mon Sep 17 00:00:00 2001
From: Christian Lent <clent@getacceptd.com>
Date: Thu, 13 Mar 2014 11:55:38 -0400
Subject: [PATCH 2/5] Fixed some external validation tests and added a few
 more. Added "return" documentation for addExternalValidator

---
 jquery.h5validate.js    |  3 ++-
 test/index.html         |  5 +++++
 test/test.h5validate.js | 40 +++++++++++++++++++++++++++++++++++++++-
 3 files changed, 46 insertions(+), 2 deletions(-)

diff --git a/jquery.h5validate.js b/jquery.h5validate.js
index 0069ca9..8491450 100644
--- a/jquery.h5validate.js
+++ b/jquery.h5validate.js
@@ -550,8 +550,9 @@
 		 *		example: [name="target-field"]
 		 * @param {Function} validator - An external validator function with the following definition:
 		 *		@param {String} value - The value of the input being validated.
-		 *		@return {Boolean} - the result of the validation (true = pass, false = fail)
+		 *		@return {Boolean} - The result of the validation (true = pass, false = fail).
 		 *		@this {DOM Element} - The dom element being validated. 
+		 * @return {Boolean} - Whether the selector was added successfully
 		 */
 		addExternalValidator: function(selector, validator) {
 			if (!$.isFunction(validator)) {
diff --git a/test/index.html b/test/index.html
index 6436592..9cf8c2c 100644
--- a/test/index.html
+++ b/test/index.html
@@ -265,6 +265,11 @@ <h2>External Form Validation Tests</h2>
 			<form id="externalValidationForm">
 				<input id="externalValidationFieldPass" type="text" />
 				<input id="externalValidationFieldFail" type="text" />
+				<input id="externalValidationFieldExample" type="text" value="example" />
+				<input id="externalValidationFieldNotExample" type="text" value="notexample" />
+			</form>
+			<form id="externalValidationFormPass">
+				<input id="externalValidationFieldUnused" type="text" />
 			</form>
 		</section>
 
diff --git a/test/test.h5validate.js b/test/test.h5validate.js
index a0b8a46..2f5d031 100644
--- a/test/test.h5validate.js
+++ b/test/test.h5validate.js
@@ -340,13 +340,51 @@
 	equal($field.h5Validate('isValid'), false, 'Adding an external validator that returns false should cause validation to fail.');
     });
 
+    test('Adding an external validator that confirms the value of the input should not cause validation to fail.',function () {
+	var $form = $('#externalValidationForm'),
+		$field = $('#externalValidationFieldExample');
+	$.h5Validate.addExternalValidator($field,function(value){return value == 'example';});
+	$form.h5Validate();
+	equal($field.h5Validate('isValid'), true, 'Adding an external validator that confirms the value of the input should not cause validation to fail.');
+    });
+
+    test('Adding an external validator that disconfirms the value of the input should cause validation to fail.',function () {
+	var $form = $('#externalValidationForm'),
+		$field = $('#externalValidationFieldNotExample');
+	$.h5Validate.addExternalValidator($field,function(value){return value == 'example';});
+	$form.h5Validate();
+	equal($field.h5Validate('isValid'), false, 'Adding an external validator that disconfirms the value of the input should cause validation to fail.');
+    });
+
     test('Adding an external validator to a selector that does not exist should not cause validation to fail.',function () {
-	var $form = $('#externalValidationForm');
+	var $form = $('#externalValidationFormPass');
 	$.h5Validate.addExternalValidator('atagthatdoesntexistinhtml',function(){return false;});
 	$form.h5Validate();
 	equal($form.h5Validate('allValid'), true, 'Adding an external validator to a selector that does not exist should not cause validation to fail.');
     });
 
+    test('External validators should be passed the value of the DOM element.',function () {
+	var $form = $('#externalValidationForm'),
+		$field = $('#externalValidationFieldExample');
+	$.h5Validate.addExternalValidator($field,function(value) {
+		equal(value, $field.val(), 'External validators should be passed the value of the DOM element.');
+		return true;
+	});
+	$form.h5Validate();
+	$field.h5Validate('isValid');
+    });
+
+    test('External validators should be run in the context of the DOM element of the target field.',function () {
+	var $form = $('#externalValidationForm'),
+		$field = $('#externalValidationFieldExample');
+	$.h5Validate.addExternalValidator($field,function() {
+		equal(this, $field.get(0), 'External validators should be run in the context of the DOM element of the target field.');
+		return true;
+	});
+	$form.h5Validate();
+	$field.h5Validate('isValid');
+    });
+
 
   }
   exports.runTests = runTests;

From e27e6ea86013f3a3e6ce5ac8768d82219409dd90 Mon Sep 17 00:00:00 2001
From: Christian Lent <clent@getacceptd.com>
Date: Fri, 14 Mar 2014 12:19:26 -0400
Subject: [PATCH 3/5] Renamed addExternalValidator to addValidator Added an
 "options" parameter for custom validators Added an option "name" for custom
 validators to identify which validator caused a fail Adding a non-function as
 a validator now causes an exception

---
 jquery.h5validate.js    |  18 ++--
 test/index.html         |   2 +
 test/test.h5validate.js | 178 ++++++++++++++++++++++++----------------
 3 files changed, 120 insertions(+), 78 deletions(-)

diff --git a/jquery.h5validate.js b/jquery.h5validate.js
index 8491450..566b667 100644
--- a/jquery.h5validate.js
+++ b/jquery.h5validate.js
@@ -93,7 +93,7 @@
 				invalidCallback: function () {},
 				validCallback: function () {},
 				
-				// Array of External Validator Functions. View the comment for addExternalValidator for more information.
+				// Array of External Validator Functions. View the comment for addValidator for more information.
 				externalValidators: [],
 
 				// Elements to validate with allValid (only validating visible elements)
@@ -288,11 +288,15 @@
 				for (var i = 0;i<settings.externalValidators.length;i++) {
 					var validator = settings.externalValidators[i].validator;
 					var selector = settings.externalValidators[i].selector;
+					var options = settings.externalValidators[i].options;
 					if ($(this).is(selector)) {
 						var boundValidator = validator.bind(this);
 						if (!boundValidator(value)) {
 							validity.valid = false;	
-							validity.failedExternalValidation = true;
+							validity.failedValidator = true;
+							if (options.name) {
+								validity.failedValidatorName = options.name;
+							}
 						}
 					}
 				}
@@ -552,15 +556,13 @@
 		 *		@param {String} value - The value of the input being validated.
 		 *		@return {Boolean} - The result of the validation (true = pass, false = fail).
 		 *		@this {DOM Element} - The dom element being validated. 
-		 * @return {Boolean} - Whether the selector was added successfully
+		 * @throws {Error} - If the validator is not a function, throw an exception
 		 */
-		addExternalValidator: function(selector, validator) {
+		addValidator: function(selector, validator, options) {
 			if (!$.isFunction(validator)) {
-				console.log("External validators should be functions. You, on the other hand, tried to add the following as a validator:",validator);
-				return false;
+				throw new Error('Expected external validator function. Saw ', validator);
 			}
-			defaults.externalValidators.push({selector: selector, validator: validator} );
-			return true;
+			defaults.externalValidators.push({selector: selector, validator: validator, options: options || {}} );
 		}
 	};
 
diff --git a/test/index.html b/test/index.html
index 9cf8c2c..b925af4 100644
--- a/test/index.html
+++ b/test/index.html
@@ -267,6 +267,8 @@ <h2>External Form Validation Tests</h2>
 				<input id="externalValidationFieldFail" type="text" />
 				<input id="externalValidationFieldExample" type="text" value="example" />
 				<input id="externalValidationFieldNotExample" type="text" value="notexample" />
+				<input id="externalValidationFieldNotExampleNotNamed" type="text" value="notexample" />
+				<input id="externalValidationFieldNotExampleNamed" type="text" value="notexample" />
 			</form>
 			<form id="externalValidationFormPass">
 				<input id="externalValidationFieldUnused" type="text" />
diff --git a/test/test.h5validate.js b/test/test.h5validate.js
index 2f5d031..eb3b553 100644
--- a/test/test.h5validate.js
+++ b/test/test.h5validate.js
@@ -302,89 +302,127 @@
       $form.empty().remove();
     });	
 
-    test('Adding an external validator should fail for non functions',function () {
-	var result = $.h5Validate.addExternalValidator('[name="target-field"]',5);
-	equal(result, false, 'Should not be able to add an integer as an external validator.');
-
-	var result = $.h5Validate.addExternalValidator('[name="target-field"]','5');
-	equal(result, false, 'Should not be able to add a string as an external validator.');
-
-	var result = $.h5Validate.addExternalValidator('[name="target-field"]',null);
-	equal(result, false, 'Should not be able to add a null as an external validator.');
+	test('Adding an external validator should fail for non functions',function () {
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',5);
+		}, Error, 'Should not be able to add an integer as an external validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]','5');
+		}, Error, 'Should not be able to add a string as an external validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',null);
+		}, Error, 'Should not be able to add a null as an external validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',{});
+		}, Error, 'Should not be able to add an object as an external validator.');
+
+		raises(function() {
+			$.h5Validate.addValidator('[name="target-field"]',[]);
+		}, Error, 'Should not be able to add an array as an external validator.');
+	});
 
-	var result = $.h5Validate.addExternalValidator('[name="target-field"]',{});
-	equal(result, false, 'Should not be able to add an object as an external validator.');
+	test('Adding an external validator should succeed for functions',function () {
+		$.h5Validate.addValidator('[name="target-field"]',function(){return true;});
+		ok(true, 'Should be able to add a function as an external validator without causing an exception.');
+	});
 
-	var result = $.h5Validate.addExternalValidator('[name="target-field"]',[]);
-	equal(result, false, 'Should not be able to add an array as an external validator.');
-    });
+	test('Adding an external validator that returns true should not cause validation to fail.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldPass');
+		$.h5Validate.addValidator($field,function(){return true;});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), true, 'Adding an external validator that returns true should not cause validation to fail.');
+	});
 
-    test('Adding an external validator should succeed for functions',function () {
-	var result = $.h5Validate.addExternalValidator('[name="target-field"]',function(){return true;});
-	equal(result, true, 'Should be able to add a function as an external validator.');
-    });
+	test('Adding an external validator that returns false should cause validation to fail.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldFail');
+		$.h5Validate.addValidator($field,function(){return false;});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), false, 'Adding an external validator that returns false should cause validation to fail.');
+	});
 
-    test('Adding an external validator that returns true should not cause validation to fail.',function () {
-	var $form = $('#externalValidationForm'),
-		$field = $('#externalValidationFieldPass');
-	$.h5Validate.addExternalValidator($field,function(){return true;});
-	$form.h5Validate();
-	equal($field.h5Validate('isValid'), true, 'Adding an external validator that returns true should not cause validation to fail.');
-    });
+	test('Adding an external validator that confirms the value of the input should not cause validation to fail.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldExample');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), true, 'Adding an external validator that confirms the value of the input should not cause validation to fail.');
+	});
 
-    test('Adding an external validator that returns false should cause validation to fail.',function () {
-	var $form = $('#externalValidationForm'),
-		$field = $('#externalValidationFieldFail');
-	$.h5Validate.addExternalValidator($field,function(){return false;});
-	$form.h5Validate();
-	equal($field.h5Validate('isValid'), false, 'Adding an external validator that returns false should cause validation to fail.');
-    });
+	test('Adding an external validator that disconfirms the value of the input should cause validation to fail.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldNotExample');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$form.h5Validate();
+		equal($field.h5Validate('isValid'), false, 'Adding an external validator that disconfirms the value of the input should cause validation to fail.');
+	});
 
-    test('Adding an external validator that confirms the value of the input should not cause validation to fail.',function () {
-	var $form = $('#externalValidationForm'),
-		$field = $('#externalValidationFieldExample');
-	$.h5Validate.addExternalValidator($field,function(value){return value == 'example';});
-	$form.h5Validate();
-	equal($field.h5Validate('isValid'), true, 'Adding an external validator that confirms the value of the input should not cause validation to fail.');
-    });
+	test('Adding an external validator to a selector that does not exist should not cause validation to fail.',function () {
+		var $form = $('#externalValidationFormPass');
+		$.h5Validate.addValidator('atagthatdoesntexistinhtml',function(){return false;});
+		$form.h5Validate();
+		equal($form.h5Validate('allValid'), true, 'Adding an external validator to a selector that does not exist should not cause validation to fail.');
+	});
 
-    test('Adding an external validator that disconfirms the value of the input should cause validation to fail.',function () {
-	var $form = $('#externalValidationForm'),
-		$field = $('#externalValidationFieldNotExample');
-	$.h5Validate.addExternalValidator($field,function(value){return value == 'example';});
-	$form.h5Validate();
-	equal($field.h5Validate('isValid'), false, 'Adding an external validator that disconfirms the value of the input should cause validation to fail.');
-    });
+	test('External validators should be passed the value of the DOM element.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldExample');
+		$.h5Validate.addValidator($field,function(value) {
+			equal(value, $field.val(), 'External validators should be passed the value of the DOM element.');
+			return true;
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
 
-    test('Adding an external validator to a selector that does not exist should not cause validation to fail.',function () {
-	var $form = $('#externalValidationFormPass');
-	$.h5Validate.addExternalValidator('atagthatdoesntexistinhtml',function(){return false;});
-	$form.h5Validate();
-	equal($form.h5Validate('allValid'), true, 'Adding an external validator to a selector that does not exist should not cause validation to fail.');
-    });
+	test('External validators should be run in the context of the DOM element of the target field.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldExample');
+		$.h5Validate.addValidator($field,function() {
+			equal(this, $field.get(0), 'External validators should be run in the context of the DOM element of the target field.');
+			return true;
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
 
-    test('External validators should be passed the value of the DOM element.',function () {
-	var $form = $('#externalValidationForm'),
-		$field = $('#externalValidationFieldExample');
-	$.h5Validate.addExternalValidator($field,function(value) {
-		equal(value, $field.val(), 'External validators should be passed the value of the DOM element.');
-		return true;
+	test('If an added validator fails, the validity "failedValidator" field should be true.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldNotExampleNotNamed');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$field.on('validated',function(event,validity) {
+			ok(validity.failedValidator, 'If an added validator fails, the validity "failedValidator" field should be true.');
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
 	});
-	$form.h5Validate();
-	$field.h5Validate('isValid');
-    });
 
-    test('External validators should be run in the context of the DOM element of the target field.',function () {
-	var $form = $('#externalValidationForm'),
-		$field = $('#externalValidationFieldExample');
-	$.h5Validate.addExternalValidator($field,function() {
-		equal(this, $field.get(0), 'External validators should be run in the context of the DOM element of the target field.');
-		return true;
+	test('If no validator name is supplied,the validity "failedValidatorName" property should be null.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldNotExampleNotNamed');
+		$.h5Validate.addValidator($field,function(value){return value == 'example';});
+		$field.on('validated',function(event,validity) {
+			equal(validity.failedValidatorName, null, 'If no validator name is supplied,the validity "failedValidatorName" property should be null.');
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
 	});
-	$form.h5Validate();
-	$field.h5Validate('isValid');
-    });
 
+	test('Supplied validator names should be assigned to the validity "failedValidatorName" property if they exist.',function () {
+		var $form = $('#externalValidationForm'),
+			$field = $('#externalValidationFieldNotExampleNamed'),
+			validatorName = 'exampleValidator';
+		$.h5Validate.addValidator($field,function(value){return value == 'example';},{name: validatorName});
+		$field.on('validated',function(event,validity) {
+			equal(validity.failedValidatorName, validatorName, 'Supplied validator names should be assigned to the validity "failedValidatorName" property if they exist.');
+		});
+		$form.h5Validate();
+		$field.h5Validate('isValid');
+	});
 
   }
   exports.runTests = runTests;

From 4a827d1b32054212c6c641348d966e03a9523ac5 Mon Sep 17 00:00:00 2001
From: Christian Lent <christian@lent.us>
Date: Sun, 17 Aug 2014 19:30:31 -0400
Subject: [PATCH 4/5] Refactored some builtin validators to use new
 "validators" array

---
 jquery.h5validate.js    | 174 ++++++++++++++++++++++------------------
 test/index.html         |  27 ++++---
 test/test.h5validate.js | 117 ++++++++++++++++-----------
 3 files changed, 184 insertions(+), 134 deletions(-)

diff --git a/jquery.h5validate.js b/jquery.h5validate.js
index 566b667..173e580 100644
--- a/jquery.h5validate.js
+++ b/jquery.h5validate.js
@@ -93,8 +93,8 @@
 				invalidCallback: function () {},
 				validCallback: function () {},
 				
-				// Array of External Validator Functions. View the comment for addValidator for more information.
-				externalValidators: [],
+				// Array of Validator Functions. View the comment for addValidator for more information.
+				validators: [],
 
 				// Elements to validate with allValid (only validating visible elements)
 				allValidSelectors: ':input:visible:not(:button):not(:disabled):not(.novalidate)',
@@ -142,7 +142,7 @@
 					$element.removeClass(options.errorClass).removeClass(options.validClass);
 					$element.form.find("#" + options.element.id).removeClass(options.errorClass).removeClass(options.validClass);
 					return $element;
-				}
+				},
 			}
 		},
 
@@ -153,6 +153,7 @@
 		createValidity = function createValidity(validity) {
 			return $.extend({
 				customError: validity.customError || false,
+				failedValidatorNames: [],
 				patternMismatch: validity.patternMismatch || false,
 				rangeOverflow: validity.rangeOverflow || false,
 				rangeUnderflow: validity.rangeUnderflow || false,
@@ -164,6 +165,66 @@
 			}, validity);
 		},
 
+		/**
+		 * Add builtin validators to h5Validate. Currently, this adds the following validators:
+		 *   Required
+		 *   Maxlength
+		 *   Pattern
+		 * @param  {object}  settings   instance settings
+		 */
+		addBuiltinValidators = function (settings) {
+			settings.validators.push({selector: "*", validator: function(value) {
+				var maxlength = parseInt($(this).attr('maxlength'), 10);
+				return isNaN(maxlength) || value.length <= maxlength;
+			}, options: {
+				validityFailureFlag: 'tooLong',
+				name: 'maxlength',
+			}});
+
+			settings.validators.push({selector: "*", validator: function(value) {
+				var required = false,
+					$checkRequired = $('<input required>'),
+					$this = $(this);
+
+				/*	If the required attribute exists, set it required to true, unless it's set 'false'.
+				*	This is a minor deviation from the spec, but it seems some browsers have falsey 
+				*	required values if the attribute is empty (should be true). The more conformant 
+				*	version of this failed sanity checking in the browser environment.
+				*	This plugin is meant to be practical, not ideologically married to the spec.
+				*/
+				if ($checkRequired.filter('[required]') && $checkRequired.filter('[required]').length) {
+					required = ($this.filter('[required]').length && $this.attr('required') !== 'false');
+				} else {
+					required = ($this.attr('required') !== undefined);
+				}
+
+				return !required || value;
+			}, options: {
+				validityFailureFlag: 'valueMissing',
+				name: 'required',
+			}});
+
+			settings.validators.push({selector: "*", validator: function(value) {
+				// Get the HTML5 pattern attribute if it exists.
+				// ** TODO: If a pattern class exists, grab the pattern from the patternLibrary, but the pattern attrib should override that value.
+				var $this = $(this),
+					pattern = $this.filter('[pattern]')[0] ? $this.attr('pattern') : false,
+					// The pattern attribute must match the whole value, not just a subset:
+					// "...as if it implied a ^(?: at the start of the pattern and a )$ at the end."
+					re = new RegExp('^(?:' + pattern + ')$');
+
+				if (settings.debug && window.console) {
+					console.log('Validate called on "' + value + '" with regex "' + re + '".'); // **DEBUG
+					console.log('Regex test: ' + re.test(value) + ', Pattern: ' + pattern); // **DEBUG
+				}
+
+				return !pattern || re.test(value) || !value;
+			}, options: {
+				validityFailureFlag: 'patternMismatch',
+				name: 'pattern',
+			}});
+		},
+		
 		methods = {
 			/**
 			 * Check the validity of the current field
@@ -234,14 +295,7 @@
 				return valid;
 			},
 			validate: function (settings) {
-				// Get the HTML5 pattern attribute if it exists.
-				// ** TODO: If a pattern class exists, grab the pattern from the patternLibrary, but the pattern attrib should override that value.
 				var $this = $(this),
-					pattern = $this.filter('[pattern]')[0] ? $this.attr('pattern') : false,
-
-					// The pattern attribute must match the whole value, not just a subset:
-					// "...as if it implied a ^(?: at the start of the pattern and a )$ at the end."
-					re = new RegExp('^(?:' + pattern + ')$'),
 					$radiosWithSameName = null,
 					value = ($this.is('[type=checkbox]')) ?
 							$this.is(':checked') : ($this.is('[type=radio]') ?
@@ -255,83 +309,45 @@
 					validClass = settings.validClass,
 					errorIDbare = $this.attr(settings.errorAttribute) || false, // Get the ID of the error element.
 					errorID = errorIDbare ? '#' + errorIDbare.replace(/(:|\.|\[|\])/g,'\\$1') : false, // Add the hash for convenience. This is done in two steps to avoid two attribute lookups.
-					required = false,
-					validity = createValidity({element: this, valid: true}),
-					$checkRequired = $('<input required>'),
-					maxlength;
+					validity = createValidity({element: this, valid: true});
 
-				/*	If the required attribute exists, set it required to true, unless it's set 'false'.
-				*	This is a minor deviation from the spec, but it seems some browsers have falsey 
-				*	required values if the attribute is empty (should be true). The more conformant 
-				*	version of this failed sanity checking in the browser environment.
-				*	This plugin is meant to be practical, not ideologically married to the spec.
-				*/
-				// Feature fork
-				if ($checkRequired.filter('[required]') && $checkRequired.filter('[required]').length) {
-					required = ($this.filter('[required]').length && $this.attr('required') !== 'false');
-				} else {
-					required = ($this.attr('required') !== undefined);
-				}
-
-				if (settings.debug && window.console) {
-					console.log('Validate called on "' + value + '" with regex "' + re + '". Required: ' + required); // **DEBUG
-					console.log('Regex test: ' + re.test(value) + ', Pattern: ' + pattern); // **DEBUG
-				}
-
-				maxlength = parseInt($this.attr('maxlength'), 10);
-				if (!isNaN(maxlength) && value.length > maxlength) {
-						validity.valid = false;	
-						validity.tooLong = true;
-				}
-				
-				// Iterate through the external validators. If any fail, the field fails.
-				for (var i = 0;i<settings.externalValidators.length;i++) {
-					var validator = settings.externalValidators[i].validator;
-					var selector = settings.externalValidators[i].selector;
-					var options = settings.externalValidators[i].options;
+				// Iterate through the validators. If any fail, the field fails.
+				for (var i = 0;i<settings.validators.length;i++) {
+					var validator = settings.validators[i].validator;
+					var selector = settings.validators[i].selector;
+					var options = settings.validators[i].options;
 					if ($(this).is(selector)) {
 						var boundValidator = validator.bind(this);
 						if (!boundValidator(value)) {
 							validity.valid = false;	
 							validity.failedValidator = true;
 							if (options.name) {
-								validity.failedValidatorName = options.name;
+								validity.failedValidatorNames.push(options.name);
+							}
+							if (options.validityFailureFlag) {
+								validity[options.validityFailureFlag] = true;
 							}
 						}
 					}
 				}
-
-				if (required && !value) {
-					validity.valid = false;
-					validity.valueMissing = true;
-				} else if (pattern && !re.test(value) && value) {
-					validity.valid = false;
-					validity.patternMismatch = true;
-				} else {
-					if (!settings.RODom) {
-						settings.markValid({
-							element: this,
-							validity: validity,
-							errorClass: errorClass,
-							validClass: validClass,
-							errorID: errorID,
-							settings: settings
-						});
+								
+				if (!settings.RODom) {
+					var options = {
+						element: this,
+						validity: validity,
+						errorClass: errorClass,
+						validClass: validClass,
+						errorID: errorID,
+						settings: settings
+					};
+					
+					if (validity.valid) {
+						settings.markValid(options);
+					} else {
+						settings.markInvalid(options);
 					}
 				}
 
-				if (!validity.valid) {
-					if (!settings.RODom) {
-						settings.markInvalid({
-							element: this,
-							validity: validity,
-							errorClass: errorClass,
-							validClass: validClass,
-							errorID: errorID,
-							settings: settings
-						});
-					}
-				}
 				$this.trigger('validated', validity);
 
 				// If it's a radio button, also validate the other radio buttons with the same name
@@ -478,6 +494,8 @@
 			// Combine defaults and options to get current settings.
 			var settings = $.extend({}, defaults, options, methods),
 				activeClass = settings.classPrefix + settings.activeClass;
+			
+			addBuiltinValidators(settings);
 
 			return $.extend(settings, {
 				activeClass: activeClass,
@@ -545,14 +563,14 @@
 			$(selector).data('regex', re);
 		},
 		/**
-		 * Takes a selector and a function that is used to do external validation of all fields.
+		 * Takes a selector and a function that is used to do validation of all fields.
 		 * This is useful for doing validation against a webservice
 		 * (e.g. 'http://example.com/is_value_valid/example_value')
 		 * Each validator will be matched using the corresponding selector against every field attached to h5Validate.
 		 * 
-		 * @param {Selector} selector - A jquery selector of the field on which to apply the external validator.
+		 * @param {Selector} selector - A jquery selector of the field on which to apply the validator.
 		 *		example: [name="target-field"]
-		 * @param {Function} validator - An external validator function with the following definition:
+		 * @param {Function} validator - An validator function with the following definition:
 		 *		@param {String} value - The value of the input being validated.
 		 *		@return {Boolean} - The result of the validation (true = pass, false = fail).
 		 *		@this {DOM Element} - The dom element being validated. 
@@ -560,9 +578,9 @@
 		 */
 		addValidator: function(selector, validator, options) {
 			if (!$.isFunction(validator)) {
-				throw new Error('Expected external validator function. Saw ', validator);
+				throw new Error('Expected validator function. Saw ', validator);
 			}
-			defaults.externalValidators.push({selector: selector, validator: validator, options: options || {}} );
+			defaults.validators.push({selector: selector, validator: validator, options: options || {}} );
 		}
 	};
 
diff --git a/test/index.html b/test/index.html
index b925af4..2991966 100644
--- a/test/index.html
+++ b/test/index.html
@@ -71,7 +71,12 @@ <h3>HTMTL5 pattern attribute. e.g.</h3>
 		</form>
 		<p><em>Hint: It's expecting mm/dd/yyyy. Try typing "jQuery rocks!" instead.</em></p>
 
-		
+		<h3>HTMTL5 maxlength attribute. e.g.</h3>
+
+		<form class="h5-defaults">
+		<label for="short-answer">Short Answer:</label>
+		<input id="short-answer" name="answer" type="text" placeholder="shortanswr" title="Short Answer" maxlength="10" />
+		</form>
 
 		<h3>Pattern Library</h3>
 		
@@ -261,17 +266,17 @@ <h2>Bypassing Validation tests (via 'formnovalidate')</h2>
 		</section>
 		
 		<section>
-			<h2>External Form Validation Tests</h2>
-			<form id="externalValidationForm">
-				<input id="externalValidationFieldPass" type="text" />
-				<input id="externalValidationFieldFail" type="text" />
-				<input id="externalValidationFieldExample" type="text" value="example" />
-				<input id="externalValidationFieldNotExample" type="text" value="notexample" />
-				<input id="externalValidationFieldNotExampleNotNamed" type="text" value="notexample" />
-				<input id="externalValidationFieldNotExampleNamed" type="text" value="notexample" />
+			<h2>Form Validation Tests</h2>
+			<form id="validationForm">
+				<input id="validationFieldPass" type="text" />
+				<input id="validationFieldFail" type="text" />
+				<input id="validationFieldExample" type="text" value="example" />
+				<input id="validationFieldNotExample" type="text" value="notexample" />
+				<input id="validationFieldNotExampleNotNamed" type="text" value="notexample" />
+				<input id="validationFieldNotExampleNamed" type="text" value="notexample" />
 			</form>
-			<form id="externalValidationFormPass">
-				<input id="externalValidationFieldUnused" type="text" />
+			<form id="validationFormPass">
+				<input id="validationFieldUnused" type="text" />
 			</form>
 		</section>
 
diff --git a/test/test.h5validate.js b/test/test.h5validate.js
index eb3b553..e7bdd04 100644
--- a/test/test.h5validate.js
+++ b/test/test.h5validate.js
@@ -17,6 +17,15 @@
       $input.val('');
     });
 
+    test('Missing required flag:', function () {
+      var $input = $('#name');
+      $input.val('');
+	  $input.on('validated',function(event,validity) {
+	    ok(validity.valueMissing, 'If the required validator fails, the validity property "valueMissing" should be true.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
     test('Pattern attribute:', function () {
       var $input = $('#birthdate');
       ok(($input.h5Validate('isValid')), 'Optional input should be valid when empty.');
@@ -26,6 +35,24 @@
       ok((!$input.h5Validate('isValid')), 'Input should be invalid when given invalid input.');
     });
 
+    test('Missing pattern flag:', function () {
+      var $input = $('#birthdate');
+      $input.val('foo');
+	  $input.on('validated',function(event,validity) {
+	    ok(validity.patternMismatch, 'If the pattern validator fails, the validity property "patternMismatch" should be true.');
+	  });
+      $input.h5Validate('isValid');
+	});
+
+    test('Missing maxlength flag', function () {
+      var $input = $('#short-answer');
+      $input.val('something longer than 10 characters');
+	  $input.on('validated',function(event,validity) {
+		ok(validity.tooLong, 'If the maxlength validator fails, the validity property "tooLong" should be true.');
+      });
+      $input.h5Validate('isValid');
+    });
+	  
     test('Pattern library:', function () {
       var $input = $('#email');
       $input.val('test@example.com');
@@ -302,88 +329,88 @@
       $form.empty().remove();
     });	
 
-	test('Adding an external validator should fail for non functions',function () {
+	test('Adding an validator should fail for non functions',function () {
 		raises(function() {
 			$.h5Validate.addValidator('[name="target-field"]',5);
-		}, Error, 'Should not be able to add an integer as an external validator.');
+		}, Error, 'Should not be able to add an integer as an validator.');
 
 		raises(function() {
 			$.h5Validate.addValidator('[name="target-field"]','5');
-		}, Error, 'Should not be able to add a string as an external validator.');
+		}, Error, 'Should not be able to add a string as an validator.');
 
 		raises(function() {
 			$.h5Validate.addValidator('[name="target-field"]',null);
-		}, Error, 'Should not be able to add a null as an external validator.');
+		}, Error, 'Should not be able to add a null as an validator.');
 
 		raises(function() {
 			$.h5Validate.addValidator('[name="target-field"]',{});
-		}, Error, 'Should not be able to add an object as an external validator.');
+		}, Error, 'Should not be able to add an object as an validator.');
 
 		raises(function() {
 			$.h5Validate.addValidator('[name="target-field"]',[]);
-		}, Error, 'Should not be able to add an array as an external validator.');
+		}, Error, 'Should not be able to add an array as an validator.');
 	});
 
-	test('Adding an external validator should succeed for functions',function () {
+	test('Adding an validator should succeed for functions',function () {
 		$.h5Validate.addValidator('[name="target-field"]',function(){return true;});
-		ok(true, 'Should be able to add a function as an external validator without causing an exception.');
+		ok(true, 'Should be able to add a function as an validator without causing an exception.');
 	});
 
-	test('Adding an external validator that returns true should not cause validation to fail.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldPass');
+	test('Adding an validator that returns true should not cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldPass');
 		$.h5Validate.addValidator($field,function(){return true;});
 		$form.h5Validate();
-		equal($field.h5Validate('isValid'), true, 'Adding an external validator that returns true should not cause validation to fail.');
+		equal($field.h5Validate('isValid'), true, 'Adding an validator that returns true should not cause validation to fail.');
 	});
 
-	test('Adding an external validator that returns false should cause validation to fail.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldFail');
+	test('Adding an validator that returns false should cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldFail');
 		$.h5Validate.addValidator($field,function(){return false;});
 		$form.h5Validate();
-		equal($field.h5Validate('isValid'), false, 'Adding an external validator that returns false should cause validation to fail.');
+		equal($field.h5Validate('isValid'), false, 'Adding an validator that returns false should cause validation to fail.');
 	});
 
-	test('Adding an external validator that confirms the value of the input should not cause validation to fail.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldExample');
+	test('Adding an validator that confirms the value of the input should not cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldExample');
 		$.h5Validate.addValidator($field,function(value){return value == 'example';});
 		$form.h5Validate();
-		equal($field.h5Validate('isValid'), true, 'Adding an external validator that confirms the value of the input should not cause validation to fail.');
+		equal($field.h5Validate('isValid'), true, 'Adding an validator that confirms the value of the input should not cause validation to fail.');
 	});
 
-	test('Adding an external validator that disconfirms the value of the input should cause validation to fail.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldNotExample');
+	test('Adding an validator that disconfirms the value of the input should cause validation to fail.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExample');
 		$.h5Validate.addValidator($field,function(value){return value == 'example';});
 		$form.h5Validate();
-		equal($field.h5Validate('isValid'), false, 'Adding an external validator that disconfirms the value of the input should cause validation to fail.');
+		equal($field.h5Validate('isValid'), false, 'Adding an validator that disconfirms the value of the input should cause validation to fail.');
 	});
 
-	test('Adding an external validator to a selector that does not exist should not cause validation to fail.',function () {
-		var $form = $('#externalValidationFormPass');
+	test('Adding an validator to a selector that does not exist should not cause validation to fail.',function () {
+		var $form = $('#validationFormPass');
 		$.h5Validate.addValidator('atagthatdoesntexistinhtml',function(){return false;});
 		$form.h5Validate();
-		equal($form.h5Validate('allValid'), true, 'Adding an external validator to a selector that does not exist should not cause validation to fail.');
+		equal($form.h5Validate('allValid'), true, 'Adding an validator to a selector that does not exist should not cause validation to fail.');
 	});
 
-	test('External validators should be passed the value of the DOM element.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldExample');
+	test('validators should be passed the value of the DOM element.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldExample');
 		$.h5Validate.addValidator($field,function(value) {
-			equal(value, $field.val(), 'External validators should be passed the value of the DOM element.');
+			equal(value, $field.val(), 'validators should be passed the value of the DOM element.');
 			return true;
 		});
 		$form.h5Validate();
 		$field.h5Validate('isValid');
 	});
 
-	test('External validators should be run in the context of the DOM element of the target field.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldExample');
+	test('validators should be run in the context of the DOM element of the target field.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldExample');
 		$.h5Validate.addValidator($field,function() {
-			equal(this, $field.get(0), 'External validators should be run in the context of the DOM element of the target field.');
+			equal(this, $field.get(0), 'validators should be run in the context of the DOM element of the target field.');
 			return true;
 		});
 		$form.h5Validate();
@@ -391,8 +418,8 @@
 	});
 
 	test('If an added validator fails, the validity "failedValidator" field should be true.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldNotExampleNotNamed');
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExampleNotNamed');
 		$.h5Validate.addValidator($field,function(value){return value == 'example';});
 		$field.on('validated',function(event,validity) {
 			ok(validity.failedValidator, 'If an added validator fails, the validity "failedValidator" field should be true.');
@@ -401,24 +428,24 @@
 		$field.h5Validate('isValid');
 	});
 
-	test('If no validator name is supplied,the validity "failedValidatorName" property should be null.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldNotExampleNotNamed');
+	test('If no validator name is supplied,the validity "failedValidatorNames" property should be null.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExampleNotNamed');
 		$.h5Validate.addValidator($field,function(value){return value == 'example';});
 		$field.on('validated',function(event,validity) {
-			equal(validity.failedValidatorName, null, 'If no validator name is supplied,the validity "failedValidatorName" property should be null.');
+			deepEqual(validity.failedValidatorNames, [], 'If no validator name is supplied,the validity "failedValidatorNames" property should be an empty array.');
 		});
 		$form.h5Validate();
 		$field.h5Validate('isValid');
 	});
 
-	test('Supplied validator names should be assigned to the validity "failedValidatorName" property if they exist.',function () {
-		var $form = $('#externalValidationForm'),
-			$field = $('#externalValidationFieldNotExampleNamed'),
+	test('Supplied validator names should be assigned to the validity "failedValidatorNames" property if they exist.',function () {
+		var $form = $('#validationForm'),
+			$field = $('#validationFieldNotExampleNamed'),
 			validatorName = 'exampleValidator';
 		$.h5Validate.addValidator($field,function(value){return value == 'example';},{name: validatorName});
 		$field.on('validated',function(event,validity) {
-			equal(validity.failedValidatorName, validatorName, 'Supplied validator names should be assigned to the validity "failedValidatorName" property if they exist.');
+			deepEqual(validity.failedValidatorNames, [validatorName], 'Supplied validator names should be assigned to the validity "failedValidatorNames" property if they exist.');
 		});
 		$form.h5Validate();
 		$field.h5Validate('isValid');

From 4480079b135f8559eabe1f346f225687a51eecb2 Mon Sep 17 00:00:00 2001
From: Christian Lent <christian@lent.us>
Date: Sun, 17 Aug 2014 22:37:52 -0400
Subject: [PATCH 5/5] Better default failure flags

---
 jquery.h5validate.js    | 19 ++++++++++-------
 test/test.h5validate.js | 45 ++++++++++++++++++++++++++++++++++++++---
 2 files changed, 54 insertions(+), 10 deletions(-)

diff --git a/jquery.h5validate.js b/jquery.h5validate.js
index 173e580..0efb9be 100644
--- a/jquery.h5validate.js
+++ b/jquery.h5validate.js
@@ -154,14 +154,11 @@
 			return $.extend({
 				customError: validity.customError || false,
 				failedValidatorNames: [],
-				patternMismatch: validity.patternMismatch || false,
 				rangeOverflow: validity.rangeOverflow || false,
 				rangeUnderflow: validity.rangeUnderflow || false,
 				stepMismatch: validity.stepMismatch || false,
-				tooLong: validity.tooLong || false,
 				typeMismatch: validity.typeMismatch || false,
 				valid: validity.valid || true,
-				valueMissing: validity.valueMissing || false
 			}, validity);
 		},
 
@@ -313,9 +310,17 @@
 
 				// Iterate through the validators. If any fail, the field fails.
 				for (var i = 0;i<settings.validators.length;i++) {
-					var validator = settings.validators[i].validator;
-					var selector = settings.validators[i].selector;
-					var options = settings.validators[i].options;
+					var validator = settings.validators[i].validator,
+						selector = settings.validators[i].selector,
+						options = settings.validators[i].options,
+						setFailureFlag = false;
+					
+					// We don't want to overwrite any of the other validity properties (such as "valid")
+					if (options.validityFailureFlag && !validity.hasOwnProperty(options.validityFailureFlag)) {
+						setFailureFlag = true;
+						validity[options.validityFailureFlag] = false;
+					}
+					
 					if ($(this).is(selector)) {
 						var boundValidator = validator.bind(this);
 						if (!boundValidator(value)) {
@@ -324,7 +329,7 @@
 							if (options.name) {
 								validity.failedValidatorNames.push(options.name);
 							}
-							if (options.validityFailureFlag) {
+							if (setFailureFlag) {
 								validity[options.validityFailureFlag] = true;
 							}
 						}
diff --git a/test/test.h5validate.js b/test/test.h5validate.js
index e7bdd04..4cf4947 100644
--- a/test/test.h5validate.js
+++ b/test/test.h5validate.js
@@ -9,6 +9,45 @@
       ok((typeof $('<div>').h5Validate === 'function'), 'h5Validate exists');
     });
 
+    test('Required validation failure flag false by default:', function () {
+      var $form = $('<form />'),
+        $input = $('<textarea />').appendTo($form);
+
+      $form.appendTo('body').h5Validate();
+
+	  $input.val('Bob');
+	  $input.on('validated',function(event,validity) {
+	    strictEqual(validity.valueMissing, false, 'If the required validator does not fail, the validity property "valueMissing" should be false.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
+    test('Maxlength validation failure flag false by default:', function () {
+      var $form = $('<form />'),
+        $input = $('<textarea />').appendTo($form);
+
+      $form.appendTo('body').h5Validate();
+
+	  $input.val('Bob');
+	  $input.on('validated',function(event,validity) {
+	    strictEqual(validity.tooLong, false, 'If the maxlength validator does not fail, the validity property "tooLong" should be false.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
+    test('Pattern validation failure flag false by default:', function () {
+      var $form = $('<form />'),
+        $input = $('<textarea />').appendTo($form);
+
+      $form.appendTo('body').h5Validate();
+
+	  $input.val('Bob');
+	  $input.on('validated',function(event,validity) {
+	    strictEqual(validity.patternMismatch, false, 'If the pattern validator does not fail, the validity property "patternMismatch" should be false.');
+	  });
+      $input.h5Validate('isValid');
+    });
+
     test('Required:', function () {
       var $input = $('#name');
       ok((!$input.h5Validate('isValid')), 'Required input should be invalid when empty.');
@@ -17,7 +56,7 @@
       $input.val('');
     });
 
-    test('Missing required flag:', function () {
+    test('Required validation failure flag set:', function () {
       var $input = $('#name');
       $input.val('');
 	  $input.on('validated',function(event,validity) {
@@ -35,7 +74,7 @@
       ok((!$input.h5Validate('isValid')), 'Input should be invalid when given invalid input.');
     });
 
-    test('Missing pattern flag:', function () {
+    test('Pattern validation failure flag set:', function () {
       var $input = $('#birthdate');
       $input.val('foo');
 	  $input.on('validated',function(event,validity) {
@@ -44,7 +83,7 @@
       $input.h5Validate('isValid');
 	});
 
-    test('Missing maxlength flag', function () {
+    test('Maxlength validation failure flag set', function () {
       var $input = $('#short-answer');
       $input.val('something longer than 10 characters');
 	  $input.on('validated',function(event,validity) {