DIR : /home/kozerus/public_html/pn/uize/site-source/js/Uize/Test/Uize/Class/mChildObjectEventBindings.js

/home/kozerus/public_html/pn/uize/site-source/js/Uize/Test/Uize/Class

/*______________
|       ______  |   U I Z E    J A V A S C R I P T    F R A M E W O R K
|     /      /  |   ---------------------------------------------------
|    /    O /   |    MODULE : Uize.Test.Uize.Class.mChildObjectEventBindings Class
|   /    / /    |
|  /    / /  /| |    ONLINE : http://www.uize.com
| /____/ /__/_| | COPYRIGHT : (c)2014-2016 UIZE
|          /___ |   LICENSE : Available under MIT License or GNU General Public License
|_______________|             http://www.uize.com/license.html
*/

/* Module Meta Data
	type: Test
	importance: 3
	codeCompleteness: 100
	docCompleteness: 100
*/

/*?
	Introduction
		The =Uize.Test.Uize.Class.mChildObjectEventBindings= module defines a suite of unit tests for the =Uize.Class.mChildObjectEventBindings= mixin module.

		*DEVELOPERS:* `Ben Ilegbodu`, original code contributed by `Zazzle Inc.`
*/

Uize.module ({
	name:'Uize.Test.Uize.Class.mChildObjectEventBindings',
	superclass:'Uize.Test.Class',
	required:[
		'Uize.Comm',
		'Uize.Test.Widget',
		'Uize.Widget'
	],
	builder:function (_superclass) {
		'use strict';

		var
			_Uize = Uize,

			_eventBindingsFunctionName = 'eventBindings',

			_global = Uize.global(),
			_processArrayAsync = Uize.Comm.processArrayAsync,
			_defaultHandler = function(_event, _source) { _event.handler.call(this, _event, _source) },
			_defaultChangedHandler = function(_event, _source) { this.get(_event.name.slice(8)).call(this, _event, _source) },
			_originalWindow,

			_class = _superclass.subclass({
				moduleToTest:'Uize.Class.mChildObjectEventBindings'
			})
		;

		function _getMockDomNode(_name) { return Uize.Test.Widget.getMockDomNode(_name) }

		function _getTestWidgetClass(_eventBindings, _children) {
			return Uize.Widget.subclass (
				_Uize.copyInto(
					{
						mixins:Uize.Class.mChildObjectEventBindings,
						childObjectEventBindings:{
							declaration:_eventBindingsFunctionName,
							instanceProperty:'children',
							addedInstanceProperty:'addedChildren',
							additionalTypes:{
								dom:{
									namePrefix:'#',
									wireWhenever:'wired',
									getObjectMethod:'getNode',
									wireObjectMethod:'wireNode',
									defaultFireIf:'enabledInherited,!busyInherited'
								}
							}
						},
						omegastructor:function() {
							this.addChildren(Uize.lookup(_children, {widgetClass:Uize.Widget}));
						}
					},
					_Uize.pairUp(_eventBindingsFunctionName, _eventBindings)
				)
			);
		}

		function _getTestWidgetClassInstance(_eventBindings, _children, _nodes, _instanceProperties) {
			return _getTestWidgetClass(_eventBindings, _children)(
				Uize.copyInto(
					{
						nodeMap:Uize.map(
							Uize.lookup(_nodes),
							function(_value, _node) { return _getMockDomNode(_node) }
						)
					},
					_instanceProperties
				)
			);
		}

		function _generateTest(_title, _eventBindingsShorthand, _eventBindingsVerbose, _wiredEvents, _deferredChildren) {
			function _generateSyntaxTests(_isVerbose) {
				var _eventBindings = _isVerbose ? _eventBindingsVerbose : _eventBindingsShorthand;

				function _getSyntaxTestWidgetClass(_children) {
					return _getTestWidgetClass(_eventBindings, _children);
				}

				function _getSyntaxTestWidgetClassInstance(_children, _nodes, _instanceProperties) {
					return _getTestWidgetClassInstance(_eventBindings, _children, _nodes, _instanceProperties);
				}

				function _generateFireTests(_type) {
					var _fireEventMethodName = _type == 'node' ? 'triggerEvent' : 'fire';

					function _generateFireTest(_expectFunc, _instanceProperties) {
						return function(_continue) {
							if (!_wiredEvents || Uize.isEmpty(_wiredEvents[_type]))
								return true;

							var
								_typeEvents = _wiredEvents[_type],
								_names = _type == 'self' ? ['self'] : Uize.keys(_typeEvents),
								_testWidgetClassInstance = _getSyntaxTestWidgetClassInstance(
									_type == 'child' ? _names : undefined,
									_type == 'node' ? _names : undefined,
									_instanceProperties
								),
								_fail = function() { _continue(true) }
							;
							_processArrayAsync(
								_names,
								function(_objectName, _nextObjectFunc) {
									_processArrayAsync(
										(_type == 'self' ? _wiredEvents : _typeEvents)[_objectName],
										function(_eventName, _nextEventFunc) {
											var
												_objectToFireOn = _type == 'self'
													? _testWidgetClassInstance
													: (_type == 'child'
														? _testWidgetClassInstance.children[_objectName]
														: _testWidgetClassInstance.getNode(_objectName)
													),
												_fireEvent = function(_fireHandler) {
													_type == 'self' && !_eventName.indexOf('Changed.')
														? _objectToFireOn.set(
															_eventName.slice(8),
															_fireHandler
														)
														: _objectToFireOn[_fireEventMethodName]({
															name:_eventName,
															handler:_fireHandler
														})
													;
												},
												_verifyEventFired = function(_nextFunc) {
													var _handlerNotCalledTimeout = setTimeout(function() { _continue(false) }, 0); // timeout for if handler isn't called
													_fireEvent(
														function(_event, _source) {
															clearTimeout(_handlerNotCalledTimeout);
															_expectFunc.call(
																this,
																{
																	_nextFunc:_nextFunc,
																	_testWidgetClassInstance:_testWidgetClassInstance,
																	_eventName:_eventName,
																	_event:_event,
																	_source:_source,
																	_fail:_fail,
																	_firedObject:_objectToFireOn
																}
															);
														}
													);
												},
												_verifyEventNotFired = function(_nextFunc) {
													var
														_handlerNotCalledTimeout = setTimeout(_nextFunc, 0)// timeout for when handler isn't called
													;

													// Verify event is not fired
													_fireEvent(
														function() { // handler shouldn't get called
															clearTimeout(_handlerNotCalledTimeout);
															_continue(false);
														}
													);
												},
												_deferredChildrenForEventObject = !Uize.isEmpty(_deferredChildren)
													&& (_type == 'self'
														? _deferredChildren.self
														: (_deferredChildren[_type] && _deferredChildren[_type][_objectName])
													),
												_deferredChildrenForEvent = _deferredChildrenForEventObject && _deferredChildrenForEventObject[_eventName]
											;

											_type == 'node' && _testWidgetClassInstance.met('wired');

											if (Uize.isEmpty(_deferredChildrenForEvent)) {
												_verifyEventFired(_nextEventFunc);
											}
											else {
												_processArrayAsync(
													_deferredChildrenForEvent,
													function(_deferredChildName, _nextDeferredChildFunc) {
														_verifyEventNotFired(
															function() {
																// Add deferred child
																_testWidgetClassInstance.addChild(_deferredChildName, Uize.Widget);

																_nextDeferredChildFunc();
															}
														);
													},
													function() {
														// Verify event is fired
														_verifyEventFired(
															function() {
																// Remove a random child
																_testWidgetClassInstance.removeChild(
																	_deferredChildrenForEvent[
																		Math.floor(Math.random() * _deferredChildrenForEvent.length)
																	]
																);

																// Verify event is not fired & then move onto next event
																_verifyEventNotFired(_nextEventFunc);
															}
														);
													}
												);
											}
										},
										_nextObjectFunc
									);
								},
								function() { _continue(true) }
							);
						};
					}

					return {
						title:Uize.capFirstChar(_type) + ' events are successfully fired',
						test:[
							{
								title:'Handler is called',
								test:_generateFireTest(
									function(_data) { _data._nextFunc() }
								)
							},
							{
								title:'"this" context is widget',
								test:_generateFireTest(
									function(_data) {
										this == _data._testWidgetClassInstance
											? _data._nextFunc()
											: _data._fail()
										;
									}
								)
							},
							{
								title:'First argument is event object',
								test:_generateFireTest(
									function(_data) {
										_data._event.name == _data._eventName
											? _data._nextFunc()
											: _data._fail()
										;
									}
								)
							},
							{
								title:'Second argument is source object',
								test:_generateFireTest(
									function(_data) {
										_data._source == _data._firedObject
											? _data._nextFunc()
											: _data._fail()
										;
									}
								)
							}
						]
					};
				}

				return {
					title:(_isVerbose ? 'Verbose' : 'Shorthand') + ' Syntax',
					test:[
						{
							title:'Widget class is a function (not null)',
							test:function() { return this.expectFunction(_getSyntaxTestWidgetClass()) }
						},
						{
							title:'Widget instance is an object (not null)',
							test:function() { return this.expectObject(_getSyntaxTestWidgetClassInstance()) }
						},
						_generateFireTests('self'),
						_generateFireTests('child'),
						{
							title:'Node events do not fire before widget is wired',
							test:function(_continue) {
								if (!_wiredEvents || Uize.isEmpty(_wiredEvents.node))
									return true;

								var
									_nodeNames = Uize.keys(_wiredEvents.node),
									_testWidgetClassInstance = _getSyntaxTestWidgetClassInstance(null, _nodeNames)
								;
								_processArrayAsync(
									_nodeNames,
									function(_nodeName, _nextNodeFunc) {
										_processArrayAsync(
											_wiredEvents.node[_nodeName],
											function(_eventName, _nextEventFunc) {
												// The handler shouldn't be called which means we won't continue to the next node,
												// so, set up a timeout to continue on if the handler is not called.
												var _notFiredTimeout = setTimeout(_nextEventFunc, 0);
												_testWidgetClassInstance.getNode(_nodeName).triggerEvent({
													name:_eventName,
													handler:function() {
														clearTimeout(_notFiredTimeout);
														_continue(false); // we should never get here
													}
												});
											},
											_nextNodeFunc
										);
									},
									function() { _continue(true) }
								);
							}
						},
						_generateFireTests('node')
					]
				};
			}

			return {
				title:_title,
				test:[
					_generateSyntaxTests(),
					_generateSyntaxTests(true)
				]
			};
		}

		return _class.declare({
			set:{
				test:[
					{
						title:'Set the global window object',
						test:function() {
							_originalWindow = _global.window;
							_global.window = _global;  // For Uize.Dom.Basics
							return true;
						}
					},
					Uize.Test.requiredModulesTest ([
						'Uize.Widget',
						'Uize.Class.mChildObjectEventBindings'
					]),
					{
						title:'Empty bindings',
						test:[
							_generateTest('When no declarative event bindings are specified, no events are wired'),
							_generateTest('When empty event bindings is specified, no events are wired')
						]
					},
					{
						title:'Child Events',
						test:[
							_generateTest(
								'When a single child with a single event binding is declared, only that child event is bound',
								{
									'foo:Click':_defaultHandler
								},
								{
									foo:{
										Click:_defaultHandler
									}
								},
								{
									child:{
										foo:['Click']
									}
								}
							),
							_generateTest(
								'When a single child with multiple event bindings are declared, only the events for that child are bound',
								Uize.lookup(
									[
										'foo:Click',
										'foo:Changed.value',
										'foo:Changed.bar'
									],
									_defaultHandler
								),
								{
									foo:{
										Click:_defaultHandler,
										'Changed.value':_defaultHandler,
										'Changed.bar':_defaultHandler
									}
								},
								{
									child:{
										foo:['Click', 'Changed.value', 'Changed.bar']
									}
								}
							),
							_generateTest(
								'When a multiple children each with a single event binding are declared, only the one event for each child is bound',
								Uize.lookup(
									[
										'foo:Changed.bar',
										'lorem:Changed.ipsum'
									],
									_defaultHandler
								),
								{
									foo:{
										'Changed.bar':_defaultHandler
									},
									lorem:{
										'Changed.ipsum':_defaultHandler
									}
								},
								{
									child:{
										foo:['Changed.bar'],
										lorem:['Changed.ipsum']
									}
								}
							),
							_generateTest(
								'When a multiple children each with multiple event bindings are declared, only the events for those children are bound',
								Uize.lookup(
									[
										'foo:Click',
										'lorem:Changed.ipsum',
										'foo:Changed.value',
										'lorem:Changed.dolor',
										'foo:Changed.bar',
										'a:Changed.b',
										'a:c',
										'a:d',
										'a:Changed.e'
									],
									_defaultHandler
								),
								{
									foo:{
										Click:_defaultHandler,
										'Changed.value':_defaultHandler,
										'Changed.bar':_defaultHandler
									},
									lorem:{
										'Changed.ipsum':_defaultHandler,
										'Changed.dolor':_defaultHandler
									},
									a:{
										'Changed.b':_defaultHandler,
										'c':_defaultHandler,
										'd':_defaultHandler,
										'Changed.e':_defaultHandler
									}
								},
								{
									child:{
										foo:['Click', 'Changed.value', 'Changed.bar'],
										lorem:['Changed.ipsum', 'Changed.dolor'],
										a:['Changed.b', 'c', 'd', 'Changed.e']
									}
								}
							),
							{
								title:'Required Children',
								test:[
									_generateTest(
										'When required is left unspecified for a child event binding, the event is fired normally (w/ no errors)',
										{
											'foo:Click':{
													handler:_defaultHandler
												}
										},
										{
											foo:{
												Click:{
													handler:_defaultHandler
												}
											}
										},
										{
											child:{
												foo:['Click']
											}
										}
									),
									_generateTest(
										'When a single required child for a child event binding is declared, the event is not fired until the child is added',
										{
											'foo:Click':{
													handler:_defaultHandler,
													required:['baz']
												}
										},
										{
											foo:{
												Click:{
													handler:_defaultHandler,
													required:['baz']
												}
											}
										},
										{
											child:{
												foo:['Click']
											}
										},
										{
											child:{
												foo:{
													Click:['baz']
												}
											}
										}
									),
									_generateTest(
										'When multiple required children for a child event binding are declared, the event is not fired until all the children are added (and order doesn\'t matter)',
										{
											'foo:Click':{
												handler:_defaultHandler,
												required:['baz', 'bat', 'baf']
											}
										},
										{
											foo:{
												Click:{
													handler:_defaultHandler,
													required:['baz', 'bat', 'baf']
												}
											}
										},
										{
											child:{
												foo:['Click']
											}
										},
										{
											child:{
												foo:{
													Click:['bat', 'baf', 'baz']
												}
											}
										}
									)
								]
							},
							{
								title:'Conditional firing (fireIf)',
								test:Uize.push(
									Uize.map(
										[
											{
												title:'When fireIf is undefined and widget is disabled, child event is fired',
												state:{enabled:false}
											},
											{
												title:'When fireIf is undefined and widget is busy, child event is fired',
												state:{busy:true}
											},
											{
												title:'When fireIf evaluates to true, child event is fired',
												fireIf:'foo',
												state:{foo:true}
											}
										],
										function(_testInfo) {
											return {
												title:_testInfo.title,
												test:function(_continue) {
													var
														_testWidgetClassInstance = _getTestWidgetClassInstance(
															{
																'foo:Click':{
																	handler:function() {
																		clearTimeout(_notFiredTimeout);
																		_continue(true);
																	},
																	fireIf:_testInfo.fireIf
																}
															},
															['foo'],
															null,
															_testInfo.state
														),
														_notFiredTimeout
													;

													_notFiredTimeout = setTimeout(
														function() { _continue(false) },
														0
													);

													_testWidgetClassInstance.children.foo.fire('Click');
												}
											};
										}
									),
									[
										{
											title:'When fireIf evaluates to false, child event isn\'t fired',
											test:function(_continue) {
												var
													_testWidgetClassInstance = _getTestWidgetClassInstance(
														{
															'foo:Click':{
																handler:function() {
																	clearTimeout(_notFiredTimeout);
																	_continue(false);
																},
																fireIf:'foo'
															}
														},
														['foo'],
														null
													),
													_notFiredTimeout
												;

												// fire child widget event (shouldn't actually be handled by widget)
												_testWidgetClassInstance.children.foo.fire('Click');

												_notFiredTimeout = setTimeout(
													function() { _continue(true) },
													0
												);
											}
										}
									]
								)
							}
						]
					},
					{
						title:'Self Events',
						test:[
							_generateTest(
								'When a single event binding is declared, only that event is bound',
								Uize.lookup(
									[
										':Click'
									],
									_defaultHandler
								),
								{
									'':{
										Click:_defaultHandler
									}
								},
								{
									self:['Click']
								}
							),
							_generateTest(
								'When multiple events binding are declared, only those events are bound',
								{
									':Click':_defaultHandler,
									':Changed.value':_defaultChangedHandler
								},
								{
									'':{
										Click:_defaultHandler,
										'Changed.value':_defaultChangedHandler
									}
								},
								{
									self:['Click', 'Changed.value']
								}
							),
							_generateTest(
								'When a single required child for a self event binding is declared, the event is not fired until the child is added',
								{
									':Click':{
										handler:_defaultHandler,
										required:['baz']
									}
								},
								{
									'':{
										Click:{
											handler:_defaultHandler,
											required:['baz']
										}
									}
								},
								{
									self:['Click']
								},
								{
									self:{
										Click:['baz']
									}
								}
							),
							_generateTest(
								'When multiple required children for a self event binding are declared, the event is not fired until all the children are added (and order doesn\'t matter)',
								{
									':Click':{
										handler:_defaultHandler,
										required:['baz', 'bat', 'baf']
									}
								},
								{
									'':{
										Click:{
											handler:_defaultHandler,
											required:['baz', 'bat', 'baf']
										}
									}
								},
								{
									self:['Click']
								},
								{
									self:{
										Click:['bat', 'baf', 'baz']
									}
								}
							),
							{
								title:'Conditional firing (fireIf)',
								test:Uize.push(
									Uize.map(
										[
											{
												title:'When fireIf is undefined and widget is disabled, self event is fired',
												state:{enabled:false}
											},
											{
												title:'When fireIf is undefined and widget is busy, self event is fired',
												state:{busy:true}
											},
											{
												title:'When fireIf evaluates to true, self event is fired',
												fireIf:'foo',
												state:{foo:true}
											}
										],
										function(_testInfo) {
											return {
												title:_testInfo.title,
												test:function(_continue) {
													var
														_testWidgetClassInstance = _getTestWidgetClassInstance(
															{
																':Click':{
																	handler:function() {
																		clearTimeout(_notFiredTimeout);
																		_continue(true);
																	},
																	fireIf:_testInfo.fireIf
																}
															},
															null,
															null,
															_testInfo.state
														),
														_notFiredTimeout
													;

													_notFiredTimeout = setTimeout(
														function() { _continue(false) },
														0
													);

													_testWidgetClassInstance.fire('Click');
												}
											};
										}
									),
									[
										{
											title:'When fireIf evaluates to false, self event isn\'t fired',
											test:function(_continue) {
												var
													_testWidgetClassInstance = _getTestWidgetClassInstance(
														{
															':Click':{
																handler:function() {
																	clearTimeout(_notFiredTimeout);
																	_continue(false);
																},
																fireIf:'foo'
															}
														},
														null,
														null
													),
													_notFiredTimeout
												;

												// fire child widget event (shouldn't actually be handled by widget)
												_testWidgetClassInstance.fire('Click');

												_notFiredTimeout = setTimeout(
													function() { _continue(true) },
													0
												);
											}
										}
									]
								)
							}
						]
					},
					{
						title:'Node Events',
						test:[
							_generateTest(
								'When a single node with a single event binding is declared, only that node event is bound',
								Uize.lookup(
									[
										'#foo:click'
									],
									_defaultHandler
								),
								{
									'#foo':{
										click:_defaultHandler
									}
								},
								{
									node:{
										foo:['click']
									}
								}
							),
							_generateTest(
								'When a single node with multiple event bindings are declared, only the events for that node are bound',
								Uize.lookup(
									[
										'#foo:click',
										'#foo:mousemove',
										'#foo:change'
									],
									_defaultHandler
								),
								{
									'#foo':{
										click:_defaultHandler,
										mousemove:_defaultHandler,
										change:_defaultHandler
									}
								},
								{
									node:{
										foo:['click', 'mousemove', 'change']
									}
								}
							),
							_generateTest(
								'When a multiple nodes each with a single event binding are declared, only the one event for each node is bound',
								Uize.lookup(
									[
										'#foo:load',
										'#lorem:unload'
									],
									_defaultHandler
								),
								{
									'#foo':{
										load:_defaultHandler
									},
									'#lorem':{
										unload:_defaultHandler
									}
								},
								{
									node:{
										foo:['load'],
										lorem:['unload']
									}
								}
							),
							_generateTest(
								'When a multiple nodes each with multiple event bindings are declared, only the events for those nodes are bound',
								Uize.lookup(
									[
										'#a:focus',
										'#foo:click',
										'#lorem:keypress',
										'#a:change',
										'#foo:mouseover',
										'#a:blur',
										'#foo:keydown',
										'#lorem:keyup',
										'#a:load'
									],
									_defaultHandler
								),
								{
									'#foo':{
										click:_defaultHandler,
										mouseover:_defaultHandler,
										keydown:_defaultHandler
									},
									'#lorem':{
										keypress:_defaultHandler,
										keyup:_defaultHandler
									},
									'#a':{
										load:_defaultHandler,
										blur:_defaultHandler,
										focus:_defaultHandler,
										change:_defaultHandler
									}
								},
								{
									node:{
										foo:['click', 'mouseover', 'keydown'],
										lorem:['keypress', 'keyup'],
										a:['load', 'blur', 'focus', 'change']
									}
								}
							),
							_generateTest(
								'When root node with a single event binding is declared, only that node event is bound',
								Uize.lookup(
									[
										'#:click'
									],
									_defaultHandler
								),
								{
									'#':{
										click:_defaultHandler
									}
								},
								{
									node:{
										'':['click']
									}
								}
							),
							_generateTest(
								'When root node with multiple event bindings are declared, only the events for the node are bound',
								Uize.lookup(
									[
										'#:click',
										'#:mousemove'
									],
									_defaultHandler
								),
								{
									'#':{
										click:_defaultHandler,
										mousemove:_defaultHandler
									}
								},
								{
									node:{
										'':['click', 'mousemove']
									}
								}
							),
							{
								title:'Required children',
								test:[
									_generateTest(
										'When required is left unspecified for a node event binding, the event is fired normally (w/ no errors)',
										{
											'#foo:click':{
												handler:_defaultHandler
											}
										},
										{
											'#foo':{
												click:{
													handler:_defaultHandler
												}
											}
										},
										{
											node:{
												foo:['click']
											}
										}
									),
									_generateTest(
										'When a single required child for a node event binding is declared, the event is not fired until the child is added',
										{
											'#foo:click':{
												handler:_defaultHandler,
												required:['baz']
											}
										},
										{
											'#foo':{
												click:{
													handler:_defaultHandler,
													required:['baz']
												}
											}
										},
										{
											node:{
												foo:['click']
											}
										},
										{
											node:{
												foo:{
													click:['baz']
												}
											}
										}
									),
									_generateTest(
										'When multiple required children for a node event binding are declared, the event is not fired until all the children are added (and order doesn\'t matter)',
										{
											'#foo:click':{
												handler:_defaultHandler,
												required:['baz', 'bat', 'baf']
											}
										},
										{
											'#foo':{
												click:{
													handler:_defaultHandler,
													required:['baz', 'bat', 'baf']
												}
											}
										},
										{
											node:{
												foo:['click']
											}
										},
										{
											node:{
												foo:{
													click:['bat', 'baf', 'baz']
												}
											}
										}
									)
								]
							},
							{
								title:'Conditional Firing (fireIf)',
								test:Uize.push(
									Uize.map(
										[
											{
												title:'When fireIf is unspecified, the wired DOM event doesn\'t fire if busy or disabled'
											},
											{
												title:'When fireIf is null, the wired DOM event doesn\'t fire if busy or disabled',
												fireIf:null
											},
											{
												title:'When fireIf is undefined, the wired DOM event doesn\'t fire if busy or disabled',
												fireIf:undefined
											},
											{
												title:'When fireIf is empty string, the wired DOM event doesn\'t fire if busy or disabled',
												fireIf:''
											}
										],
										function (_eventBindingsInfo) {
											return {
												title:_eventBindingsInfo.title,
												test:function(_continue) {
													var
														_testWidgetClassInstance = _getTestWidgetClassInstance(
															{
																'#myNode:click':Uize.copyInto(
																	{
																		handler:function() {
																			clearTimeout(_notFiredTimeout);
																			_continue(false);
																		}
																	},
																	_eventBindingsInfo.fireIf ? {fireIf:_eventBindingsInfo.fireIf} : null
																)
															},
															null,
															['myNode']
														),
														_notFiredTimeout
													;

													_testWidgetClassInstance.met('wired');

													// set widget to busy or disabled
													_testWidgetClassInstance.set(
														Math.floor(Math.random() * 2)
															? {enabled:false}
															: {busy:true}
													);

													// fire DOM node event (shouldn't actually be handled by widget)
													_testWidgetClassInstance.getNode('myNode').triggerEvent({
														name:'click'
													});

													_notFiredTimeout = setTimeout(
														function() { _continue(true) },
														0
													);
												}
											};
										}
									),
									[
										{
											title:'When fireIf is specified, the wired DOM event doesn\'t fire if the condition hasn\'t been met',
											test:function(_continue) {
												var
													_testWidgetClassInstance = _getTestWidgetClassInstance(
														{
															'#myNode:click':{
																handler:function() {
																	clearTimeout(_notFiredTimeout);
																	_continue(false);
																},
																fireIf:'foo'
															}
														},
														null,
														['myNode']
													),
													_notFiredTimeout
												;

												_testWidgetClassInstance.met('wired');

												// fire DOM node event (shouldn't actually be handled by widget)
												_testWidgetClassInstance.getNode('myNode').triggerEvent({
													name:'click'
												});

												_notFiredTimeout = setTimeout(
													function() { _continue(true) },
													0
												);
											}
										},
										{
											title:'When fireIf is specified, the wired DOM event fires when the condition has been met',
											test:function(_continue) {
												var
													_testWidgetClassInstance = _getTestWidgetClassInstance(
														{
															'#myNode:click':{
																handler:function() {
																	clearTimeout(_notFiredTimeout);
																	_continue(true);
																},
																fireIf:'foo'
															}
														},
														null,
														['myNode']
													),
													_notFiredTimeout
												;

												_testWidgetClassInstance.met('wired');
												_testWidgetClassInstance.met('foo');

												_notFiredTimeout = setTimeout(
													function() { _continue(false) },
													0
												);

												// fire DOM node event (shouldn't actually be handled by widget)
												_testWidgetClassInstance.getNode('myNode').triggerEvent({
													name:'click'
												});
											}
										}
									]
								)
							}
						]
					},
					{
						title:'Potential Collision Events',
						test:[
							_generateTest(
								'When events for a child and node with the same name are declared, the proper events are bound',
								Uize.lookup(
									[
										'foo:Click',
										'foo:Changed.bar',
										'#foo:click',
										'#foo:unload',
										'#lorem:change',
										'lorem:Changed.ipsum'
									],
									_defaultHandler
								),
								{
									'foo':{
										Click:_defaultHandler,
										'Changed.bar':_defaultHandler
									},
									'#foo':{
										click:_defaultHandler,
										unload:_defaultHandler
									},
									'#lorem':{
										change:_defaultHandler
									},
									'lorem':{
										'Changed.ipsum':_defaultHandler
									}
								},
								{
									child:{
										'foo':['Click', 'Changed.bar'],
										'lorem':['Changed.ipsum']
									},
									node:{
										'foo':['click', 'unload'],
										'lorem':['change']
									}
								}
							),
							_generateTest(
								'When events for a self and root node with the same name are declared, the proper events are bound',
								Uize.copyInto(
									Uize.lookup(
										[
											':Click',
											'#:click',
											'#:unload'
										],
										_defaultHandler
									),
									{
										':Changed.bar':_defaultChangedHandler
									}
								),
								{
									'':{
										Click:_defaultHandler,
										'Changed.bar':_defaultChangedHandler
									},
									'#':{
										click:_defaultHandler,
										unload:_defaultHandler
									}
								},
								{
									self:['Click', 'Changed.bar'],
									node:{
										'':['click', 'unload']
									}
								}
							)
						]
					},
					{
						title:'All Event Types',
						test:[
							_generateTest(
								'When all 3 types of events are declared, some with required blocks, the proper events are bound and fire at the right time',
								{
									':Click':{
										handler:_defaultHandler,
										required:['green']
									},
									':Changed.bar':_defaultChangedHandler,
									'#:click':_defaultHandler,
									'#:unload':_defaultHandler,
									'#lorem:change':{
										handler:_defaultHandler,
										required:['blah']
									},
									'lorem:Changed.ipsum':_defaultHandler,
									'foo:Click':_defaultHandler,
									'foo:Changed.bar':{
										handler:_defaultHandler,
										required:['hiya']
									},
									'#foo:click':_defaultHandler,
									'#foo:unload':_defaultHandler,
									'#a:load':_defaultHandler,
									'#a:blur':{
										handler:_defaultHandler,
										required:['red','blue']
									},
									'#a:focus':_defaultHandler,
									'#a:change':_defaultHandler
								},
								{
									'':{
										Click:{
											handler:_defaultHandler,
											required:['green']
										},
										'Changed.bar':_defaultChangedHandler
									},
									'#':{
										click:_defaultHandler,
										unload:_defaultHandler
									},
									'#lorem':{
										change:{
											handler:_defaultHandler,
											required:['blah']
										}
									},
									'lorem':{
										'Changed.ipsum':_defaultHandler
									},
									'foo':{
										Click:_defaultHandler,
										'Changed.bar':{
											handler:_defaultHandler,
											required:['hiya']
										}
									},
									'#foo':{
										click:_defaultHandler,
										unload:_defaultHandler
									},
									'#a':{
										load:_defaultHandler,
										blur:{
											handler:_defaultHandler,
											required:['red','blue']
										},
										focus:_defaultHandler,
										change:_defaultHandler
									}
								},
								{
									self:['Click', 'Changed.bar'],
									child:{
										'foo':['Click', 'Changed.bar'],
										'lorem':['Changed.ipsum']
									},
									node:{
										'':['click', 'unload'],
										'foo':['click', 'unload'],
										'lorem':['change'],
										a:['load', 'blur', 'focus', 'change']
									}
								},
								{
									node:{
										lorem:{
											change:['blah']
										},
										a:{
											blur:['red','blue']
										}
									},
									child:{
										foo:{
											'Changed.bar':['hiya']
										}
									},
									self:{
										Click:['green']
									}
								}
							)
						]
					},
					{
						title:'Edge cases',
						test:[
							{
								title:'When a bound child is removed, a fired event on the child is properly handled (no errors & not fired on parent)',
								test:function(_continue) {
									var
										_widget = _getTestWidgetClassInstance(
											{
												'childA:Click':function() { _continue(false) }
											},
											['childA']
										),
										_childToRemove = _widget.children.childA // keep reference so we'll have it after removal
									;

									_widget.removeChild(_childToRemove);

									// fire child event (shouldn't actually be handled by the parent)
									_childToRemove.fire('Click');

									setTimeout(
										function() { _continue(true) },
										0
									);
								}
							},
							{
								title:'When a bound child is removed, and a new same-named child is re-added, a child event is handled by the parent',
								test:function(_continue) {
									var
										_widget = _getTestWidgetClassInstance(
											{
												'childA:Click':function() {
													clearTimeout(_failTimeout);
													_continue(true);
												}
											},
											['childA']
										),
										_failTimeout
									;

									// remove child
									_widget.removeChild('childA');

									// add new same-named child
									var _newChild = _widget.addChild('childA', Uize.Widget);

									// this shouldn't happen because the handler should be rebound when new child was added
									_failTimeout = setTimeout(
										function() { _continue(false) },
										0
									);

									_newChild.fire('Click'); // fire child event (should be handled by parent)
								}
							},
							{
								title:'When a subclass declares the same child/event combination, the base class\' handler is called',
								test:function(_continue) {
									var
										_WidgetClass = _getTestWidgetClass(
											{
												'childA:Click':function() {
													clearTimeout(_failTimeout);
													_continue(true);
												}
											},
											['childA']
										),
										_WidgetSubclass = _WidgetClass.subclass(
											_Uize.pairUp(
												_eventBindingsFunctionName,
												{
													'childA:Click':_Uize.nop
												}
											)
										),
										_failTimeout
									;

									// this shouldn't happen because the base class' handler should be called
									_failTimeout = setTimeout(
										function() { _continue(false) },
										0
									);

									_WidgetSubclass().children.childA.fire('Click');
								}
							}
						]
					},
					{
						title:'Restore the global window object',
						test:function() {
							_global.window = _originalWindow;
							return true;
						}
					}
				]
			}
		});
	}
});