From d593b1c870225c3ecff10c970939da3f8cf15f78 Mon Sep 17 00:00:00 2001
From: Ingo Schommer <ingo@silverstripe.com>
Date: Thu, 26 Nov 2009 03:07:33 +0000
Subject: [PATCH] MINOR Moved jsparty/jquery/plugins/form to
 sapphire/thirdparty/jquery-form

git-svn-id: svn://svn.silverstripe.com/silverstripe/open/modules/sapphire/branches/2.4@93550 467b73ca-7a2a-4603-9d3b-597d59a354a9
---
 thirdparty/jquery-form/META.json              |  32 +
 thirdparty/jquery-form/jquery.form.js         | 892 ++++++++++++++++
 .../jquery-form/test/doc-with-scripts.html    |  27 +
 thirdparty/jquery-form/test/index.html        | 984 ++++++++++++++++++
 thirdparty/jquery-form/test/json.php          |   3 +
 thirdparty/jquery-form/test/json.txt          |   1 +
 thirdparty/jquery-form/test/script.txt        |   3 +
 thirdparty/jquery-form/test/submit.gif        | Bin 0 -> 1648 bytes
 thirdparty/jquery-form/test/test.xml          |   5 +
 thirdparty/jquery-form/test/text.php          |  12 +
 10 files changed, 1959 insertions(+)
 create mode 100644 thirdparty/jquery-form/META.json
 create mode 100644 thirdparty/jquery-form/jquery.form.js
 create mode 100644 thirdparty/jquery-form/test/doc-with-scripts.html
 create mode 100644 thirdparty/jquery-form/test/index.html
 create mode 100644 thirdparty/jquery-form/test/json.php
 create mode 100644 thirdparty/jquery-form/test/json.txt
 create mode 100644 thirdparty/jquery-form/test/script.txt
 create mode 100644 thirdparty/jquery-form/test/submit.gif
 create mode 100644 thirdparty/jquery-form/test/test.xml
 create mode 100644 thirdparty/jquery-form/test/text.php

diff --git a/thirdparty/jquery-form/META.json b/thirdparty/jquery-form/META.json
new file mode 100644
index 000000000..ffac08c16
--- /dev/null
+++ b/thirdparty/jquery-form/META.json
@@ -0,0 +1,32 @@
+{
+	"name": "jQuery-Form",
+	"version": 0.9,
+	"author": [
+		"Mike Alsup <malsup@gmail.com>"
+	],
+	"abstract": "Unobtrusively convert regular forms into Ajax forms.",
+	"license": "mit, gpl",
+	"distribution_type": "plugin",
+	"requires": {
+		"jQuery": ">= 1.0.3, < 1.2"
+	},
+	"build_requires": {
+		"jQuery.TestRunner": 0
+	},
+	"provides": {
+		"jQuery.Form": {
+			"version": 0.9,
+			"file": "jquery.form.js"
+		}
+	},
+	"keywords": [
+		"forms",
+		"unobtrusive"
+	],
+	"stability": "Official",
+	"meta-spec": {
+		"version": 1.3,
+		"url": "http://module-build.sourceforge.net/META-spec-v1.3.html"
+	},
+	"generated_by": "Yehuda Katz"
+}
diff --git a/thirdparty/jquery-form/jquery.form.js b/thirdparty/jquery-form/jquery.form.js
new file mode 100644
index 000000000..51ffd468b
--- /dev/null
+++ b/thirdparty/jquery-form/jquery.form.js
@@ -0,0 +1,892 @@
+/*
+ * jQuery Form Plugin
+ * version: 2.08 (04/29/2008)
+ * @requires jQuery v1.2.2 or later
+ *
+ * Examples at: http://malsup.com/jquery/form/
+ * Dual licensed under the MIT and GPL licenses:
+ *   http://www.opensource.org/licenses/mit-license.php
+ *   http://www.gnu.org/licenses/gpl.html
+ *
+ * Revision: $Id: jquery.form.js 5359 2008-04-30 00:19:42Z malsup $
+ */
+(function($) {
+
+/**
+ * ajaxSubmit() provides a mechanism for submitting an HTML form using AJAX.
+ *
+ * ajaxSubmit accepts a single argument which can be either a success callback function
+ * or an options Object.  If a function is provided it will be invoked upon successful
+ * completion of the submit and will be passed the response from the server.
+ * If an options Object is provided, the following attributes are supported:
+ *
+ *  target:   Identifies the element(s) in the page to be updated with the server response.
+ *            This value may be specified as a jQuery selection string, a jQuery object,
+ *            or a DOM element.
+ *            default value: null
+ *
+ *  url:      URL to which the form data will be submitted.
+ *            default value: value of form's 'action' attribute
+ *
+ *  type:     The method in which the form data should be submitted, 'GET' or 'POST'.
+ *            default value: value of form's 'method' attribute (or 'GET' if none found)
+ *
+ *  data:     Additional data to add to the request, specified as key/value pairs (see $.ajax).
+ *
+ *  beforeSubmit:  Callback method to be invoked before the form is submitted.
+ *            default value: null
+ *
+ *  success:  Callback method to be invoked after the form has been successfully submitted
+ *            and the response has been returned from the server
+ *            default value: null
+ *
+ *  dataType: Expected dataType of the response.  One of: null, 'xml', 'script', or 'json'
+ *            default value: null
+ *
+ *  semantic: Boolean flag indicating whether data must be submitted in semantic order (slower).
+ *            default value: false
+ *
+ *  resetForm: Boolean flag indicating whether the form should be reset if the submit is successful
+ *
+ *  clearForm: Boolean flag indicating whether the form should be cleared if the submit is successful
+ *
+ *
+ * The 'beforeSubmit' callback can be provided as a hook for running pre-submit logic or for
+ * validating the form data.  If the 'beforeSubmit' callback returns false then the form will
+ * not be submitted. The 'beforeSubmit' callback is invoked with three arguments: the form data
+ * in array format, the jQuery object, and the options object passed into ajaxSubmit.
+ * The form data array takes the following form:
+ *
+ *     [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
+ *
+ * If a 'success' callback method is provided it is invoked after the response has been returned
+ * from the server.  It is passed the responseText or responseXML value (depending on dataType).
+ * See jQuery.ajax for further details.
+ *
+ *
+ * The dataType option provides a means for specifying how the server response should be handled.
+ * This maps directly to the jQuery.httpData method.  The following values are supported:
+ *
+ *      'xml':    if dataType == 'xml' the server response is treated as XML and the 'success'
+ *                   callback method, if specified, will be passed the responseXML value
+ *      'json':   if dataType == 'json' the server response will be evaluted and passed to
+ *                   the 'success' callback, if specified
+ *      'script': if dataType == 'script' the server response is evaluated in the global context
+ *
+ *
+ * Note that it does not make sense to use both the 'target' and 'dataType' options.  If both
+ * are provided the target will be ignored.
+ *
+ * The semantic argument can be used to force form serialization in semantic order.
+ * This is normally true anyway, unless the form contains input elements of type='image'.
+ * If your form must be submitted with name/value pairs in semantic order and your form
+ * contains an input of type='image" then pass true for this arg, otherwise pass false
+ * (or nothing) to avoid the overhead for this logic.
+ *
+ *
+ * When used on its own, ajaxSubmit() is typically bound to a form's submit event like this:
+ *
+ * $("#form-id").submit(function() {
+ *     $(this).ajaxSubmit(options);
+ *     return false; // cancel conventional submit
+ * });
+ *
+ * When using ajaxForm(), however, this is done for you.
+ *
+ * @example
+ * $('#myForm').ajaxSubmit(function(data) {
+ *     alert('Form submit succeeded! Server returned: ' + data);
+ * });
+ * @desc Submit form and alert server response
+ *
+ *
+ * @example
+ * var options = {
+ *     target: '#myTargetDiv'
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc Submit form and update page element with server response
+ *
+ *
+ * @example
+ * var options = {
+ *     success: function(responseText) {
+ *         alert(responseText);
+ *     }
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc Submit form and alert the server response
+ *
+ *
+ * @example
+ * var options = {
+ *     beforeSubmit: function(formArray, jqForm) {
+ *         if (formArray.length == 0) {
+ *             alert('Please enter data.');
+ *             return false;
+ *         }
+ *     }
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc Pre-submit validation which aborts the submit operation if form data is empty
+ *
+ *
+ * @example
+ * var options = {
+ *     url: myJsonUrl.php,
+ *     dataType: 'json',
+ *     success: function(data) {
+ *        // 'data' is an object representing the the evaluated json data
+ *     }
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc json data returned and evaluated
+ *
+ *
+ * @example
+ * var options = {
+ *     url: myXmlUrl.php,
+ *     dataType: 'xml',
+ *     success: function(responseXML) {
+ *        // responseXML is XML document object
+ *        var data = $('myElement', responseXML).text();
+ *     }
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc XML data returned from server
+ *
+ *
+ * @example
+ * var options = {
+ *     resetForm: true
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc submit form and reset it if successful
+ *
+ * @example
+ * $('#myForm).submit(function() {
+ *    $(this).ajaxSubmit();
+ *    return false;
+ * });
+ * @desc Bind form's submit event to use ajaxSubmit
+ *
+ *
+ * @name ajaxSubmit
+ * @type jQuery
+ * @param options  object literal containing options which control the form submission process
+ * @cat Plugins/Form
+ * @return jQuery
+ */
+$.fn.ajaxSubmit = function(options) {
+    // fast fail if nothing selected (http://dev.jquery.com/ticket/2752)
+    if (!this.length) {
+        log('ajaxSubmit: skipping submit process - no element selected');
+        return this;
+    }
+
+    if (typeof options == 'function')
+        options = { success: options };
+
+    options = $.extend({
+        url:  this.attr('action') || window.location.toString(),
+        type: this.attr('method') || 'GET'
+    }, options || {});
+
+    // hook for manipulating the form data before it is extracted;
+    // convenient for use with rich editors like tinyMCE or FCKEditor
+    var veto = {};
+    this.trigger('form-pre-serialize', [this, options, veto]);
+    if (veto.veto) {
+        log('ajaxSubmit: submit vetoed via form-pre-serialize trigger');
+        return this;
+   }
+
+    var a = this.formToArray(options.semantic);
+    if (options.data) {
+        options.extraData = options.data;
+        for (var n in options.data)
+            a.push( { name: n, value: options.data[n] } );
+    }
+
+    // give pre-submit callback an opportunity to abort the submit
+    if (options.beforeSubmit && options.beforeSubmit(a, this, options) === false) {
+        log('ajaxSubmit: submit aborted via beforeSubmit callback');
+        return this;
+    }    
+
+    // fire vetoable 'validate' event
+    this.trigger('form-submit-validate', [a, this, options, veto]);
+    if (veto.veto) {
+        log('ajaxSubmit: submit vetoed via form-submit-validate trigger');
+        return this;
+    }    
+
+    var q = $.param(a);
+
+    if (options.type.toUpperCase() == 'GET') {
+        options.url += (options.url.indexOf('?') >= 0 ? '&' : '?') + q;
+        options.data = null;  // data is null for 'get'
+    }
+    else
+        options.data = q; // data is the query string for 'post'
+
+    var $form = this, callbacks = [];
+    if (options.resetForm) callbacks.push(function() { $form.resetForm(); });
+    if (options.clearForm) callbacks.push(function() { $form.clearForm(); });
+
+    // perform a load on the target only if dataType is not provided
+    if (!options.dataType && options.target) {
+        var oldSuccess = options.success || function(){};
+        callbacks.push(function(data) {
+            $(options.target).html(data).each(oldSuccess, arguments);
+        });
+    }
+    else if (options.success)
+        callbacks.push(options.success);
+
+    options.success = function(data, status) {
+        for (var i=0, max=callbacks.length; i < max; i++)
+            callbacks[i](data, status, $form);
+    };
+
+    // are there files to upload?
+    var files = $('input:file', this).fieldValue();
+    var found = false;
+    for (var j=0; j < files.length; j++)
+        if (files[j])
+            found = true;
+
+    // options.iframe allows user to force iframe mode
+   if (options.iframe || found) { 
+       // hack to fix Safari hang (thanks to Tim Molendijk for this)
+       // see:  http://groups.google.com/group/jquery-dev/browse_thread/thread/36395b7ab510dd5d
+       if ($.browser.safari && options.closeKeepAlive)
+           $.get(options.closeKeepAlive, fileUpload);
+       else
+           fileUpload();
+       }
+   else
+       $.ajax(options);
+
+    // fire 'notify' event
+    this.trigger('form-submit-notify', [this, options]);
+    return this;
+
+
+    // private function for handling file uploads (hat tip to YAHOO!)
+    function fileUpload() {
+        var form = $form[0];
+        var opts = $.extend({}, $.ajaxSettings, options);
+
+        var id = 'jqFormIO' + (new Date().getTime());
+        var $io = $('<iframe id="' + id + '" name="' + id + '" />');
+        var io = $io[0];
+        var op8 = $.browser.opera && window.opera.version() < 9;
+        if ($.browser.msie || op8) io.src = 'javascript:false;document.write("");';
+        $io.css({ position: 'absolute', top: '-1000px', left: '-1000px' });
+
+        var xhr = { // mock object
+            responseText: null,
+            responseXML: null,
+            status: 0,
+            statusText: 'n/a',
+            getAllResponseHeaders: function() {},
+            getResponseHeader: function() {},
+            setRequestHeader: function() {}
+        };
+
+        var g = opts.global;
+        // trigger ajax global events so that activity/block indicators work like normal
+        if (g && ! $.active++) $.event.trigger("ajaxStart");
+        if (g) $.event.trigger("ajaxSend", [xhr, opts]);
+
+        var cbInvoked = 0;
+        var timedOut = 0;
+
+        // take a breath so that pending repaints get some cpu time before the upload starts
+        setTimeout(function() {
+            // make sure form attrs are set
+            var t = $form.attr('target'), a = $form.attr('action');
+            $form.attr({
+                target:   id,
+                encoding: 'multipart/form-data',
+                enctype:  'multipart/form-data',
+                method:   'POST',
+                action:   opts.url
+            });
+
+            // support timout
+            if (opts.timeout)
+                setTimeout(function() { timedOut = true; cb(); }, opts.timeout);
+
+            // add "extra" data to form if provided in options
+            var extraInputs = [];
+            try {
+                if (options.extraData)
+                    for (var n in options.extraData)
+                        extraInputs.push(
+                            $('<input type="hidden" name="'+n+'" value="'+options.extraData[n]+'" />')
+                                .appendTo(form)[0]);
+            
+                // add iframe to doc and submit the form
+                $io.appendTo('body');
+                io.attachEvent ? io.attachEvent('onload', cb) : io.addEventListener('load', cb, false);
+                form.submit();
+            }
+            finally {
+                // reset attrs and remove "extra" input elements
+                $form.attr('action', a);
+                t ? $form.attr('target', t) : $form.removeAttr('target');
+                $(extraInputs).remove();
+            }
+        }, 10);
+
+        function cb() {
+            if (cbInvoked++) return;
+
+            io.detachEvent ? io.detachEvent('onload', cb) : io.removeEventListener('load', cb, false);
+
+            var ok = true;
+            try {
+                if (timedOut) throw 'timeout';
+                // extract the server response from the iframe
+                var data, doc;
+                doc = io.contentWindow ? io.contentWindow.document : io.contentDocument ? io.contentDocument : io.document;
+                xhr.responseText = doc.body ? doc.body.innerHTML : null;
+                xhr.responseXML = doc.XMLDocument ? doc.XMLDocument : doc;
+                xhr.getResponseHeader = function(header){
+                    var headers = {'content-type': opts.dataType};
+                    return headers[header];
+                };
+
+                if (opts.dataType == 'json' || opts.dataType == 'script') {
+                    var ta = doc.getElementsByTagName('textarea')[0];
+                    xhr.responseText = ta ? ta.value : xhr.responseText;
+                }
+                else if (opts.dataType == 'xml' && !xhr.responseXML && xhr.responseText != null) {
+                    xhr.responseXML = toXml(xhr.responseText);
+                }
+                data = $.httpData(xhr, opts.dataType);
+            }
+            catch(e){
+                ok = false;
+                $.handleError(opts, xhr, 'error', e);
+            }
+
+            // ordering of these callbacks/triggers is odd, but that's how $.ajax does it
+            if (ok) {
+                opts.success(data, 'success');
+                if (g) $.event.trigger("ajaxSuccess", [xhr, opts]);
+            }
+            if (g) $.event.trigger("ajaxComplete", [xhr, opts]);
+            if (g && ! --$.active) $.event.trigger("ajaxStop");
+            if (opts.complete) opts.complete(xhr, ok ? 'success' : 'error');
+
+            // clean up
+            setTimeout(function() {
+                $io.remove();
+                xhr.responseXML = null;
+            }, 100);
+        };
+
+        function toXml(s, doc) {
+            if (window.ActiveXObject) {
+                doc = new ActiveXObject('Microsoft.XMLDOM');
+                doc.async = 'false';
+                doc.loadXML(s);
+            }
+            else
+                doc = (new DOMParser()).parseFromString(s, 'text/xml');
+            return (doc && doc.documentElement && doc.documentElement.tagName != 'parsererror') ? doc : null;
+        };
+    };
+};
+
+/**
+ * ajaxForm() provides a mechanism for fully automating form submission.
+ *
+ * The advantages of using this method instead of ajaxSubmit() are:
+ *
+ * 1: This method will include coordinates for <input type="image" /> elements (if the element
+ *    is used to submit the form).
+ * 2. This method will include the submit element's name/value data (for the element that was
+ *    used to submit the form).
+ * 3. This method binds the submit() method to the form for you.
+ *
+ * Note that for accurate x/y coordinates of image submit elements in all browsers
+ * you need to also use the "dimensions" plugin (this method will auto-detect its presence).
+ *
+ * The options argument for ajaxForm works exactly as it does for ajaxSubmit.  ajaxForm merely
+ * passes the options argument along after properly binding events for submit elements and
+ * the form itself.  See ajaxSubmit for a full description of the options argument.
+ *
+ *
+ * @example
+ * var options = {
+ *     target: '#myTargetDiv'
+ * };
+ * $('#myForm').ajaxSForm(options);
+ * @desc Bind form's submit event so that 'myTargetDiv' is updated with the server response
+ *       when the form is submitted.
+ *
+ *
+ * @example
+ * var options = {
+ *     success: function(responseText) {
+ *         alert(responseText);
+ *     }
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc Bind form's submit event so that server response is alerted after the form is submitted.
+ *
+ *
+ * @example
+ * var options = {
+ *     beforeSubmit: function(formArray, jqForm) {
+ *         if (formArray.length == 0) {
+ *             alert('Please enter data.');
+ *             return false;
+ *         }
+ *     }
+ * };
+ * $('#myForm').ajaxSubmit(options);
+ * @desc Bind form's submit event so that pre-submit callback is invoked before the form
+ *       is submitted.
+ *
+ *
+ * @name   ajaxForm
+ * @param  options  object literal containing options which control the form submission process
+ * @return jQuery
+ * @cat    Plugins/Form
+ * @type   jQuery
+ */
+$.fn.ajaxForm = function(options) {
+    return this.ajaxFormUnbind().bind('submit.form-plugin',function() {
+        $(this).ajaxSubmit(options);
+        return false;
+    }).each(function() {
+        // store options in hash
+        $(":submit,input:image", this).bind('click.form-plugin',function(e) {
+            var $form = this.form;
+            $form.clk = this;
+            if (this.type == 'image') {
+                if (e.offsetX != undefined) {
+                    $form.clk_x = e.offsetX;
+                    $form.clk_y = e.offsetY;
+                } else if (typeof $.fn.offset == 'function') { // try to use dimensions plugin
+                    var offset = $(this).offset();
+                    $form.clk_x = e.pageX - offset.left;
+                    $form.clk_y = e.pageY - offset.top;
+                } else {
+                    $form.clk_x = e.pageX - this.offsetLeft;
+                    $form.clk_y = e.pageY - this.offsetTop;
+                }
+            }
+            // clear form vars
+            setTimeout(function() { $form.clk = $form.clk_x = $form.clk_y = null; }, 10);
+        });
+    });
+};
+
+
+/**
+ * ajaxFormUnbind unbinds the event handlers that were bound by ajaxForm
+ *
+ * @name   ajaxFormUnbind
+ * @return jQuery
+ * @cat    Plugins/Form
+ * @type   jQuery
+ */
+$.fn.ajaxFormUnbind = function() {
+    this.unbind('submit.form-plugin');
+    return this.each(function() {
+        $(":submit,input:image", this).unbind('click.form-plugin');
+    });
+
+};
+
+/**
+ * formToArray() gathers form element data into an array of objects that can
+ * be passed to any of the following ajax functions: $.get, $.post, or load.
+ * Each object in the array has both a 'name' and 'value' property.  An example of
+ * an array for a simple login form might be:
+ *
+ * [ { name: 'username', value: 'jresig' }, { name: 'password', value: 'secret' } ]
+ *
+ * It is this array that is passed to pre-submit callback functions provided to the
+ * ajaxSubmit() and ajaxForm() methods.
+ *
+ * The semantic argument can be used to force form serialization in semantic order.
+ * This is normally true anyway, unless the form contains input elements of type='image'.
+ * If your form must be submitted with name/value pairs in semantic order and your form
+ * contains an input of type='image" then pass true for this arg, otherwise pass false
+ * (or nothing) to avoid the overhead for this logic.
+ *
+ * @example var data = $("#myForm").formToArray();
+ * $.post( "myscript.cgi", data );
+ * @desc Collect all the data from a form and submit it to the server.
+ *
+ * @name formToArray
+ * @param semantic true if serialization must maintain strict semantic ordering of elements (slower)
+ * @type Array<Object>
+ * @cat Plugins/Form
+ */
+$.fn.formToArray = function(semantic) {
+    var a = [];
+    if (this.length == 0) return a;
+
+    var form = this[0];
+    var els = semantic ? form.getElementsByTagName('*') : form.elements;
+    if (!els) return a;
+    for(var i=0, max=els.length; i < max; i++) {
+        var el = els[i];
+        var n = el.name;
+        if (!n) continue;
+
+        if (semantic && form.clk && el.type == "image") {
+            // handle image inputs on the fly when semantic == true
+            if(!el.disabled && form.clk == el)
+                a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
+            continue;
+        }
+
+        var v = $.fieldValue(el, true);
+        if (v && v.constructor == Array) {
+            for(var j=0, jmax=v.length; j < jmax; j++)
+                a.push({name: n, value: v[j]});
+        }
+        else if (v !== null && typeof v != 'undefined')
+            a.push({name: n, value: v});
+    }
+
+    if (!semantic && form.clk) {
+        // input type=='image' are not found in elements array! handle them here
+        var inputs = form.getElementsByTagName("input");
+        for(var i=0, max=inputs.length; i < max; i++) {
+            var input = inputs[i];
+            var n = input.name;
+            if(n && !input.disabled && input.type == "image" && form.clk == input)
+                a.push({name: n+'.x', value: form.clk_x}, {name: n+'.y', value: form.clk_y});
+        }
+    }
+    return a;
+};
+
+
+/**
+ * Serializes form data into a 'submittable' string. This method will return a string
+ * in the format: name1=value1&amp;name2=value2
+ *
+ * The semantic argument can be used to force form serialization in semantic order.
+ * If your form must be submitted with name/value pairs in semantic order then pass
+ * true for this arg, otherwise pass false (or nothing) to avoid the overhead for
+ * this logic (which can be significant for very large forms).
+ *
+ * @example var data = $("#myForm").formSerialize();
+ * $.ajax('POST', "myscript.cgi", data);
+ * @desc Collect all the data from a form into a single string
+ *
+ * @name formSerialize
+ * @param semantic true if serialization must maintain strict semantic ordering of elements (slower)
+ * @type String
+ * @cat Plugins/Form
+ */
+$.fn.formSerialize = function(semantic) {
+    //hand off to jQuery.param for proper encoding
+    return $.param(this.formToArray(semantic));
+};
+
+
+/**
+ * Serializes all field elements in the jQuery object into a query string.
+ * This method will return a string in the format: name1=value1&amp;name2=value2
+ *
+ * The successful argument controls whether or not serialization is limited to
+ * 'successful' controls (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
+ * The default value of the successful argument is true.
+ *
+ * @example var data = $("input").fieldSerialize();
+ * @desc Collect the data from all successful input elements into a query string
+ *
+ * @example var data = $(":radio").fieldSerialize();
+ * @desc Collect the data from all successful radio input elements into a query string
+ *
+ * @example var data = $("#myForm :checkbox").fieldSerialize();
+ * @desc Collect the data from all successful checkbox input elements in myForm into a query string
+ *
+ * @example var data = $("#myForm :checkbox").fieldSerialize(false);
+ * @desc Collect the data from all checkbox elements in myForm (even the unchecked ones) into a query string
+ *
+ * @example var data = $(":input").fieldSerialize();
+ * @desc Collect the data from all successful input, select, textarea and button elements into a query string
+ *
+ * @name fieldSerialize
+ * @param successful true if only successful controls should be serialized (default is true)
+ * @type String
+ * @cat Plugins/Form
+ */
+$.fn.fieldSerialize = function(successful) {
+    var a = [];
+    this.each(function() {
+        var n = this.name;
+        if (!n) return;
+        var v = $.fieldValue(this, successful);
+        if (v && v.constructor == Array) {
+            for (var i=0,max=v.length; i < max; i++)
+                a.push({name: n, value: v[i]});
+        }
+        else if (v !== null && typeof v != 'undefined')
+            a.push({name: this.name, value: v});
+    });
+    //hand off to jQuery.param for proper encoding
+    return $.param(a);
+};
+
+
+/**
+ * Returns the value(s) of the element in the matched set.  For example, consider the following form:
+ *
+ *  <form><fieldset>
+ *      <input name="A" type="text" />
+ *      <input name="A" type="text" />
+ *      <input name="B" type="checkbox" value="B1" />
+ *      <input name="B" type="checkbox" value="B2"/>
+ *      <input name="C" type="radio" value="C1" />
+ *      <input name="C" type="radio" value="C2" />
+ *  </fieldset></form>
+ *
+ *  var v = $(':text').fieldValue();
+ *  // if no values are entered into the text inputs
+ *  v == ['','']
+ *  // if values entered into the text inputs are 'foo' and 'bar'
+ *  v == ['foo','bar']
+ *
+ *  var v = $(':checkbox').fieldValue();
+ *  // if neither checkbox is checked
+ *  v === undefined
+ *  // if both checkboxes are checked
+ *  v == ['B1', 'B2']
+ *
+ *  var v = $(':radio').fieldValue();
+ *  // if neither radio is checked
+ *  v === undefined
+ *  // if first radio is checked
+ *  v == ['C1']
+ *
+ * The successful argument controls whether or not the field element must be 'successful'
+ * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
+ * The default value of the successful argument is true.  If this value is false the value(s)
+ * for each element is returned.
+ *
+ * Note: This method *always* returns an array.  If no valid value can be determined the
+ *       array will be empty, otherwise it will contain one or more values.
+ *
+ * @example var data = $("#myPasswordElement").fieldValue();
+ * alert(data[0]);
+ * @desc Alerts the current value of the myPasswordElement element
+ *
+ * @example var data = $("#myForm :input").fieldValue();
+ * @desc Get the value(s) of the form elements in myForm
+ *
+ * @example var data = $("#myForm :checkbox").fieldValue();
+ * @desc Get the value(s) for the successful checkbox element(s) in the jQuery object.
+ *
+ * @example var data = $("#mySingleSelect").fieldValue();
+ * @desc Get the value(s) of the select control
+ *
+ * @example var data = $(':text').fieldValue();
+ * @desc Get the value(s) of the text input or textarea elements
+ *
+ * @example var data = $("#myMultiSelect").fieldValue();
+ * @desc Get the values for the select-multiple control
+ *
+ * @name fieldValue
+ * @param Boolean successful true if only the values for successful controls should be returned (default is true)
+ * @type Array<String>
+ * @cat Plugins/Form
+ */
+$.fn.fieldValue = function(successful) {
+    for (var val=[], i=0, max=this.length; i < max; i++) {
+        var el = this[i];
+        var v = $.fieldValue(el, successful);
+        if (v === null || typeof v == 'undefined' || (v.constructor == Array && !v.length))
+            continue;
+        v.constructor == Array ? $.merge(val, v) : val.push(v);
+    }
+    return val;
+};
+
+/**
+ * Returns the value of the field element.
+ *
+ * The successful argument controls whether or not the field element must be 'successful'
+ * (per http://www.w3.org/TR/html4/interact/forms.html#successful-controls).
+ * The default value of the successful argument is true.  If the given element is not
+ * successful and the successful arg is not false then the returned value will be null.
+ *
+ * Note: If the successful flag is true (default) but the element is not successful, the return will be null
+ * Note: The value returned for a successful select-multiple element will always be an array.
+ * Note: If the element has no value the return value will be undefined.
+ *
+ * @example var data = jQuery.fieldValue($("#myPasswordElement")[0]);
+ * @desc Gets the current value of the myPasswordElement element
+ *
+ * @name fieldValue
+ * @param Element el The DOM element for which the value will be returned
+ * @param Boolean successful true if value returned must be for a successful controls (default is true)
+ * @type String or Array<String> or null or undefined
+ * @cat Plugins/Form
+ */
+$.fieldValue = function(el, successful) {
+    var n = el.name, t = el.type, tag = el.tagName.toLowerCase();
+    if (typeof successful == 'undefined') successful = true;
+
+    if (successful && (!n || el.disabled || t == 'reset' || t == 'button' ||
+        (t == 'checkbox' || t == 'radio') && !el.checked ||
+        (t == 'submit' || t == 'image') && el.form && el.form.clk != el ||
+        tag == 'select' && el.selectedIndex == -1))
+            return null;
+
+    if (tag == 'select') {
+        var index = el.selectedIndex;
+        if (index < 0) return null;
+        var a = [], ops = el.options;
+        var one = (t == 'select-one');
+        var max = (one ? index+1 : ops.length);
+        for(var i=(one ? index : 0); i < max; i++) {
+            var op = ops[i];
+            if (op.selected) {
+                // extra pain for IE...
+                var v = $.browser.msie && !(op.attributes['value'].specified) ? op.text : op.value;
+                if (one) return v;
+                a.push(v);
+            }
+        }
+        return a;
+    }
+    return el.value;
+};
+
+
+/**
+ * Clears the form data.  Takes the following actions on the form's input fields:
+ *  - input text fields will have their 'value' property set to the empty string
+ *  - select elements will have their 'selectedIndex' property set to -1
+ *  - checkbox and radio inputs will have their 'checked' property set to false
+ *  - inputs of type submit, button, reset, and hidden will *not* be effected
+ *  - button elements will *not* be effected
+ *
+ * @example $('form').clearForm();
+ * @desc Clears all forms on the page.
+ *
+ * @name clearForm
+ * @type jQuery
+ * @cat Plugins/Form
+ */
+$.fn.clearForm = function() {
+    return this.each(function() {
+        $('input,select,textarea', this).clearFields();
+    });
+};
+
+/**
+ * Clears the selected form elements.  Takes the following actions on the matched elements:
+ *  - input text fields will have their 'value' property set to the empty string
+ *  - select elements will have their 'selectedIndex' property set to -1
+ *  - checkbox and radio inputs will have their 'checked' property set to false
+ *  - inputs of type submit, button, reset, and hidden will *not* be effected
+ *  - button elements will *not* be effected
+ *
+ * @example $('.myInputs').clearFields();
+ * @desc Clears all inputs with class myInputs
+ *
+ * @name clearFields
+ * @type jQuery
+ * @cat Plugins/Form
+ */
+$.fn.clearFields = $.fn.clearInputs = function() {
+    return this.each(function() {
+        var t = this.type, tag = this.tagName.toLowerCase();
+        if (t == 'text' || t == 'password' || tag == 'textarea')
+            this.value = '';
+        else if (t == 'checkbox' || t == 'radio')
+            this.checked = false;
+        else if (tag == 'select')
+            this.selectedIndex = -1;
+    });
+};
+
+
+/**
+ * Resets the form data.  Causes all form elements to be reset to their original value.
+ *
+ * @example $('form').resetForm();
+ * @desc Resets all forms on the page.
+ *
+ * @name resetForm
+ * @type jQuery
+ * @cat Plugins/Form
+ */
+$.fn.resetForm = function() {
+    return this.each(function() {
+        // guard against an input with the name of 'reset'
+        // note that IE reports the reset function as an 'object'
+        if (typeof this.reset == 'function' || (typeof this.reset == 'object' && !this.reset.nodeType))
+            this.reset();
+    });
+};
+
+
+/**
+ * Enables or disables any matching elements.
+ *
+ * @example $(':radio').enabled(false);
+ * @desc Disables all radio buttons
+ *
+ * @name select
+ * @type jQuery
+ * @cat Plugins/Form
+ */
+$.fn.enable = function(b) { 
+    if (b == undefined) b = true;
+    return this.each(function() { 
+        this.disabled = !b 
+    });
+};
+
+/**
+ * Checks/unchecks any matching checkboxes or radio buttons and
+ * selects/deselects and matching option elements.
+ *
+ * @example $(':checkbox').select();
+ * @desc Checks all checkboxes
+ *
+ * @name select
+ * @type jQuery
+ * @cat Plugins/Form
+ */
+$.fn.select = function(select) {
+    if (select == undefined) select = true;
+    return this.each(function() { 
+        var t = this.type;
+        if (t == 'checkbox' || t == 'radio')
+            this.checked = select;
+        else if (this.tagName.toLowerCase() == 'option') {
+            var $sel = $(this).parent('select');
+            if (select && $sel[0] && $sel[0].type == 'select-one') {
+                // deselect all other options
+                $sel.find('option').select(false);
+            }
+            this.selected = select;
+        }
+    });
+};
+
+// helper fn for console logging
+// set $.fn.ajaxSubmit.debug to true to enable debug logging
+function log() {
+    if ($.fn.ajaxSubmit.debug && window.console && window.console.log)
+        window.console.log('[jquery.form] ' + Array.prototype.join.call(arguments,''));
+};
+
+})(jQuery);
diff --git a/thirdparty/jquery-form/test/doc-with-scripts.html b/thirdparty/jquery-form/test/doc-with-scripts.html
new file mode 100644
index 000000000..523df8655
--- /dev/null
+++ b/thirdparty/jquery-form/test/doc-with-scripts.html
@@ -0,0 +1,27 @@
+<div>
+
+Lorem ipsum dolor sit amet
+
+<script type="text/javascript">
+    // set global var
+    var unitTestVariable1 = true;
+</script>
+
+Lorem ipsum dolor sit amet
+
+<script type="text/javascript">
+    // set another global var
+    var unitTestVariable2 = true;
+</script>
+
+<script type="text/javascript">
+    // set global var
+    if (typeof scriptCount == 'undefined')
+        var scriptCount = 1;
+    else
+        scriptCount++;
+</script>
+
+Lorem ipsum dolor sit amet
+
+</div>
diff --git a/thirdparty/jquery-form/test/index.html b/thirdparty/jquery-form/test/index.html
new file mode 100644
index 000000000..0b7ab776a
--- /dev/null
+++ b/thirdparty/jquery-form/test/index.html
@@ -0,0 +1,984 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
+<title>jQuery form.js Unit Test</title>
+
+<!-- load latest build of jquery.js -->
+<script type="text/javascript" src="../../../jquery/dist/jquery.js"></script>
+
+<!-- load testrunner from jquery project -->
+<script type="text/javascript" src="../../../jquery/test/data/testrunner.js"></script>
+
+<!-- load form.js (this is what we're testing! -->
+<script type="text/javascript" src="../jquery.form.js"></script>
+
+<link rel="Stylesheet" media="screen" href="../../../jquery/test/data/testsuite.css" />
+
+<script>
+_config.asyncTimeout = 5;
+
+// test form with inputs named 'action' and 'method'
+test("'action' and 'method' form attributes", function() {
+    var f = $("#form1");
+    ok( f.attr('action').match('text.php'), "form 'action'");
+    ok( f.attr('method').match('get'), "form 'method'");
+});
+
+// test serialization to array
+test("formToArray: multi-select", function() {
+    var a = $("#form1").formToArray();
+    ok( a.constructor == Array, "type check");
+    ok( a.length == 13, "array length");
+    ok( arrayCount(a, 'Multiple') == 3, "multi-select");
+});
+
+// test serialization to array
+test("formToArray: 'action' and 'method' inputs", function() {
+    var a = $("#form1").formToArray();
+    ok( a.constructor == Array, "type check");
+    ok( arrayValue(a, 'action') == 1, "input name=action");
+    ok( arrayValue(a, 'method') == 2, "input name=method");
+});
+
+// test formToArray semantic support
+test("formToArray: semantic test", function() {
+    var formData = $("#form2").formToArray(true);
+    var testData = ['a','b','c','d','e','f'];
+    for (var i=0; i < 6; i++) {
+        ok(formData[i].name == testData[i], "match value at index="+i);
+    }
+});
+
+test("formToArray: text promotion for missing value attributes", function() {
+    var expected = [
+        { name: 'A', value: ''},
+        { name: 'B', value: 'MISSING_ATTR'},
+        { name: 'C', value: ''},
+        { name: 'C', value: 'MISSING_ATTR'}
+    ];
+
+    var a = $('#form6').formToArray(true);
+
+    // verify all the option values
+    for (var i=0; i < a.length; i++) {
+        ok( a[i].name  == expected[i].name,  'Name: '  + a[i].name  + ' = ' + expected[i].name);
+        ok( a[i].value == expected[i].value, 'Value: ' + a[i].value + ' = ' + expected[i].value);
+    }
+});
+
+// test string serialization
+test("serialize: param count", function() {
+    var s = $("#form1").formSerialize();
+    ok( s.constructor == String, "type check");
+    ok( s.split('&').length == 13, "string array length");
+});
+
+// test support for input elements not contained within a form
+test("serialize: pseudo form", function() {
+    var s = $("#pseudo *").fieldSerialize();
+    ok( s.constructor == String, "type check");
+    ok( s.split('&').length == 3, "string array length");
+});
+
+
+// test resetForm
+test("resetForm (text input)", function() {
+    var $el = $('#form1 input[@name=Name]');
+    var val = $el.val();
+    ok( 'MyName1' == val, 'beforeSubmit: ' + val);
+    $el.val("test");
+    val = $el.val();
+    ok( 'test' == $el.val(), 'update: ' + val);
+    $('#form1').resetForm();
+    val = $el.val();
+    ok( 'MyName1' == val, 'success: ' + val);
+});
+
+// test resetForm
+test("resetForm (select)", function() {
+    var $el = $('#form1 select[@name=Single]');
+    var val = $el.val();
+    ok( 'one' == val, 'beforeSubmit: ' + val);
+    $el.val("two");
+    val = $el.val();
+    ok( 'two' == $el.val(), 'update: ' + val);
+    $('#form1').resetForm();
+    val = $el.val();
+    ok( 'one' == val, 'success: ' + val);
+});
+
+// test resetForm
+test("resetForm (textarea)", function() {
+    var $el = $('#form1 textarea');
+    var val = $el.val();
+    ok( 'This is Form1' == val, 'beforeSubmit: ' + val);
+    $el.val("test");
+    val = $el.val();
+    ok( 'test' == val, 'udpate: ' + val);
+    $('#form1').resetForm();
+    val = $el.val();
+    ok( 'This is Form1' == val, 'success: ' + val);
+});
+
+// test resetForm
+test("resetForm (checkbox)", function() {
+    var el = $('#form1 input:checkbox:checked')[0];
+    var val = el.value;
+    ok( el.checked, 'beforeSubmit: ' + el.checked);
+    el.checked = false;
+    ok( !el.checked, 'update: ' + el.checked);
+    $('#form1').resetForm();
+    ok( el.checked, 'success: ' + el.checked);
+});
+
+// test resetForm
+test("resetForm (radio)", function() {
+    var el = $('#form1 input:radio:checked')[0];
+    var val = el.value;
+    ok( el.checked, 'beforeSubmit: ' + el.checked);
+    el.checked = false;
+    ok( !el.checked, 'update: ' + el.checked);
+    $('#form1').resetForm();
+    ok( el.checked, 'success: ' + el.checked);
+});
+
+
+// test clearForm
+test("clearForm (text input)", function() {
+    var $el = $('#form1 input[@name=Name]');
+    var val = $el.val();
+    ok( 'MyName1' == val, 'beforeSubmit: ' + val);
+    $('#form1').clearForm();
+    val = $el.val();
+    ok( !val, 'success: ' + val);
+});
+
+// test resetForm
+test("clearForm (select)", function() {
+    var $el = $('#form1 select[@name=Single]');
+    var val = $el.val();
+    ok( 'one' == val, 'beforeSubmit: ' + val);
+    $('#form1').clearForm();
+    val = $el.val();
+    ok( '' == val, 'success: ' + val);
+});
+
+// test clearForm; here we're testing that a hidden field is NOT cleared
+test("clearForm: (hidden input)", function() {
+    var $el = $('#form1 input:hidden');
+    var val = $el.val();
+    ok( 'hiddenValue' == val, 'beforeSubmit: ' + val);
+    $('#form1').clearForm();
+    val = $el.val();
+    ok( 'hiddenValue' == val, 'success: ' + val);
+});
+
+
+// test clearForm; here we're testing that a submit element is NOT cleared
+test("clearForm: (submit input)", function() {
+    var $el = $('#form1 input:submit');
+    var val = $el.val();
+    ok( 'Submit1' == val, 'beforeSubmit: ' + val);
+    $('#form1').clearForm();
+    val = $el.val();
+    ok( 'Submit1' == val, 'success: ' + val);
+});
+
+// test clearForm
+test("clearForm (checkbox)", function() {
+    var el = $('#form1 input:checkbox:checked')[0];
+    ok( el.checked, 'beforeSubmit: ' + el.checked);
+    $('#form1').clearForm();
+    ok( !el.checked, 'success: ' + el.checked);
+});
+
+
+// test clearForm
+test("clearForm (radio)", function() {
+    var el = $('#form1 input:radio:checked')[0];
+    ok( el.checked, 'beforeSubmit: ' + el.checked);
+    $('#form1').clearForm();
+    ok( !el.checked, 'success: ' + el.checked);
+});
+
+// test ajaxSubmit target update
+test("ajaxSubmit: target == String", function() {
+    $('#targetDiv').empty();
+    stop();
+    var opts = {
+        target: '#targetDiv',
+        success: function() { // post-callback
+            ok( true, 'post-callback');
+            ok( $('#targetDiv').text().match("Lorem ipsum"), "targetDiv updated");
+            start();
+        }
+    };
+
+    expect(2);
+    $('#form3').ajaxSubmit(opts);
+});
+
+// test passing jQuery object as the target
+test("ajaxSubmit: target == jQuery object", function() {
+    stop();
+    var target = $('#targetDiv');
+    target.empty();
+
+    var opts = {
+        target: target,
+        success: function(responseText) { // post-callback
+            ok( true, 'post-callback');
+            ok( $('#targetDiv').text().match("Lorem ipsum"), "targetDiv updated");
+            start();
+        }
+    };
+
+    expect(2);
+    $("#form2").ajaxSubmit(opts);
+});
+
+// test passing DOM element as the target
+test("ajaxSubmit: target == DOM element", function() {
+    stop();
+    $('#targetDiv').empty();
+    var target = $('#targetDiv')[0];
+
+    var opts = {
+        target: target,
+        success: function(responseText) { // post-callback
+            ok( true, 'post-callback');
+            ok( $('#targetDiv').text().match("Lorem ipsum"), "targetDiv updated");
+            start();
+        }
+    };
+
+    expect(2);
+    $("#form2").ajaxSubmit(opts);
+});
+
+// test simulated $.load behavior
+test("ajaxSubmit: load target with scripts", function() {
+    stop();
+    $('#targetDiv').empty();
+
+    var opts = {
+        target: '#targetDiv',
+        url:    'doc-with-scripts.html?' + new Date().getTime(),
+        success: function(responseText) { // post-callback
+            ok( true, 'success-callback');
+            ok( $('#targetDiv').text().match("Lorem ipsum"), "targetDiv updated");
+            ok( typeof unitTestVariable1 != 'undefined', 'first script block executed');
+            ok( typeof unitTestVariable2 != 'undefined', 'second script block executed');
+            ok( typeof scriptCount != 'undefined', 'third script block executed');
+            ok( scriptCount == 1, 'scripts executed once: ' + scriptCount);
+            start();
+        }
+    };
+
+    expect(6);
+    $("#form2").ajaxSubmit(opts);
+});
+
+// test ajaxSubmit pre-submit callback
+test("ajaxSubmit: pre-submit callback", function() {
+    var opts = {
+        beforeSubmit: function(a, jq) { // pre-submit callback
+            ok( true, 'pre-submit callback');
+            ok( a.constructor == Array, "type check array");
+            ok( jq.jquery, "type check jQuery");
+            ok( jq[0].tagName.toLowerCase() == 'form', "jQuery arg == 'form': " + jq[0].tagName.toLowerCase());
+        }
+    };
+
+    expect(4);
+    $('#form3').ajaxSubmit(opts);
+});
+
+// test ajaxSubmit post-submit callback for response and status text
+test("ajaxSubmit: post-submit callback", function() {
+    stop();
+
+    var opts = {
+        success: function(responseText, statusText) { // post-submit callback
+            ok( true, 'post-submit callback');
+            ok( responseText.match("Lorem ipsum"), "responseText");
+            ok( statusText == "success", "statusText");
+            start();
+        }
+    };
+
+    expect(3);
+    $('#form3').ajaxSubmit(opts);
+});
+
+// test ajaxSubmit with function argument
+test("ajaxSubmit: function arg", function() {
+    stop();
+
+    expect(1);
+    $('#form3').ajaxSubmit(function() {
+        ok( true, 'callback hit');
+        start();
+    });
+});
+
+// test semantic support via ajaxSubmit's pre-submit callback
+test("ajaxSubmit: semantic test", function() {
+    var testData = ['a','b','c','d','e','f'];
+
+    var opts = {
+        semantic: true,
+        beforeSubmit: function(a, jq) { // pre-submit callback
+            ok( true, 'pre-submit callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+            for (var i=0; i < a.length; i++) {
+                ok(a[i].name == testData[i], "match value at index="+i);
+            }
+        }
+    };
+
+    expect(9);
+    $('#form2').ajaxSubmit(opts);
+});
+
+// test json datatype
+test("ajaxSubmit: dataType == json", function() {
+    stop();
+
+    var opts = {
+        url: 'json.txt',
+        dataType: 'json',
+        success: function(data, statusText) { // post-submit callback
+            // assert that the json data was evaluated
+            ok( typeof data == 'object', 'json data type');
+            ok( data.name == 'jquery-test', 'json data contents');
+            start();
+        }
+    };
+
+    expect(2);
+    $('#form2').ajaxSubmit(opts);
+});
+
+// test script datatype
+test("ajaxSubmit: dataType == script", function() {
+    stop();
+
+    var opts = {
+        url: 'script.txt?' + new Date().getTime(), // don't let ie cache it
+        dataType: 'script',
+        success: function(responseText, statusText) { // post-submit callback
+            ok( typeof formScriptTest == 'function', 'script evaluated');
+            ok( responseText.match('formScriptTest'), 'script returned');
+            start();
+        }
+    };
+
+    expect(2);
+    $('#form2').ajaxSubmit(opts);
+});
+
+// test xml datatype
+test("ajaxSubmit: dataType == xml", function() {
+    stop();
+
+    var opts = {
+        url: 'test.xml',
+        dataType: 'xml',
+        success: function(responseXML, statusText) { // post-submit callback
+            ok( typeof responseXML == 'object', 'data type xml');
+            ok( $('test', responseXML).size() == 3, 'xml data query');
+            start();
+        }
+    };
+
+    expect(2);
+    $('#form2').ajaxSubmit(opts);
+});
+
+
+// test that args embedded in the action are honored; no real way
+// to assert this so successful callback is used to signal success
+test("ajaxSubmit: existing args in action attr", function() {
+    stop();
+
+    var opts = {
+        success: function() { // post-submit callback
+            ok( true, 'post callback');
+            start();
+        }
+    };
+
+    expect(1);
+    $('#form5').ajaxSubmit(opts);
+});
+
+// test ajaxSubmit using pre-submit callback to cancel submit
+test("ajaxSubmit: cancel submit", function() {
+
+    var opts = {
+        beforeSubmit: function(a, jq) { // pre-submit callback
+            ok( true, 'pre-submit callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+            return false;  // return false to abort submit
+        },
+        success: function() { // post-submit callback
+            ok( false, "should not hit this post-submit callback");
+        }
+    };
+
+    expect(3);
+    $('#form3').ajaxSubmit(opts);
+});
+
+// test submitting a pseudo-form
+test("ajaxSubmit: pseudo-form", function() {
+    stop();
+
+    var opts = {
+        beforeSubmit: function(a, jq) { // pre-submit callback
+            ok( true, 'pre-submit callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+            ok( jq[0].tagName.toLowerCase() == 'div', "jQuery arg == 'div'");
+        },
+        success: function() { // post-submit callback
+            ok( true, 'post-submit callback');
+            start();
+        },
+        // url and method must be provided for a pseudo form since they can
+        // not be extracted from the markup
+        url:  'text.php',
+        type: 'post'
+    };
+
+    expect(5);
+    $("#pseudo").ajaxSubmit(opts);
+});
+
+// test eval of json response
+test("ajaxSubmit: evaluate response", function() {
+    stop();
+
+    var opts = {
+        success: function(responseText) { // post-callback
+            ok( true, 'post-callback');
+            var data = eval.call(window, '('+responseText+')');
+            ok( data.name == 'jquery-test', 'evaled response');
+            start();
+        },
+        url: 'json.txt'
+    };
+
+    expect(2);
+    $("#form2").ajaxSubmit(opts);
+});
+
+
+// test pre and post callbacks for ajaxForm
+test("ajaxForm: pre and post callbacks", function() {
+    stop();
+
+    var opts = {
+        beforeSubmit: function(a, jq) { // pre-submit callback
+            ok( true, 'pre-submit callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+        },
+        success: function() { // post-submit callback
+            ok( true, 'post-submit callback');
+            start();
+        }
+    };
+
+    expect(4);
+    $("#form4").ajaxForm(opts);
+    $('#submitForm4')[0].click();  // trigger the submit button
+});
+
+// test that the value of the submit button is captured
+test("ajaxForm: capture submit element", function() {
+
+    var opts = {
+        beforeSubmit: function(a, jq) { // pre-callback
+            ok( true, 'pre-callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+            ok( arrayValue(a, 'form4inputName') != null, "submit button");
+        }
+    };
+
+    expect(4);
+    $("#form4").ajaxForm(opts);
+    $('#submitForm4withName')[0].click();
+});
+
+// test image submit support
+test("ajaxForm: capture submit image coordinates", function() {
+
+    var opts = {
+        beforeSubmit: function(a, jq) { // pre-callback
+            ok( true, 'pre-callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+            ok( arrayValue(a, 'myImage.x') != null, "x coord");
+            ok( arrayValue(a, 'myImage.y') != null, "y coord");
+        }
+    };
+
+    expect(5);
+    $("#form4").ajaxForm(opts);
+    $('#form4imageSubmit')[0].click();
+});
+
+// test image submit support
+test("ajaxForm: capture submit image coordinates (semantic=true)", function() {
+
+    var opts = {
+        semantic: true,
+        beforeSubmit: function(a, jq) { // pre-callback
+            ok( true, 'pre-callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+            ok( arrayValue(a, 'myImage.x') != null, "x coord");
+            ok( arrayValue(a, 'myImage.y') != null, "y coord");
+        }
+    };
+
+    expect(5);
+    $("#form4").ajaxForm(opts);
+    $('#form4imageSubmit')[0].click();
+});
+
+// test that the targetDiv gets updated
+test("ajaxForm: update target div", function() {
+    $('#targetDiv').empty();
+    stop();
+
+    var opts = {
+        target: '#targetDiv',
+        beforeSubmit: function(a, jq) { // pre-callback
+            ok( true, 'pre-callback');
+            ok( a.constructor == Array, "type check");
+            ok( jq.jquery, "type check jQuery");
+        },
+        success: function() {
+            ok( true, 'post-callback');
+            ok( $('#targetDiv').text().match("Lorem ipsum"), "targetDiv updated");
+            start();
+        }
+    };
+
+    expect(5);
+    $("#form4").ajaxForm(opts);
+    $('#submitForm4')[0].click();
+});
+
+test("'success' callback", function() {
+    $('#targetDiv').empty();
+    stop();
+
+    var opts = {
+        success: function() {
+            ok( true, 'post-callback');
+            start();
+        }
+    };
+
+    expect(1);
+    $('#form3').ajaxSubmit(opts);
+});
+
+test("'error' callback", function() {
+    $('#targetDiv').empty();
+    stop();
+
+    var opts = {
+        url: 'bogus.php',
+        error: function() {
+            ok( true, 'error-callback');
+            start();
+        },
+        success: function() { // post-submit callback
+            ok( false, "should not hit post-submit callback");
+        }
+    };
+
+    expect(1);
+    $('#form3').ajaxSubmit(opts);
+});
+
+
+test("fieldValue(true)", function() {
+    ok ('5'  == $('#fieldTest input').fieldValue(true)[0], 'input');
+    ok ('1'  == $('#fieldTest :input').fieldValue(true)[0], ':input');
+    ok ('5'  == $('#fieldTest :hidden').fieldValue(true)[0], ':hidden');
+    ok ('14' == $('#fieldTest :password').fieldValue(true)[0], ':password');
+    ok ('12' == $('#fieldTest :radio').fieldValue(true)[0], ':radio');
+    ok ('1'  == $('#fieldTest select').fieldValue(true)[0], 'select');
+
+    var expected = ['8','10'];
+    var result = $('#fieldTest :checkbox').fieldValue(true);
+    ok (result.length == expected.length, 'result size check (checkbox): ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok ( result[i] == expected[i], expected[i] );
+
+    expected = ['3','4'];
+    result = $('#fieldTest [@name=B]').fieldValue(true);
+    ok (result.length == expected.length, 'result size check (select-multiple): ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok ( result[i] == expected[i], expected[i] );
+});
+
+test("fieldValue(false)", function() {
+    ok ('5'  == $('#fieldTest input').fieldValue(false)[0], 'input');
+    ok ('1'  == $('#fieldTest :input').fieldValue(false)[0], ':input');
+    ok ('5'  == $('#fieldTest :hidden').fieldValue(false)[0], ':hidden');
+    ok ('14' == $('#fieldTest :password').fieldValue(false)[0], ':password');
+    ok ('1'  == $('#fieldTest select').fieldValue(false)[0], 'select');
+
+    var expected = ['8','9','10'];
+    var result = $('#fieldTest :checkbox').fieldValue(false);
+    ok (result.length == expected.length, 'result size check (checkbox): ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok ( result[i] == expected[i], expected[i] );
+
+    expected = ['11','12','13'];
+    result = $('#fieldTest :radio').fieldValue(false);
+    ok (result.length == expected.length, 'result size check (radio): ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok ( result[i] == expected[i], expected[i] );
+
+    expected = ['3','4'];
+    result = $('#fieldTest [@name=B]').fieldValue(false);
+    ok (result.length == expected.length, 'result size check (select-multiple): ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok ( result[i] == expected[i], expected[i] );
+});
+
+test("fieldSerialize(true) input", function() {
+    var expected = ['C=5', 'D=6', 'F=8', 'F=10', 'G=12', 'H=14'];
+
+    var result = $('#fieldTest input').fieldSerialize(true);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(true) :input", function() {
+    var expected = ['A=1','B=3','B=4','C=5','D=6','E=7','F=8','F=10','G=12','H=14'];
+
+    var result = $('#fieldTest :input').fieldSerialize(true);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(false) :input", function() {
+    var expected = ['A=1','B=3','B=4','C=5','D=6','E=7','F=8','F=9','F=10','G=11','G=12','G=13','H=14','I=15','J=16'];
+
+    var result = $('#fieldTest :input').fieldSerialize(false);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(true) select-mulitple", function() {
+    var expected = ['B=3','B=4'];
+
+    var result = $('#fieldTest [@name=B]').fieldSerialize(true);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(true) :checkbox", function() {
+    var expected = ['F=8','F=10'];
+
+    var result = $('#fieldTest :checkbox').fieldSerialize(true);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(false) :checkbox", function() {
+    var expected = ['F=8','F=9','F=10'];
+
+    var result = $('#fieldTest :checkbox').fieldSerialize(false);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(true) :radio", function() {
+    var expected = ['G=12'];
+
+    var result = $('#fieldTest :radio').fieldSerialize(true);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+test("fieldSerialize(false) :radio", function() {
+    var expected = ['G=11','G=12','G=13'];
+
+    var result = $('#fieldTest :radio').fieldSerialize(false);
+    result = result.split('&');
+
+    ok (result.length == expected.length, 'result size check: ' + result.length + '=' + expected.length);
+    for (var i=0; i < result.length; i++)
+        ok( result[i] == expected[i], expected[i] + ' = ' + result[i]);
+});
+
+
+test("ajaxForm - auto unbind", function() {
+    $('#targetDiv').empty();
+    stop();
+
+    var opts = {
+        target: '#targetDiv',
+        beforeSubmit: function(a, jq) { // pre-callback
+            ok( true, 'pre-callback');
+        },
+        success: function() {
+            ok( true, 'post-callback');
+            start();
+        }
+    };
+
+    expect(2);
+    // multiple binds
+    $("#form8").ajaxForm(opts).ajaxForm(opts).ajaxForm(opts);
+    $('#submitForm8')[0].click();
+});
+
+test("ajaxFormUnbind", function() {
+    $('#targetDiv').empty();
+    stop();
+
+    var opts = {
+        target: '#targetDiv',
+        beforeSubmit: function(a, jq) { // pre-callback
+            ok( true, 'pre-callback');
+        },
+        success: function() {
+            ok( true, 'post-callback');
+            start();
+        }
+    };
+
+    expect(0);
+    // multiple binds
+    $("#form9").ajaxForm(opts).submit(function(){return false;});
+    $("#form9").ajaxFormUnbind(opts);
+    $('#submitForm9')[0].click();
+    
+    setTimeout(start, 500);
+});
+
+// helper method
+function arrayCount(arr, key) {
+    var count=0;
+    for (var i=0; i < arr.length; i++) {
+        if (arr[i].name == key)
+            count++;
+    }
+    return count;
+}
+
+// helper method
+function arrayValue(arr, key) {
+    for (var i=0; i < arr.length; i++) {
+        if (arr[i].name == key)
+            return arr[i].value;
+    }
+}
+</script>
+</head>
+<body id="body">
+	<h1 id="banner">jQuery form.js - Test Suite</h1>
+	<h2 id="userAgent"></h2>
+
+	<!-- Test HTML -->
+	<div id="main" style="display: none;">
+
+        <!-- form1 -->
+        <form id="form1" action="text.php" method="get"><div>
+                <input type="hidden" name="Hidden" value="hiddenValue" />
+                <input name="Name" type="text" value="MyName1" />
+                <input name="Password" type="password" />
+                <select name="Multiple" multiple="multiple">
+                    <optgroup label="block 1">
+                        <option value="one" selected="selected">One</option>
+                        <option value="two">Two</option>
+                        <option value="three">Three</option>
+                    </optgroup>
+                    <optgroup label="block 2">
+                        <option value="four" selected="selected">Four</option>
+                        <option value="five">Five</option>
+                        <option value="six" selected="selected">Six</option>
+                    </optgroup>
+                </select>
+                <select name="Single">
+                    <option value="one" selected="selected">One</option>
+                    <option value="two">Two</option>
+                    <option value="three">Three</option>
+                </select>
+                <select name="Single2">
+                    <optgroup label="block 3">
+                        <option value="A" selected="selected">A</option>
+                        <option value="B">B</option>
+                        <option value="C">C</option>
+                    </optgroup>
+                    <optgroup label="block 3">
+                        <option value="D">D</option>
+                        <option value="E">E</option>
+                        <option value="F">F</option>
+                    </optgroup>
+                </select>
+                <input type="checkbox" name="Check" value="1" />
+                <input type="checkbox" name="Check" value="2" checked="checked" />
+                <input type="checkbox" name="Check" value="3" />
+                <input type="radio" name="Radio" value="1" />
+                <input type="radio" name="Radio" value="2" checked="checked" />
+                <input type="radio" name="Radio" value="3" />
+                <input type="text" name="action" value="1" />
+                <input type="text" name="method" value="2" />
+                <textarea name="Text" rows="2" cols="20">This is Form1</textarea>
+                <input type="submit"  name="submitButton" value="Submit1" />
+                <input type="submit"  name="submitButton" value="Submit2" />
+                <input type="submit"  name="submitButton" value="Submit3" />
+                <input type="image"   name="submitButton" value="Submit4" src="submit.gif" />
+                <input type="reset"   name="resetButton " value="Reset" />
+        </div></form>
+
+        <!-- form2 -->
+        <form id="form2" action="text.php" method="get"><div>
+            <input    name="a" type="text" />
+            <textarea name="b" rows="1" cols="1"></textarea>
+            <input    name="c" type="text" />
+            <select   name="d"><option value="x">x</option></select>
+            <textarea name="e" rows="1" cols="1"></textarea>
+            <input    name="f" type="text" />
+            <input type="reset"   name="resetButton " value="Reset" />
+        </div></form>
+
+        <!-- form3 -->
+        <form id="form3" action="text.php" method="post"><div>
+            <input name="a" type="text" />
+        </div></form>
+
+        <!-- form4 -->
+        <form id="form4" action="text.php" method="get"><div>
+            <input name="a" type="text" />
+            <input type="submit" id="submitForm4" />
+            <input type="submit" id="submitForm4withName" name="form4inputName" />
+            <input type="image"  id="form4imageSubmit" name="myImage" src="submit.gif" />
+        </div></form>
+
+        <!-- form5 -->
+        <form id="form5" action="text.php?test=form" method="get"><div>
+            <input name="a" type="text" />
+            <input type="submit" />
+            <input type="submit" name="form5inputName" />
+            <input type="image"  id="form5imageSubmit" name="myImage" src="submit.gif" />
+        </div></form>
+
+        <!-- form6, 'option' testing -->
+        <form id="form6" action="text.php" method="get"><div>
+            <select name="A">
+                <option value="" selected="selected">EMPTY_STRING</option>    <!-- TEST A: value === empty string -->
+            </select>
+            <select name="B">
+                <option selected="selected">MISSING_ATTR</option>             <!-- TEST B: no value attr -->
+            </select>
+            <select name="C" multiple="multiple">
+                <option value="" selected="selected">EMPTY_STRING</option>
+                <option selected="selected">MISSING_ATTR</option>
+            </select>
+        </div></form>
+
+        <!-- form7, 'enctype' testing -->
+        <form id="form7" action="text.php" method="post" enctype="text/css"><div>
+            <textarea name="doc">body { padding: 0}</textarea>
+        </div></form>
+
+        <form id="form8" action="text.php" method="post"><div>
+            <textarea name="ta">blah</textarea>
+            <input type="submit" id="submitForm8" />
+        </div></form>
+
+        <form id="form9" action="text.php" method="post"><div>
+            <textarea name="ta">blah</textarea>
+            <input type="submit" id="submitForm9" />
+        </div></form>
+
+        <!-- pseudo-form -->
+        <div id="pseudo">
+            <input name="a" type="text" />
+            <input type="checkbox" name="Check" value="1" />
+            <input type="checkbox" name="Check" value="2" checked="checked" />
+            <select name="Select">
+                <option value="opt1" />
+                <option value="opt2" selected="selected" />
+            </select>
+            <input type="submit" value="button" />
+        </div>
+
+        <div id="targetDiv"></div>
+	</div>
+
+    <!--
+    ********************************************************************************
+    NOTE: The "fieldTest" form is intentionally placed outside of the "main" div
+          because reseting the test fixture causes the default value of the password
+          input to be lost in IE (which causes many test failures in the fieldValue
+          and fieldSerialize tests)
+    ********************************************************************************
+    -->
+
+    <form style="display:none" id="fieldTest" action="text.php" method="post"><div>
+        <select name="A">
+            <option value="1" selected="selected">ONE</option>
+            <option value="2">TWO</option>
+        </select>
+        <select name="B" multiple="multiple">
+            <option value="3" selected="selected">ONE</option>
+            <option value="4" selected="selected">TWO</option>
+            <option value="4b">THREE</option>
+        </select>
+        <input name="C" type="hidden" value="5" />
+        <input name="D" type="text" value="6" />
+        <textarea name="E">7</textarea>
+        <input name="F" type="checkbox" value="8" checked="checked" />
+        <input name="F" type="checkbox" value="9" />
+        <input name="F" type="checkbox" value="10" checked="checked" />
+        <input name="G" type="radio" value="11" />
+        <input name="G" type="radio" value="12" checked="checked" />
+        <input name="G" type="radio" value="13" />
+        <input name="H" type="password" value="14" />
+        <input name="I" type="submit" value="15" />
+        <input name="J" type="reset" value="16" />
+    </div></form>
+
+
+	<ol id="tests"></ol>
+</body>
+</html>
diff --git a/thirdparty/jquery-form/test/json.php b/thirdparty/jquery-form/test/json.php
new file mode 100644
index 000000000..c078ba306
--- /dev/null
+++ b/thirdparty/jquery-form/test/json.php
@@ -0,0 +1,3 @@
+<?php
+	echo '{ "name": "jquery-test" }';
+?>
\ No newline at end of file
diff --git a/thirdparty/jquery-form/test/json.txt b/thirdparty/jquery-form/test/json.txt
new file mode 100644
index 000000000..d5dad436d
--- /dev/null
+++ b/thirdparty/jquery-form/test/json.txt
@@ -0,0 +1 @@
+{ "name": "jquery-test" }
\ No newline at end of file
diff --git a/thirdparty/jquery-form/test/script.txt b/thirdparty/jquery-form/test/script.txt
new file mode 100644
index 000000000..99c5849e9
--- /dev/null
+++ b/thirdparty/jquery-form/test/script.txt
@@ -0,0 +1,3 @@
+formScriptTest = function() {
+    // no-op
+}
diff --git a/thirdparty/jquery-form/test/submit.gif b/thirdparty/jquery-form/test/submit.gif
new file mode 100644
index 0000000000000000000000000000000000000000..cb930be18d8908ab5cdc34d09321179b91f8fc98
GIT binary patch
literal 1648
zcmeH`?@tqV0LH()UXKF`J=YTobmWvmjvu;C3!*mo1u7H+<c2tbVRmSlxK#sNaWzA7
zEmc66vZdKjN>T(Dj5y1WEgi$<(1Oe`SCZl&!K9JGNQPOLkgY>pC;Joj+ULdd?s@Ti
zo;>*ld6|2wjshAqgH53*isQIgEG7toBuSY}CYQ@8ic%;PG)<?ar74w4l}eSFnW<K*
zA%q%@Myu5p78WuLQ(9VDR#sM7S;?}jPN%D>snP58wY9YdgTZJtHZ(MF9A~juT3TA#
z+uJ)jI;>V}XJ@C)X0zMveSLlX{rv+20}h8{WMstYbdHUU@jUNxxu&M3rl+UfZnwwd
znVXwiSXl6Sy*{6BWo2b`b=B|pudS^G0)dT<jbJeNUx`=tiopLNu<dX3Wh@BNHp82r
z0C*6XaJklDA8*2?DV0->p8L&2!XcY>@cKlXZ1?*MQ-i$^u28v`<OM@IO{|>6Wn545
zk6%Iq3*c}P)|vP&2`DNzJdOflW2YG{ZcRjh(|*Dm0mSmhIP0Y~5+EL<0|FS*OpI03
zm*w=go8Lspnum;t6RIb7d9ne2$*ej%RI{=Oz}EOZ3oaR%GcHAd?6eGlmbQJgiYklJ
zOo~8-SU=7!Km86xJkB}5H=8n0qNS}4aB^gaTWz23!GK&DHRUZ~=g3&8q_oy9{Ow{!
zfBc<5lQ$HIQWVC9!QlwgPYK1K_WI)G(e#_|1Qn*P?P3s_G3wx{Kg^QUyc4Ubu+jBs
zcg7<PIDc+3nyLPa2nS_u0U~lT?(nxJ7!y?2FkF?;<mX|QrTSieT+0zgA}d@LVkF@y
zKdvgeScUipQJ1(;z+Q#45x0Z`nxgWvXaY70UpSte@*PYhOzs<m5TJy|B-n`(d_<ZP
z<IwpfB@{fU|BA{>H#(xTRVdGKF}{^12?nTpuv-L$#4cdp-YqbAE3gC><B_|9YypUi
z4+R&ZKec-htp0)-{`vy9gsR3d^z(S!as;1CW+4)a!f`B8SDj4k*hpq?ep7Bmz`6Bc
zh$iCfdQva!JVrC8!U6!5^pwYz0^hOLUI4>9^KT<F03c}HzAf+Fj<Pf{(AEq;0{<ks
z#j0_NVd7M&OJP;p`1_)z2-J(Bb>3yDux5T%GIaS9ns|MAIrpSc_i@+VOo9a;RGC;|
z(Ulay+k^!G4nZ~G%b`oj*Gu=Rld`kuYca%)GwFwK!+^J<@ql%`y8BiuK@qK@(Ol5}
zn(t`k9+`4c^K%T$i8!#}H{+*Y?oE6>OZ|?!XSC9Am3CuTpI5G4F8*^ia1|DPZ-=7&
zhe&ft`mB|6K74GbIQjI8YZ(|4%W`)xow7sU6j~I^M~W^Sl+Md$s3-a@4o5;bB4cP1
zYUer8R-bbXVrkEA9S-4B3Bh>@DHMcQm~XXR5=)L?^tdAThYu%qK3^UA<;?SE&NoN`
G?Ee=Z3Z8BN

literal 0
HcmV?d00001

diff --git a/thirdparty/jquery-form/test/test.xml b/thirdparty/jquery-form/test/test.xml
new file mode 100644
index 000000000..c4c129b4b
--- /dev/null
+++ b/thirdparty/jquery-form/test/test.xml
@@ -0,0 +1,5 @@
+<root>
+    <test></test>
+    <test></test>
+    <test></test>
+</root>
\ No newline at end of file
diff --git a/thirdparty/jquery-form/test/text.php b/thirdparty/jquery-form/test/text.php
new file mode 100644
index 000000000..b9df4cf3b
--- /dev/null
+++ b/thirdparty/jquery-form/test/text.php
@@ -0,0 +1,12 @@
+Lorem ipsum dolor sit amet
+consectetuer adipiscing elit
+Sed lorem leo
+lorem leo consectetuer adipiscing elit
+Sed lorem leo
+rhoncus sit amet
+elementum at
+bibendum at, eros
+Cras at mi et tortor egestas vestibulum
+sed Cras at mi vestibulum
+Phasellus sed felis sit amet
+orci dapibus semper.