initial import

static/bower_components/bootstrap-datepicker/tests/README.md

@@ -0,0 +1,30 @@
+Unit tests, written with [QUnit](https://qunitjs.com), are used to
+expose bugs for squashing, prevent bugs from respawning, and suppress new
+bugs when adding new features and making changes.
+
+# Running the tests
+
+The simplest way to run the tests is to open `tests/tests.html` in your browser.
+The test suites will automatically run themselves and present their results.
+
+To run the tests from the command line (after running jshint and jscs, which is
+recommended), install Grunt and run the `test` task from anywhere within the
+repo:
+
+    $ grunt test
+
+# Adding tests
+
+Tests go in js files in the `tests/suites/` directory tree. QUnit organizes
+tests into suites called "modules"; there is one module per js file.  If the
+tests you are adding do not fit into an existing module, create a new one at
+`tests/suites/<new module>.js`, where `<new module>` is a broad yet
+descriptive name for the suite.  If tests have many year-specific cases (ie,
+behave differently in leap years vs normal years, or have specific buggy
+behavior in a certain year), create the module in a new directory,
+`tests/suites/<new module>/<year>.js`, where `<new module>` is the decriptive
+name and `<year>` is the four-digit year the tests pertain to.
+
+In order for new tests to be run, they must be imported into `tests/tests.html`.
+Find the script includes headed by the html comment `<!-- Test suites -->`, and
+add a new one to the list which includes the new js files.

static/bower_components/bootstrap-datepicker/tests/assets/coverage.js

@@ -0,0 +1,48 @@
+(function(){
+    //we want this at global scope so outside callers can find it. In a more realistic implementation we
+    //should probably put it in a namespace.
+    window.getCoverageByLine = function(silent) {
+        var key = null;
+        var lines = null;
+        var source = null;
+        //look for code coverage data
+        if (typeof window._$jscoverage === 'object') {
+            for (key in _$jscoverage) {}
+            lines = _$jscoverage[key];
+        }
+
+        if (!lines && !silent) {
+           console.log('code coverage data is NOT available');
+        }
+
+        return { 'key': key, 'lines': lines };
+    };
+
+    QUnit.done = function(t) {
+        var cvgInfo = getCoverageByLine(true);
+        if (!!cvgInfo.key) {
+            var testableLines = 0;
+            var testedLines = 0;
+            var untestableLines = 0;
+            for (lineIdx in cvgInfo.lines) {
+                var cvg = cvgInfo.lines[lineIdx];
+                if (typeof cvg === 'number') {
+                    testableLines += 1;
+                    if (cvg > 0) {
+                        testedLines += 1;
+                    }
+                } else {
+                    untestableLines += 1;
+                }
+            }
+            var coverage = '' + Math.floor(100 * testedLines / testableLines) + '%';
+
+            var result = document.getElementById('qunit-testresult');
+            if (result != null) {
+                result.innerHTML = result.innerHTML + ' ' + coverage + ' test coverage of ' + cvgInfo.key;
+            } else {
+                console.log('can\'t find test-result element to update');
+            }
+        }
+    };
+}());

static/bower_components/bootstrap-datepicker/tests/assets/mock.js

@@ -0,0 +1,49 @@
+;(function(){
+
+window.patch_date = function patch(f){
+    var NativeDate = window.Date;
+    var date = function date(y,m,d,h,i,s,j){
+        switch(arguments.length){
+            case 0: return date.now ? new NativeDate(date.now) : new NativeDate();
+            case 1: return new NativeDate(y);
+            case 2: return new NativeDate(y,m);
+            case 3: return new NativeDate(y,m,d);
+            case 4: return new NativeDate(y,m,d,h);
+            case 5: return new NativeDate(y,m,d,h,i);
+            case 6: return new NativeDate(y,m,d,h,i,s);
+            case 7: return new NativeDate(y,y,m,d,h,i,s,j);
+        }
+    };
+    date.UTC = NativeDate.UTC;
+    return function(){
+        Array.prototype.push.call(arguments, date);
+        window.Date = date;
+        f.apply(this, arguments);
+        window.Date = NativeDate;
+    };
+};
+
+
+window.patch_show_hide = function patch(f){
+    var oldShow = $.fn.show,
+        newShow = function () {
+            $(this).removeClass('foo');
+            return oldShow.apply(this, arguments);
+        };
+
+    var oldHide = $.fn.hide,
+        newHide = function () {
+            $(this).addClass('foo');
+            return oldHide.apply(this, arguments);
+        };
+
+    return function(){
+        $.fn.show = newShow;
+        $.fn.hide = newHide;
+        f.apply(this, arguments);
+        $.fn.show = oldShow;
+        $.fn.hide = oldHide;
+    };
+};
+
+}());

static/bower_components/bootstrap-datepicker/tests/assets/qunit-logging.js

@@ -0,0 +1,29 @@
+// Dummy logging calls (ie, if tests are run in IE)
+window.console = window.console || {};
+window.console.log = window.console.log || function(){};
+window.console.debug = window.console.debug || function(){};
+window.console.info = window.console.info || function(){};
+window.console.warn = window.console.warn || function(){};
+window.console.error = window.console.error || function(){};
+
+(function() {
+   var modName, testName;
+
+   //arg: { name }
+    QUnit.testStart = function(t) {
+        modName = t.module;
+        testName = t.name;
+    };
+
+    //arg: { name, failed, passed, total }
+    QUnit.testDone = function(t) {
+        if (t.failed)
+            console.log('Test "' + t.module + ': ' + t.name + '" completed: ' + (0 === t.failed ? 'pass' : 'FAIL') + '\n')
+    };
+
+    //{ result, actual, expected, message }
+    QUnit.log = function(t) {
+        if (!t.result)
+            console.log('Test "' + modName + ': ' + testName + '" assertion failed. Expected <' + t.expected + '> Actual <' + t.actual + '>' + (t.message ? ': \'' + t.message + '\'' : ''));
+    };
+}());

static/bower_components/bootstrap-datepicker/tests/assets/qunit.css

@@ -0,0 +1,235 @@
+/**
+ * QUnit v1.5.0 - A JavaScript Unit Testing Framework
+ *
+ * http://docs.jquery.com/QUnit
+ *
+ * Copyright (c) 2012 John Resig, Jörn Zaefferer
+ * Dual licensed under the MIT (MIT-LICENSE.txt)
+ * or GPL (GPL-LICENSE.txt) licenses.
+ */
+
+/** Font Family and Sizes */
+
+#qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
+	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
+}
+
+#qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
+#qunit-tests { font-size: smaller; }
+
+
+/** Resets */
+
+#qunit-tests, #qunit-tests ol, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult {
+	margin: 0;
+	padding: 0;
+}
+
+
+/** Header */
+
+#qunit-header {
+	padding: 0.5em 0 0.5em 1em;
+
+	color: #8699a4;
+	background-color: #0d3349;
+
+	font-size: 1.5em;
+	line-height: 1em;
+	font-weight: normal;
+
+	border-radius: 15px 15px 0 0;
+	-moz-border-radius: 15px 15px 0 0;
+	-webkit-border-top-right-radius: 15px;
+	-webkit-border-top-left-radius: 15px;
+}
+
+#qunit-header a {
+	text-decoration: none;
+	color: #c2ccd1;
+}
+
+#qunit-header a:hover,
+#qunit-header a:focus {
+	color: #fff;
+}
+
+#qunit-header label {
+	display: inline-block;
+}
+
+#qunit-banner {
+	height: 5px;
+}
+
+#qunit-testrunner-toolbar {
+	padding: 0.5em 0 0.5em 2em;
+	color: #5E740B;
+	background-color: #eee;
+}
+
+#qunit-userAgent {
+	padding: 0.5em 0 0.5em 2.5em;
+	background-color: #2b81af;
+	color: #fff;
+	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
+}
+
+
+/** Tests: Pass/Fail */
+
+#qunit-tests {
+	list-style-position: inside;
+}
+
+#qunit-tests li {
+	padding: 0.4em 0.5em 0.4em 2.5em;
+	border-bottom: 1px solid #fff;
+	list-style-position: inside;
+}
+
+#qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
+	display: none;
+}
+
+#qunit-tests li strong {
+	cursor: pointer;
+}
+
+#qunit-tests li a {
+	padding: 0.5em;
+	color: #c2ccd1;
+	text-decoration: none;
+}
+#qunit-tests li a:hover,
+#qunit-tests li a:focus {
+	color: #000;
+}
+
+#qunit-tests ol {
+	margin-top: 0.5em;
+	padding: 0.5em;
+
+	background-color: #fff;
+
+	border-radius: 15px;
+	-moz-border-radius: 15px;
+	-webkit-border-radius: 15px;
+
+	box-shadow: inset 0px 2px 13px #999;
+	-moz-box-shadow: inset 0px 2px 13px #999;
+	-webkit-box-shadow: inset 0px 2px 13px #999;
+}
+
+#qunit-tests table {
+	border-collapse: collapse;
+	margin-top: .2em;
+}
+
+#qunit-tests th {
+	text-align: right;
+	vertical-align: top;
+	padding: 0 .5em 0 0;
+}
+
+#qunit-tests td {
+	vertical-align: top;
+}
+
+#qunit-tests pre {
+	margin: 0;
+	white-space: pre-wrap;
+	word-wrap: break-word;
+}
+
+#qunit-tests del {
+	background-color: #e0f2be;
+	color: #374e0c;
+	text-decoration: none;
+}
+
+#qunit-tests ins {
+	background-color: #ffcaca;
+	color: #500;
+	text-decoration: none;
+}
+
+/*** Test Counts */
+
+#qunit-tests b.counts                       { color: black; }
+#qunit-tests b.passed                       { color: #5E740B; }
+#qunit-tests b.failed                       { color: #710909; }
+
+#qunit-tests li li {
+	margin: 0.5em;
+	padding: 0.4em 0.5em 0.4em 0.5em;
+	background-color: #fff;
+	border-bottom: none;
+	list-style-position: inside;
+}
+
+/*** Passing Styles */
+
+#qunit-tests li li.pass {
+	color: #5E740B;
+	background-color: #fff;
+	border-left: 26px solid #C6E746;
+}
+
+#qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
+#qunit-tests .pass .test-name               { color: #366097; }
+
+#qunit-tests .pass .test-actual,
+#qunit-tests .pass .test-expected           { color: #999999; }
+
+#qunit-banner.qunit-pass                    { background-color: #C6E746; }
+
+/*** Failing Styles */
+
+#qunit-tests li li.fail {
+	color: #710909;
+	background-color: #fff;
+	border-left: 26px solid #EE5757;
+	white-space: pre;
+}
+
+#qunit-tests > li:last-child {
+	border-radius: 0 0 15px 15px;
+	-moz-border-radius: 0 0 15px 15px;
+	-webkit-border-bottom-right-radius: 15px;
+	-webkit-border-bottom-left-radius: 15px;
+}
+
+#qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
+#qunit-tests .fail .test-name,
+#qunit-tests .fail .module-name             { color: #000000; }
+
+#qunit-tests .fail .test-actual             { color: #EE5757; }
+#qunit-tests .fail .test-expected           { color: green;   }
+
+#qunit-banner.qunit-fail                    { background-color: #EE5757; }
+
+
+/** Result */
+
+#qunit-testresult {
+	padding: 0.5em 0.5em 0.5em 2.5em;
+
+	color: #2b81af;
+	background-color: #D2E0E6;
+
+	border-bottom: 1px solid white;
+}
+#qunit-testresult .module-name {
+	font-weight: bold;
+}
+
+/** Fixture */
+
+#qunit-fixture {
+	position: absolute;
+	top: -10000px;
+	left: -10000px;
+	width: 1000px;
+	height: 1000px;
+}

static/bower_components/bootstrap-datepicker/tests/assets/utils.js

@@ -0,0 +1,21 @@
+function UTCDate(){
+    return new Date(Date.UTC.apply(Date, arguments));
+}
+
+
+function format_date(date){
+    var y = date.getUTCFullYear(),
+        m = date.getUTCMonth() + 1,
+        d = date.getUTCDate(),
+        h = date.getUTCHours(),
+        i = date.getUTCMinutes(),
+        s = date.getUTCSeconds(),
+        l = date.getUTCMilliseconds();
+    function z(i){return (i <= 9 ? '0'+i : i);}
+    return y+'-'+z(m)+'-'+z(d)+' '+z(h)+':'+z(i)+':'+z(s)+'.'+z(l);
+}
+
+
+function datesEqual(actual, expected, message){
+    QUnit.push(QUnit.equiv(actual, expected), format_date(actual), format_date(expected), message);
+}

static/bower_components/bootstrap-datepicker/tests/suites/calendar-weeks.js

@@ -0,0 +1,48 @@
+module('Calendar Weeks', {
+    setup: function(){
+        this.input = $('<input type="text">')
+            .appendTo('#qunit-fixture')
+            .val('2013-01-14')
+            .datepicker({
+                format: 'yyyy-mm-dd',
+                calendarWeeks: true
+            })
+            .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('adds cw header column', function(){
+    var target = this.picker.find('.datepicker-days thead tr:nth-child(3) th:first-child');
+    ok(target.hasClass('cw'), 'First column heading is from cw column');
+});
+
+test('adds calendar week cells to each day row', function(){
+    var target = this.picker.find('.datepicker-days tbody tr');
+
+    expect(target.length);
+    target.each(function(i){
+        var t = $(this).children().first();
+        ok(t.hasClass('cw'), "First column is cw column");
+    });
+});
+
+test('displays correct calendar week', function(){
+    var target = this.picker.find('.datepicker-days tbody tr');
+
+    expect(target.length);
+    target.each(function(i){
+        var t = $(this).children().first();
+        equal(t.text(), i+1, "Displays correct calendar weeks");
+    });
+});
+
+test('it prepends column to switcher thead row', function(){
+    var target = this.picker.find('.datepicker-days thead tr:nth-child(2)');
+    equal(target.children().length, 3, 'first row has 3 columns');
+    ok(!target.children().first().hasClass('cw'), 'cw column is not prepended');
+});

static/bower_components/bootstrap-datepicker/tests/suites/component.js

@@ -0,0 +1,274 @@
+module('Component', {
+    setup: function(){
+        this.fieldset = $('<fieldset>' +
+                                '<div class="input-append date" id="datepicker">'+
+                                    '<input size="16" type="text" value="12-02-2012" readonly>'+
+                                    '<span class="add-on"><i class="icon-th"></i></span>'+
+                                '</div>' +
+                            '<fieldset>')
+                        .appendTo('#qunit-fixture');
+
+        this.component = this.fieldset.find('.input-append')
+                            .datepicker({format: "dd-mm-yyyy"});
+        this.input = this.component.find('input');
+        this.addon = this.component.find('.add-on');
+        this.dp = this.component.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+
+test('Component gets date/viewDate from input value', function(){
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 12));
+});
+
+test('Activation by component', function(){
+    ok(!this.picker.is(':visible'));
+    this.addon.click();
+    ok(this.picker.is(':visible'));
+});
+
+test('Dont activation (by disabled) by component', function(){
+    ok(!this.picker.is(':visible'));
+    this.input.prop('disabled', true);
+    this.addon.click();
+    ok(!this.picker.is(':visible'));
+    this.input.prop('disabled', false);
+    this.fieldset.prop('disabled', true);
+    this.addon.click();
+    ok(!this.picker.is(':visible'));
+});
+
+test('simple keyboard nav test', function(){
+    var target;
+
+    // Keyboard nav only works with non-readonly inputs
+    this.input.removeAttr('readonly');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 12));
+
+    // Focus/open
+    this.addon.click();
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 11));
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 11));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 month, shift + right arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39,
+        shiftKey: true
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 11));
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 11));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 11));
+    datesEqual(this.dp.getUTCDate(), UTCDate(2012, 1, 12));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 11));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+});
+
+test('setValue', function(){
+    this.dp.dates.replace(UTCDate(2012, 2, 13));
+    this.dp.setValue();
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+    equal(this.input.val(), '13-03-2012');
+});
+
+test('update', function(){
+    this.input.val('13-03-2012');
+    this.dp.update();
+    equal(this.dp.dates.length, 1);
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+});
+
+test('Navigating to/from decade view', function(){
+    var target;
+
+    this.addon.click();
+    this.input.val('31-03-2012');
+    this.dp.update();
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+
+    // Change years to test internal state changes
+    target = this.picker.find('.datepicker-years tbody span:contains(2011)');
+    target.click();
+    equal(this.dp.viewMode, 1);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 3, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 31));
+});
+
+test('Selecting date resets viewDate and date', function(){
+    var target;
+
+    this.addon.click();
+    this.input.val('31-03-2012');
+    this.dp.update();
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Feb 26
+
+    // Updated internally on click
+    target.click();
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 26));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 1, 26));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Jan 29
+});
+
+test('"destroy" removes associated HTML', function(){
+    var datepickerDivSelector = '.datepicker';
+
+    $('#datepicker').datepicker('show');
+
+    //there should be one datepicker initiated so that means one hidden .datepicker div
+    equal($(datepickerDivSelector).length, 1);
+    this.component.datepicker('destroy');
+    equal($(datepickerDivSelector).length, 0);//hidden HTML should be gone
+});
+
+test('"remove" is an alias for "destroy"', function(){
+    var called, originalDestroy = this.dp.destroy;
+    this.dp.destroy = function () {
+        called = true;
+        return originalDestroy.apply(this, arguments);
+    };
+    this.dp.remove();
+    ok(called);
+});
+
+test('Does not block events', function(){
+    var clicks = 0;
+    function handler(){
+        clicks++;
+    }
+    $('#qunit-fixture').on('click', '.add-on', handler);
+    this.addon.click();
+    equal(clicks, 1);
+    $('#qunit-fixture').off('click', '.add-on', handler);
+});
+
+
+test('date and viewDate must be between startDate and endDate when setStartDate called', function() {
+    this.dp.setDate(new Date(2013, 1, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2013, 1, 1));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 1, 1));
+    this.dp.setStartDate(new Date(2013, 5, 6));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 5, 6));
+    equal(this.dp.dates.length, 0);
+});
+
+test('date and viewDate must be between startDate and endDate when setEndDate called', function() {
+    this.dp.setDate(new Date(2013, 11, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2013, 11, 1));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 11, 1));
+    this.dp.setEndDate(new Date(2013, 5, 6));
+    datesEqual(this.dp.viewDate, UTCDate(2013, 5, 6));
+    equal(this.dp.dates.length, 0);
+});
+
+test('picker should render fine when `$.fn.show` and `$.fn.hide` are overridden', patch_show_hide(function () {
+    var viewModes = $.fn.datepicker.DPGlobal.viewModes,
+        minViewMode = this.dp.o.minViewMode,
+        maxViewMode = this.dp.o.maxViewMode,
+        childDivs = this.picker.children('div');
+
+    this.dp.setViewMode(minViewMode);
+
+    // Overwritten `$.fn.hide` method adds the `foo` class to its matched elements
+    var curDivShowing = childDivs.filter('.datepicker-' + viewModes[minViewMode].clsName);
+    ok(!curDivShowing.hasClass('foo'), 'Shown div does not have overridden `$.fn.hide` side-effects');
+
+    // Check that other classes do have `foo` class
+    var divNotShown;
+    for (var curViewMode = minViewMode + 1; curViewMode <= maxViewMode; curViewMode++) {
+        divNotShown = childDivs.filter('.datepicker-' + viewModes[curViewMode].clsName);
+        ok(divNotShown.hasClass('foo'), 'Other divs do have overridden `$.fn.hide` side-effects');
+    }
+}));
+
+test('Focused ceil for decade/century/millenium views', function(){
+    var input = $('<input />')
+      .appendTo('#qunit-fixture')
+      .datepicker({
+        startView: 2,
+        defaultViewDate: {
+          year: 2115
+        }
+      }),
+      dp = input.data('datepicker'),
+      picker = dp.picker,
+      target;
+
+    input.focus();
+
+    target = picker.find('.datepicker-years tbody .focused');
+    ok(target.text() === '2115', 'Year cell is focused');
+
+    picker.find('.datepicker-years thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-decades tbody .focused');
+    ok(target.text() === '2110', 'Decade cell is focused');
+
+    picker.find('.datepicker-decades thead th.datepicker-switch').click();
+    target = picker.find('.datepicker-centuries tbody .focused');
+    ok(target.text() === '2100', 'Century cell is focused');
+});

static/bower_components/bootstrap-datepicker/tests/suites/data-api.js

@@ -0,0 +1,114 @@
+module('DATA-API');
+
+test('DATA-API: data-provide="datepicker" on input; focus', function(){
+    var input = $('<input data-provide="datepicker" />')
+                .appendTo('#qunit-fixture');
+    input.focus();
+    ok(input.data('datepicker'), 'datepicker is initialized by "focus" event');
+});
+
+test('DATA-API: data-provide="datepicker" on input; click', function(){
+    var input = $('<input data-provide="datepicker" />')
+                .appendTo('#qunit-fixture');
+    input.click();
+    ok(input.data('datepicker'), 'datepicker is initialized by "focus" event');
+});
+
+test('DATA-API: data-provide="datepicker" on component', function(){
+    var html, comp;
+
+    html = '<div class="input-append date" data-provide="datepicker">'+
+                '<input><span class="add-on"><i class="icon-th"></i></span>'+
+            '</div>';
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input').focus();
+    ok(comp.data('datepicker'), 'append component initialized by "focus" event on input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input').click();
+    ok(comp.data('datepicker'), 'append component initialized by "click" event on input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('.add-on').focus();
+    ok(comp.data('datepicker'), 'append component initialized by "focus" event on add-on');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('.add-on').click();
+    ok(comp.data('datepicker'), 'append component initialized by "click" event on add-on');
+    comp.remove();
+
+
+    html = '<div class="input-prepend date" data-provide="datepicker">'+
+                '<span class="add-on"><i class="icon-th"></i></span><input>'+
+            '</div>';
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('input').focus();
+    ok(comp.data('datepicker'), 'prepend component initialized by "focus" event on input');
+    comp.remove();
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('input').click();
+    ok(comp.data('datepicker'), 'prepend component initialized by "click" event on input');
+    comp.remove();
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('.add-on').focus();
+    ok(comp.data('datepicker'), 'prepend component initialized by "focus" event on add-on');
+    comp.remove();
+
+    comp = $(html).prependTo('#qunit-fixture');
+    comp.find('.add-on').click();
+    ok(comp.data('datepicker'), 'prepend component initialized by "click" event on add-on');
+    comp.remove();
+});
+
+test('DATA-API: data-provide="datepicker" on button', function(){
+    var html, comp;
+
+    html = '<button data-provide="datepicker">';
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.focus();
+    ok(comp.data('datepicker'), 'button initialized by "focus" event on input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.click();
+    ok(comp.data('datepicker'), 'button initialized by "click" event on input');
+    comp.remove();
+});
+
+test('DATA-API: data-provide="datepicker" on rangepicker', function(){
+    var html, comp;
+
+    html = '<div class="input-daterange" data-provide="datepicker">'+
+                '<input class="datepicker">'+
+                '<span class="add-on">to</span>'+
+                '<input class="datepicker">'+
+            '</div>';
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:first').focus();
+    ok(comp.data('datepicker'), 'range initialized by "focus" event on first input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:first').click();
+    ok(comp.data('datepicker'), 'range initialized by "click" event on first input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:last').focus();
+    ok(comp.data('datepicker'), 'range initialized by "focus" event on last input');
+    comp.remove();
+
+    comp = $(html).appendTo('#qunit-fixture');
+    comp.find('input:last').click();
+    ok(comp.data('datepicker'), 'range initialized by "click" event on last input');
+    comp.remove();
+});

static/bower_components/bootstrap-datepicker/tests/suites/events.js

@@ -0,0 +1,507 @@
+module('Events on initialization', {
+    setup: function(){
+        this.input = $('<input type="text" value="31-03-2011">')
+            .appendTo('#qunit-fixture')
+    }
+});
+
+test('When initializing the datepicker, it should trigger no change or changeDate events', function(){
+    var triggered_change = 0,
+        triggered_changeDate = 0;
+
+    this.input.on({
+        change: function(){
+            triggered_change++;
+        },
+        changeDate: function(){
+            triggered_changeDate++;
+        }
+    });
+
+    this.input.datepicker({format: 'dd-mm-yyyy'});
+
+    equal(triggered_change, 0);
+    equal(triggered_changeDate, 0);
+});
+
+module('Events', {
+    setup: function(){
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Selecting a year from decade view triggers changeYear', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeYear', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+
+    // Change years to test internal state changes
+    target = this.picker.find('.datepicker-years tbody span:contains(2010)');
+    target.click();
+    equal(this.dp.viewMode, 1);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2010, 2, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+    equal(triggered, 1);
+});
+
+test('Navigating forward/backward from month view triggers changeYear', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeYear', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+
+    target = this.picker.find('.datepicker-months thead th.prev');
+    ok(target.is(':visible'), 'Prev switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(triggered, 1);
+
+    target = this.picker.find('.datepicker-months thead th.next');
+    ok(target.is(':visible'), 'Next switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(triggered, 2);
+});
+
+test('Selecting a month from year view triggers changeMonth', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 3, 1));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 31));
+    equal(triggered, 1);
+});
+
+test('Navigating forward/backward from month view triggers changeMonth', function(){
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.prev');
+    ok(target.is(':visible'), 'Prev switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Day picker is visible');
+    equal(triggered, 1);
+
+    target = this.picker.find('.datepicker-days thead th.next');
+    ok(target.is(':visible'), 'Next switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Day picker is visible');
+    equal(triggered, 2);
+});
+
+test('format() returns a formatted date string', function(){
+    var target,
+        error, out;
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format();
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    target.click();
+
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 14));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 14));
+    equal(error, undefined);
+    equal(out, '14-03-2011');
+});
+
+test('format(altformat) returns a formatted date string', function(){
+    var target,
+        error, out;
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format('m/d/yy');
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    target.click();
+
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 14));
+    datesEqual(this.dp.dates[0], UTCDate(2011, 2, 14));
+    equal(error, undefined);
+    equal(out, '3/14/11');
+});
+
+test('format(ix) returns a formatted date string of the ix\'th date selected', function(){
+    var target,
+        error, out;
+
+    this.dp._process_options({multidate: true});
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format(2);
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    target = this.picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '6'); // Mar 6
+    target.click();
+
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '14'); // Mar 16
+    target.click();
+
+    equal(this.dp.dates.length, 3);
+
+    equal(error, undefined);
+    equal(out, '14-03-2011');
+});
+
+test('format(ix, altformat) returns a formatted date string', function(){
+    var target,
+        error, out;
+
+    this.dp._process_options({multidate: true});
+
+    this.input.on('changeDate', function(e){
+        try{
+            out = e.format(2, 'm/d/yy');
+        }
+        catch(e){
+            error = e;
+        }
+    });
+
+    target = this.picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '6'); // Mar 6
+    target.click();
+
+    target = this.picker.find('.datepicker-days tbody td:nth(15)');
+    equal(target.text(), '14'); // Mar 16
+    target.click();
+
+    equal(this.dp.dates.length, 3);
+
+    equal(error, undefined);
+    equal(out, '3/14/11');
+});
+
+test('Clear button: triggers change and changeDate events', function(){
+    this.input = $('<input type="text" value="31-03-2011">')
+                    .appendTo('#qunit-fixture')
+                    .datepicker({
+                        format: "dd-mm-yyyy",
+                        clearBtn: true
+                    })
+                    .focus(); // Activate for visibility checks
+    this.dp = this.input.data('datepicker');
+    this.picker = this.dp.picker;
+
+    var target,
+        triggered_change = 0,
+        triggered_changeDate = 0;
+
+    this.input.on({
+        changeDate: function(){
+            triggered_changeDate++;
+        },
+        change: function(){
+            triggered_change++;
+        }
+    });
+
+    this.input.focus();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+    ok(this.picker.find('.datepicker-days tfoot .clear').is(':visible'), 'Clear button visible');
+
+    target = this.picker.find('.datepicker-days tfoot .clear');
+    target.click();
+
+    equal(triggered_change, 1);
+    equal(triggered_changeDate, 1);
+});
+
+test('setDate: triggers change and changeDate events', function(){
+    this.input = $('<input type="text" value="31-03-2011">')
+                    .appendTo('#qunit-fixture')
+                    .datepicker({
+                        format: "dd-mm-yyyy"
+                    })
+                    .focus(); // Activate for visibility checks
+    this.dp = this.input.data('datepicker');
+    this.picker = this.dp.picker;
+
+    var target,
+        triggered_change = 0,
+        triggered_changeDate = 0;
+
+    this.input.on({
+        changeDate: function(){
+            triggered_changeDate++;
+        },
+        change: function(){
+            triggered_change++;
+        }
+    });
+
+    this.input.focus();
+    ok(this.picker.find('.datepicker-days').is(':visible'), 'Days view visible');
+
+    this.dp.setDate(new Date(2011, 2, 5));
+
+    equal(triggered_change, 1);
+    equal(triggered_changeDate, 1);
+});
+
+test('paste must update the date', function() {
+    var dateToPaste = '22-07-2015';
+    var evt = {
+        type: 'paste',
+        originalEvent: {
+            clipboardData: {
+                types: ['text/plain'],
+                getData: function() { return dateToPaste; }
+            },
+            preventDefault: function() { evt.originalEvent.isDefaultPrevented = true; },
+            isDefaultPrevented: false
+        }
+    };
+    this.input.trigger(evt);
+    datesEqual(this.dp.dates[0], UTCDate(2015, 6, 22));
+
+    ok(evt.originalEvent.isDefaultPrevented, 'prevented original event');
+});
+
+test('clicking outside datepicker triggers \'hide\' event', function(){
+    var $otherelement = $('<div />');
+    $('body').append($otherelement);
+
+    var isHideTriggered;
+    this.input.on('hide', function() { isHideTriggered = true; });
+
+    $otherelement.trigger('mousedown');
+
+    ok(isHideTriggered, '\'hide\' event is not triggered');
+
+    $otherelement.remove();
+});
+
+test('Selecting date from previous month triggers changeMonth', function() {
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:first');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggered, 1);
+});
+
+test('Selecting date from previous month in january triggers changeMonth/changeYear', function() {
+    var target,
+        triggeredM = 0,
+        triggeredY = 0;
+
+    this.input.val('01-01-2011');
+    this.dp.update();
+
+    this.input.on('changeMonth', function(){
+        triggeredM++;
+    });
+
+    this.input.on('changeYear', function(){
+        triggeredY++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:first');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggeredM, 1);
+    equal(triggeredY, 1);
+});
+
+test('Selecting date from next month triggers changeMonth', function() {
+    var target,
+        triggered = 0;
+
+    this.input.on('changeMonth', function(){
+        triggered++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:last');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggered, 1);
+});
+
+test('Selecting date from next month in december triggers changeMonth/changeYear', function() {
+    var target,
+        triggeredM = 0,
+        triggeredY = 0;
+
+    this.input.val('01-12-2011');
+    this.dp.update();
+
+    this.input.on('changeMonth', function(){
+        triggeredM++;
+    });
+
+    this.input.on('changeYear', function(){
+        triggeredY++;
+    });
+
+    // find first day of previous month
+    target = this.picker.find('.datepicker-days tbody td:last');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggeredM, 1);
+    equal(triggeredY, 1);
+});
+
+test('Changing view mode triggers changeViewMode', function () {
+  var viewMode = -1,
+    triggered = 0;
+
+  this.input.val('22-07-2016');
+  this.dp.update();
+
+  this.input.on('changeViewMode', function (e) {
+    viewMode = e.viewMode;
+    triggered++;
+  });
+
+  // change from days to months
+  this.picker.find('.datepicker-days .datepicker-switch').click();
+  equal(triggered, 1);
+  equal(viewMode, 1);
+
+  // change from months to years
+  this.picker.find('.datepicker-months .datepicker-switch').click();
+  equal(triggered, 2);
+  equal(viewMode, 2);
+
+  // change from years to decade
+  this.picker.find('.datepicker-years .datepicker-switch').click();
+  equal(triggered, 3);
+  equal(viewMode, 3);
+
+  // change from decades to centuries
+  this.picker.find('.datepicker-decades .datepicker-switch').click();
+  equal(triggered, 4);
+  equal(viewMode, 4);
+
+});
+
+test('Clicking inside content of date with custom beforeShowDay content works', function(){
+    this.input = $('<input type="text" value="31-03-2011">')
+                    .appendTo('#qunit-fixture')
+                    .datepicker({
+                        format: "dd-mm-yyyy",
+                        beforeShowDay: function (date) { return { content: '<div><div>' + date.getDate() + '</div></div>' }; }
+                    })
+                    .focus(); // Activate for visibility checks
+    this.dp = this.input.data('datepicker');
+    this.picker = this.dp.picker;
+
+    var target,
+        triggered = 0;
+
+    this.input.on('changeDate', function(){
+        triggered++;
+    });
+
+    // find deepest date
+    target = this.picker.find('.datepicker-days tbody td:first div div');
+    target.click();
+
+    // ensure event has been triggered
+    equal(triggered, 1);
+});

static/bower_components/bootstrap-datepicker/tests/suites/formats.js

@@ -0,0 +1,314 @@
+module('Formats', {
+    setup: function(){
+        this.input = $('<input type="text">').appendTo('#qunit-fixture');
+        this.date = UTCDate(2012, 2, 15, 0, 0, 0, 0); // March 15, 2012
+    },
+    teardown: function(){
+        this.input.data('datepicker').picker.remove();
+    }
+});
+
+test('d: Day of month, no leading zero.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-mm-d'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[2], '5');
+});
+
+test('dd: Day of month, leading zero.', function(){
+    this.input
+        .val('2012-03-5')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[2], '05');
+});
+
+test('D: Day of week, short.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-mm-dd-D'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[3], 'Mon');
+});
+
+test('DD: Day of week, long.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-mm-dd-DD'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[3], 'Monday');
+});
+
+test('m: Month, no leading zero.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yyyy-m-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], '3');
+});
+
+test('mm: Month, leading zero.', function(){
+    this.input
+        .val('2012-3-5')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], '03');
+});
+
+test('M: Month shortname.', function(){
+    this.input
+        .val('2012-Mar-05')
+        .datepicker({format: 'yyyy-M-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'Mar');
+});
+
+test('M: Month shortname case insensitive.', function(){
+    this.input
+        .val('2012-MAR-05')
+        .datepicker({format: 'yyyy-M-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'Mar');
+});
+
+test('MM: Month full name.', function(){
+    this.input
+        .val('2012-March-5')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'March');
+});
+
+test('M: Month fullname case insensitive.', function(){
+    this.input
+        .val('2012-MARCH-05')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[1], 'March');
+});
+
+test('yy: Year, two-digit.', function(){
+    this.input
+        .val('2012-03-05')
+        .datepicker({format: 'yy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[0], '12');
+});
+
+test('yyyy: Year, four-digit.', function(){
+    this.input
+        .val('2012-03-5')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val().split('-')[0], '2012');
+});
+
+test('dd-mm-yyyy: Regression: Prevent potential month overflow in small-to-large formats (Mar 31, 2012 -> Mar 01, 2012)', function(){
+    this.input
+        .val('31-03-2012')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '31-03-2012');
+});
+
+test('dd-mm-yyyy: Leap day', function(){
+    this.input
+        .val('29-02-2012')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '29-02-2012');
+});
+
+test('yyyy-mm-dd: Alternative format', function(){
+    this.input
+        .val('2012-02-12')
+        .datepicker({format: 'yyyy-mm-dd'})
+        .datepicker('setValue');
+    equal(this.input.val(), '2012-02-12');
+});
+
+test('yyyy-MM-dd: Regression: Infinite loop when numbers used for month', function(){
+    this.input
+        .val('2012-02-12')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .datepicker('setValue');
+    equal(this.input.val(), '2012-February-12');
+});
+
+test('+1d: Tomorrow', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1d')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '16-03-2012');
+}));
+
+test('tomorrow (alias for +1d): Tomorrow', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('tomorrow')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '16-03-2012');
+}));
+
+test('-1d: Yesterday', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1d')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '14-03-2012');
+}));
+
+test('yesterday (alias for -1d): Yesterday', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('yesterday')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '14-03-2012');
+}));
+
+test('+1w: Next week', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1w')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '22-03-2012');
+}));
+
+test('-1w: Last week', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1w')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '08-03-2012');
+}));
+
+test('+1m: Next month', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1m')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-04-2012');
+}));
+
+test('-1m: Last month', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1m')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-02-2012');
+}));
+
+test('+1y: Next year', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('+1y')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-03-2013');
+}));
+
+test('-1y: Last year', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1y')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-03-2011');
+}));
+
+test('-1y +2m: Multiformat', patch_date(function(Date){
+    Date.now = UTCDate(2012, 2, 15);
+    this.input
+        .val('-1y +2m')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '15-05-2011');
+}));
+
+test('Regression: End-of-month bug', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('29-02-2012')
+        .datepicker({format: 'dd-mm-yyyy'})
+        .datepicker('setValue');
+    equal(this.input.val(), '29-02-2012');
+}));
+
+test('Invalid formats are force-parsed into a valid date on tab', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('44-44-4444')
+        .datepicker({format: 'yyyy-MM-dd'})
+        .focus();
+
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 9
+    });
+
+    equal(this.input.val(), '56-September-30');
+}));
+
+test('Trailing separators', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('29.02.2012.')
+        .datepicker({format: 'dd.mm.yyyy.'})
+        .datepicker('setValue');
+    equal(this.input.val(), '29.02.2012.');
+}));
+
+test('Assume nearby year - last century', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/91')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/1991');
+}));
+
+test('Assume nearby year - this century (- 1 year)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/01')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/2001');
+}));
+
+test('Assume nearby year - this century (+ 7 years)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/19')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/2019');
+}));
+
+test('Assume nearby year - this century (+ 13 years)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/23')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: true})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/1923');
+}));
+
+test('Assume nearby year - this century (+ 13 years, threshold = 30)', patch_date(function(Date){
+    Date.now = UTCDate(2012, 4, 31);
+    this.input
+        .val('02/14/23')
+        .datepicker({format: 'mm/dd/yyyy', assumeNearbyYear: 30})
+        .datepicker('setValue');
+    equal(this.input.val(), '02/14/2023');
+}));

static/bower_components/bootstrap-datepicker/tests/suites/inline.js

@@ -0,0 +1,28 @@
+module('Inline', {
+    setup: function(){
+        this.component = $('<div data-date="12-02-2012"></div>')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"});
+        this.dp = this.component.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+
+test('Picker gets date/viewDate from data-date attr', function(){
+    datesEqual(this.dp.dates[0], UTCDate(2012, 1, 12));
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 12));
+});
+
+
+test('Visible after init', function(){
+    ok(this.picker.is(':visible'));
+});
+
+test('update', function(){
+    this.dp.update('13-03-2012');
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+});

static/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2011.js

@@ -0,0 +1,228 @@
+module('Keyboard Navigation 2011', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2011.  Fun facts:
+
+            * March 1, 2011 was on a Tuesday
+            * March 31, 2011 was on a Thursday
+        */
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Regression: by week (up/down arrows); up from Mar 6, 2011 should go to Feb 27, 2011', function(){
+    var target;
+
+    this.input.val('06-03-2011').datepicker('update');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 6));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 6));
+    equal(this.dp.focusDate, null);
+
+    // Navigation: -1 week, up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 27));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 6));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 27));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by day (left/right arrows); left from Mar 1, 2011 should go to Feb 28, 2011', function(){
+    var target;
+
+    this.input.val('01-03-2011').datepicker('update');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 1));
+    equal(this.dp.focusDate, null);
+
+    // Navigation: -1 day left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 1));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 28));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by month (shift + left/right arrows); left from Mar 15, 2011 should go to Feb 15, 2011', function(){
+    var target;
+
+    this.input.val('15-03-2011').datepicker('update');
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+    equal(this.dp.focusDate, null);
+
+    // Navigation: -1 month, shift + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        shiftKey: true
+    });
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 15));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 15));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by month with view mode = 1 (left/right arrow); left from March 15, 2011 should go to February 15, 2011', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 1,
+      startView: 1
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 1);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 37
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2011, 1, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2011, 1, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'February 2011', 'Title is "February 2011"');
+});
+
+test('Regression: by month with view mode = 1 (up/down arrow); down from March 15, 2011 should go to July 15, 2010', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 1,
+      startView: 1
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 1);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 40
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2011, 6, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2011, 6, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'July 2011', 'Title is "July 2011"');
+});
+
+test('Regression: by year with view mode = 2 (left/right arrow); left from March 15, 2011 should go to March 15, 2010', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 2,
+      startView: 2
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 2);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 37
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2010, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2010, 2, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2010', 'Title is "March 2010"');
+});
+
+test('Regression: by year with view mode = 2 (up/down arrow); dows from March 15, 2011 should go to March 15, 2015', function () {
+  this.picker.remove();
+  this.input = $('<input type="text" value="15-03-2011">')
+    .appendTo('#qunit-fixture')
+    .datepicker({
+      format: "dd-mm-yyyy",
+      minViewMode: 2,
+      startView: 2
+    })
+    .focus(); // Activate for visibility checks
+  this.dp = this.input.data('datepicker');
+  this.picker = this.dp.picker;
+
+  this.input.val('15-03-2011').datepicker('update');
+  equal(this.dp.viewMode, 2);
+
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2011', 'Title is "March 2011"');
+  datesEqual(this.dp.viewDate, UTCDate(2011, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  equal(this.dp.focusDate, null);
+
+  this.input.trigger({
+    type: 'keydown',
+    keyCode: 40
+  });
+
+  datesEqual(this.dp.viewDate, UTCDate(2015, 2, 15));
+  datesEqual(this.dp.dates.get(-1), UTCDate(2011, 2, 15));
+  datesEqual(this.dp.focusDate, UTCDate(2015, 2, 15));
+  target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+  equal(target.text(), 'March 2015', 'Title is "March 2015"');
+});

static/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/2012.js

@@ -0,0 +1,483 @@
+module('Keyboard Navigation 2012', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2012.  Fun facts:
+
+            * February 1, 2012 was on a Wednesday
+            * February 29, 2012 was on a Wednesday
+            * March 1, 2012 was on a Thursday
+            * March 31, 2012 was on a Saturday
+        */
+        this.input = $('<input type="text" value="31-03-2012">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+
+test('by day (right/left arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 30));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: +1 day, right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 1));
+    // Month changed: April 1 (this is not a joke!)
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by week (up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 week, up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 24));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 24));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: +1 week, down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 7));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 7));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by month, v1 (shift + left/right arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 month, shift + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful date ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 29));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 month, shift + right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 29));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by month, v2 (shift + up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 month, shift + up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful date ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 29));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 month, shift + down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 3, 29));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'April 2012', 'Title is "April 2012"');
+});
+
+test('by year, v1 (ctrl + left/right arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39,
+            ctrlKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, v2 (ctrl + up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40,
+            ctrlKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, v3 (ctrl + shift + left/right arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + right arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 39,
+            ctrlKey: true,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, v4 (ctrl + shift + up/down arrows)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 year, ctrl + up arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 38,
+        ctrlKey: true,
+        shiftKey: true
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 2, 31));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2011', 'Title is "March 2011"');
+
+    // Navigation: +1 year, ctrl + down arrow key
+    for (var i=0; i<2; i++)
+        this.input.trigger({
+            type: 'keydown',
+            keyCode: 40,
+            ctrlKey: true,
+            shiftKey: true
+        });
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 2, 31));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2013', 'Title is "March 2013"');
+});
+
+test('by year, from leap day', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+
+    this.input.val('29-02-2012').datepicker('update');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    equal(this.dp.focusDate, null);
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: -1 year
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful month ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2011, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    datesEqual(this.dp.focusDate, UTCDate(2011, 1, 28));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2011', 'Title is "February 2011"');
+
+    // Navigation: +1 year, back to leap year
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful month ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 1, 28));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2012', 'Title is "February 2012"');
+
+    // Navigation: +1 year
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39,
+        ctrlKey: true
+    });
+    // view and focus updated on keyboard navigation w/ graceful month ends, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2013, 1, 28));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 29));
+    datesEqual(this.dp.focusDate, UTCDate(2013, 1, 28));
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'February 2013', 'Title is "February 2013"');
+});
+
+test('Selection (enter)', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 30));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Selection: Enter
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 13
+    });
+    // view and selection updated, focus cleared
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 30));
+    equal(this.dp.focusDate, null);
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    ok(this.picker.is(':visible'), 'Picker is not hidden');
+});
+
+test('Selection + hide (enter)', function(){
+    var target;
+
+    this.dp._process_options({autoclose: true});
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Navigation: -1 day, left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+    // view and focus updated on keyboard navigation, not selected
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+    datesEqual(this.dp.focusDate, UTCDate(2012, 2, 30));
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    // Selection: Enter
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 13
+    });
+    // view and selection updatedfocus cleared
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 30));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 30));
+    equal(this.dp.focusDate, null);
+    // Month not changed
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+});
+
+test('Toggle hide/show (escape); navigation while hidden is suppressed', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    equal(target.text(), 'March 2012', 'Title is "March 2012"');
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+
+    // Hide
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 27
+    });
+
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // left arrow key, *doesn't* navigate
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Show - with escape key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 27
+    });
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Hide
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 27
+    });
+
+    // Show - with down key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 40
+    });
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+});
+

static/bower_components/bootstrap-datepicker/tests/suites/keyboard_navigation/all.js

@@ -0,0 +1,62 @@
+module('Keyboard Navigation (All)', {
+    setup: function(){
+        this.input = $('<input type="text">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('TAB hides picker', function(){
+    var target;
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 9
+    });
+
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+});
+
+test('by day (right/left arrows) with daysOfWeekDisabled', function(){
+    var target;
+
+    this.input.val('04-03-2013');
+    this.dp.setDaysOfWeekDisabled('0,6');
+    this.dp.update();
+
+    this.input.focus();
+
+    // Navigation: -1 day left arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 37
+    });
+
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 1));
+});
+
+test('by day (right/left arrows) with datesDisabled', function(){
+    var target;
+
+    this.input.val('04-03-2013');
+    this.dp.setDatesDisabled(['05-03-2013']);
+    this.dp.update();
+
+    this.input.focus();
+
+    // Navigation: +1 day right arrow key
+    this.input.trigger({
+        type: 'keydown',
+        keyCode: 39
+    });
+
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 6));
+});

static/bower_components/bootstrap-datepicker/tests/suites/methods.js

@@ -0,0 +1,188 @@
+module('Methods', {
+    setup: function(){
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"});
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.dp.remove();
+    }
+});
+
+test('remove', function(){
+    var returnedObject = this.dp.remove();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('show', function(){
+    var returnedObject = this.dp.show();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('hide', function(){
+    var returnedObject = this.dp.hide();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - String', function(){
+    var returnedObject = this.dp.update('13-03-2012');
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+    var date = this.dp.picker.find('.datepicker-days td:contains(13)');
+    ok(date.hasClass('active'), 'Date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - Date', function(){
+    var returnedObject = this.dp.update(new Date(2012, 2, 13));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13));
+    var date = this.dp.picker.find('.datepicker-days td:contains(13)');
+    ok(date.hasClass('active'), 'Date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - Date with time', function(){
+    var returnedObject = this.dp.update(new Date(2012, 2, 13, 23, 59, 59, 999));
+    datesEqual(this.dp.dates[0], UTCDate(2012, 2, 13, 23, 59, 59, 999));
+    var date = this.dp.picker.find('.datepicker-days td:contains(13)');
+    ok(date.hasClass('active'), 'Date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('update - null', function(){
+    var returnedObject = this.dp.update(null);
+    equal(this.dp.dates[0], undefined);
+    var selected = this.dp.picker.find('.datepicker-days td.active');
+    equal(selected.length, 0, 'No date is selected');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDate', function(){
+    var date_in = new Date(2013, 1, 1),
+        expected_date = new Date(Date.UTC(2013, 1, 1)),
+        returnedObject;
+
+    notEqual(this.dp.dates[0], date_in);
+    returnedObject = this.dp.setDate(date_in);
+    strictEqual(returnedObject, this.dp, "is chainable");
+    datesEqual(this.dp.dates[0], expected_date);
+});
+
+test('setUTCDate', function(){
+    var date_in = new Date(Date.UTC(2012, 3, 5)),
+        expected_date = date_in,
+        returnedObject;
+
+    notEqual(this.dp.dates[0], date_in);
+    returnedObject = this.dp.setUTCDate(date_in);
+    strictEqual(returnedObject, this.dp, "is chainable");
+    datesEqual(this.dp.dates[0], expected_date);
+});
+
+test('setStartDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setStartDate(date_in);
+    // ...
+    datesEqual(this.dp.o.startDate, expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setEndDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setEndDate(date_in);
+    // ...
+    datesEqual(this.dp.o.endDate, expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('getStartDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setStartDate(date_in);
+    // ...
+    datesEqual(returnedObject.getStartDate(), expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('getEndDate', function(){
+    var date_in = new Date(2012, 3, 5),
+        expected_date = new Date(Date.UTC(2012, 3, 5)),
+        returnedObject = this.dp.setEndDate(date_in);
+    // ...
+    datesEqual(returnedObject.getEndDate(), expected_date);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDaysOfWeekDisabled - String', function(){
+    var days_in = "0,6",
+        expected_days = [0,6],
+        returnedObject = this.dp.setDaysOfWeekDisabled(days_in);
+    // ...
+    deepEqual(this.dp.o.daysOfWeekDisabled, expected_days);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDaysOfWeekDisabled - Array', function(){
+    var days_in = [0,6],
+        expected_days = days_in,
+        returnedObject = this.dp.setDaysOfWeekDisabled(days_in);
+    // ...
+    deepEqual(this.dp.o.daysOfWeekDisabled, expected_days);
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setDatesDisabled', function(){
+    var monthShown = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    var returnedObject = this.dp.setDatesDisabled(['01-03-2011']);
+    ok(this.picker.find('.datepicker-days tbody td.day:not(.old):first').hasClass('disabled'), 'day is disabled');
+    this.dp.setDatesDisabled(['01-01-2011']);
+    equal(monthShown.text(), 'March 2011', 'should not change viewDate');
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('setValue', function(){
+    var returnedObject = this.dp.setValue();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('place', function(){
+    var returnedObject = this.dp.place();
+    // ...
+    strictEqual(returnedObject, this.dp, "is chainable");
+});
+
+test('moveMonth - can handle invalid date', function(){
+    // any input which results in an invalid date, f.e. an incorrectly formatted.
+    var invalidDate = new Date("invalid"),
+        returnedObject = this.dp.moveMonth(invalidDate, 1);
+    // ...
+    equal(this.input.val(), "31-03-2011", "date is reset");
+});
+
+test('parseDate - outputs correct value', function(){
+    var parsedDate = $.fn.datepicker.DPGlobal.parseDate('11/13/2015', $.fn.datepicker.DPGlobal.parseFormat('mm/dd/yyyy'), 'en');
+    equal(parsedDate.getUTCDate(), "13", "date is correct");
+    equal(parsedDate.getUTCMonth(), "10", "month is correct");
+    equal(parsedDate.getUTCFullYear(), "2015", "fullyear is correct");
+});
+
+test('parseDate - outputs correct value for yyyy\u5E74mm\u6708dd\u65E5 format', function(){
+    var parsedDate = $.fn.datepicker.DPGlobal.parseDate('2015\u5E7411\u670813', $.fn.datepicker.DPGlobal.parseFormat('yyyy\u5E74mm\u6708dd\u65E5'), 'ja');
+    equal(parsedDate.getUTCDate(), "13", "date is correct");
+    equal(parsedDate.getUTCMonth(), "10", "month is correct");
+    equal(parsedDate.getUTCFullYear(), "2015", "fullyear is correct");
+});
+
+test('parseDate - outputs correct value for dates containing unicodes', function(){
+    var parsedDate = $.fn.datepicker.DPGlobal.parseDate('\u5341\u4E00\u6708 13 2015', $.fn.datepicker.DPGlobal.parseFormat('MM dd yyyy'), 'zh-CN');
+    equal(parsedDate.getUTCDate(), "13", "date is correct");
+    equal(parsedDate.getUTCMonth(), "10", "month is correct");
+    equal(parsedDate.getUTCFullYear(), "2015", "fullyear is correct");
+});

static/bower_components/bootstrap-datepicker/tests/suites/methods_jquery.js

@@ -0,0 +1,26 @@
+module('Methods (jQuery)', {
+    setup: function(){
+        this.$inputs = $('<input><input>')
+            .datepicker()
+            .appendTo('#qunit-fixture');
+    },
+    teardown: function(){
+        this.$inputs.each(function(){
+            $.data(this, 'datepicker').picker.remove();
+        });
+    }
+});
+
+test('Methods', function(){
+    [
+        'show',
+        'hide',
+        'setValue',
+        'place'
+    ].forEach($.proxy(function(index, value){
+        var returnedObject = this.$inputs.datepicker(value);
+
+        strictEqual(returnedObject, this.$inputs, "is jQuery element");
+        strictEqual(returnedObject.length, 2, "correct length of jQuery elements");
+    }, this));
+});

static/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2011.js

@@ -0,0 +1,66 @@
+module('Mouse Navigation 2011', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2011.
+        */
+        this.input = $('<input type="text" value="31-03-2011">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Selecting date from previous month while in January changes month and year displayed', function(){
+    var target;
+
+    this.input.val('01-01-2011');
+    this.dp.update();
+    datesEqual(this.dp.viewDate, UTCDate(2011, 0, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 0, 1));
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Dec 26
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'January 2011');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'December 2010');
+    datesEqual(this.dp.viewDate, UTCDate(2010, 11, 26));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2010, 11, 26));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '28'); // Should be Nov 28
+});
+
+test('Selecting date from next month while in December changes month and year displayed', function(){
+    var target;
+
+    this.input.val('01-12-2010');
+    this.dp.update();
+    datesEqual(this.dp.viewDate, UTCDate(2010, 11, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2010, 11, 1));
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:last');
+    equal(target.text(), '8'); // Should be Jan 8
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'December 2010');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'January 2011');
+    datesEqual(this.dp.viewDate, UTCDate(2011, 0, 8));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2011, 0, 8));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Dec 26
+});

static/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/2012.js

@@ -0,0 +1,266 @@
+module('Mouse Navigation 2012', {
+    setup: function(){
+        /*
+            Tests start with picker on March 31, 2012.  Fun facts:
+
+            * February 1, 2012 was on a Wednesday
+            * February 29, 2012 was on a Wednesday
+            * March 1, 2012 was on a Thursday
+            * March 31, 2012 was on a Saturday
+        */
+        this.input = $('<input type="text" value="31-03-2012">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Selecting date resets viewDate and date', function(){
+    var target;
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:nth(7)');
+    equal(target.text(), '4'); // Should be Mar 4
+
+    // Updated internally on click
+    target.click();
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 4));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 4));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Feb 29
+});
+
+test('Navigating next/prev by month', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.prev');
+    ok(target.is(':visible'), 'Month:prev nav is visible');
+
+    // Updated internally on click
+    target.click();
+    // Should handle month-length changes gracefully
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Jan 29
+
+    target = this.picker.find('.datepicker-days thead th.next');
+    ok(target.is(':visible'), 'Month:next nav is visible');
+
+    // Updated internally on click
+    target.click().click();
+    // Graceful moonth-end handling carries over
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 29));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '25'); // Should be Mar 25
+    // (includes "old" days at start of month, even if that's all the first week-row consists of)
+});
+
+test('Navigating to/from year view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Change months to test internal state
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2012, 3, 1)); // Apr 30
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Navigating to/from decade view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Change years to test internal state changes
+    target = this.picker.find('.datepicker-years tbody span:contains(2011)');
+    target.click();
+    equal(this.dp.viewMode, 1);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months tbody span:contains(Apr)');
+    target.click();
+    equal(this.dp.viewMode, 0);
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 3, 1));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Navigating prev/next in year view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    equal(this.picker.find('.datepicker-months thead th.datepicker-switch').text(), '2012');
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to next year (2013)
+    target = this.picker.find('.datepicker-months thead th.next');
+    target.click();
+    equal(this.picker.find('.datepicker-months thead th.datepicker-switch').text(), '2013');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2013, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to prev year (x2 == 2011)
+    target = this.picker.find('.datepicker-months thead th.prev');
+    target.click().click();
+    equal(this.picker.find('.datepicker-months thead th.datepicker-switch').text(), '2011');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2011, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Navigating prev/next in decade view', function(){
+    var target;
+
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-months').is(':visible'), 'Month picker is visible');
+    equal(this.dp.viewMode, 1);
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    target = this.picker.find('.datepicker-months thead th.datepicker-switch');
+    ok(target.is(':visible'), 'View switcher is visible');
+
+    target.click();
+    ok(this.picker.find('.datepicker-years').is(':visible'), 'Year picker is visible');
+    equal(this.dp.viewMode, 2);
+    equal(this.picker.find('.datepicker-years thead th.datepicker-switch').text(), '2010-2019');
+    // Not modified when switching modes
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to next decade (2020-29)
+    target = this.picker.find('.datepicker-years thead th.next');
+    target.click();
+    equal(this.picker.find('.datepicker-years thead th.datepicker-switch').text(), '2020-2029');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2022, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+
+    // Go to prev year (x2 == 2000-09)
+    target = this.picker.find('.datepicker-years thead th.prev');
+    target.click().click();
+    equal(this.picker.find('.datepicker-years thead th.datepicker-switch').text(), '2000-2009');
+    // Only viewDate modified
+    datesEqual(this.dp.viewDate, UTCDate(2002, 2, 31));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 2, 31));
+});
+
+test('Selecting date from previous month resets viewDate and date, changing month displayed', function(){
+    var target;
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '26'); // Should be Feb 26
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'March 2012');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'February 2012');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 1, 26));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 1, 26));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Jan 29
+});
+
+test('Selecting date from next month resets viewDate and date, changing month displayed', function(){
+    var target;
+
+    this.input.val('01-04-2012');
+    this.dp.update();
+
+    // Rendered correctly
+    equal(this.dp.viewMode, 0);
+    target = this.picker.find('.datepicker-days tbody td:last');
+    equal(target.text(), '5'); // Should be May 5
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'April 2012');
+
+    // Updated internally on click
+    target.click();
+    equal(this.picker.find('.datepicker-days thead th.datepicker-switch').text(), 'May 2012');
+    datesEqual(this.dp.viewDate, UTCDate(2012, 4, 5));
+    datesEqual(this.dp.dates.get(-1), UTCDate(2012, 4, 5));
+
+    // Re-rendered on click
+    target = this.picker.find('.datepicker-days tbody td:first');
+    equal(target.text(), '29'); // Should be Apr 29
+});
+
+test('Selecting today from next month', patch_date(function(Date){
+    var target;
+    this.dp.o.todayHighlight = true;
+    Date.now = new Date(2012, 2, 3); // Mar 3
+    this.input.val('01-02-2012');    // Feb 1
+    this.dp.update();
+
+    // Click the today button
+    target = this.picker.find('.datepicker-days tbody td.today');
+    equal(target.text(), '3'); // Should be Mar 3
+    target.click();
+
+    datesEqual(this.dp.viewDate, UTCDate(2012, 2, 3));
+}));

static/bower_components/bootstrap-datepicker/tests/suites/mouse_navigation/all.js

@@ -0,0 +1,33 @@
+module('Mouse Navigation (All)', {
+    setup: function(){
+        this.input = $('<input type="text">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Clicking datepicker does not hide datepicker', function(){
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    this.picker.trigger('mousedown');
+    ok(this.picker.is(':visible'), 'Picker is still visible');
+});
+
+test('Clicking outside datepicker hides datepicker', function(){
+    var $otherelement = $('<div />');
+    $('body').append($otherelement);
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    this.input.trigger('click');
+    ok(this.picker.is(':visible'), 'Picker is still visible');
+
+    $otherelement.trigger('mousedown');
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+
+    $otherelement.remove();
+});

static/bower_components/bootstrap-datepicker/tests/suites/noconflict.js

@@ -0,0 +1,20 @@
+module('NoConflict', {
+    setup: function(){
+        var datepicker = $.fn.datepicker.noConflict();
+        $.fn.bootstrapDP = datepicker;
+    },
+    teardown: function(){
+        $.fn.datepicker = $.fn.bootstrapDP;
+        delete $.fn.bootstrapDP;
+    }
+});
+
+test('Datepicker starts after calling noConflict() (no undefined defaults or locale_opts)', function(){
+    $('<div class="input-append date" id="datepicker">'+
+        '<input size="16" type="text" value="12-02-2012" readonly>'+
+        '<span class="add-on"><i class="icon-th"></i></span>'+
+        '</div>')
+        .appendTo('#qunit-fixture')
+        .bootstrapDP();
+    expect(0);
+});

static/bower_components/bootstrap-datepicker/tests/suites/timezone.js

@@ -0,0 +1,24 @@
+module('Component', {
+    setup: function(){
+        this.component = $('<div class="input-append date" id="datepicker">'+
+                               '<input type="text">'+
+                           '</div>')
+                        .appendTo('#qunit-fixture')
+                        .datepicker();
+        this.dp = this.component.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Check title with timezone', function(){
+    var target;
+
+    this.dp.viewDate = UTCDate(2015, 7, 1);
+    this.dp.fill();
+
+    target = this.picker.find('.datepicker-days .datepicker-switch');
+    equal(target.text(), 'August 2015', 'Title is "August 2015"');
+});

static/bower_components/bootstrap-datepicker/tests/suites/touch_navigation/all.js

@@ -0,0 +1,27 @@
+module('Touch Navigation (All)', {
+    setup: function(){
+        this.input = $('<input type="text">')
+                        .appendTo('#qunit-fixture')
+                        .datepicker({format: "dd-mm-yyyy"})
+                        .focus(); // Activate for visibility checks
+        this.dp = this.input.data('datepicker');
+        this.picker = this.dp.picker;
+    },
+    teardown: function(){
+        this.picker.remove();
+    }
+});
+
+test('Tapping outside datepicker hides datepicker', function(){
+    var $otherelement = $('<div />');
+    $('body').append($otherelement);
+
+    ok(this.picker.is(':visible'), 'Picker is visible');
+    this.input.trigger('click');
+    ok(this.picker.is(':visible'), 'Picker is still visible');
+
+    $otherelement.trigger('touchstart');
+    ok(this.picker.is(':not(:visible)'), 'Picker is hidden');
+
+    $otherelement.remove();
+});

static/bower_components/bootstrap-datepicker/tests/tests.html

@@ -0,0 +1,55 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <link rel="stylesheet" href="assets/qunit.css">
+        <script src="assets/qunit.js"></script>
+        <!-- console.log for test failures: enable locally if you need extra debug info-->
+        <!--<script src="assets/qunit-logging.js"></script>-->
+        <script src="assets/jquery-1.7.1.min.js"></script>
+        <script src="../js/bootstrap-datepicker.js"></script>
+        <!-- This locale is included to test usage of titleFormat when available: see tests/suites/options.js -->
+        <script src="../js/locales/bootstrap-datepicker.zh-CN.js"></script>
+
+        <style>
+            .datepicker {
+                /* Appended to body, abs-pos off the page */
+                position: absolute;
+                display: none;
+                top: -9999em;
+                left: -9999em;
+            }
+        </style>
+
+        <!-- Utilities -->
+        <script src="assets/utils.js"></script>
+        <script src="assets/mock.js"></script>
+
+        <!-- Test suites -->
+        <script src="suites/formats.js"></script>
+        <script src="suites/mouse_navigation/all.js"></script>
+        <script src="suites/mouse_navigation/2012.js"></script>
+        <script src="suites/mouse_navigation/2011.js"></script>
+        <script src="suites/keyboard_navigation/all.js"></script>
+        <script src="suites/keyboard_navigation/2012.js"></script>
+        <script src="suites/keyboard_navigation/2011.js"></script>
+        <script src="suites/touch_navigation/all.js"></script>
+        <script src="suites/component.js"></script>
+        <script src="suites/events.js"></script>
+        <script src="suites/options.js"></script>
+        <script src="suites/inline.js"></script>
+        <script src="suites/calendar-weeks.js"></script>
+        <script src="suites/data-api.js"></script>
+        <script src="suites/noconflict.js"></script>
+        <script src="suites/methods.js"></script>
+        <script src="suites/methods_jquery.js"></script>
+    </head>
+    <body>
+        <h1 id="qunit-header">bootstrap-datepicker</h1>
+        <h2 id="qunit-banner"></h2>
+        <div id="qunit-testrunner-toolbar"></div>
+        <h2 id="qunit-userAgent"></h2>
+        <ol id="qunit-tests"></ol>
+        <div id="qunit-fixture"></div>
+    </body>
+</html>

static/bower_components/bootstrap-datepicker/tests/timezone.html

@@ -0,0 +1,36 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <link rel="stylesheet" href="assets/qunit.css">
+        <script src="assets/qunit.js"></script>
+        <!-- console.log for test failures: enable locally if you need extra debug info-->
+        <!--<script src="assets/qunit-logging.js"></script>-->
+        <script src="assets/jquery-1.7.1.min.js"></script>
+        <script src="../js/bootstrap-datepicker.js"></script>
+
+        <style>
+            .datepicker {
+                /* Appended to body, abs-pos off the page */
+                position: absolute;
+                display: none;
+                top: -9999em;
+                left: -9999em;
+            }
+        </style>
+
+        <!-- Utilities -->
+        <script src="assets/utils.js"></script>
+
+        <!-- Test suites -->
+        <script src="suites/timezone.js"></script>
+    </head>
+    <body>
+        <h1 id="qunit-header">bootstrap-datepicker</h1>
+        <h2 id="qunit-banner"></h2>
+        <div id="qunit-testrunner-toolbar"></div>
+        <h2 id="qunit-userAgent"></h2>
+        <ol id="qunit-tests"></ol>
+        <div id="qunit-fixture"></div>
+    </body>
+</html>