/*!

 * QUnit 1.18.0

 * http://qunitjs.com/

 * Copyright jQuery Foundation and other contributors

 * Released under the MIT license

 * http://jquery.org/license

 *

 * Date: 2015-04-03T10:23Z

(function( window ) {

var QUnit,

	config,

	onErrorFnPrev,

	loggingCallbacks = {},

	fileName = ( sourceFromStacktrace( 0 ) || "" ).replace( /(:\d+)+\)?/, "" ).replace( /.+\//, "" ),

	toString = Object.prototype.toString,

	hasOwn = Object.prototype.hasOwnProperty,

	// Keep a local reference to Date (GH-283)

	Date = window.Date,

	now = Date.now || function() {

		return new Date().getTime();

	},

	globalStartCalled = false,

	runStarted = false,

	setTimeout = window.setTimeout,

	clearTimeout = window.clearTimeout,

	defined = {

		document: window.document !== undefined,

		setTimeout: window.setTimeout !== undefined,

		sessionStorage: (function() {

			var x = "qunit-test-string";

			try {

				sessionStorage.setItem( x, x );

				sessionStorage.removeItem( x );

				return true;

			} catch ( e ) {

				return false;

			}

		}())

	},

	/**

	 * Provides a normalized error string, correcting an issue

	 * with IE 7 (and prior) where Error.prototype.toString is

	 * not properly implemented

	 *

	 * Based on http://es5.github.com/#x15.11.4.4

	 *

	 * @param {String|Error} error

	 * @return {String} error message

	 */

	errorString = function( error ) {

		var name, message,

			errorString = error.toString();

		if ( errorString.substring( 0, 7 ) === "[object" ) {

			name = error.name ? error.name.toString() : "Error";

			message = error.message ? error.message.toString() : "";

			if ( name && message ) {

				return name + ": " + message;

			} else if ( name ) {

				return name;

			} else if ( message ) {

				return message;

			} else {

				return "Error";

			}

		} else {

			return errorString;

	/**

	 * Makes a clone of an object using only Array or Object as base,

	 * and copies over the own enumerable properties.

	 *

	 * @param {Object} obj

	 * @return {Object} New object with only the own properties (recursively).

	 */

	objectValues = function( obj ) {

		var key, val,

			vals = QUnit.is( "array", obj ) ? [] : {};

		for ( key in obj ) {

			if ( hasOwn.call( obj, key ) ) {

				val = obj[ key ];

				vals[ key ] = val === Object( val ) ? objectValues( val ) : val;

		}

		return vals;

	};

QUnit = {};

/**

 * Config object: Maintain internal state

 * Later exposed as QUnit.config

 * `config` initialized at top of scope

 */

config = {

	// The queue of tests to run

	queue: [],

	// block until document ready

	blocking: true,

	// by default, run previously failed tests first

	// very useful in combination with "Hide passed tests" checked

	reorder: true,

	// by default, modify document.title when suite is done

	altertitle: true,

	// by default, scroll to top of the page when suite is done

	scrolltop: true,

	// when enabled, all tests must call expect()

	requireExpects: false,

	// depth up-to which object will be dumped

	maxDepth: 5,

	// add checkboxes that are persisted in the query-string

	// when enabled, the id is set to `true` as a `QUnit.config` property

	urlConfig: [

		{

			id: "hidepassed",

			label: "Hide passed tests",

			tooltip: "Only show tests and assertions that fail. Stored as query-strings."

		},

		{

			id: "noglobals",

			label: "Check for Globals",

			tooltip: "Enabling this will test if any test introduces new properties on the " +

				"`window` object. Stored as query-strings."

		},

		{

			id: "notrycatch",

			label: "No try-catch",

			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging " +

				"exceptions in IE reasonable. Stored as query-strings."

		}

	],

	// Set of all modules.

	modules: [],

	// The first unnamed module

	currentModule: {

		name: "",

		tests: []

	callbacks: {}

};

// Push a loose unnamed module to the modules collection

config.modules.push( config.currentModule );

// Initialize more QUnit.config and QUnit.urlParams

(function() {

	var i, current,

		location = window.location || { search: "", protocol: "file:" },

		params = location.search.slice( 1 ).split( "&" ),

		length = params.length,

		urlParams = {};

	if ( params[ 0 ] ) {

		for ( i = 0; i < length; i++ ) {

			current = params[ i ].split( "=" );

			current[ 0 ] = decodeURIComponent( current[ 0 ] );

			// allow just a key to turn on a flag, e.g., test.html?noglobals

			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;

			if ( urlParams[ current[ 0 ] ] ) {

				urlParams[ current[ 0 ] ] = [].concat( urlParams[ current[ 0 ] ], current[ 1 ] );

			} else {

				urlParams[ current[ 0 ] ] = current[ 1 ];

			}

		}

	}

	if ( urlParams.filter === true ) {

		delete urlParams.filter;

	}

	QUnit.urlParams = urlParams;

	// String search anywhere in moduleName+testName

	config.filter = urlParams.filter;

	if ( urlParams.maxDepth ) {

		config.maxDepth = parseInt( urlParams.maxDepth, 10 ) === -1 ?

			Number.POSITIVE_INFINITY :

			urlParams.maxDepth;

	}

	config.testId = [];

	if ( urlParams.testId ) {

		// Ensure that urlParams.testId is an array

		urlParams.testId = decodeURIComponent( urlParams.testId ).split( "," );

		for ( i = 0; i < urlParams.testId.length; i++ ) {

			config.testId.push( urlParams.testId[ i ] );

		}

	}

	// Figure out if we're running the tests from a server or not

	QUnit.isLocal = location.protocol === "file:";

	// Expose the current QUnit version

	QUnit.version = "1.18.0";

}());

// Root QUnit object.

// `QUnit` initialized at top of scope

extend( QUnit, {

	// call on start of module test to prepend name to all tests

	module: function( name, testEnvironment ) {

		var currentModule = {

			name: name,

			testEnvironment: testEnvironment,

			tests: []

		};

		// DEPRECATED: handles setup/teardown functions,

		// beforeEach and afterEach should be used instead

		if ( testEnvironment && testEnvironment.setup ) {

			testEnvironment.beforeEach = testEnvironment.setup;

			delete testEnvironment.setup;

		}

		if ( testEnvironment && testEnvironment.teardown ) {

			testEnvironment.afterEach = testEnvironment.teardown;

			delete testEnvironment.teardown;

		}

		config.modules.push( currentModule );

		config.currentModule = currentModule;

	},

	// DEPRECATED: QUnit.asyncTest() will be removed in QUnit 2.0.

	asyncTest: function( testName, expected, callback ) {

			expected = null;

		QUnit.test( testName, expected, callback, true );

	test: function( testName, expected, callback, async ) {

		var test;

		test = new Test({

			testName: testName,

			expected: expected,

			async: async,

			callback: callback

		});

		test.queue();

	},

	skip: function( testName ) {

		var test = new Test({

			testName: testName,

			skip: true

		test.queue();

	},

	// DEPRECATED: The functionality of QUnit.start() will be altered in QUnit 2.0.

	// In QUnit 2.0, invoking it will ONLY affect the `QUnit.config.autostart` blocking behavior.

	start: function( count ) {

		var globalStartAlreadyCalled = globalStartCalled;

		if ( !config.current ) {

			globalStartCalled = true;

			if ( runStarted ) {

				throw new Error( "Called start() outside of a test context while already started" );

			} else if ( globalStartAlreadyCalled || count > 1 ) {

				throw new Error( "Called start() outside of a test context too many times" );

			} else if ( config.autostart ) {

				throw new Error( "Called start() outside of a test context when " +

					"QUnit.config.autostart was true" );

			} else if ( !config.pageLoaded ) {

				// The page isn't completely loaded yet, so bail out and let `QUnit.load` handle it

				config.autostart = true;

				return;

		} else {

			// If a test is running, adjust its semaphore

			config.current.semaphore -= count || 1;

			// Don't start until equal number of stop-calls

			if ( config.current.semaphore > 0 ) {

				return;

			// throw an Error if start is called more often than stop

			if ( config.current.semaphore < 0 ) {

				config.current.semaphore = 0;

				QUnit.pushFailure(

					"Called start() while already started (test's semaphore was 0 already)",

					sourceFromStacktrace( 2 )

				);

				return;

		resumeProcessing();

	// DEPRECATED: QUnit.stop() will be removed in QUnit 2.0.

	stop: function( count ) {

		// If there isn't a test running, don't allow QUnit.stop() to be called

		if ( !config.current ) {

			throw new Error( "Called stop() outside of a test context" );

		}

		// If a test is running, adjust its semaphore

		config.current.semaphore += count || 1;

		pauseProcessing();

	config: config,

		return QUnit.objectType( obj ) === type;

	objectType: function( obj ) {

		if ( typeof obj === "undefined" ) {

			return "undefined";

		}

		// Consider: typeof null === object

		if ( obj === null ) {

			return "null";

		}

		var match = toString.call( obj ).match( /^\[object\s(.*)\]$/ ),

			type = match && match[ 1 ] || "";

		switch ( type ) {

			case "Number":

				if ( isNaN( obj ) ) {

					return "nan";

				}

				return "number";

			case "String":

			case "Boolean":

			case "Array":

			case "Date":

			case "RegExp":

			case "Function":

				return type.toLowerCase();

		}

		if ( typeof obj === "object" ) {

			return "object";

		}

		return undefined;

	},

	extend: extend,

	load: function() {

		config.pageLoaded = true;

		// Initialize the configuration options

		extend( config, {

			stats: { all: 0, bad: 0 },

			moduleStats: { all: 0, bad: 0 },

			started: 0,

			updateRate: 1000,

			autostart: true,

			filter: ""

		}, true );

		config.blocking = false;

		if ( config.autostart ) {

			resumeProcessing();

});

// Register logging callbacks

(function() {

	var i, l, key,

		callbacks = [ "begin", "done", "log", "testStart", "testDone",

			"moduleStart", "moduleDone" ];

	function registerLoggingCallback( key ) {

		var loggingCallback = function( callback ) {

			if ( QUnit.objectType( callback ) !== "function" ) {

				throw new Error(

					"QUnit logging methods require a callback function as their first parameters."

				);

			}

			config.callbacks[ key ].push( callback );

		};

		// DEPRECATED: This will be removed on QUnit 2.0.0+

		// Stores the registered functions allowing restoring

		// at verifyLoggingCallbacks() if modified

		loggingCallbacks[ key ] = loggingCallback;

		return loggingCallback;

	for ( i = 0, l = callbacks.length; i < l; i++ ) {

		key = callbacks[ i ];

		// Initialize key collection of logging callback

		if ( QUnit.objectType( config.callbacks[ key ] ) === "undefined" ) {

			config.callbacks[ key ] = [];

		}

		QUnit[ key ] = registerLoggingCallback( key );

	}

})();

// `onErrorFnPrev` initialized at top of scope

// Preserve other handlers

onErrorFnPrev = window.onerror;

// Cover uncaught exceptions

// Returning true will suppress the default browser handler,

// returning false will let it run.

window.onerror = function( error, filePath, linerNr ) {

	var ret = false;

	if ( onErrorFnPrev ) {

		ret = onErrorFnPrev( error, filePath, linerNr );

	}

	// Treat return value as window.onerror itself does,

	// Only do our handling if not suppressed.

	if ( ret !== true ) {

		if ( QUnit.config.current ) {

			if ( QUnit.config.current.ignoreGlobalErrors ) {

				return true;

			QUnit.pushFailure( error, filePath + ":" + linerNr );

		} else {

			QUnit.test( "global failure", extend(function() {

				QUnit.pushFailure( error, filePath + ":" + linerNr );

			}, { validTest: true } ) );

		}

		return false;

	return ret;

};

	var runtime, passed;

	if ( config.previousModule ) {

		runLoggingCallbacks( "moduleDone", {

			name: config.previousModule.name,

			tests: config.previousModule.tests,

			failed: config.moduleStats.bad,

			passed: config.moduleStats.all - config.moduleStats.bad,

			total: config.moduleStats.all,

			runtime: now() - config.moduleStats.started

		});

	delete config.previousModule;

	runtime = now() - config.started;

	passed = config.stats.all - config.stats.bad;

	runLoggingCallbacks( "done", {

		failed: config.stats.bad,

		passed: passed,

		total: config.stats.all,

		runtime: runtime