├── .gitignore
├── README.md
├── bootstrap-contextmenu.js
├── bower.json
├── gulpfile.js
├── index.html
├── package.json
└── test
    ├── qunit.html
    ├── unit
        └── bootstrap-contextmenu.js
    └── vendor
        ├── jquery.js
        ├── qunit.css
        └── qunit.js


/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | Bootstrap Context Menu
  2 | ======================
  3 | 
  4 | #This project is unmaintained. Please use the alternative https://github.com/swisnl/jQuery-contextMenu.
  5 | 
  6 | I have an issue with the plugin but I would still like to use it.
  7 | 
  8 | -- Please fork the project and do your fixes.
  9 | 
 10 | Where can I get support if can't fix some issue?
 11 | 
 12 | -- You can check the issues page or pull request page if someone has a fix for your problem and merge it with your fork.
 13 | 
 14 | I still can't find fixes of my issues.
 15 | 
 16 | -- Get plenty of sleep. :)
 17 | 
 18 | 
 19 | ## A context menu extension of Bootstrap made for everyone's convenience.
 20 | 
 21 | See a [demo page] [id].
 22 | [id]:http://sydcanem.github.io/bootstrap-contextmenu/
 23 | 
 24 | Installation
 25 | ------------
 26 | 
 27 | `bower install bootstrap-contextmenu`
 28 | 
 29 | Note: Requires bootstrap.css
 30 | 
 31 | Usage
 32 | -----
 33 | 
 34 | ### Via data attributes
 35 | 
 36 | Add `data-toggle="context"` to any element that needs a custom context menu and via CSS set `position: relative` to the element.
 37 | 
 38 | Point `data-target` attribute to your custom context menu.
 39 | 
 40 | `<div class="context" data-toggle="context" data-target="#context-menu"></div>`
 41 | 
 42 | ### Via Javascript
 43 | 
 44 | Call the context menu via JavaScript:
 45 | 
 46 | ```js
 47 | $('.context').contextmenu({
 48 |   target:'#context-menu', 
 49 |   before: function(e,context) {
 50 |     // execute code before context menu if shown
 51 |   },
 52 |   onItem: function(context,e) {
 53 |     // execute on menu item selection
 54 |   }
 55 | })
 56 | ```
 57 | 
 58 | ### Options
 59 | 
 60 | `target` - is the equivalent of the `data-target` attribute. It identifies the html of the menu that will be displayed. 
 61 | 
 62 | `before` - is a function that is called before the context menu is displayed. If this function returns false, the context menu will not be displayed. It is passed two parameters,
 63 | 
 64 |   - `e` - the original event. (You can do an `e.preventDefault()` to cancel the browser event). 
 65 |   - `context` - the DOM element where right click occured.
 66 | 
 67 | `onItem` - is a function that is called when a menu item is clicked. Useful when you want to execute a specific function when an item is clicked. It is passed two parameters,
 68 | 
 69 |   - `context` - the DOM element where right click occured.
 70 |   - `e` - the click event of the menu item, $(e.target) is the item element.
 71 | 
 72 | `scopes` - DOM selector for dynamically added context elements. See [issue](https://github.com/sydcanem/bootstrap-contextmenu/issues/56).
 73 | 
 74 | ### Events
 75 | 
 76 | All events are fired at the context's menu. Check out `dropdown` plugin for
 77 | a complete description of events.
 78 | 
 79 | - `show.bs.context` - This event fires immediately when the menu is opened. 
 80 | - `shown.bs.context` - This event is fired when the dropdown has been made visible to the user. 
 81 | - `hide.bs.context` - This event is fired immediately when the hide instance method has been called. 
 82 | - `hidden.bs.context` - This event is fired when the dropdown has finished being hidden from the user (will wait for CSS transitions, to complete).
 83 |   
 84 | Sample
 85 | 
 86 | ```js
 87 | $('#myMenu').on('show.bs.context',function () {
 88 |   // do something...
 89 | });
 90 | ```
 91 | 
 92 | Example
 93 | -------
 94 | 
 95 | Activate and specify selector for context menu
 96 | 
 97 | ```js
 98 | $('#main').contextmenu({'target':'#context-menu'});
 99 | ```
100 | 
101 | Activate within a div, but not on spans
102 | 
103 | ```js
104 | $('#main').contextmenu({
105 |   target: '#context-menu2',
106 |   before: function (e, element, target) {
107 |       e.preventDefault();
108 |       if (e.target.tagName == 'SPAN') {
109 |           e.preventDefault();
110 |           this.closemenu();
111 |           return false;
112 |       }
113 |       return true;
114 |   }
115 | });
116 | ```
117 | 
118 | Modify the menu dynamically
119 | 
120 | ```js
121 | $('#main').contextmenu({
122 |   target: "#myMenu",
123 |   before: function(e) { 
124 |     this.getMenu().find("li").eq(2).find('a').html("This was dynamically changed");
125 |   }
126 | });
127 | ```
128 | 
129 | Show menu name on selection
130 | 
131 | ```js
132 | $('#main').contextmenu({
133 |   onItem: function(context, e) {
134 |     alert($(e.target).text());
135 |   }
136 | });
137 | ```
138 | 
139 | ### Nice to have features:
140 | 
141 |  - Close and open animations
142 |  - Keyboard shortcuts for menus
143 | 
144 | ### License
145 | MIT
146 | 


--------------------------------------------------------------------------------
/bootstrap-contextmenu.js:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * Bootstrap Context Menu
  3 |  * Author: @sydcanem
  4 |  * https://github.com/sydcanem/bootstrap-contextmenu
  5 |  *
  6 |  * Inspired by Bootstrap's dropdown plugin.
  7 |  * Bootstrap (http://getbootstrap.com).
  8 |  *
  9 |  * Licensed under MIT
 10 |  * ========================================================= */
 11 | 
 12 | ;(function($) {
 13 | 
 14 | 	'use strict';
 15 | 
 16 | 	/* CONTEXTMENU CLASS DEFINITION
 17 | 	 * ============================ */
 18 | 	var toggle = '[data-toggle="context"]';
 19 | 
 20 | 	var ContextMenu = function (element, options) {
 21 | 		this.$element = $(element);
 22 | 
 23 | 		this.before = options.before || this.before;
 24 | 		this.onItem = options.onItem || this.onItem;
 25 | 		this.scopes = options.scopes || null;
 26 | 
 27 | 		if (options.target) {
 28 | 			this.$element.data('target', options.target);
 29 | 		}
 30 | 
 31 | 		this.listen();
 32 | 	};
 33 | 
 34 | 	ContextMenu.prototype = {
 35 | 
 36 | 		constructor: ContextMenu
 37 | 		,show: function(e) {
 38 | 
 39 | 			var $menu
 40 | 				, evt
 41 | 				, tp
 42 | 				, items
 43 | 				, relatedTarget = { relatedTarget: this, target: e.currentTarget };
 44 | 
 45 | 			if (this.isDisabled()) return;
 46 | 
 47 | 			this.closemenu();
 48 | 
 49 | 			if (this.before.call(this,e,$(e.currentTarget)) === false) return;
 50 | 
 51 | 			$menu = this.getMenu();
 52 | 			$menu.trigger(evt = $.Event('show.bs.context', relatedTarget));
 53 | 
 54 | 			tp = this.getPosition(e, $menu);
 55 | 			items = 'li:not(.divider)';
 56 | 			$menu.attr('style', '')
 57 | 				.css(tp)
 58 | 				.addClass('open')
 59 | 				.on('click.context.data-api', items, $.proxy(this.onItem, this, $(e.currentTarget)))
 60 | 				.trigger('shown.bs.context', relatedTarget);
 61 | 
 62 | 			// Delegating the `closemenu` only on the currently opened menu.
 63 | 			// This prevents other opened menus from closing.
 64 | 			$('html')
 65 | 				.on('click.context.data-api', $menu.selector, $.proxy(this.closemenu, this));
 66 | 
 67 | 			return false;
 68 | 		}
 69 | 
 70 | 		,closemenu: function(e) {
 71 | 			var $menu
 72 | 				, evt
 73 | 				, items
 74 | 				, relatedTarget;
 75 | 
 76 | 			$menu = this.getMenu();
 77 | 
 78 | 			if(!$menu.hasClass('open')) return;
 79 | 
 80 | 			relatedTarget = { relatedTarget: this };
 81 | 			$menu.trigger(evt = $.Event('hide.bs.context', relatedTarget));
 82 | 
 83 | 			items = 'li:not(.divider)';
 84 | 			$menu.removeClass('open')
 85 | 				.off('click.context.data-api', items)
 86 | 				.trigger('hidden.bs.context', relatedTarget);
 87 | 
 88 | 			$('html')
 89 | 				.off('click.context.data-api', $menu.selector);
 90 | 			// Don't propagate click event so other currently
 91 | 			// opened menus won't close.
 92 | 			if (e) {
 93 | 				e.stopPropagation();
 94 | 			}
 95 | 		}
 96 | 
 97 | 		,keydown: function(e) {
 98 | 			if (e.which == 27) this.closemenu(e);
 99 | 		}
100 | 
101 | 		,before: function(e) {
102 | 			return true;
103 | 		}
104 | 
105 | 		,onItem: function(e) {
106 | 			return true;
107 | 		}
108 | 
109 | 		,listen: function () {
110 | 			this.$element.on('contextmenu.context.data-api', this.scopes, $.proxy(this.show, this));
111 | 			$('html').on('click.context.data-api', $.proxy(this.closemenu, this));
112 | 			$('html').on('keydown.context.data-api', $.proxy(this.keydown, this));
113 | 		}
114 | 
115 | 		,destroy: function() {
116 | 			this.$element.off('.context.data-api').removeData('context');
117 | 			$('html').off('.context.data-api');
118 | 		}
119 | 
120 | 		,isDisabled: function() {
121 | 			return this.$element.hasClass('disabled') || 
122 | 					this.$element.attr('disabled');
123 | 		}
124 | 
125 | 		,getMenu: function () {
126 | 			var selector = this.$element.data('target')
127 | 				, $menu;
128 | 
129 | 			if (!selector) {
130 | 				selector = this.$element.attr('href');
131 | 				selector = selector && selector.replace(/.*(?=#[^\s]*$)/, ''); //strip for ie7
132 | 			}
133 | 
134 | 			$menu = $(selector);
135 | 
136 | 			return $menu && $menu.length ? $menu : this.$element.find(selector);
137 | 		}
138 | 
139 | 		,getPosition: function(e, $menu) {
140 | 			var mouseX = e.clientX
141 | 				, mouseY = e.clientY
142 | 				, boundsX = $(window).width()
143 | 				, boundsY = $(window).height()
144 | 				, menuWidth = $menu.find('.dropdown-menu').outerWidth()
145 | 				, menuHeight = $menu.find('.dropdown-menu').outerHeight()
146 | 				, tp = {"position":"absolute","z-index":9999}
147 | 				, Y, X, parentOffset;
148 | 
149 | 			if (mouseY + menuHeight > boundsY) {
150 | 				Y = {"top": mouseY - menuHeight + $(window).scrollTop()};
151 | 			} else {
152 | 				Y = {"top": mouseY + $(window).scrollTop()};
153 | 			}
154 | 
155 | 			if ((mouseX + menuWidth > boundsX) && ((mouseX - menuWidth) > 0)) {
156 | 				X = {"left": mouseX - menuWidth + $(window).scrollLeft()};
157 | 			} else {
158 | 				X = {"left": mouseX + $(window).scrollLeft()};
159 | 			}
160 | 
161 | 			// If context-menu's parent is positioned using absolute or relative positioning,
162 | 			// the calculated mouse position will be incorrect.
163 | 			// Adjust the position of the menu by its offset parent position.
164 | 			parentOffset = $menu.offsetParent().offset();
165 | 			X.left = X.left - parentOffset.left;
166 | 			Y.top = Y.top - parentOffset.top;
167 |  
168 | 			return $.extend(tp, Y, X);
169 | 		}
170 | 
171 | 	};
172 | 
173 | 	/* CONTEXT MENU PLUGIN DEFINITION
174 | 	 * ========================== */
175 | 
176 | 	$.fn.contextmenu = function (option,e) {
177 | 		return this.each(function () {
178 | 			var $this = $(this)
179 | 				, data = $this.data('context')
180 | 				, options = (typeof option == 'object') && option;
181 | 
182 | 			if (!data) $this.data('context', (data = new ContextMenu($this, options)));
183 | 			if (typeof option == 'string') data[option].call(data, e);
184 | 		});
185 | 	};
186 | 
187 | 	$.fn.contextmenu.Constructor = ContextMenu;
188 | 
189 | 	/* APPLY TO STANDARD CONTEXT MENU ELEMENTS
190 | 	 * =================================== */
191 | 
192 | 	$(document)
193 | 	   .on('contextmenu.context.data-api', function() {
194 | 			$(toggle).each(function () {
195 | 				var data = $(this).data('context');
196 | 				if (!data) return;
197 | 				data.closemenu();
198 | 			});
199 | 		})
200 | 		.on('contextmenu.context.data-api', toggle, function(e) {
201 | 			$(this).contextmenu('show', e);
202 | 
203 | 			e.preventDefault();
204 | 			e.stopPropagation();
205 | 		});
206 | 		
207 | }(jQuery));
208 | 


--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "bootstrap-contextmenu",
 3 |   "main": "bootstrap-contextmenu.js",
 4 |   "version": "0.3.4",
 5 |   "homepage": "https://github.com/sydcanem/bootstrap-contextmenu",
 6 |   "authors": [
 7 |     "sydcanem <icqhv.santos@gmail.com>"
 8 |   ],
 9 |   "description": "Context-menu extension for the Bootstrap framework",
10 |   "keywords": [
11 |     "boostrap",
12 |     "contextmenu"
13 |   ],
14 |   "license": "MIT",
15 |   "ignore": [
16 |     "**/.*",
17 |     "node_modules",
18 |     "bower_components",
19 |     "test",
20 |     "tests"
21 |   ]
22 | }
23 | 


--------------------------------------------------------------------------------
/gulpfile.js:
--------------------------------------------------------------------------------
1 | var gulp = require('gulp'),
2 | 	qunit = require('gulp-qunit');
3 | 
4 | gulp.task('test', function () {
5 | 	return gulp.src('./test/qunit.html')
6 | 		.pipe(qunit());
7 | });


--------------------------------------------------------------------------------
/index.html:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html lang="en"><head><meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  3 |     <meta charset="utf-8">
  4 |     <title>Bootstrap</title>
  5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  6 |     <meta name="description" content="">
  7 |     <meta name="author" content="">
  8 | 
  9 |     <!-- Le styles -->
 10 | 	  <link href="http://cdnjs.cloudflare.com/ajax/libs/prettify/r224/prettify.css" type="text/css">
 11 |     <style>
 12 |       body {
 13 |         padding-top: 60px; /* 60px to make the container go all the way to the bottom of the topbar */
 14 |       }
 15 |     </style>
 16 |     <link href="http://netdna.bootstrapcdn.com/twitter-bootstrap/2.3.2/css/bootstrap-combined.min.css" rel="stylesheet">
 17 | 
 18 |     <!-- Le HTML5 shim, for IE6-8 support of HTML5 elements -->
 19 |     <!--[if lt IE 9]>
 20 |       <script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
 21 |     <![endif]-->
 22 | 
 23 |     <!-- Le fav and touch icons -->
 24 |   </head>
 25 | 
 26 |   <body onload="prettyPrint()">
 27 | 
 28 |     <div class="navbar navbar-inverse navbar-fixed-top">
 29 |       <div class="navbar-inner">
 30 |         <div class="container">
 31 |           <a class="btn btn-navbar" data-toggle="collapse" data-target=".nav-collapse">
 32 |             <span class="icon-bar"></span>
 33 |             <span class="icon-bar"></span>
 34 |             <span class="icon-bar"></span>
 35 |           </a>
 36 |           <a class="brand" href="https://github.com/sydcanem/bootstrap-contextmenu">Context Menu Plugin Extension</a>
 37 |         </div>
 38 |       </div>
 39 |     </div>
 40 | 
 41 |     <div class="container">
 42 |     	<div class="span7">
 43 |         <h1>Demo</h1>
 44 | 	      <p>Right click inside the box to trigger the menu</p>
 45 | 
 46 |         <h5>Demo 1</h5>
 47 |         <p>Using <code>data-toggle="context"</code> to attach a context-menu</p>
 48 | 	      <!-- Element div that needs a custom context menu -->
 49 | 	      <div id="context" data-toggle="context" data-target="#context-menu" style="height:300px;width:650px;border:1px solid #ddd">
 50 | 	      </div>
 51 | 
 52 | 	      <!-- Your custom menu with dropdown-menu as default styling -->
 53 | 	      <div id="context-menu">
 54 | 	      	<ul class="dropdown-menu" role="menu">
 55 |             <li><a tabindex="-1">Action</a></li>
 56 | 	           <li><a tabindex="-1">Another action</a></li>
 57 | 	           <li><a tabindex="-1">Something else here</a></li>
 58 | 	           <li class="divider"></li>
 59 | 	           <li><a tabindex="-1">Separated link</a></li>
 60 | 	      	</ul>
 61 | 	      </div>
 62 | 
 63 |         <h5>Demo 2</h5>
 64 |         <div id="main" data-toggle="context">This is an area where the context menu is active <span style="background-color: #cecece">However, we wont allow it here.</span> But anywhere else in this text should be perfectly fine. This one is started with only javascript</div>
 65 |    
 66 |         <div id="context-menu2">
 67 |           <ul class="dropdown-menu" role="menu">
 68 |               <li><a tabindex="-1">Action</a></li>
 69 |               <li><a tabindex="-1">Another action</a></li>
 70 |               <li><a tabindex="-1">Something else here</a></li>
 71 |               <li class="divider"></li>
 72 |               <li><a tabindex="-1">Separated link</a></li>
 73 |           </ul>
 74 |         </div>
 75 | 
 76 |         <h5>Demo 3</h5>
 77 |         <p>Show the menu name of the item that was selected</p>
 78 |         <!-- Element div that needs a custom context menu -->
 79 |         <div id="context2" data-toggle="context" style="height:300px;width:650px;border:1px solid #ddd">
 80 |         </div>
 81 | 
 82 | 	      <h2>Usage</h2>
 83 | 	      <h3>Via data attributes</h3>
 84 | 	      <p>Add <code>data-toggle="context"</code> to an element that needs a context menu.</p>
 85 | 	      <pre class="prettyprint linenums">
 86 | &lt;div id="context" data-toggle="context" data-target="#context-menu"&gt;
 87 |   ...
 88 | &lt;/div&gt;</pre>
 89 | 			<p>Your menu <code>&lt;ul&gt;</code> element must have a <code>dropdown-menu</code> class.
 90 | 			<pre class="prettyprint linenums">
 91 | &lt;div id="context-menu"&gt;
 92 |   &lt;ul class="dropdown-menu" role="menu"&gt;
 93 |     &lt;li&gt;&lt;a tabindex="-1" href="#"&gt;Action&lt;/a&gt;&lt;/li&gt;
 94 | 	...
 95 |     &lt;li&gt;&lt;a tabindex="-1" href="#"&gt;Separated link&lt;/a&gt;&lt;/li&gt;
 96 |   &lt;/ul&gt;
 97 | &lt;/div&gt;</pre>
 98 | 		<h3>Via Javascript</h3>
 99 | 	    <p>Call the context menus via Javascript:</p>
100 | 	    <pre class="prettyprint linenums">
101 | $('.context').contextmenu();</pre>
102 |     </div> <!-- /container -->
103 | 
104 | 
105 |     <!-- Le javascript
106 |     ================================================== -->
107 |     <!-- Placed at the end of the document so the pages load faster -->
108 |     <script src="http://codeorigin.jquery.com/jquery-1.10.2.min.js"></script>
109 |     <script src="bootstrap-contextmenu.js"></script>
110 |     <script src="http://cdnjs.cloudflare.com/ajax/libs/prettify/r224/prettify.js"></script>
111 |     <script type="text/javascript">
112 |       // Demo 2
113 |       $('#main').contextmenu({
114 |         target: '#context-menu2',
115 |         before: function (e) {
116 |           // This function is optional.
117 |           // Here we use it to stop the event if the user clicks a span
118 |           e.preventDefault();
119 |           if (e.target.tagName == 'SPAN') {
120 |             e.preventDefault();
121 |             this.closemenu();
122 |             return false;
123 |           }
124 |           this.getMenu().find("li").eq(2).find('a').html("This was dynamically changed");
125 |           return true;
126 |         }
127 |       });
128 |     </script>
129 |     <script type="text/javascript">
130 |       // Demo 3
131 |       $('#context2').contextmenu({
132 |         target: '#context-menu2',
133 |         onItem: function (context, e) {
134 |           alert($(e.target).text());
135 |         }
136 |       });
137 | 
138 |       $('#context-menu2').on('show.bs.context', function (e) {
139 |         console.log('before show event');
140 |       });
141 | 
142 |       $('#context-menu2').on('shown.bs.context', function (e) {
143 |         console.log('after show event');
144 |       });
145 | 
146 |       $('#context-menu2').on('hide.bs.context', function (e) {
147 |         console.log('before hide event');
148 |       });
149 | 
150 |       $('#context-menu2').on('hidden.bs.context', function (e) {
151 |         console.log('after hide event');
152 |       });
153 |     </script>
154 | </body></html>


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "bootstrap-contextmenu",
 3 |   "version": "0.3.4",
 4 |   "description": "Context-menu extension for the Bootstrap framework",
 5 |   "main": "bootstrap-contextmenu.js",
 6 |   "directories": {
 7 |     "test": "test"
 8 |   },
 9 |   "scripts": {
10 |     "test": "gulp test"
11 |   },
12 |   "repository": {
13 |     "type": "git",
14 |     "url": "git://github.com/sydcanem/bootstrap-contextmenu.git"
15 |   },
16 |   "keywords": [
17 |     "bootstrap"
18 |   ],
19 |   "author": "James Santos",
20 |   "license": "MIT",
21 |   "bugs": {
22 |     "url": "https://github.com/sydcanem/bootstrap-contextmenu/issues"
23 |   },
24 |   "homepage": "https://github.com/sydcanem/bootstrap-contextmenu",
25 |   "devDependencies": {
26 |     "gulp": "^3.6.0",
27 |     "gulp-qunit": "^0.3.3"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/qunit.html:
--------------------------------------------------------------------------------
 1 | <!DOCTYPE html>
 2 | <html>
 3 |   <head>
 4 |     <meta charset="utf-8">
 5 |     <title>Bootstrap Context-Menu Plugin Test Suite</title>
 6 | 
 7 |     <!-- jQuery -->
 8 |     <script src="vendor/jquery.js"></script>
 9 | 
10 |     <!-- QUnit -->
11 |     <link rel="stylesheet" href="vendor/qunit.css" media="screen">
12 |     <script src="vendor/qunit.js"></script>
13 |     <script src="../bootstrap-contextmenu.js"></script>
14 |     <!-- Unit tests -->
15 |     <script src="unit/bootstrap-contextmenu.js"></script>
16 | 
17 |   </head>
18 |   <body>
19 |     <div>
20 |       <div id="qunit"></div>
21 |       <div id="qunit-fixture"></div>
22 |     </div>
23 |   </body>
24 | </html>


--------------------------------------------------------------------------------
/test/unit/bootstrap-contextmenu.js:
--------------------------------------------------------------------------------
  1 | $(function () {
  2 | 	
  3 | 	module('contextmenus');
  4 | 
  5 | 	test('contextmenu defined on jquery object', function () {
  6 | 		ok($(document.body).contextmenu, 'contextmenu method is defined');
  7 | 	});
  8 | 
  9 | 	test('returns element', function () {
 10 | 		var el = $('<div />');
 11 | 		ok(el.contextmenu()[0] === el[0], 'same element returned');
 12 | 	});
 13 | 
 14 | 	test('should not open context-menu if context is disabled via element disabled attribute', function () {
 15 | 		var contextHTML = '<div>' +
 16 | 				'<div id="main" data-toggle="context" data-target="#context-menu" disabled>' +
 17 | 				'  <div id="context-menu">' +
 18 | 				'    <ul class="dropdown-menu">' +
 19 | 				'      <li><a href="#">Action</a></li>' +
 20 | 				'      <li><a href="#">Something else here</a></li>' +
 21 | 				'      <li class="divider"></li>' +
 22 | 				'      <li><a href="#">Another link</a></li>' +
 23 | 				'   <ul>' +
 24 | 				'  </div>' +
 25 | 				'</div>' +
 26 | 				'</div>',
 27 | 			contextmenu = $(contextHTML).find('[data-toggle="context"]').contextmenu().trigger('contextmenu');
 28 | 		
 29 | 		ok(!contextmenu.find('#context-menu').hasClass('open'), 'open class added on contextmenu');
 30 | 	});
 31 | 
 32 | 	test('should not open context-menu if context is disabled via element disabled class', function () {
 33 | 		var contextHTML = '<div>' +
 34 | 				'<div id="main" data-toggle="context" data-target="#context-menu" class="disabled">' +
 35 | 				'  <div id="context-menu">' +
 36 | 				'    <ul class="dropdown-menu">' +
 37 | 				'      <li><a href="#">Action</a></li>' +
 38 | 				'      <li><a href="#">Something else here</a></li>' +
 39 | 				'      <li class="divider"></li>' +
 40 | 				'      <li><a href="#">Another link</a></li>' +
 41 | 				'   <ul>' +
 42 | 				'  </div>' +
 43 | 				'</div>' +
 44 | 				'</div>',
 45 | 			contextmenu = $(contextHTML).find('[data-toggle="context"]').contextmenu().trigger('contextmenu');
 46 | 		
 47 | 		ok(!contextmenu.find('#context-menu').hasClass('open'), 'open class added on contextmenu');
 48 | 	});
 49 | 
 50 | 	test('should add class open to menu if context is right clicked', function () {
 51 | 		var contextHTML = '<div>' + 
 52 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
 53 | 				'  <div id="context-menu">' +
 54 | 				'    <ul class="dropdown-menu">' +
 55 | 				'      <li><a href="#">Action</a></li>' +
 56 | 				'      <li><a href="#">Something else here</a></li>' +
 57 | 				'      <li class="divider"></li>' +
 58 | 				'      <li><a href="#">Another link</a></li>' +
 59 | 				'    <ul>' +
 60 | 				'  </div>' +
 61 | 				'</div>' +
 62 | 				'</div>',
 63 | 			contextmenu = $(contextHTML).find('[data-toggle="context"]').contextmenu().trigger('contextmenu');
 64 | 		
 65 | 		ok(contextmenu.find('#context-menu').hasClass('open'), 'open class added on contextmenu');
 66 | 	});
 67 | 
 68 | 	test('should remove open class if body/document is clicked', function () {
 69 | 		var contextHTML = '<div>' +
 70 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
 71 | 				'  <div id="context-menu">' +
 72 | 				'    <ul class="dropdown-menu">' +
 73 | 				'      <li><a href="#">Action</a></li>' +
 74 | 				'      <li><a href="#">Something else here</a></li>' +
 75 | 				'      <li class="divider"></li>' +
 76 | 				'      <li><a href="#">Another link</a></li>' +
 77 | 				'    <ul>' +
 78 | 				'  </div>' +
 79 | 				'</div>' +
 80 | 				'</div>',
 81 | 			contextmenu = $(contextHTML)
 82 | 				.appendTo('#qunit-fixture')
 83 | 				.find('[data-toggle="context"]')
 84 | 				.contextmenu()
 85 | 				.trigger('contextmenu');
 86 | 
 87 | 		ok(contextmenu.find('#context-menu').hasClass('open'), 'open class added on right click');
 88 | 		$('body').click();
 89 | 		ok(!contextmenu.find('#context-menu').hasClass('open'), 'open class removed');
 90 | 		contextmenu.remove();
 91 | 	});
 92 | 
 93 | 	test('should remove open class if body is right clicked with multiple contextmenus', function () {
 94 | 		var contextHTML = '<div>' +
 95 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
 96 | 				'  <div id="context-menu">' +
 97 | 				'    <ul class="dropdown-menu">' +
 98 | 				'      <li><a href="#">Action</a></li>' +
 99 | 				'      <li><a href="#">Something else here</a></li>' +
100 | 				'      <li class="divider"></li>' +
101 | 				'      <li><a href="#">Another link</a></li>' +
102 | 				'    <ul>' +
103 | 				'  </div>' +
104 | 				'</div>' +
105 | 				'<div data-toggle="context" data-target="#context-menu2">' +
106 | 				'  <div id="context-menu2">' +
107 | 				'    <ul class="dropdown-menu">' +
108 | 				'      <li><a href="#">Action</a></li>' +
109 | 				'      <li><a href="#">Something else here</a></li>' +
110 | 				'      <li class="divider"></li>' +
111 | 				'      <li><a href="#">Another link</a></li>' +
112 | 				'    <ul>' +
113 | 				'  </div>' +
114 | 				'</div>' +
115 | 				'</div>',
116 | 			contextmenus = $(contextHTML).appendTo('#qunit-fixture').find('[data-toggle="context"]'),
117 | 			first = contextmenus.first(),
118 | 			last = contextmenus.last();
119 | 
120 | 		ok(contextmenus.length === 2, 'Should be two contextmenus');
121 | 		// Open first contextmenu
122 | 		first.trigger('contextmenu');
123 | 		ok(first.find('#context-menu.open').length === 1, 'open class added to first on right click');
124 | 		ok($('#qunit-fixture .open').length === 1, 'only one menu is open');
125 | 		$('body').click();
126 | 		ok($('#qunit-fixture .open').length === 0, 'open class removed');
127 | 		// Open last contextmenu
128 | 		last.trigger('contextmenu');
129 | 		ok(last.find('#context-menu2.open').length === 1, 'open class added to last on right click');
130 | 		ok($('#qunit-fixture .open').length === 1, 'only one menu is open');
131 | 		$('body').click();
132 | 		ok($('#qunit-fixture .open').length === 0, 'open class removed');
133 | 		// Open both contextmenus
134 | 		first.trigger('contextmenu');
135 | 		last.trigger('contextmenu');
136 | 		ok($('#qunit-fixture .open').length === 2, 'two menus is open');
137 | 		$('body').click();
138 | 		ok($('#qunit-fixture .open').length === 0, 'both menus is closed');
139 | 
140 | 		$('#qunit-fixture').html();
141 | 	});
142 | 
143 | 	test('should not remove open class from other context menus if menu item is clicked', function () {
144 | 				var contextHTML = '<div>' +
145 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
146 | 				'  <div id="context-menu">' +
147 | 				'    <ul class="dropdown-menu">' +
148 | 				'      <li><a href="#">Action</a></li>' +
149 | 				'      <li><a href="#">Something else here</a></li>' +
150 | 				'      <li class="divider"></li>' +
151 | 				'      <li><a href="#">Another link</a></li>' +
152 | 				'    <ul>' +
153 | 				'  </div>' +
154 | 				'</div>' +
155 | 				'<div data-toggle="context" data-target="#context-menu2">' +
156 | 				'  <div id="context-menu2">' +
157 | 				'    <ul class="dropdown-menu">' +
158 | 				'      <li><a href="#">Action</a></li>' +
159 | 				'      <li><a href="#">Something else here</a></li>' +
160 | 				'      <li class="divider"></li>' +
161 | 				'      <li><a href="#">Another link</a></li>' +
162 | 				'    <ul>' +
163 | 				'  </div>' +
164 | 				'</div>' +
165 | 				'</div>',
166 | 			contextmenus = $(contextHTML).appendTo('#qunit-fixture').find('[data-toggle="context"]'),
167 | 			first = contextmenus.first(),
168 | 			last = contextmenus.last();
169 | 
170 | 		ok(contextmenus.length === 2, 'Should be two contextmenus');
171 | 		// Open both contextmenu
172 | 		first.trigger('contextmenu');
173 | 		last.trigger('contextmenu');
174 | 		ok($('#qunit-fixture .open').length === 2, 'opened two contextmenus');
175 | 		
176 | 		first.find('ul > li:first a').click();
177 | 		ok($('#qunit-fixture .open').length === 1, 'only one contextmenu');
178 | 
179 | 		last.find('ul > li:first a').click();
180 | 		ok($('#qunit-fixture .open').length === 0, 'contextmenus closed');
181 | 
182 | 		$('#qunit-fixture').html();
183 | 	});
184 | 
185 | 	test('calls before callback', function () {
186 | 		var contextHTML = '<div>' + 
187 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
188 | 				'  <div id="context-menu">' +
189 | 				'    <ul class="dropdown-menu">' +
190 | 				'      <li><a href="#">Action</a></li>' +
191 | 				'      <li><a href="#">Something else here</a></li>' +
192 | 				'      <li class="divider"></li>' +
193 | 				'      <li><a href="#">Another link</a></li>' +
194 | 				'    <ul>' +
195 | 				'  </div>' +
196 | 				'</div>' +
197 | 				'</div>',
198 | 			calls = 0,
199 | 			before = function () {
200 | 				calls++;
201 | 			},
202 | 			contextmenu = $(contextHTML)
203 | 				.find('[data-toggle="context"]')
204 | 				.contextmenu({
205 | 					'before': before
206 | 				}).trigger('contextmenu');
207 | 
208 | 		ok(calls === 1, 'called before callback');
209 | 		contextmenu.remove();
210 | 	});
211 | 
212 | 	test('should not open context-menu if before returns false', function () {
213 | 		var contextHTML = '<div>' +
214 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
215 | 				'  <div id="context-menu">' +
216 | 				'    <ul class="dropdown-menu">' +
217 | 				'      <li><a href="#">Action</a></li>' +
218 | 				'      <li><a href="#">Something else here</a></li>' +
219 | 				'      <li class="divider"></li>' +
220 | 				'      <li><a href="#">Another link</a></li>' +
221 | 				'   <ul>' +
222 | 				'  </div>' +
223 | 				'</div>' +
224 | 				'</div>',
225 | 			contextmenu = $(contextHTML).find('[data-toggle="context"]').contextmenu({ before: function() { return false; }}).trigger('contextmenu');
226 | 		
227 | 		ok(!contextmenu.find('#context-menu').hasClass('open'), 'open class added on contextmenu');
228 | 	});
229 | 
230 | 	test('should open context-menu if before does not return anything', function () {
231 | 		var contextHTML = '<div>' +
232 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
233 | 				'  <div id="context-menu">' +
234 | 				'    <ul class="dropdown-menu">' +
235 | 				'      <li><a href="#">Action</a></li>' +
236 | 				'      <li><a href="#">Something else here</a></li>' +
237 | 				'      <li class="divider"></li>' +
238 | 				'      <li><a href="#">Another link</a></li>' +
239 | 				'   <ul>' +
240 | 				'  </div>' +
241 | 				'</div>' +
242 | 				'</div>',
243 | 			contextmenu = $(contextHTML).find('[data-toggle="context"]').contextmenu({ before: function() { }}).trigger('contextmenu');
244 | 		
245 | 		ok(contextmenu.find('#context-menu').hasClass('open'), 'open class not added on contextmenu');
246 | 	});
247 | 
248 | 	test('calls onItem callback if an menu item is clicked', function () {
249 | 		var contextHTML = '<div>' + 
250 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
251 | 				'  <div id="context-menu">' +
252 | 				'    <ul class="dropdown-menu">' +
253 | 				'      <li><a href="#">Action</a></li>' +
254 | 				'      <li><a href="#">Something else here</a></li>' +
255 | 				'      <li class="divider"></li>' +
256 | 				'      <li><a href="#">Another link</a></li>' +
257 | 				'    <ul>' +
258 | 				'  </div>' +
259 | 				'</div>' +
260 | 				'</div>',
261 | 			calls = 0,
262 | 			onItem = function () {
263 | 				calls++;
264 | 			},
265 | 			contextmenu = $(contextHTML)
266 | 				.find('[data-toggle="context"]')
267 | 				.contextmenu({
268 | 					'onItem': onItem
269 | 				})
270 | 				.trigger('contextmenu');
271 | 
272 | 		contextmenu.find('ul > li:first a').click();
273 | 		ok(calls === 1, 'called onItem callback');
274 | 		contextmenu.remove();
275 | 	});
276 | 
277 | 	test('should fire show and hide event', function () {
278 | 		var contextHTML = '<div>' + 
279 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
280 | 				'  <div id="context-menu">' +
281 | 				'    <ul class="dropdown-menu">' +
282 | 				'      <li><a href="#">Action</a></li>' +
283 | 				'      <li><a href="#">Something else here</a></li>' +
284 | 				'      <li class="divider"></li>' +
285 | 				'      <li><a href="#">Another link</a></li>' +
286 | 				'    <ul>' +
287 | 				'  </div>' +
288 | 				'</div>' +
289 | 				'</div>',
290 | 			contextmenu = $(contextHTML)
291 | 				.appendTo('#qunit-fixture')
292 | 				.find('[data-toggle="context"]')
293 | 				.contextmenu();
294 | 		
295 | 		stop();
296 | 
297 | 		contextmenu
298 | 			.find('#context-menu')
299 | 			.on('show.bs.context', function () {
300 | 				ok(true, 'show was called');
301 | 			})
302 | 			.on('hide.bs.context', function () {
303 | 				ok(true, 'hide was called');
304 | 				start();
305 | 			});
306 | 
307 | 		contextmenu.trigger('contextmenu');
308 | 		$(document.body).click();
309 | 	});
310 | 
311 | 	test('should fire shown and hidden event', function () {
312 | 		var contextHTML = '<div>' + 
313 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
314 | 				'  <div id="context-menu">' +
315 | 				'    <ul class="dropdown-menu">' +
316 | 				'      <li><a href="#">Action</a></li>' +
317 | 				'      <li><a href="#">Something else here</a></li>' +
318 | 				'      <li class="divider"></li>' +
319 | 				'      <li><a href="#">Another link</a></li>' +
320 | 				'    <ul>' +
321 | 				'  </div>' +
322 | 				'</div>' +
323 | 				'</div>',
324 | 			contextmenu = $(contextHTML)
325 | 				.appendTo('#qunit-fixture')
326 | 				.find('[data-toggle="context"]')
327 | 				.contextmenu();
328 | 		
329 | 		stop();
330 | 
331 | 		contextmenu
332 | 			.find('#context-menu')
333 | 			.on('shown.bs.context', function () {
334 | 				ok(true, 'shown was called');
335 | 			})
336 | 			.on('hidden.bs.context', function () {
337 | 				ok(true, 'hidden was called');
338 | 				start();
339 | 			});
340 | 
341 | 		contextmenu.trigger('contextmenu');
342 | 		$(document.body).click();
343 | 	});
344 | 
345 | 		test('should remove open class if keyboard escape key is pressed', function () {
346 | 		var contextHTML = '<div>' +
347 | 				'<div id="main" data-toggle="context" data-target="#context-menu">' +
348 | 				'  <div id="context-menu">' +
349 | 				'    <ul class="dropdown-menu">' +
350 | 				'      <li><a href="#">Action</a></li>' +
351 | 				'      <li><a href="#">Something else here</a></li>' +
352 | 				'      <li class="divider"></li>' +
353 | 				'      <li><a href="#">Another link</a></li>' +
354 | 				'    <ul>' +
355 | 				'  </div>' +
356 | 				'</div>' +
357 | 				'</div>',
358 | 			contextmenu = $(contextHTML)
359 | 				.appendTo('#qunit-fixture')
360 | 				.find('[data-toggle="context"]')
361 | 				.contextmenu()
362 | 				.trigger('contextmenu');
363 | 
364 | 
365 | 		ok(contextmenu.find('#context-menu').hasClass('open'), 'open class added on right click');
366 | 		$('body').trigger($.Event('keydown', { which: 27 }));
367 | 		ok(!contextmenu.find('#context-menu').hasClass('open'), 'open class removed');
368 | 		contextmenu.remove();
369 | 	});
370 | });
371 | 


--------------------------------------------------------------------------------
/test/vendor/qunit.css:
--------------------------------------------------------------------------------
  1 | /*!
  2 |  * QUnit 1.14.0
  3 |  * http://qunitjs.com/
  4 |  *
  5 |  * Copyright 2013 jQuery Foundation and other contributors
  6 |  * Released under the MIT license
  7 |  * http://jquery.org/license
  8 |  *
  9 |  * Date: 2014-01-31T16:40Z
 10 |  */
 11 | 
 12 | /** Font Family and Sizes */
 13 | 
 14 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
 15 | 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 16 | }
 17 | 
 18 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 19 | #qunit-tests { font-size: smaller; }
 20 | 
 21 | 
 22 | /** Resets */
 23 | 
 24 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 25 | 	margin: 0;
 26 | 	padding: 0;
 27 | }
 28 | 
 29 | 
 30 | /** Header */
 31 | 
 32 | #qunit-header {
 33 | 	padding: 0.5em 0 0.5em 1em;
 34 | 
 35 | 	color: #8699A4;
 36 | 	background-color: #0D3349;
 37 | 
 38 | 	font-size: 1.5em;
 39 | 	line-height: 1em;
 40 | 	font-weight: 400;
 41 | 
 42 | 	border-radius: 5px 5px 0 0;
 43 | }
 44 | 
 45 | #qunit-header a {
 46 | 	text-decoration: none;
 47 | 	color: #C2CCD1;
 48 | }
 49 | 
 50 | #qunit-header a:hover,
 51 | #qunit-header a:focus {
 52 | 	color: #FFF;
 53 | }
 54 | 
 55 | #qunit-testrunner-toolbar label {
 56 | 	display: inline-block;
 57 | 	padding: 0 0.5em 0 0.1em;
 58 | }
 59 | 
 60 | #qunit-banner {
 61 | 	height: 5px;
 62 | }
 63 | 
 64 | #qunit-testrunner-toolbar {
 65 | 	padding: 0.5em 0 0.5em 2em;
 66 | 	color: #5E740B;
 67 | 	background-color: #EEE;
 68 | 	overflow: hidden;
 69 | }
 70 | 
 71 | #qunit-userAgent {
 72 | 	padding: 0.5em 0 0.5em 2.5em;
 73 | 	background-color: #2B81AF;
 74 | 	color: #FFF;
 75 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 76 | }
 77 | 
 78 | #qunit-modulefilter-container {
 79 | 	float: right;
 80 | }
 81 | 
 82 | /** Tests: Pass/Fail */
 83 | 
 84 | #qunit-tests {
 85 | 	list-style-position: inside;
 86 | }
 87 | 
 88 | #qunit-tests li {
 89 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 90 | 	border-bottom: 1px solid #FFF;
 91 | 	list-style-position: inside;
 92 | }
 93 | 
 94 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 95 | 	display: none;
 96 | }
 97 | 
 98 | #qunit-tests li strong {
 99 | 	cursor: pointer;
100 | }
101 | 
102 | #qunit-tests li a {
103 | 	padding: 0.5em;
104 | 	color: #C2CCD1;
105 | 	text-decoration: none;
106 | }
107 | #qunit-tests li a:hover,
108 | #qunit-tests li a:focus {
109 | 	color: #000;
110 | }
111 | 
112 | #qunit-tests li .runtime {
113 | 	float: right;
114 | 	font-size: smaller;
115 | }
116 | 
117 | .qunit-assert-list {
118 | 	margin-top: 0.5em;
119 | 	padding: 0.5em;
120 | 
121 | 	background-color: #FFF;
122 | 
123 | 	border-radius: 5px;
124 | }
125 | 
126 | .qunit-collapsed {
127 | 	display: none;
128 | }
129 | 
130 | #qunit-tests table {
131 | 	border-collapse: collapse;
132 | 	margin-top: 0.2em;
133 | }
134 | 
135 | #qunit-tests th {
136 | 	text-align: right;
137 | 	vertical-align: top;
138 | 	padding: 0 0.5em 0 0;
139 | }
140 | 
141 | #qunit-tests td {
142 | 	vertical-align: top;
143 | }
144 | 
145 | #qunit-tests pre {
146 | 	margin: 0;
147 | 	white-space: pre-wrap;
148 | 	word-wrap: break-word;
149 | }
150 | 
151 | #qunit-tests del {
152 | 	background-color: #E0F2BE;
153 | 	color: #374E0C;
154 | 	text-decoration: none;
155 | }
156 | 
157 | #qunit-tests ins {
158 | 	background-color: #FFCACA;
159 | 	color: #500;
160 | 	text-decoration: none;
161 | }
162 | 
163 | /*** Test Counts */
164 | 
165 | #qunit-tests b.counts                       { color: #000; }
166 | #qunit-tests b.passed                       { color: #5E740B; }
167 | #qunit-tests b.failed                       { color: #710909; }
168 | 
169 | #qunit-tests li li {
170 | 	padding: 5px;
171 | 	background-color: #FFF;
172 | 	border-bottom: none;
173 | 	list-style-position: inside;
174 | }
175 | 
176 | /*** Passing Styles */
177 | 
178 | #qunit-tests li li.pass {
179 | 	color: #3C510C;
180 | 	background-color: #FFF;
181 | 	border-left: 10px solid #C6E746;
182 | }
183 | 
184 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
185 | #qunit-tests .pass .test-name               { color: #366097; }
186 | 
187 | #qunit-tests .pass .test-actual,
188 | #qunit-tests .pass .test-expected           { color: #999; }
189 | 
190 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
191 | 
192 | /*** Failing Styles */
193 | 
194 | #qunit-tests li li.fail {
195 | 	color: #710909;
196 | 	background-color: #FFF;
197 | 	border-left: 10px solid #EE5757;
198 | 	white-space: pre;
199 | }
200 | 
201 | #qunit-tests > li:last-child {
202 | 	border-radius: 0 0 5px 5px;
203 | }
204 | 
205 | #qunit-tests .fail                          { color: #000; background-color: #EE5757; }
206 | #qunit-tests .fail .test-name,
207 | #qunit-tests .fail .module-name             { color: #000; }
208 | 
209 | #qunit-tests .fail .test-actual             { color: #EE5757; }
210 | #qunit-tests .fail .test-expected           { color: #008000; }
211 | 
212 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
213 | 
214 | 
215 | /** Result */
216 | 
217 | #qunit-testresult {
218 | 	padding: 0.5em 0.5em 0.5em 2.5em;
219 | 
220 | 	color: #2B81AF;
221 | 	background-color: #D2E0E6;
222 | 
223 | 	border-bottom: 1px solid #FFF;
224 | }
225 | #qunit-testresult .module-name {
226 | 	font-weight: 700;
227 | }
228 | 
229 | /** Fixture */
230 | 
231 | #qunit-fixture {
232 | 	position: absolute;
233 | 	top: -10000px;
234 | 	left: -10000px;
235 | 	width: 1000px;
236 | 	height: 1000px;
237 | }
238 | 


--------------------------------------------------------------------------------
/test/vendor/qunit.js:
--------------------------------------------------------------------------------
   1 | /*!
   2 |  * QUnit 1.14.0
   3 |  * http://qunitjs.com/
   4 |  *
   5 |  * Copyright 2013 jQuery Foundation and other contributors
   6 |  * Released under the MIT license
   7 |  * http://jquery.org/license
   8 |  *
   9 |  * Date: 2014-01-31T16:40Z
  10 |  */
  11 | 
  12 | (function( window ) {
  13 | 
  14 | var QUnit,
  15 | 	assert,
  16 | 	config,
  17 | 	onErrorFnPrev,
  18 | 	testId = 0,
  19 | 	fileName = (sourceFromStacktrace( 0 ) || "" ).replace(/(:\d+)+\)?/, "").replace(/.+\//, ""),
  20 | 	toString = Object.prototype.toString,
  21 | 	hasOwn = Object.prototype.hasOwnProperty,
  22 | 	// Keep a local reference to Date (GH-283)
  23 | 	Date = window.Date,
  24 | 	setTimeout = window.setTimeout,
  25 | 	clearTimeout = window.clearTimeout,
  26 | 	defined = {
  27 | 		document: typeof window.document !== "undefined",
  28 | 		setTimeout: typeof window.setTimeout !== "undefined",
  29 | 		sessionStorage: (function() {
  30 | 			var x = "qunit-test-string";
  31 | 			try {
  32 | 				sessionStorage.setItem( x, x );
  33 | 				sessionStorage.removeItem( x );
  34 | 				return true;
  35 | 			} catch( e ) {
  36 | 				return false;
  37 | 			}
  38 | 		}())
  39 | 	},
  40 | 	/**
  41 | 	 * Provides a normalized error string, correcting an issue
  42 | 	 * with IE 7 (and prior) where Error.prototype.toString is
  43 | 	 * not properly implemented
  44 | 	 *
  45 | 	 * Based on http://es5.github.com/#x15.11.4.4
  46 | 	 *
  47 | 	 * @param {String|Error} error
  48 | 	 * @return {String} error message
  49 | 	 */
  50 | 	errorString = function( error ) {
  51 | 		var name, message,
  52 | 			errorString = error.toString();
  53 | 		if ( errorString.substring( 0, 7 ) === "[object" ) {
  54 | 			name = error.name ? error.name.toString() : "Error";
  55 | 			message = error.message ? error.message.toString() : "";
  56 | 			if ( name && message ) {
  57 | 				return name + ": " + message;
  58 | 			} else if ( name ) {
  59 | 				return name;
  60 | 			} else if ( message ) {
  61 | 				return message;
  62 | 			} else {
  63 | 				return "Error";
  64 | 			}
  65 | 		} else {
  66 | 			return errorString;
  67 | 		}
  68 | 	},
  69 | 	/**
  70 | 	 * Makes a clone of an object using only Array or Object as base,
  71 | 	 * and copies over the own enumerable properties.
  72 | 	 *
  73 | 	 * @param {Object} obj
  74 | 	 * @return {Object} New object with only the own properties (recursively).
  75 | 	 */
  76 | 	objectValues = function( obj ) {
  77 | 		// Grunt 0.3.x uses an older version of jshint that still has jshint/jshint#392.
  78 | 		/*jshint newcap: false */
  79 | 		var key, val,
  80 | 			vals = QUnit.is( "array", obj ) ? [] : {};
  81 | 		for ( key in obj ) {
  82 | 			if ( hasOwn.call( obj, key ) ) {
  83 | 				val = obj[key];
  84 | 				vals[key] = val === Object(val) ? objectValues(val) : val;
  85 | 			}
  86 | 		}
  87 | 		return vals;
  88 | 	};
  89 | 
  90 | 
  91 | // Root QUnit object.
  92 | // `QUnit` initialized at top of scope
  93 | QUnit = {
  94 | 
  95 | 	// call on start of module test to prepend name to all tests
  96 | 	module: function( name, testEnvironment ) {
  97 | 		config.currentModule = name;
  98 | 		config.currentModuleTestEnvironment = testEnvironment;
  99 | 		config.modules[name] = true;
 100 | 	},
 101 | 
 102 | 	asyncTest: function( testName, expected, callback ) {
 103 | 		if ( arguments.length === 2 ) {
 104 | 			callback = expected;
 105 | 			expected = null;
 106 | 		}
 107 | 
 108 | 		QUnit.test( testName, expected, callback, true );
 109 | 	},
 110 | 
 111 | 	test: function( testName, expected, callback, async ) {
 112 | 		var test,
 113 | 			nameHtml = "<span class='test-name'>" + escapeText( testName ) + "</span>";
 114 | 
 115 | 		if ( arguments.length === 2 ) {
 116 | 			callback = expected;
 117 | 			expected = null;
 118 | 		}
 119 | 
 120 | 		if ( config.currentModule ) {
 121 | 			nameHtml = "<span class='module-name'>" + escapeText( config.currentModule ) + "</span>: " + nameHtml;
 122 | 		}
 123 | 
 124 | 		test = new Test({
 125 | 			nameHtml: nameHtml,
 126 | 			testName: testName,
 127 | 			expected: expected,
 128 | 			async: async,
 129 | 			callback: callback,
 130 | 			module: config.currentModule,
 131 | 			moduleTestEnvironment: config.currentModuleTestEnvironment,
 132 | 			stack: sourceFromStacktrace( 2 )
 133 | 		});
 134 | 
 135 | 		if ( !validTest( test ) ) {
 136 | 			return;
 137 | 		}
 138 | 
 139 | 		test.queue();
 140 | 	},
 141 | 
 142 | 	// Specify the number of expected assertions to guarantee that failed test (no assertions are run at all) don't slip through.
 143 | 	expect: function( asserts ) {
 144 | 		if (arguments.length === 1) {
 145 | 			config.current.expected = asserts;
 146 | 		} else {
 147 | 			return config.current.expected;
 148 | 		}
 149 | 	},
 150 | 
 151 | 	start: function( count ) {
 152 | 		// QUnit hasn't been initialized yet.
 153 | 		// Note: RequireJS (et al) may delay onLoad
 154 | 		if ( config.semaphore === undefined ) {
 155 | 			QUnit.begin(function() {
 156 | 				// This is triggered at the top of QUnit.load, push start() to the event loop, to allow QUnit.load to finish first
 157 | 				setTimeout(function() {
 158 | 					QUnit.start( count );
 159 | 				});
 160 | 			});
 161 | 			return;
 162 | 		}
 163 | 
 164 | 		config.semaphore -= count || 1;
 165 | 		// don't start until equal number of stop-calls
 166 | 		if ( config.semaphore > 0 ) {
 167 | 			return;
 168 | 		}
 169 | 		// ignore if start is called more often then stop
 170 | 		if ( config.semaphore < 0 ) {
 171 | 			config.semaphore = 0;
 172 | 			QUnit.pushFailure( "Called start() while already started (QUnit.config.semaphore was 0 already)", null, sourceFromStacktrace(2) );
 173 | 			return;
 174 | 		}
 175 | 		// A slight delay, to avoid any current callbacks
 176 | 		if ( defined.setTimeout ) {
 177 | 			setTimeout(function() {
 178 | 				if ( config.semaphore > 0 ) {
 179 | 					return;
 180 | 				}
 181 | 				if ( config.timeout ) {
 182 | 					clearTimeout( config.timeout );
 183 | 				}
 184 | 
 185 | 				config.blocking = false;
 186 | 				process( true );
 187 | 			}, 13);
 188 | 		} else {
 189 | 			config.blocking = false;
 190 | 			process( true );
 191 | 		}
 192 | 	},
 193 | 
 194 | 	stop: function( count ) {
 195 | 		config.semaphore += count || 1;
 196 | 		config.blocking = true;
 197 | 
 198 | 		if ( config.testTimeout && defined.setTimeout ) {
 199 | 			clearTimeout( config.timeout );
 200 | 			config.timeout = setTimeout(function() {
 201 | 				QUnit.ok( false, "Test timed out" );
 202 | 				config.semaphore = 1;
 203 | 				QUnit.start();
 204 | 			}, config.testTimeout );
 205 | 		}
 206 | 	}
 207 | };
 208 | 
 209 | // We use the prototype to distinguish between properties that should
 210 | // be exposed as globals (and in exports) and those that shouldn't
 211 | (function() {
 212 | 	function F() {}
 213 | 	F.prototype = QUnit;
 214 | 	QUnit = new F();
 215 | 	// Make F QUnit's constructor so that we can add to the prototype later
 216 | 	QUnit.constructor = F;
 217 | }());
 218 | 
 219 | /**
 220 |  * Config object: Maintain internal state
 221 |  * Later exposed as QUnit.config
 222 |  * `config` initialized at top of scope
 223 |  */
 224 | config = {
 225 | 	// The queue of tests to run
 226 | 	queue: [],
 227 | 
 228 | 	// block until document ready
 229 | 	blocking: true,
 230 | 
 231 | 	// when enabled, show only failing tests
 232 | 	// gets persisted through sessionStorage and can be changed in UI via checkbox
 233 | 	hidepassed: false,
 234 | 
 235 | 	// by default, run previously failed tests first
 236 | 	// very useful in combination with "Hide passed tests" checked
 237 | 	reorder: true,
 238 | 
 239 | 	// by default, modify document.title when suite is done
 240 | 	altertitle: true,
 241 | 
 242 | 	// by default, scroll to top of the page when suite is done
 243 | 	scrolltop: true,
 244 | 
 245 | 	// when enabled, all tests must call expect()
 246 | 	requireExpects: false,
 247 | 
 248 | 	// add checkboxes that are persisted in the query-string
 249 | 	// when enabled, the id is set to `true` as a `QUnit.config` property
 250 | 	urlConfig: [
 251 | 		{
 252 | 			id: "noglobals",
 253 | 			label: "Check for Globals",
 254 | 			tooltip: "Enabling this will test if any test introduces new properties on the `window` object. Stored as query-strings."
 255 | 		},
 256 | 		{
 257 | 			id: "notrycatch",
 258 | 			label: "No try-catch",
 259 | 			tooltip: "Enabling this will run tests outside of a try-catch block. Makes debugging exceptions in IE reasonable. Stored as query-strings."
 260 | 		}
 261 | 	],
 262 | 
 263 | 	// Set of all modules.
 264 | 	modules: {},
 265 | 
 266 | 	// logging callback queues
 267 | 	begin: [],
 268 | 	done: [],
 269 | 	log: [],
 270 | 	testStart: [],
 271 | 	testDone: [],
 272 | 	moduleStart: [],
 273 | 	moduleDone: []
 274 | };
 275 | 
 276 | // Initialize more QUnit.config and QUnit.urlParams
 277 | (function() {
 278 | 	var i, current,
 279 | 		location = window.location || { search: "", protocol: "file:" },
 280 | 		params = location.search.slice( 1 ).split( "&" ),
 281 | 		length = params.length,
 282 | 		urlParams = {};
 283 | 
 284 | 	if ( params[ 0 ] ) {
 285 | 		for ( i = 0; i < length; i++ ) {
 286 | 			current = params[ i ].split( "=" );
 287 | 			current[ 0 ] = decodeURIComponent( current[ 0 ] );
 288 | 
 289 | 			// allow just a key to turn on a flag, e.g., test.html?noglobals
 290 | 			current[ 1 ] = current[ 1 ] ? decodeURIComponent( current[ 1 ] ) : true;
 291 | 			if ( urlParams[ current[ 0 ] ] ) {
 292 | 				urlParams[ current[ 0 ] ] = [].concat( urlParams[ current[ 0 ] ], current[ 1 ] );
 293 | 			} else {
 294 | 				urlParams[ current[ 0 ] ] = current[ 1 ];
 295 | 			}
 296 | 		}
 297 | 	}
 298 | 
 299 | 	QUnit.urlParams = urlParams;
 300 | 
 301 | 	// String search anywhere in moduleName+testName
 302 | 	config.filter = urlParams.filter;
 303 | 
 304 | 	// Exact match of the module name
 305 | 	config.module = urlParams.module;
 306 | 
 307 | 	config.testNumber = [];
 308 | 	if ( urlParams.testNumber ) {
 309 | 
 310 | 		// Ensure that urlParams.testNumber is an array
 311 | 		urlParams.testNumber = [].concat( urlParams.testNumber );
 312 | 		for ( i = 0; i < urlParams.testNumber.length; i++ ) {
 313 | 			current = urlParams.testNumber[ i ];
 314 | 			config.testNumber.push( parseInt( current, 10 ) );
 315 | 		}
 316 | 	}
 317 | 
 318 | 	// Figure out if we're running the tests from a server or not
 319 | 	QUnit.isLocal = location.protocol === "file:";
 320 | }());
 321 | 
 322 | extend( QUnit, {
 323 | 
 324 | 	config: config,
 325 | 
 326 | 	// Initialize the configuration options
 327 | 	init: function() {
 328 | 		extend( config, {
 329 | 			stats: { all: 0, bad: 0 },
 330 | 			moduleStats: { all: 0, bad: 0 },
 331 | 			started: +new Date(),
 332 | 			updateRate: 1000,
 333 | 			blocking: false,
 334 | 			autostart: true,
 335 | 			autorun: false,
 336 | 			filter: "",
 337 | 			queue: [],
 338 | 			semaphore: 1
 339 | 		});
 340 | 
 341 | 		var tests, banner, result,
 342 | 			qunit = id( "qunit" );
 343 | 
 344 | 		if ( qunit ) {
 345 | 			qunit.innerHTML =
 346 | 				"<h1 id='qunit-header'>" + escapeText( document.title ) + "</h1>" +
 347 | 				"<h2 id='qunit-banner'></h2>" +
 348 | 				"<div id='qunit-testrunner-toolbar'></div>" +
 349 | 				"<h2 id='qunit-userAgent'></h2>" +
 350 | 				"<ol id='qunit-tests'></ol>";
 351 | 		}
 352 | 
 353 | 		tests = id( "qunit-tests" );
 354 | 		banner = id( "qunit-banner" );
 355 | 		result = id( "qunit-testresult" );
 356 | 
 357 | 		if ( tests ) {
 358 | 			tests.innerHTML = "";
 359 | 		}
 360 | 
 361 | 		if ( banner ) {
 362 | 			banner.className = "";
 363 | 		}
 364 | 
 365 | 		if ( result ) {
 366 | 			result.parentNode.removeChild( result );
 367 | 		}
 368 | 
 369 | 		if ( tests ) {
 370 | 			result = document.createElement( "p" );
 371 | 			result.id = "qunit-testresult";
 372 | 			result.className = "result";
 373 | 			tests.parentNode.insertBefore( result, tests );
 374 | 			result.innerHTML = "Running...<br/>&nbsp;";
 375 | 		}
 376 | 	},
 377 | 
 378 | 	// Resets the test setup. Useful for tests that modify the DOM.
 379 | 	/*
 380 | 	DEPRECATED: Use multiple tests instead of resetting inside a test.
 381 | 	Use testStart or testDone for custom cleanup.
 382 | 	This method will throw an error in 2.0, and will be removed in 2.1
 383 | 	*/
 384 | 	reset: function() {
 385 | 		var fixture = id( "qunit-fixture" );
 386 | 		if ( fixture ) {
 387 | 			fixture.innerHTML = config.fixture;
 388 | 		}
 389 | 	},
 390 | 
 391 | 	// Safe object type checking
 392 | 	is: function( type, obj ) {
 393 | 		return QUnit.objectType( obj ) === type;
 394 | 	},
 395 | 
 396 | 	objectType: function( obj ) {
 397 | 		if ( typeof obj === "undefined" ) {
 398 | 			return "undefined";
 399 | 		}
 400 | 
 401 | 		// Consider: typeof null === object
 402 | 		if ( obj === null ) {
 403 | 			return "null";
 404 | 		}
 405 | 
 406 | 		var match = toString.call( obj ).match(/^\[object\s(.*)\]$/),
 407 | 			type = match && match[1] || "";
 408 | 
 409 | 		switch ( type ) {
 410 | 			case "Number":
 411 | 				if ( isNaN(obj) ) {
 412 | 					return "nan";
 413 | 				}
 414 | 				return "number";
 415 | 			case "String":
 416 | 			case "Boolean":
 417 | 			case "Array":
 418 | 			case "Date":
 419 | 			case "RegExp":
 420 | 			case "Function":
 421 | 				return type.toLowerCase();
 422 | 		}
 423 | 		if ( typeof obj === "object" ) {
 424 | 			return "object";
 425 | 		}
 426 | 		return undefined;
 427 | 	},
 428 | 
 429 | 	push: function( result, actual, expected, message ) {
 430 | 		if ( !config.current ) {
 431 | 			throw new Error( "assertion outside test context, was " + sourceFromStacktrace() );
 432 | 		}
 433 | 
 434 | 		var output, source,
 435 | 			details = {
 436 | 				module: config.current.module,
 437 | 				name: config.current.testName,
 438 | 				result: result,
 439 | 				message: message,
 440 | 				actual: actual,
 441 | 				expected: expected
 442 | 			};
 443 | 
 444 | 		message = escapeText( message ) || ( result ? "okay" : "failed" );
 445 | 		message = "<span class='test-message'>" + message + "</span>";
 446 | 		output = message;
 447 | 
 448 | 		if ( !result ) {
 449 | 			expected = escapeText( QUnit.jsDump.parse(expected) );
 450 | 			actual = escapeText( QUnit.jsDump.parse(actual) );
 451 | 			output += "<table><tr class='test-expected'><th>Expected: </th><td><pre>" + expected + "</pre></td></tr>";
 452 | 
 453 | 			if ( actual !== expected ) {
 454 | 				output += "<tr class='test-actual'><th>Result: </th><td><pre>" + actual + "</pre></td></tr>";
 455 | 				output += "<tr class='test-diff'><th>Diff: </th><td><pre>" + QUnit.diff( expected, actual ) + "</pre></td></tr>";
 456 | 			}
 457 | 
 458 | 			source = sourceFromStacktrace();
 459 | 
 460 | 			if ( source ) {
 461 | 				details.source = source;
 462 | 				output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 463 | 			}
 464 | 
 465 | 			output += "</table>";
 466 | 		}
 467 | 
 468 | 		runLoggingCallbacks( "log", QUnit, details );
 469 | 
 470 | 		config.current.assertions.push({
 471 | 			result: !!result,
 472 | 			message: output
 473 | 		});
 474 | 	},
 475 | 
 476 | 	pushFailure: function( message, source, actual ) {
 477 | 		if ( !config.current ) {
 478 | 			throw new Error( "pushFailure() assertion outside test context, was " + sourceFromStacktrace(2) );
 479 | 		}
 480 | 
 481 | 		var output,
 482 | 			details = {
 483 | 				module: config.current.module,
 484 | 				name: config.current.testName,
 485 | 				result: false,
 486 | 				message: message
 487 | 			};
 488 | 
 489 | 		message = escapeText( message ) || "error";
 490 | 		message = "<span class='test-message'>" + message + "</span>";
 491 | 		output = message;
 492 | 
 493 | 		output += "<table>";
 494 | 
 495 | 		if ( actual ) {
 496 | 			output += "<tr class='test-actual'><th>Result: </th><td><pre>" + escapeText( actual ) + "</pre></td></tr>";
 497 | 		}
 498 | 
 499 | 		if ( source ) {
 500 | 			details.source = source;
 501 | 			output += "<tr class='test-source'><th>Source: </th><td><pre>" + escapeText( source ) + "</pre></td></tr>";
 502 | 		}
 503 | 
 504 | 		output += "</table>";
 505 | 
 506 | 		runLoggingCallbacks( "log", QUnit, details );
 507 | 
 508 | 		config.current.assertions.push({
 509 | 			result: false,
 510 | 			message: output
 511 | 		});
 512 | 	},
 513 | 
 514 | 	url: function( params ) {
 515 | 		params = extend( extend( {}, QUnit.urlParams ), params );
 516 | 		var key,
 517 | 			querystring = "?";
 518 | 
 519 | 		for ( key in params ) {
 520 | 			if ( hasOwn.call( params, key ) ) {
 521 | 				querystring += encodeURIComponent( key ) + "=" +
 522 | 					encodeURIComponent( params[ key ] ) + "&";
 523 | 			}
 524 | 		}
 525 | 		return window.location.protocol + "//" + window.location.host +
 526 | 			window.location.pathname + querystring.slice( 0, -1 );
 527 | 	},
 528 | 
 529 | 	extend: extend,
 530 | 	id: id,
 531 | 	addEvent: addEvent,
 532 | 	addClass: addClass,
 533 | 	hasClass: hasClass,
 534 | 	removeClass: removeClass
 535 | 	// load, equiv, jsDump, diff: Attached later
 536 | });
 537 | 
 538 | /**
 539 |  * @deprecated: Created for backwards compatibility with test runner that set the hook function
 540 |  * into QUnit.{hook}, instead of invoking it and passing the hook function.
 541 |  * QUnit.constructor is set to the empty F() above so that we can add to it's prototype here.
 542 |  * Doing this allows us to tell if the following methods have been overwritten on the actual
 543 |  * QUnit object.
 544 |  */
 545 | extend( QUnit.constructor.prototype, {
 546 | 
 547 | 	// Logging callbacks; all receive a single argument with the listed properties
 548 | 	// run test/logs.html for any related changes
 549 | 	begin: registerLoggingCallback( "begin" ),
 550 | 
 551 | 	// done: { failed, passed, total, runtime }
 552 | 	done: registerLoggingCallback( "done" ),
 553 | 
 554 | 	// log: { result, actual, expected, message }
 555 | 	log: registerLoggingCallback( "log" ),
 556 | 
 557 | 	// testStart: { name }
 558 | 	testStart: registerLoggingCallback( "testStart" ),
 559 | 
 560 | 	// testDone: { name, failed, passed, total, runtime }
 561 | 	testDone: registerLoggingCallback( "testDone" ),
 562 | 
 563 | 	// moduleStart: { name }
 564 | 	moduleStart: registerLoggingCallback( "moduleStart" ),
 565 | 
 566 | 	// moduleDone: { name, failed, passed, total }
 567 | 	moduleDone: registerLoggingCallback( "moduleDone" )
 568 | });
 569 | 
 570 | if ( !defined.document || document.readyState === "complete" ) {
 571 | 	config.autorun = true;
 572 | }
 573 | 
 574 | QUnit.load = function() {
 575 | 	runLoggingCallbacks( "begin", QUnit, {} );
 576 | 
 577 | 	// Initialize the config, saving the execution queue
 578 | 	var banner, filter, i, j, label, len, main, ol, toolbar, val, selection,
 579 | 		urlConfigContainer, moduleFilter, userAgent,
 580 | 		numModules = 0,
 581 | 		moduleNames = [],
 582 | 		moduleFilterHtml = "",
 583 | 		urlConfigHtml = "",
 584 | 		oldconfig = extend( {}, config );
 585 | 
 586 | 	QUnit.init();
 587 | 	extend(config, oldconfig);
 588 | 
 589 | 	config.blocking = false;
 590 | 
 591 | 	len = config.urlConfig.length;
 592 | 
 593 | 	for ( i = 0; i < len; i++ ) {
 594 | 		val = config.urlConfig[i];
 595 | 		if ( typeof val === "string" ) {
 596 | 			val = {
 597 | 				id: val,
 598 | 				label: val
 599 | 			};
 600 | 		}
 601 | 		config[ val.id ] = QUnit.urlParams[ val.id ];
 602 | 		if ( !val.value || typeof val.value === "string" ) {
 603 | 			urlConfigHtml += "<input id='qunit-urlconfig-" + escapeText( val.id ) +
 604 | 				"' name='" + escapeText( val.id ) +
 605 | 				"' type='checkbox'" +
 606 | 				( val.value ? " value='" + escapeText( val.value ) + "'" : "" ) +
 607 | 				( config[ val.id ] ? " checked='checked'" : "" ) +
 608 | 				" title='" + escapeText( val.tooltip ) +
 609 | 				"'><label for='qunit-urlconfig-" + escapeText( val.id ) +
 610 | 				"' title='" + escapeText( val.tooltip ) + "'>" + val.label + "</label>";
 611 | 		} else {
 612 | 			urlConfigHtml += "<label for='qunit-urlconfig-" + escapeText( val.id ) +
 613 | 				"' title='" + escapeText( val.tooltip ) +
 614 | 				"'>" + val.label +
 615 | 				": </label><select id='qunit-urlconfig-" + escapeText( val.id ) +
 616 | 				"' name='" + escapeText( val.id ) +
 617 | 				"' title='" + escapeText( val.tooltip ) +
 618 | 				"'><option></option>";
 619 | 			selection = false;
 620 | 			if ( QUnit.is( "array", val.value ) ) {
 621 | 				for ( j = 0; j < val.value.length; j++ ) {
 622 | 					urlConfigHtml += "<option value='" + escapeText( val.value[j] ) + "'" +
 623 | 						( config[ val.id ] === val.value[j] ?
 624 | 							(selection = true) && " selected='selected'" :
 625 | 							"" ) +
 626 | 						">" + escapeText( val.value[j] ) + "</option>";
 627 | 				}
 628 | 			} else {
 629 | 				for ( j in val.value ) {
 630 | 					if ( hasOwn.call( val.value, j ) ) {
 631 | 						urlConfigHtml += "<option value='" + escapeText( j ) + "'" +
 632 | 							( config[ val.id ] === j ?
 633 | 								(selection = true) && " selected='selected'" :
 634 | 								"" ) +
 635 | 							">" + escapeText( val.value[j] ) + "</option>";
 636 | 					}
 637 | 				}
 638 | 			}
 639 | 			if ( config[ val.id ] && !selection ) {
 640 | 				urlConfigHtml += "<option value='" + escapeText( config[ val.id ] ) +
 641 | 					"' selected='selected' disabled='disabled'>" +
 642 | 					escapeText( config[ val.id ] ) +
 643 | 					"</option>";
 644 | 			}
 645 | 			urlConfigHtml += "</select>";
 646 | 		}
 647 | 	}
 648 | 	for ( i in config.modules ) {
 649 | 		if ( config.modules.hasOwnProperty( i ) ) {
 650 | 			moduleNames.push(i);
 651 | 		}
 652 | 	}
 653 | 	numModules = moduleNames.length;
 654 | 	moduleNames.sort( function( a, b ) {
 655 | 		return a.localeCompare( b );
 656 | 	});
 657 | 	moduleFilterHtml += "<label for='qunit-modulefilter'>Module: </label><select id='qunit-modulefilter' name='modulefilter'><option value='' " +
 658 | 		( config.module === undefined  ? "selected='selected'" : "" ) +
 659 | 		">< All Modules ></option>";
 660 | 
 661 | 
 662 | 	for ( i = 0; i < numModules; i++) {
 663 | 			moduleFilterHtml += "<option value='" + escapeText( encodeURIComponent(moduleNames[i]) ) + "' " +
 664 | 				( config.module === moduleNames[i] ? "selected='selected'" : "" ) +
 665 | 				">" + escapeText(moduleNames[i]) + "</option>";
 666 | 	}
 667 | 	moduleFilterHtml += "</select>";
 668 | 
 669 | 	// `userAgent` initialized at top of scope
 670 | 	userAgent = id( "qunit-userAgent" );
 671 | 	if ( userAgent ) {
 672 | 		userAgent.innerHTML = navigator.userAgent;
 673 | 	}
 674 | 
 675 | 	// `banner` initialized at top of scope
 676 | 	banner = id( "qunit-header" );
 677 | 	if ( banner ) {
 678 | 		banner.innerHTML = "<a href='" + QUnit.url({ filter: undefined, module: undefined, testNumber: undefined }) + "'>" + banner.innerHTML + "</a> ";
 679 | 	}
 680 | 
 681 | 	// `toolbar` initialized at top of scope
 682 | 	toolbar = id( "qunit-testrunner-toolbar" );
 683 | 	if ( toolbar ) {
 684 | 		// `filter` initialized at top of scope
 685 | 		filter = document.createElement( "input" );
 686 | 		filter.type = "checkbox";
 687 | 		filter.id = "qunit-filter-pass";
 688 | 
 689 | 		addEvent( filter, "click", function() {
 690 | 			var tmp,
 691 | 				ol = id( "qunit-tests" );
 692 | 
 693 | 			if ( filter.checked ) {
 694 | 				ol.className = ol.className + " hidepass";
 695 | 			} else {
 696 | 				tmp = " " + ol.className.replace( /[\n\t\r]/g, " " ) + " ";
 697 | 				ol.className = tmp.replace( / hidepass /, " " );
 698 | 			}
 699 | 			if ( defined.sessionStorage ) {
 700 | 				if (filter.checked) {
 701 | 					sessionStorage.setItem( "qunit-filter-passed-tests", "true" );
 702 | 				} else {
 703 | 					sessionStorage.removeItem( "qunit-filter-passed-tests" );
 704 | 				}
 705 | 			}
 706 | 		});
 707 | 
 708 | 		if ( config.hidepassed || defined.sessionStorage && sessionStorage.getItem( "qunit-filter-passed-tests" ) ) {
 709 | 			filter.checked = true;
 710 | 			// `ol` initialized at top of scope
 711 | 			ol = id( "qunit-tests" );
 712 | 			ol.className = ol.className + " hidepass";
 713 | 		}
 714 | 		toolbar.appendChild( filter );
 715 | 
 716 | 		// `label` initialized at top of scope
 717 | 		label = document.createElement( "label" );
 718 | 		label.setAttribute( "for", "qunit-filter-pass" );
 719 | 		label.setAttribute( "title", "Only show tests and assertions that fail. Stored in sessionStorage." );
 720 | 		label.innerHTML = "Hide passed tests";
 721 | 		toolbar.appendChild( label );
 722 | 
 723 | 		urlConfigContainer = document.createElement("span");
 724 | 		urlConfigContainer.innerHTML = urlConfigHtml;
 725 | 		// For oldIE support:
 726 | 		// * Add handlers to the individual elements instead of the container
 727 | 		// * Use "click" instead of "change" for checkboxes
 728 | 		// * Fallback from event.target to event.srcElement
 729 | 		addEvents( urlConfigContainer.getElementsByTagName("input"), "click", function( event ) {
 730 | 			var params = {},
 731 | 				target = event.target || event.srcElement;
 732 | 			params[ target.name ] = target.checked ?
 733 | 				target.defaultValue || true :
 734 | 				undefined;
 735 | 			window.location = QUnit.url( params );
 736 | 		});
 737 | 		addEvents( urlConfigContainer.getElementsByTagName("select"), "change", function( event ) {
 738 | 			var params = {},
 739 | 				target = event.target || event.srcElement;
 740 | 			params[ target.name ] = target.options[ target.selectedIndex ].value || undefined;
 741 | 			window.location = QUnit.url( params );
 742 | 		});
 743 | 		toolbar.appendChild( urlConfigContainer );
 744 | 
 745 | 		if (numModules > 1) {
 746 | 			moduleFilter = document.createElement( "span" );
 747 | 			moduleFilter.setAttribute( "id", "qunit-modulefilter-container" );
 748 | 			moduleFilter.innerHTML = moduleFilterHtml;
 749 | 			addEvent( moduleFilter.lastChild, "change", function() {
 750 | 				var selectBox = moduleFilter.getElementsByTagName("select")[0],
 751 | 					selectedModule = decodeURIComponent(selectBox.options[selectBox.selectedIndex].value);
 752 | 
 753 | 				window.location = QUnit.url({
 754 | 					module: ( selectedModule === "" ) ? undefined : selectedModule,
 755 | 					// Remove any existing filters
 756 | 					filter: undefined,
 757 | 					testNumber: undefined
 758 | 				});
 759 | 			});
 760 | 			toolbar.appendChild(moduleFilter);
 761 | 		}
 762 | 	}
 763 | 
 764 | 	// `main` initialized at top of scope
 765 | 	main = id( "qunit-fixture" );
 766 | 	if ( main ) {
 767 | 		config.fixture = main.innerHTML;
 768 | 	}
 769 | 
 770 | 	if ( config.autostart ) {
 771 | 		QUnit.start();
 772 | 	}
 773 | };
 774 | 
 775 | if ( defined.document ) {
 776 | 	addEvent( window, "load", QUnit.load );
 777 | }
 778 | 
 779 | // `onErrorFnPrev` initialized at top of scope
 780 | // Preserve other handlers
 781 | onErrorFnPrev = window.onerror;
 782 | 
 783 | // Cover uncaught exceptions
 784 | // Returning true will suppress the default browser handler,
 785 | // returning false will let it run.
 786 | window.onerror = function ( error, filePath, linerNr ) {
 787 | 	var ret = false;
 788 | 	if ( onErrorFnPrev ) {
 789 | 		ret = onErrorFnPrev( error, filePath, linerNr );
 790 | 	}
 791 | 
 792 | 	// Treat return value as window.onerror itself does,
 793 | 	// Only do our handling if not suppressed.
 794 | 	if ( ret !== true ) {
 795 | 		if ( QUnit.config.current ) {
 796 | 			if ( QUnit.config.current.ignoreGlobalErrors ) {
 797 | 				return true;
 798 | 			}
 799 | 			QUnit.pushFailure( error, filePath + ":" + linerNr );
 800 | 		} else {
 801 | 			QUnit.test( "global failure", extend( function() {
 802 | 				QUnit.pushFailure( error, filePath + ":" + linerNr );
 803 | 			}, { validTest: validTest } ) );
 804 | 		}
 805 | 		return false;
 806 | 	}
 807 | 
 808 | 	return ret;
 809 | };
 810 | 
 811 | function done() {
 812 | 	config.autorun = true;
 813 | 
 814 | 	// Log the last module results
 815 | 	if ( config.previousModule ) {
 816 | 		runLoggingCallbacks( "moduleDone", QUnit, {
 817 | 			name: config.previousModule,
 818 | 			failed: config.moduleStats.bad,
 819 | 			passed: config.moduleStats.all - config.moduleStats.bad,
 820 | 			total: config.moduleStats.all
 821 | 		});
 822 | 	}
 823 | 	delete config.previousModule;
 824 | 
 825 | 	var i, key,
 826 | 		banner = id( "qunit-banner" ),
 827 | 		tests = id( "qunit-tests" ),
 828 | 		runtime = +new Date() - config.started,
 829 | 		passed = config.stats.all - config.stats.bad,
 830 | 		html = [
 831 | 			"Tests completed in ",
 832 | 			runtime,
 833 | 			" milliseconds.<br/>",
 834 | 			"<span class='passed'>",
 835 | 			passed,
 836 | 			"</span> assertions of <span class='total'>",
 837 | 			config.stats.all,
 838 | 			"</span> passed, <span class='failed'>",
 839 | 			config.stats.bad,
 840 | 			"</span> failed."
 841 | 		].join( "" );
 842 | 
 843 | 	if ( banner ) {
 844 | 		banner.className = ( config.stats.bad ? "qunit-fail" : "qunit-pass" );
 845 | 	}
 846 | 
 847 | 	if ( tests ) {
 848 | 		id( "qunit-testresult" ).innerHTML = html;
 849 | 	}
 850 | 
 851 | 	if ( config.altertitle && defined.document && document.title ) {
 852 | 		// show ✖ for good, ✔ for bad suite result in title
 853 | 		// use escape sequences in case file gets loaded with non-utf-8-charset
 854 | 		document.title = [
 855 | 			( config.stats.bad ? "\u2716" : "\u2714" ),
 856 | 			document.title.replace( /^[\u2714\u2716] /i, "" )
 857 | 		].join( " " );
 858 | 	}
 859 | 
 860 | 	// clear own sessionStorage items if all tests passed
 861 | 	if ( config.reorder && defined.sessionStorage && config.stats.bad === 0 ) {
 862 | 		// `key` & `i` initialized at top of scope
 863 | 		for ( i = 0; i < sessionStorage.length; i++ ) {
 864 | 			key = sessionStorage.key( i++ );
 865 | 			if ( key.indexOf( "qunit-test-" ) === 0 ) {
 866 | 				sessionStorage.removeItem( key );
 867 | 			}
 868 | 		}
 869 | 	}
 870 | 
 871 | 	// scroll back to top to show results
 872 | 	if ( config.scrolltop && window.scrollTo ) {
 873 | 		window.scrollTo(0, 0);
 874 | 	}
 875 | 
 876 | 	runLoggingCallbacks( "done", QUnit, {
 877 | 		failed: config.stats.bad,
 878 | 		passed: passed,
 879 | 		total: config.stats.all,
 880 | 		runtime: runtime
 881 | 	});
 882 | }
 883 | 
 884 | /** @return Boolean: true if this test should be ran */
 885 | function validTest( test ) {
 886 | 	var include,
 887 | 		filter = config.filter && config.filter.toLowerCase(),
 888 | 		module = config.module && config.module.toLowerCase(),
 889 | 		fullName = ( test.module + ": " + test.testName ).toLowerCase();
 890 | 
 891 | 	// Internally-generated tests are always valid
 892 | 	if ( test.callback && test.callback.validTest === validTest ) {
 893 | 		delete test.callback.validTest;
 894 | 		return true;
 895 | 	}
 896 | 
 897 | 	if ( config.testNumber.length > 0 ) {
 898 | 		if ( inArray( test.testNumber, config.testNumber ) < 0 ) {
 899 | 			return false;
 900 | 		}
 901 | 	}
 902 | 
 903 | 	if ( module && ( !test.module || test.module.toLowerCase() !== module ) ) {
 904 | 		return false;
 905 | 	}
 906 | 
 907 | 	if ( !filter ) {
 908 | 		return true;
 909 | 	}
 910 | 
 911 | 	include = filter.charAt( 0 ) !== "!";
 912 | 	if ( !include ) {
 913 | 		filter = filter.slice( 1 );
 914 | 	}
 915 | 
 916 | 	// If the filter matches, we need to honour include
 917 | 	if ( fullName.indexOf( filter ) !== -1 ) {
 918 | 		return include;
 919 | 	}
 920 | 
 921 | 	// Otherwise, do the opposite
 922 | 	return !include;
 923 | }
 924 | 
 925 | // so far supports only Firefox, Chrome and Opera (buggy), Safari (for real exceptions)
 926 | // Later Safari and IE10 are supposed to support error.stack as well
 927 | // See also https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error/Stack
 928 | function extractStacktrace( e, offset ) {
 929 | 	offset = offset === undefined ? 3 : offset;
 930 | 
 931 | 	var stack, include, i;
 932 | 
 933 | 	if ( e.stacktrace ) {
 934 | 		// Opera
 935 | 		return e.stacktrace.split( "\n" )[ offset + 3 ];
 936 | 	} else if ( e.stack ) {
 937 | 		// Firefox, Chrome
 938 | 		stack = e.stack.split( "\n" );
 939 | 		if (/^error$/i.test( stack[0] ) ) {
 940 | 			stack.shift();
 941 | 		}
 942 | 		if ( fileName ) {
 943 | 			include = [];
 944 | 			for ( i = offset; i < stack.length; i++ ) {
 945 | 				if ( stack[ i ].indexOf( fileName ) !== -1 ) {
 946 | 					break;
 947 | 				}
 948 | 				include.push( stack[ i ] );
 949 | 			}
 950 | 			if ( include.length ) {
 951 | 				return include.join( "\n" );
 952 | 			}
 953 | 		}
 954 | 		return stack[ offset ];
 955 | 	} else if ( e.sourceURL ) {
 956 | 		// Safari, PhantomJS
 957 | 		// hopefully one day Safari provides actual stacktraces
 958 | 		// exclude useless self-reference for generated Error objects
 959 | 		if ( /qunit.js$/.test( e.sourceURL ) ) {
 960 | 			return;
 961 | 		}
 962 | 		// for actual exceptions, this is useful
 963 | 		return e.sourceURL + ":" + e.line;
 964 | 	}
 965 | }
 966 | function sourceFromStacktrace( offset ) {
 967 | 	try {
 968 | 		throw new Error();
 969 | 	} catch ( e ) {
 970 | 		return extractStacktrace( e, offset );
 971 | 	}
 972 | }
 973 | 
 974 | /**
 975 |  * Escape text for attribute or text content.
 976 |  */
 977 | function escapeText( s ) {
 978 | 	if ( !s ) {
 979 | 		return "";
 980 | 	}
 981 | 	s = s + "";
 982 | 	// Both single quotes and double quotes (for attributes)
 983 | 	return s.replace( /['"<>&]/g, function( s ) {
 984 | 		switch( s ) {
 985 | 			case "'":
 986 | 				return "&#039;";
 987 | 			case "\"":
 988 | 				return "&quot;";
 989 | 			case "<":
 990 | 				return "&lt;";
 991 | 			case ">":
 992 | 				return "&gt;";
 993 | 			case "&":
 994 | 				return "&amp;";
 995 | 		}
 996 | 	});
 997 | }
 998 | 
 999 | function synchronize( callback, last ) {
1000 | 	config.queue.push( callback );
1001 | 
1002 | 	if ( config.autorun && !config.blocking ) {
1003 | 		process( last );
1004 | 	}
1005 | }
1006 | 
1007 | function process( last ) {
1008 | 	function next() {
1009 | 		process( last );
1010 | 	}
1011 | 	var start = new Date().getTime();
1012 | 	config.depth = config.depth ? config.depth + 1 : 1;
1013 | 
1014 | 	while ( config.queue.length && !config.blocking ) {
1015 | 		if ( !defined.setTimeout || config.updateRate <= 0 || ( ( new Date().getTime() - start ) < config.updateRate ) ) {
1016 | 			config.queue.shift()();
1017 | 		} else {
1018 | 			setTimeout( next, 13 );
1019 | 			break;
1020 | 		}
1021 | 	}
1022 | 	config.depth--;
1023 | 	if ( last && !config.blocking && !config.queue.length && config.depth === 0 ) {
1024 | 		done();
1025 | 	}
1026 | }
1027 | 
1028 | function saveGlobal() {
1029 | 	config.pollution = [];
1030 | 
1031 | 	if ( config.noglobals ) {
1032 | 		for ( var key in window ) {
1033 | 			if ( hasOwn.call( window, key ) ) {
1034 | 				// in Opera sometimes DOM element ids show up here, ignore them
1035 | 				if ( /^qunit-test-output/.test( key ) ) {
1036 | 					continue;
1037 | 				}
1038 | 				config.pollution.push( key );
1039 | 			}
1040 | 		}
1041 | 	}
1042 | }
1043 | 
1044 | function checkPollution() {
1045 | 	var newGlobals,
1046 | 		deletedGlobals,
1047 | 		old = config.pollution;
1048 | 
1049 | 	saveGlobal();
1050 | 
1051 | 	newGlobals = diff( config.pollution, old );
1052 | 	if ( newGlobals.length > 0 ) {
1053 | 		QUnit.pushFailure( "Introduced global variable(s): " + newGlobals.join(", ") );
1054 | 	}
1055 | 
1056 | 	deletedGlobals = diff( old, config.pollution );
1057 | 	if ( deletedGlobals.length > 0 ) {
1058 | 		QUnit.pushFailure( "Deleted global variable(s): " + deletedGlobals.join(", ") );
1059 | 	}
1060 | }
1061 | 
1062 | // returns a new Array with the elements that are in a but not in b
1063 | function diff( a, b ) {
1064 | 	var i, j,
1065 | 		result = a.slice();
1066 | 
1067 | 	for ( i = 0; i < result.length; i++ ) {
1068 | 		for ( j = 0; j < b.length; j++ ) {
1069 | 			if ( result[i] === b[j] ) {
1070 | 				result.splice( i, 1 );
1071 | 				i--;
1072 | 				break;
1073 | 			}
1074 | 		}
1075 | 	}
1076 | 	return result;
1077 | }
1078 | 
1079 | function extend( a, b ) {
1080 | 	for ( var prop in b ) {
1081 | 		if ( hasOwn.call( b, prop ) ) {
1082 | 			// Avoid "Member not found" error in IE8 caused by messing with window.constructor
1083 | 			if ( !( prop === "constructor" && a === window ) ) {
1084 | 				if ( b[ prop ] === undefined ) {
1085 | 					delete a[ prop ];
1086 | 				} else {
1087 | 					a[ prop ] = b[ prop ];
1088 | 				}
1089 | 			}
1090 | 		}
1091 | 	}
1092 | 
1093 | 	return a;
1094 | }
1095 | 
1096 | /**
1097 |  * @param {HTMLElement} elem
1098 |  * @param {string} type
1099 |  * @param {Function} fn
1100 |  */
1101 | function addEvent( elem, type, fn ) {
1102 | 	if ( elem.addEventListener ) {
1103 | 
1104 | 		// Standards-based browsers
1105 | 		elem.addEventListener( type, fn, false );
1106 | 	} else if ( elem.attachEvent ) {
1107 | 
1108 | 		// support: IE <9
1109 | 		elem.attachEvent( "on" + type, fn );
1110 | 	} else {
1111 | 
1112 | 		// Caller must ensure support for event listeners is present
1113 | 		throw new Error( "addEvent() was called in a context without event listener support" );
1114 | 	}
1115 | }
1116 | 
1117 | /**
1118 |  * @param {Array|NodeList} elems
1119 |  * @param {string} type
1120 |  * @param {Function} fn
1121 |  */
1122 | function addEvents( elems, type, fn ) {
1123 | 	var i = elems.length;
1124 | 	while ( i-- ) {
1125 | 		addEvent( elems[i], type, fn );
1126 | 	}
1127 | }
1128 | 
1129 | function hasClass( elem, name ) {
1130 | 	return (" " + elem.className + " ").indexOf(" " + name + " ") > -1;
1131 | }
1132 | 
1133 | function addClass( elem, name ) {
1134 | 	if ( !hasClass( elem, name ) ) {
1135 | 		elem.className += (elem.className ? " " : "") + name;
1136 | 	}
1137 | }
1138 | 
1139 | function removeClass( elem, name ) {
1140 | 	var set = " " + elem.className + " ";
1141 | 	// Class name may appear multiple times
1142 | 	while ( set.indexOf(" " + name + " ") > -1 ) {
1143 | 		set = set.replace(" " + name + " " , " ");
1144 | 	}
1145 | 	// If possible, trim it for prettiness, but not necessarily
1146 | 	elem.className = typeof set.trim === "function" ? set.trim() : set.replace(/^\s+|\s+$/g, "");
1147 | }
1148 | 
1149 | function id( name ) {
1150 | 	return defined.document && document.getElementById && document.getElementById( name );
1151 | }
1152 | 
1153 | function registerLoggingCallback( key ) {
1154 | 	return function( callback ) {
1155 | 		config[key].push( callback );
1156 | 	};
1157 | }
1158 | 
1159 | // Supports deprecated method of completely overwriting logging callbacks
1160 | function runLoggingCallbacks( key, scope, args ) {
1161 | 	var i, callbacks;
1162 | 	if ( QUnit.hasOwnProperty( key ) ) {
1163 | 		QUnit[ key ].call(scope, args );
1164 | 	} else {
1165 | 		callbacks = config[ key ];
1166 | 		for ( i = 0; i < callbacks.length; i++ ) {
1167 | 			callbacks[ i ].call( scope, args );
1168 | 		}
1169 | 	}
1170 | }
1171 | 
1172 | // from jquery.js
1173 | function inArray( elem, array ) {
1174 | 	if ( array.indexOf ) {
1175 | 		return array.indexOf( elem );
1176 | 	}
1177 | 
1178 | 	for ( var i = 0, length = array.length; i < length; i++ ) {
1179 | 		if ( array[ i ] === elem ) {
1180 | 			return i;
1181 | 		}
1182 | 	}
1183 | 
1184 | 	return -1;
1185 | }
1186 | 
1187 | function Test( settings ) {
1188 | 	extend( this, settings );
1189 | 	this.assertions = [];
1190 | 	this.testNumber = ++Test.count;
1191 | }
1192 | 
1193 | Test.count = 0;
1194 | 
1195 | Test.prototype = {
1196 | 	init: function() {
1197 | 		var a, b, li,
1198 | 			tests = id( "qunit-tests" );
1199 | 
1200 | 		if ( tests ) {
1201 | 			b = document.createElement( "strong" );
1202 | 			b.innerHTML = this.nameHtml;
1203 | 
1204 | 			// `a` initialized at top of scope
1205 | 			a = document.createElement( "a" );
1206 | 			a.innerHTML = "Rerun";
1207 | 			a.href = QUnit.url({ testNumber: this.testNumber });
1208 | 
1209 | 			li = document.createElement( "li" );
1210 | 			li.appendChild( b );
1211 | 			li.appendChild( a );
1212 | 			li.className = "running";
1213 | 			li.id = this.id = "qunit-test-output" + testId++;
1214 | 
1215 | 			tests.appendChild( li );
1216 | 		}
1217 | 	},
1218 | 	setup: function() {
1219 | 		if (
1220 | 			// Emit moduleStart when we're switching from one module to another
1221 | 			this.module !== config.previousModule ||
1222 | 				// They could be equal (both undefined) but if the previousModule property doesn't
1223 | 				// yet exist it means this is the first test in a suite that isn't wrapped in a
1224 | 				// module, in which case we'll just emit a moduleStart event for 'undefined'.
1225 | 				// Without this, reporters can get testStart before moduleStart  which is a problem.
1226 | 				!hasOwn.call( config, "previousModule" )
1227 | 		) {
1228 | 			if ( hasOwn.call( config, "previousModule" ) ) {
1229 | 				runLoggingCallbacks( "moduleDone", QUnit, {
1230 | 					name: config.previousModule,
1231 | 					failed: config.moduleStats.bad,
1232 | 					passed: config.moduleStats.all - config.moduleStats.bad,
1233 | 					total: config.moduleStats.all
1234 | 				});
1235 | 			}
1236 | 			config.previousModule = this.module;
1237 | 			config.moduleStats = { all: 0, bad: 0 };
1238 | 			runLoggingCallbacks( "moduleStart", QUnit, {
1239 | 				name: this.module
1240 | 			});
1241 | 		}
1242 | 
1243 | 		config.current = this;
1244 | 
1245 | 		this.testEnvironment = extend({
1246 | 			setup: function() {},
1247 | 			teardown: function() {}
1248 | 		}, this.moduleTestEnvironment );
1249 | 
1250 | 		this.started = +new Date();
1251 | 		runLoggingCallbacks( "testStart", QUnit, {
1252 | 			name: this.testName,
1253 | 			module: this.module
1254 | 		});
1255 | 
1256 | 		/*jshint camelcase:false */
1257 | 
1258 | 
1259 | 		/**
1260 | 		 * Expose the current test environment.
1261 | 		 *
1262 | 		 * @deprecated since 1.12.0: Use QUnit.config.current.testEnvironment instead.
1263 | 		 */
1264 | 		QUnit.current_testEnvironment = this.testEnvironment;
1265 | 
1266 | 		/*jshint camelcase:true */
1267 | 
1268 | 		if ( !config.pollution ) {
1269 | 			saveGlobal();
1270 | 		}
1271 | 		if ( config.notrycatch ) {
1272 | 			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
1273 | 			return;
1274 | 		}
1275 | 		try {
1276 | 			this.testEnvironment.setup.call( this.testEnvironment, QUnit.assert );
1277 | 		} catch( e ) {
1278 | 			QUnit.pushFailure( "Setup failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
1279 | 		}
1280 | 	},
1281 | 	run: function() {
1282 | 		config.current = this;
1283 | 
1284 | 		var running = id( "qunit-testresult" );
1285 | 
1286 | 		if ( running ) {
1287 | 			running.innerHTML = "Running: <br/>" + this.nameHtml;
1288 | 		}
1289 | 
1290 | 		if ( this.async ) {
1291 | 			QUnit.stop();
1292 | 		}
1293 | 
1294 | 		this.callbackStarted = +new Date();
1295 | 
1296 | 		if ( config.notrycatch ) {
1297 | 			this.callback.call( this.testEnvironment, QUnit.assert );
1298 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
1299 | 			return;
1300 | 		}
1301 | 
1302 | 		try {
1303 | 			this.callback.call( this.testEnvironment, QUnit.assert );
1304 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
1305 | 		} catch( e ) {
1306 | 			this.callbackRuntime = +new Date() - this.callbackStarted;
1307 | 
1308 | 			QUnit.pushFailure( "Died on test #" + (this.assertions.length + 1) + " " + this.stack + ": " + ( e.message || e ), extractStacktrace( e, 0 ) );
1309 | 			// else next test will carry the responsibility
1310 | 			saveGlobal();
1311 | 
1312 | 			// Restart the tests if they're blocking
1313 | 			if ( config.blocking ) {
1314 | 				QUnit.start();
1315 | 			}
1316 | 		}
1317 | 	},
1318 | 	teardown: function() {
1319 | 		config.current = this;
1320 | 		if ( config.notrycatch ) {
1321 | 			if ( typeof this.callbackRuntime === "undefined" ) {
1322 | 				this.callbackRuntime = +new Date() - this.callbackStarted;
1323 | 			}
1324 | 			this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
1325 | 			return;
1326 | 		} else {
1327 | 			try {
1328 | 				this.testEnvironment.teardown.call( this.testEnvironment, QUnit.assert );
1329 | 			} catch( e ) {
1330 | 				QUnit.pushFailure( "Teardown failed on " + this.testName + ": " + ( e.message || e ), extractStacktrace( e, 1 ) );
1331 | 			}
1332 | 		}
1333 | 		checkPollution();
1334 | 	},
1335 | 	finish: function() {
1336 | 		config.current = this;
1337 | 		if ( config.requireExpects && this.expected === null ) {
1338 | 			QUnit.pushFailure( "Expected number of assertions to be defined, but expect() was not called.", this.stack );
1339 | 		} else if ( this.expected !== null && this.expected !== this.assertions.length ) {
1340 | 			QUnit.pushFailure( "Expected " + this.expected + " assertions, but " + this.assertions.length + " were run", this.stack );
1341 | 		} else if ( this.expected === null && !this.assertions.length ) {
1342 | 			QUnit.pushFailure( "Expected at least one assertion, but none were run - call expect(0) to accept zero assertions.", this.stack );
1343 | 		}
1344 | 
1345 | 		var i, assertion, a, b, time, li, ol,
1346 | 			test = this,
1347 | 			good = 0,
1348 | 			bad = 0,
1349 | 			tests = id( "qunit-tests" );
1350 | 
1351 | 		this.runtime = +new Date() - this.started;
1352 | 		config.stats.all += this.assertions.length;
1353 | 		config.moduleStats.all += this.assertions.length;
1354 | 
1355 | 		if ( tests ) {
1356 | 			ol = document.createElement( "ol" );
1357 | 			ol.className = "qunit-assert-list";
1358 | 
1359 | 			for ( i = 0; i < this.assertions.length; i++ ) {
1360 | 				assertion = this.assertions[i];
1361 | 
1362 | 				li = document.createElement( "li" );
1363 | 				li.className = assertion.result ? "pass" : "fail";
1364 | 				li.innerHTML = assertion.message || ( assertion.result ? "okay" : "failed" );
1365 | 				ol.appendChild( li );
1366 | 
1367 | 				if ( assertion.result ) {
1368 | 					good++;
1369 | 				} else {
1370 | 					bad++;
1371 | 					config.stats.bad++;
1372 | 					config.moduleStats.bad++;
1373 | 				}
1374 | 			}
1375 | 
1376 | 			// store result when possible
1377 | 			if ( QUnit.config.reorder && defined.sessionStorage ) {
1378 | 				if ( bad ) {
1379 | 					sessionStorage.setItem( "qunit-test-" + this.module + "-" + this.testName, bad );
1380 | 				} else {
1381 | 					sessionStorage.removeItem( "qunit-test-" + this.module + "-" + this.testName );
1382 | 				}
1383 | 			}
1384 | 
1385 | 			if ( bad === 0 ) {
1386 | 				addClass( ol, "qunit-collapsed" );
1387 | 			}
1388 | 
1389 | 			// `b` initialized at top of scope
1390 | 			b = document.createElement( "strong" );
1391 | 			b.innerHTML = this.nameHtml + " <b class='counts'>(<b class='failed'>" + bad + "</b>, <b class='passed'>" + good + "</b>, " + this.assertions.length + ")</b>";
1392 | 
1393 | 			addEvent(b, "click", function() {
1394 | 				var next = b.parentNode.lastChild,
1395 | 					collapsed = hasClass( next, "qunit-collapsed" );
1396 | 				( collapsed ? removeClass : addClass )( next, "qunit-collapsed" );
1397 | 			});
1398 | 
1399 | 			addEvent(b, "dblclick", function( e ) {
1400 | 				var target = e && e.target ? e.target : window.event.srcElement;
1401 | 				if ( target.nodeName.toLowerCase() === "span" || target.nodeName.toLowerCase() === "b" ) {
1402 | 					target = target.parentNode;
1403 | 				}
1404 | 				if ( window.location && target.nodeName.toLowerCase() === "strong" ) {
1405 | 					window.location = QUnit.url({ testNumber: test.testNumber });
1406 | 				}
1407 | 			});
1408 | 
1409 | 			// `time` initialized at top of scope
1410 | 			time = document.createElement( "span" );
1411 | 			time.className = "runtime";
1412 | 			time.innerHTML = this.runtime + " ms";
1413 | 
1414 | 			// `li` initialized at top of scope
1415 | 			li = id( this.id );
1416 | 			li.className = bad ? "fail" : "pass";
1417 | 			li.removeChild( li.firstChild );
1418 | 			a = li.firstChild;
1419 | 			li.appendChild( b );
1420 | 			li.appendChild( a );
1421 | 			li.appendChild( time );
1422 | 			li.appendChild( ol );
1423 | 
1424 | 		} else {
1425 | 			for ( i = 0; i < this.assertions.length; i++ ) {
1426 | 				if ( !this.assertions[i].result ) {
1427 | 					bad++;
1428 | 					config.stats.bad++;
1429 | 					config.moduleStats.bad++;
1430 | 				}
1431 | 			}
1432 | 		}
1433 | 
1434 | 		runLoggingCallbacks( "testDone", QUnit, {
1435 | 			name: this.testName,
1436 | 			module: this.module,
1437 | 			failed: bad,
1438 | 			passed: this.assertions.length - bad,
1439 | 			total: this.assertions.length,
1440 | 			runtime: this.runtime,
1441 | 			// DEPRECATED: this property will be removed in 2.0.0, use runtime instead
1442 | 			duration: this.runtime
1443 | 		});
1444 | 
1445 | 		QUnit.reset();
1446 | 
1447 | 		config.current = undefined;
1448 | 	},
1449 | 
1450 | 	queue: function() {
1451 | 		var bad,
1452 | 			test = this;
1453 | 
1454 | 		synchronize(function() {
1455 | 			test.init();
1456 | 		});
1457 | 		function run() {
1458 | 			// each of these can by async
1459 | 			synchronize(function() {
1460 | 				test.setup();
1461 | 			});
1462 | 			synchronize(function() {
1463 | 				test.run();
1464 | 			});
1465 | 			synchronize(function() {
1466 | 				test.teardown();
1467 | 			});
1468 | 			synchronize(function() {
1469 | 				test.finish();
1470 | 			});
1471 | 		}
1472 | 
1473 | 		// `bad` initialized at top of scope
1474 | 		// defer when previous test run passed, if storage is available
1475 | 		bad = QUnit.config.reorder && defined.sessionStorage &&
1476 | 						+sessionStorage.getItem( "qunit-test-" + this.module + "-" + this.testName );
1477 | 
1478 | 		if ( bad ) {
1479 | 			run();
1480 | 		} else {
1481 | 			synchronize( run, true );
1482 | 		}
1483 | 	}
1484 | };
1485 | 
1486 | // `assert` initialized at top of scope
1487 | // Assert helpers
1488 | // All of these must either call QUnit.push() or manually do:
1489 | // - runLoggingCallbacks( "log", .. );
1490 | // - config.current.assertions.push({ .. });
1491 | assert = QUnit.assert = {
1492 | 	/**
1493 | 	 * Asserts rough true-ish result.
1494 | 	 * @name ok
1495 | 	 * @function
1496 | 	 * @example ok( "asdfasdf".length > 5, "There must be at least 5 chars" );
1497 | 	 */
1498 | 	ok: function( result, msg ) {
1499 | 		if ( !config.current ) {
1500 | 			throw new Error( "ok() assertion outside test context, was " + sourceFromStacktrace(2) );
1501 | 		}
1502 | 		result = !!result;
1503 | 		msg = msg || ( result ? "okay" : "failed" );
1504 | 
1505 | 		var source,
1506 | 			details = {
1507 | 				module: config.current.module,
1508 | 				name: config.current.testName,
1509 | 				result: result,
1510 | 				message: msg
1511 | 			};
1512 | 
1513 | 		msg = "<span class='test-message'>" + escapeText( msg ) + "</span>";
1514 | 
1515 | 		if ( !result ) {
1516 | 			source = sourceFromStacktrace( 2 );
1517 | 			if ( source ) {
1518 | 				details.source = source;
1519 | 				msg += "<table><tr class='test-source'><th>Source: </th><td><pre>" +
1520 | 					escapeText( source ) +
1521 | 					"</pre></td></tr></table>";
1522 | 			}
1523 | 		}
1524 | 		runLoggingCallbacks( "log", QUnit, details );
1525 | 		config.current.assertions.push({
1526 | 			result: result,
1527 | 			message: msg
1528 | 		});
1529 | 	},
1530 | 
1531 | 	/**
1532 | 	 * Assert that the first two arguments are equal, with an optional message.
1533 | 	 * Prints out both actual and expected values.
1534 | 	 * @name equal
1535 | 	 * @function
1536 | 	 * @example equal( format( "Received {0} bytes.", 2), "Received 2 bytes.", "format() replaces {0} with next argument" );
1537 | 	 */
1538 | 	equal: function( actual, expected, message ) {
1539 | 		/*jshint eqeqeq:false */
1540 | 		QUnit.push( expected == actual, actual, expected, message );
1541 | 	},
1542 | 
1543 | 	/**
1544 | 	 * @name notEqual
1545 | 	 * @function
1546 | 	 */
1547 | 	notEqual: function( actual, expected, message ) {
1548 | 		/*jshint eqeqeq:false */
1549 | 		QUnit.push( expected != actual, actual, expected, message );
1550 | 	},
1551 | 
1552 | 	/**
1553 | 	 * @name propEqual
1554 | 	 * @function
1555 | 	 */
1556 | 	propEqual: function( actual, expected, message ) {
1557 | 		actual = objectValues(actual);
1558 | 		expected = objectValues(expected);
1559 | 		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
1560 | 	},
1561 | 
1562 | 	/**
1563 | 	 * @name notPropEqual
1564 | 	 * @function
1565 | 	 */
1566 | 	notPropEqual: function( actual, expected, message ) {
1567 | 		actual = objectValues(actual);
1568 | 		expected = objectValues(expected);
1569 | 		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
1570 | 	},
1571 | 
1572 | 	/**
1573 | 	 * @name deepEqual
1574 | 	 * @function
1575 | 	 */
1576 | 	deepEqual: function( actual, expected, message ) {
1577 | 		QUnit.push( QUnit.equiv(actual, expected), actual, expected, message );
1578 | 	},
1579 | 
1580 | 	/**
1581 | 	 * @name notDeepEqual
1582 | 	 * @function
1583 | 	 */
1584 | 	notDeepEqual: function( actual, expected, message ) {
1585 | 		QUnit.push( !QUnit.equiv(actual, expected), actual, expected, message );
1586 | 	},
1587 | 
1588 | 	/**
1589 | 	 * @name strictEqual
1590 | 	 * @function
1591 | 	 */
1592 | 	strictEqual: function( actual, expected, message ) {
1593 | 		QUnit.push( expected === actual, actual, expected, message );
1594 | 	},
1595 | 
1596 | 	/**
1597 | 	 * @name notStrictEqual
1598 | 	 * @function
1599 | 	 */
1600 | 	notStrictEqual: function( actual, expected, message ) {
1601 | 		QUnit.push( expected !== actual, actual, expected, message );
1602 | 	},
1603 | 
1604 | 	"throws": function( block, expected, message ) {
1605 | 		var actual,
1606 | 			expectedOutput = expected,
1607 | 			ok = false;
1608 | 
1609 | 		// 'expected' is optional
1610 | 		if ( !message && typeof expected === "string" ) {
1611 | 			message = expected;
1612 | 			expected = null;
1613 | 		}
1614 | 
1615 | 		config.current.ignoreGlobalErrors = true;
1616 | 		try {
1617 | 			block.call( config.current.testEnvironment );
1618 | 		} catch (e) {
1619 | 			actual = e;
1620 | 		}
1621 | 		config.current.ignoreGlobalErrors = false;
1622 | 
1623 | 		if ( actual ) {
1624 | 
1625 | 			// we don't want to validate thrown error
1626 | 			if ( !expected ) {
1627 | 				ok = true;
1628 | 				expectedOutput = null;
1629 | 
1630 | 			// expected is an Error object
1631 | 			} else if ( expected instanceof Error ) {
1632 | 				ok = actual instanceof Error &&
1633 | 					 actual.name === expected.name &&
1634 | 					 actual.message === expected.message;
1635 | 
1636 | 			// expected is a regexp
1637 | 			} else if ( QUnit.objectType( expected ) === "regexp" ) {
1638 | 				ok = expected.test( errorString( actual ) );
1639 | 
1640 | 			// expected is a string
1641 | 			} else if ( QUnit.objectType( expected ) === "string" ) {
1642 | 				ok = expected === errorString( actual );
1643 | 
1644 | 			// expected is a constructor
1645 | 			} else if ( actual instanceof expected ) {
1646 | 				ok = true;
1647 | 
1648 | 			// expected is a validation function which returns true is validation passed
1649 | 			} else if ( expected.call( {}, actual ) === true ) {
1650 | 				expectedOutput = null;
1651 | 				ok = true;
1652 | 			}
1653 | 
1654 | 			QUnit.push( ok, actual, expectedOutput, message );
1655 | 		} else {
1656 | 			QUnit.pushFailure( message, null, "No exception was thrown." );
1657 | 		}
1658 | 	}
1659 | };
1660 | 
1661 | /**
1662 |  * @deprecated since 1.8.0
1663 |  * Kept assertion helpers in root for backwards compatibility.
1664 |  */
1665 | extend( QUnit.constructor.prototype, assert );
1666 | 
1667 | /**
1668 |  * @deprecated since 1.9.0
1669 |  * Kept to avoid TypeErrors for undefined methods.
1670 |  */
1671 | QUnit.constructor.prototype.raises = function() {
1672 | 	QUnit.push( false, false, false, "QUnit.raises has been deprecated since 2012 (fad3c1ea), use QUnit.throws instead" );
1673 | };
1674 | 
1675 | /**
1676 |  * @deprecated since 1.0.0, replaced with error pushes since 1.3.0
1677 |  * Kept to avoid TypeErrors for undefined methods.
1678 |  */
1679 | QUnit.constructor.prototype.equals = function() {
1680 | 	QUnit.push( false, false, false, "QUnit.equals has been deprecated since 2009 (e88049a0), use QUnit.equal instead" );
1681 | };
1682 | QUnit.constructor.prototype.same = function() {
1683 | 	QUnit.push( false, false, false, "QUnit.same has been deprecated since 2009 (e88049a0), use QUnit.deepEqual instead" );
1684 | };
1685 | 
1686 | // Test for equality any JavaScript type.
1687 | // Author: Philippe Rathé <prathe@gmail.com>
1688 | QUnit.equiv = (function() {
1689 | 
1690 | 	// Call the o related callback with the given arguments.
1691 | 	function bindCallbacks( o, callbacks, args ) {
1692 | 		var prop = QUnit.objectType( o );
1693 | 		if ( prop ) {
1694 | 			if ( QUnit.objectType( callbacks[ prop ] ) === "function" ) {
1695 | 				return callbacks[ prop ].apply( callbacks, args );
1696 | 			} else {
1697 | 				return callbacks[ prop ]; // or undefined
1698 | 			}
1699 | 		}
1700 | 	}
1701 | 
1702 | 	// the real equiv function
1703 | 	var innerEquiv,
1704 | 		// stack to decide between skip/abort functions
1705 | 		callers = [],
1706 | 		// stack to avoiding loops from circular referencing
1707 | 		parents = [],
1708 | 		parentsB = [],
1709 | 
1710 | 		getProto = Object.getPrototypeOf || function ( obj ) {
1711 | 			/*jshint camelcase:false */
1712 | 			return obj.__proto__;
1713 | 		},
1714 | 		callbacks = (function () {
1715 | 
1716 | 			// for string, boolean, number and null
1717 | 			function useStrictEquality( b, a ) {
1718 | 				/*jshint eqeqeq:false */
1719 | 				if ( b instanceof a.constructor || a instanceof b.constructor ) {
1720 | 					// to catch short annotation VS 'new' annotation of a
1721 | 					// declaration
1722 | 					// e.g. var i = 1;
1723 | 					// var j = new Number(1);
1724 | 					return a == b;
1725 | 				} else {
1726 | 					return a === b;
1727 | 				}
1728 | 			}
1729 | 
1730 | 			return {
1731 | 				"string": useStrictEquality,
1732 | 				"boolean": useStrictEquality,
1733 | 				"number": useStrictEquality,
1734 | 				"null": useStrictEquality,
1735 | 				"undefined": useStrictEquality,
1736 | 
1737 | 				"nan": function( b ) {
1738 | 					return isNaN( b );
1739 | 				},
1740 | 
1741 | 				"date": function( b, a ) {
1742 | 					return QUnit.objectType( b ) === "date" && a.valueOf() === b.valueOf();
1743 | 				},
1744 | 
1745 | 				"regexp": function( b, a ) {
1746 | 					return QUnit.objectType( b ) === "regexp" &&
1747 | 						// the regex itself
1748 | 						a.source === b.source &&
1749 | 						// and its modifiers
1750 | 						a.global === b.global &&
1751 | 						// (gmi) ...
1752 | 						a.ignoreCase === b.ignoreCase &&
1753 | 						a.multiline === b.multiline &&
1754 | 						a.sticky === b.sticky;
1755 | 				},
1756 | 
1757 | 				// - skip when the property is a method of an instance (OOP)
1758 | 				// - abort otherwise,
1759 | 				// initial === would have catch identical references anyway
1760 | 				"function": function() {
1761 | 					var caller = callers[callers.length - 1];
1762 | 					return caller !== Object && typeof caller !== "undefined";
1763 | 				},
1764 | 
1765 | 				"array": function( b, a ) {
1766 | 					var i, j, len, loop, aCircular, bCircular;
1767 | 
1768 | 					// b could be an object literal here
1769 | 					if ( QUnit.objectType( b ) !== "array" ) {
1770 | 						return false;
1771 | 					}
1772 | 
1773 | 					len = a.length;
1774 | 					if ( len !== b.length ) {
1775 | 						// safe and faster
1776 | 						return false;
1777 | 					}
1778 | 
1779 | 					// track reference to avoid circular references
1780 | 					parents.push( a );
1781 | 					parentsB.push( b );
1782 | 					for ( i = 0; i < len; i++ ) {
1783 | 						loop = false;
1784 | 						for ( j = 0; j < parents.length; j++ ) {
1785 | 							aCircular = parents[j] === a[i];
1786 | 							bCircular = parentsB[j] === b[i];
1787 | 							if ( aCircular || bCircular ) {
1788 | 								if ( a[i] === b[i] || aCircular && bCircular ) {
1789 | 									loop = true;
1790 | 								} else {
1791 | 									parents.pop();
1792 | 									parentsB.pop();
1793 | 									return false;
1794 | 								}
1795 | 							}
1796 | 						}
1797 | 						if ( !loop && !innerEquiv(a[i], b[i]) ) {
1798 | 							parents.pop();
1799 | 							parentsB.pop();
1800 | 							return false;
1801 | 						}
1802 | 					}
1803 | 					parents.pop();
1804 | 					parentsB.pop();
1805 | 					return true;
1806 | 				},
1807 | 
1808 | 				"object": function( b, a ) {
1809 | 					/*jshint forin:false */
1810 | 					var i, j, loop, aCircular, bCircular,
1811 | 						// Default to true
1812 | 						eq = true,
1813 | 						aProperties = [],
1814 | 						bProperties = [];
1815 | 
1816 | 					// comparing constructors is more strict than using
1817 | 					// instanceof
1818 | 					if ( a.constructor !== b.constructor ) {
1819 | 						// Allow objects with no prototype to be equivalent to
1820 | 						// objects with Object as their constructor.
1821 | 						if ( !(( getProto(a) === null && getProto(b) === Object.prototype ) ||
1822 | 							( getProto(b) === null && getProto(a) === Object.prototype ) ) ) {
1823 | 								return false;
1824 | 						}
1825 | 					}
1826 | 
1827 | 					// stack constructor before traversing properties
1828 | 					callers.push( a.constructor );
1829 | 
1830 | 					// track reference to avoid circular references
1831 | 					parents.push( a );
1832 | 					parentsB.push( b );
1833 | 
1834 | 					// be strict: don't ensure hasOwnProperty and go deep
1835 | 					for ( i in a ) {
1836 | 						loop = false;
1837 | 						for ( j = 0; j < parents.length; j++ ) {
1838 | 							aCircular = parents[j] === a[i];
1839 | 							bCircular = parentsB[j] === b[i];
1840 | 							if ( aCircular || bCircular ) {
1841 | 								if ( a[i] === b[i] || aCircular && bCircular ) {
1842 | 									loop = true;
1843 | 								} else {
1844 | 									eq = false;
1845 | 									break;
1846 | 								}
1847 | 							}
1848 | 						}
1849 | 						aProperties.push(i);
1850 | 						if ( !loop && !innerEquiv(a[i], b[i]) ) {
1851 | 							eq = false;
1852 | 							break;
1853 | 						}
1854 | 					}
1855 | 
1856 | 					parents.pop();
1857 | 					parentsB.pop();
1858 | 					callers.pop(); // unstack, we are done
1859 | 
1860 | 					for ( i in b ) {
1861 | 						bProperties.push( i ); // collect b's properties
1862 | 					}
1863 | 
1864 | 					// Ensures identical properties name
1865 | 					return eq && innerEquiv( aProperties.sort(), bProperties.sort() );
1866 | 				}
1867 | 			};
1868 | 		}());
1869 | 
1870 | 	innerEquiv = function() { // can take multiple arguments
1871 | 		var args = [].slice.apply( arguments );
1872 | 		if ( args.length < 2 ) {
1873 | 			return true; // end transition
1874 | 		}
1875 | 
1876 | 		return (function( a, b ) {
1877 | 			if ( a === b ) {
1878 | 				return true; // catch the most you can
1879 | 			} else if ( a === null || b === null || typeof a === "undefined" ||
1880 | 					typeof b === "undefined" ||
1881 | 					QUnit.objectType(a) !== QUnit.objectType(b) ) {
1882 | 				return false; // don't lose time with error prone cases
1883 | 			} else {
1884 | 				return bindCallbacks(a, callbacks, [ b, a ]);
1885 | 			}
1886 | 
1887 | 			// apply transition with (1..n) arguments
1888 | 		}( args[0], args[1] ) && innerEquiv.apply( this, args.splice(1, args.length - 1 )) );
1889 | 	};
1890 | 
1891 | 	return innerEquiv;
1892 | }());
1893 | 
1894 | /**
1895 |  * jsDump Copyright (c) 2008 Ariel Flesler - aflesler(at)gmail(dot)com |
1896 |  * http://flesler.blogspot.com Licensed under BSD
1897 |  * (http://www.opensource.org/licenses/bsd-license.php) Date: 5/15/2008
1898 |  *
1899 |  * @projectDescription Advanced and extensible data dumping for Javascript.
1900 |  * @version 1.0.0
1901 |  * @author Ariel Flesler
1902 |  * @link {http://flesler.blogspot.com/2008/05/jsdump-pretty-dump-of-any-javascript.html}
1903 |  */
1904 | QUnit.jsDump = (function() {
1905 | 	function quote( str ) {
1906 | 		return "\"" + str.toString().replace( /"/g, "\\\"" ) + "\"";
1907 | 	}
1908 | 	function literal( o ) {
1909 | 		return o + "";
1910 | 	}
1911 | 	function join( pre, arr, post ) {
1912 | 		var s = jsDump.separator(),
1913 | 			base = jsDump.indent(),
1914 | 			inner = jsDump.indent(1);
1915 | 		if ( arr.join ) {
1916 | 			arr = arr.join( "," + s + inner );
1917 | 		}
1918 | 		if ( !arr ) {
1919 | 			return pre + post;
1920 | 		}
1921 | 		return [ pre, inner + arr, base + post ].join(s);
1922 | 	}
1923 | 	function array( arr, stack ) {
1924 | 		var i = arr.length, ret = new Array(i);
1925 | 		this.up();
1926 | 		while ( i-- ) {
1927 | 			ret[i] = this.parse( arr[i] , undefined , stack);
1928 | 		}
1929 | 		this.down();
1930 | 		return join( "[", ret, "]" );
1931 | 	}
1932 | 
1933 | 	var reName = /^function (\w+)/,
1934 | 		jsDump = {
1935 | 			// type is used mostly internally, you can fix a (custom)type in advance
1936 | 			parse: function( obj, type, stack ) {
1937 | 				stack = stack || [ ];
1938 | 				var inStack, res,
1939 | 					parser = this.parsers[ type || this.typeOf(obj) ];
1940 | 
1941 | 				type = typeof parser;
1942 | 				inStack = inArray( obj, stack );
1943 | 
1944 | 				if ( inStack !== -1 ) {
1945 | 					return "recursion(" + (inStack - stack.length) + ")";
1946 | 				}
1947 | 				if ( type === "function" )  {
1948 | 					stack.push( obj );
1949 | 					res = parser.call( this, obj, stack );
1950 | 					stack.pop();
1951 | 					return res;
1952 | 				}
1953 | 				return ( type === "string" ) ? parser : this.parsers.error;
1954 | 			},
1955 | 			typeOf: function( obj ) {
1956 | 				var type;
1957 | 				if ( obj === null ) {
1958 | 					type = "null";
1959 | 				} else if ( typeof obj === "undefined" ) {
1960 | 					type = "undefined";
1961 | 				} else if ( QUnit.is( "regexp", obj) ) {
1962 | 					type = "regexp";
1963 | 				} else if ( QUnit.is( "date", obj) ) {
1964 | 					type = "date";
1965 | 				} else if ( QUnit.is( "function", obj) ) {
1966 | 					type = "function";
1967 | 				} else if ( typeof obj.setInterval !== undefined && typeof obj.document !== "undefined" && typeof obj.nodeType === "undefined" ) {
1968 | 					type = "window";
1969 | 				} else if ( obj.nodeType === 9 ) {
1970 | 					type = "document";
1971 | 				} else if ( obj.nodeType ) {
1972 | 					type = "node";
1973 | 				} else if (
1974 | 					// native arrays
1975 | 					toString.call( obj ) === "[object Array]" ||
1976 | 					// NodeList objects
1977 | 					( typeof obj.length === "number" && typeof obj.item !== "undefined" && ( obj.length ? obj.item(0) === obj[0] : ( obj.item( 0 ) === null && typeof obj[0] === "undefined" ) ) )
1978 | 				) {
1979 | 					type = "array";
1980 | 				} else if ( obj.constructor === Error.prototype.constructor ) {
1981 | 					type = "error";
1982 | 				} else {
1983 | 					type = typeof obj;
1984 | 				}
1985 | 				return type;
1986 | 			},
1987 | 			separator: function() {
1988 | 				return this.multiline ?	this.HTML ? "<br />" : "\n" : this.HTML ? "&nbsp;" : " ";
1989 | 			},
1990 | 			// extra can be a number, shortcut for increasing-calling-decreasing
1991 | 			indent: function( extra ) {
1992 | 				if ( !this.multiline ) {
1993 | 					return "";
1994 | 				}
1995 | 				var chr = this.indentChar;
1996 | 				if ( this.HTML ) {
1997 | 					chr = chr.replace( /\t/g, "   " ).replace( / /g, "&nbsp;" );
1998 | 				}
1999 | 				return new Array( this.depth + ( extra || 0 ) ).join(chr);
2000 | 			},
2001 | 			up: function( a ) {
2002 | 				this.depth += a || 1;
2003 | 			},
2004 | 			down: function( a ) {
2005 | 				this.depth -= a || 1;
2006 | 			},
2007 | 			setParser: function( name, parser ) {
2008 | 				this.parsers[name] = parser;
2009 | 			},
2010 | 			// The next 3 are exposed so you can use them
2011 | 			quote: quote,
2012 | 			literal: literal,
2013 | 			join: join,
2014 | 			//
2015 | 			depth: 1,
2016 | 			// This is the list of parsers, to modify them, use jsDump.setParser
2017 | 			parsers: {
2018 | 				window: "[Window]",
2019 | 				document: "[Document]",
2020 | 				error: function(error) {
2021 | 					return "Error(\"" + error.message + "\")";
2022 | 				},
2023 | 				unknown: "[Unknown]",
2024 | 				"null": "null",
2025 | 				"undefined": "undefined",
2026 | 				"function": function( fn ) {
2027 | 					var ret = "function",
2028 | 						// functions never have name in IE
2029 | 						name = "name" in fn ? fn.name : (reName.exec(fn) || [])[1];
2030 | 
2031 | 					if ( name ) {
2032 | 						ret += " " + name;
2033 | 					}
2034 | 					ret += "( ";
2035 | 
2036 | 					ret = [ ret, QUnit.jsDump.parse( fn, "functionArgs" ), "){" ].join( "" );
2037 | 					return join( ret, QUnit.jsDump.parse(fn,"functionCode" ), "}" );
2038 | 				},
2039 | 				array: array,
2040 | 				nodelist: array,
2041 | 				"arguments": array,
2042 | 				object: function( map, stack ) {
2043 | 					/*jshint forin:false */
2044 | 					var ret = [ ], keys, key, val, i;
2045 | 					QUnit.jsDump.up();
2046 | 					keys = [];
2047 | 					for ( key in map ) {
2048 | 						keys.push( key );
2049 | 					}
2050 | 					keys.sort();
2051 | 					for ( i = 0; i < keys.length; i++ ) {
2052 | 						key = keys[ i ];
2053 | 						val = map[ key ];
2054 | 						ret.push( QUnit.jsDump.parse( key, "key" ) + ": " + QUnit.jsDump.parse( val, undefined, stack ) );
2055 | 					}
2056 | 					QUnit.jsDump.down();
2057 | 					return join( "{", ret, "}" );
2058 | 				},
2059 | 				node: function( node ) {
2060 | 					var len, i, val,
2061 | 						open = QUnit.jsDump.HTML ? "&lt;" : "<",
2062 | 						close = QUnit.jsDump.HTML ? "&gt;" : ">",
2063 | 						tag = node.nodeName.toLowerCase(),
2064 | 						ret = open + tag,
2065 | 						attrs = node.attributes;
2066 | 
2067 | 					if ( attrs ) {
2068 | 						for ( i = 0, len = attrs.length; i < len; i++ ) {
2069 | 							val = attrs[i].nodeValue;
2070 | 							// IE6 includes all attributes in .attributes, even ones not explicitly set.
2071 | 							// Those have values like undefined, null, 0, false, "" or "inherit".
2072 | 							if ( val && val !== "inherit" ) {
2073 | 								ret += " " + attrs[i].nodeName + "=" + QUnit.jsDump.parse( val, "attribute" );
2074 | 							}
2075 | 						}
2076 | 					}
2077 | 					ret += close;
2078 | 
2079 | 					// Show content of TextNode or CDATASection
2080 | 					if ( node.nodeType === 3 || node.nodeType === 4 ) {
2081 | 						ret += node.nodeValue;
2082 | 					}
2083 | 
2084 | 					return ret + open + "/" + tag + close;
2085 | 				},
2086 | 				// function calls it internally, it's the arguments part of the function
2087 | 				functionArgs: function( fn ) {
2088 | 					var args,
2089 | 						l = fn.length;
2090 | 
2091 | 					if ( !l ) {
2092 | 						return "";
2093 | 					}
2094 | 
2095 | 					args = new Array(l);
2096 | 					while ( l-- ) {
2097 | 						// 97 is 'a'
2098 | 						args[l] = String.fromCharCode(97+l);
2099 | 					}
2100 | 					return " " + args.join( ", " ) + " ";
2101 | 				},
2102 | 				// object calls it internally, the key part of an item in a map
2103 | 				key: quote,
2104 | 				// function calls it internally, it's the content of the function
2105 | 				functionCode: "[code]",
2106 | 				// node calls it internally, it's an html attribute value
2107 | 				attribute: quote,
2108 | 				string: quote,
2109 | 				date: quote,
2110 | 				regexp: literal,
2111 | 				number: literal,
2112 | 				"boolean": literal
2113 | 			},
2114 | 			// if true, entities are escaped ( <, >, \t, space and \n )
2115 | 			HTML: false,
2116 | 			// indentation unit
2117 | 			indentChar: "  ",
2118 | 			// if true, items in a collection, are separated by a \n, else just a space.
2119 | 			multiline: true
2120 | 		};
2121 | 
2122 | 	return jsDump;
2123 | }());
2124 | 
2125 | /*
2126 |  * Javascript Diff Algorithm
2127 |  *  By John Resig (http://ejohn.org/)
2128 |  *  Modified by Chu Alan "sprite"
2129 |  *
2130 |  * Released under the MIT license.
2131 |  *
2132 |  * More Info:
2133 |  *  http://ejohn.org/projects/javascript-diff-algorithm/
2134 |  *
2135 |  * Usage: QUnit.diff(expected, actual)
2136 |  *
2137 |  * QUnit.diff( "the quick brown fox jumped over", "the quick fox jumps over" ) == "the  quick <del>brown </del> fox <del>jumped </del><ins>jumps </ins> over"
2138 |  */
2139 | QUnit.diff = (function() {
2140 | 	/*jshint eqeqeq:false, eqnull:true */
2141 | 	function diff( o, n ) {
2142 | 		var i,
2143 | 			ns = {},
2144 | 			os = {};
2145 | 
2146 | 		for ( i = 0; i < n.length; i++ ) {
2147 | 			if ( !hasOwn.call( ns, n[i] ) ) {
2148 | 				ns[ n[i] ] = {
2149 | 					rows: [],
2150 | 					o: null
2151 | 				};
2152 | 			}
2153 | 			ns[ n[i] ].rows.push( i );
2154 | 		}
2155 | 
2156 | 		for ( i = 0; i < o.length; i++ ) {
2157 | 			if ( !hasOwn.call( os, o[i] ) ) {
2158 | 				os[ o[i] ] = {
2159 | 					rows: [],
2160 | 					n: null
2161 | 				};
2162 | 			}
2163 | 			os[ o[i] ].rows.push( i );
2164 | 		}
2165 | 
2166 | 		for ( i in ns ) {
2167 | 			if ( hasOwn.call( ns, i ) ) {
2168 | 				if ( ns[i].rows.length === 1 && hasOwn.call( os, i ) && os[i].rows.length === 1 ) {
2169 | 					n[ ns[i].rows[0] ] = {
2170 | 						text: n[ ns[i].rows[0] ],
2171 | 						row: os[i].rows[0]
2172 | 					};
2173 | 					o[ os[i].rows[0] ] = {
2174 | 						text: o[ os[i].rows[0] ],
2175 | 						row: ns[i].rows[0]
2176 | 					};
2177 | 				}
2178 | 			}
2179 | 		}
2180 | 
2181 | 		for ( i = 0; i < n.length - 1; i++ ) {
2182 | 			if ( n[i].text != null && n[ i + 1 ].text == null && n[i].row + 1 < o.length && o[ n[i].row + 1 ].text == null &&
2183 | 						n[ i + 1 ] == o[ n[i].row + 1 ] ) {
2184 | 
2185 | 				n[ i + 1 ] = {
2186 | 					text: n[ i + 1 ],
2187 | 					row: n[i].row + 1
2188 | 				};
2189 | 				o[ n[i].row + 1 ] = {
2190 | 					text: o[ n[i].row + 1 ],
2191 | 					row: i + 1
2192 | 				};
2193 | 			}
2194 | 		}
2195 | 
2196 | 		for ( i = n.length - 1; i > 0; i-- ) {
2197 | 			if ( n[i].text != null && n[ i - 1 ].text == null && n[i].row > 0 && o[ n[i].row - 1 ].text == null &&
2198 | 						n[ i - 1 ] == o[ n[i].row - 1 ]) {
2199 | 
2200 | 				n[ i - 1 ] = {
2201 | 					text: n[ i - 1 ],
2202 | 					row: n[i].row - 1
2203 | 				};
2204 | 				o[ n[i].row - 1 ] = {
2205 | 					text: o[ n[i].row - 1 ],
2206 | 					row: i - 1
2207 | 				};
2208 | 			}
2209 | 		}
2210 | 
2211 | 		return {
2212 | 			o: o,
2213 | 			n: n
2214 | 		};
2215 | 	}
2216 | 
2217 | 	return function( o, n ) {
2218 | 		o = o.replace( /\s+$/, "" );
2219 | 		n = n.replace( /\s+$/, "" );
2220 | 
2221 | 		var i, pre,
2222 | 			str = "",
2223 | 			out = diff( o === "" ? [] : o.split(/\s+/), n === "" ? [] : n.split(/\s+/) ),
2224 | 			oSpace = o.match(/\s+/g),
2225 | 			nSpace = n.match(/\s+/g);
2226 | 
2227 | 		if ( oSpace == null ) {
2228 | 			oSpace = [ " " ];
2229 | 		}
2230 | 		else {
2231 | 			oSpace.push( " " );
2232 | 		}
2233 | 
2234 | 		if ( nSpace == null ) {
2235 | 			nSpace = [ " " ];
2236 | 		}
2237 | 		else {
2238 | 			nSpace.push( " " );
2239 | 		}
2240 | 
2241 | 		if ( out.n.length === 0 ) {
2242 | 			for ( i = 0; i < out.o.length; i++ ) {
2243 | 				str += "<del>" + out.o[i] + oSpace[i] + "</del>";
2244 | 			}
2245 | 		}
2246 | 		else {
2247 | 			if ( out.n[0].text == null ) {
2248 | 				for ( n = 0; n < out.o.length && out.o[n].text == null; n++ ) {
2249 | 					str += "<del>" + out.o[n] + oSpace[n] + "</del>";
2250 | 				}
2251 | 			}
2252 | 
2253 | 			for ( i = 0; i < out.n.length; i++ ) {
2254 | 				if (out.n[i].text == null) {
2255 | 					str += "<ins>" + out.n[i] + nSpace[i] + "</ins>";
2256 | 				}
2257 | 				else {
2258 | 					// `pre` initialized at top of scope
2259 | 					pre = "";
2260 | 
2261 | 					for ( n = out.n[i].row + 1; n < out.o.length && out.o[n].text == null; n++ ) {
2262 | 						pre += "<del>" + out.o[n] + oSpace[n] + "</del>";
2263 | 					}
2264 | 					str += " " + out.n[i].text + nSpace[i] + pre;
2265 | 				}
2266 | 			}
2267 | 		}
2268 | 
2269 | 		return str;
2270 | 	};
2271 | }());
2272 | 
2273 | // For browser, export only select globals
2274 | if ( typeof window !== "undefined" ) {
2275 | 	extend( window, QUnit.constructor.prototype );
2276 | 	window.QUnit = QUnit;
2277 | }
2278 | 
2279 | // For CommonJS environments, export everything
2280 | if ( typeof module !== "undefined" && module.exports ) {
2281 | 	module.exports = QUnit;
2282 | }
2283 | 
2284 | 
2285 | // Get a reference to the global object, like window in browsers
2286 | }( (function() {
2287 | 	return this;
2288 | })() ));
2289 | 


--------------------------------------------------------------------------------