github-migration
/
prototype
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
prototype/test/unit/event.html

269 lines
9.6 KiB
HTML
Raw Normal View History

prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Prototype Unit test file</title>
<meta http-equiv="content-type" content="text/html; charset=utf-8" />
<script src="../../dist/prototype.js" type="text/javascript"></script>
<script src="../lib/unittest.js" type="text/javascript"></script>
<link rel="stylesheet" href="../test.css" type="text/css" />
<style type="text/css" media="screen">
/* <![CDATA[ */
#testcss1 { font-size:11px; color: #f00; }
#testcss2 { font-size:12px; color: #0f0; display: none; }
/* ]]> */
</style>
</head>
<body>
<h1>Prototype Unit test file</h1>
<p>
Test of event handling code in event.js
</p>
<!-- Log output -->
<div id="testlog"> </div>
<div id="outer" style="display: none">
<p id="inner">One two three <span id="span">four</span></p>
</div>
<!-- Tests follow -->
<script type="text/javascript" language="javascript" charset="utf-8">
// <![CDATA[
prototype: Add document.loaded, a boolean that is set to true once dom:loaded is fired.
2008-01-04 00:30:53 +00:00
var eventResults = { }, documentLoaded = document.loaded;
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
new Test.Unit.Runner({
// test firing an event and observing it on the element it's fired from
testCustomEventFiring: function() { with(this) {
var span = $("span"), fired = false, observer = function(event) {
assertEqual(span, event.element());
assertEqual(1, event.memo.index);
fired = true;
}
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened", { index: 1 });
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(fired);
fired = false;
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.fire("test:somethingElseHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(!fired);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.stopObserving("test:somethingHappened", observer);
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(!fired);
}},
// test firing an event and observing it on a containing element
testCustomEventBubbling: function() { with(this) {
var span = $("span"), outer = $("outer"), fired = false, observer = function(event) {
assertEqual(span, event.element());
fired = true;
};
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
outer.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(fired);
fired = false;
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.fire("test:somethingElseHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(!fired);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
outer.stopObserving("test:somethingHappened", observer);
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(!fired);
}},
testCustomEventCanceling: function() { with(this) {
var span = $("span"), outer = $("outer"), inner = $("inner");
var fired = false, stopped = false;
function outerObserver(event) {
fired = span == event.element();
}
function innerObserver(event) {
event.stop();
stopped = true;
}
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
inner.observe("test:somethingHappened", innerObserver);
outer.observe("test:somethingHappened", outerObserver);
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(stopped);
assert(!fired);
fired = stopped = false;
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
inner.stopObserving("test:somethingHappened", innerObserver);
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assert(!stopped);
assert(fired);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
outer.stopObserving("test:somethingHappened", outerObserver);
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
}},
testEventObjectIsExtended: function() { with(this) {
prototype: Event.fire/Element#fire now returns the newly-fired event instead of the event's target element.
2007-08-11 18:46:02 +00:00
var span = $("span"), event, observedEvent, observer = function(e) { observedEvent = e };
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
event = span.fire("test:somethingHappened");
prototype: Event.fire/Element#fire now returns the newly-fired event instead of the event's target element.
2007-08-11 18:46:02 +00:00
assertEqual(event, observedEvent);
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(Event.Methods.stop.methodize(), event.stop);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.stopObserving("test:somethingHappened", observer);
prototype: Ensure Event#fire always returns an extended event. Make Event#findElement's expression argument optional. Perf optimizations for Event#findElement.
2007-11-13 21:48:09 +00:00
event = span.fire("test:somethingHappenedButNoOneIsListening");
assertEqual(Event.Methods.stop.methodize(), event.stop);
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
}},
prototype: Event handlers are now bound to the observed element, not the event's target element.
2007-08-17 16:17:26 +00:00
testEventObserversAreBoundToTheObservedElement: function() { with(this) {
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
var span = $("span"), target, observer = function() { target = this };
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened");
span.stopObserving("test:somethingHappened", observer);
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(span, target);
target = null;
var outer = $("outer");
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
outer.observe("test:somethingHappened", observer);
span.fire("test:somethingHappened");
outer.stopObserving("test:somethingHappened", observer);
prototype: Event handlers are now bound to the observed element, not the event's target element.
2007-08-17 16:17:26 +00:00
assertEqual(outer, target);
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
}},
testMultipleCustomEventObserversWithTheSameHandler: function() { with(this) {
var span = $("span"), count = 0, observer = function() { count++ };
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
span.observe("test:somethingElseHappened", observer);
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(1, count);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.fire("test:somethingElseHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(2, count);
}},
testStopObservingWithoutArguments: function() { with(this) {
var span = $("span"), count = 0, observer = function() { count++ };
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
span.observe("test:somethingElseHappened", observer);
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
span.stopObserving();
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(0, count);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.fire("test:somethingElseHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(0, count);
}},
testStopObservingWithoutHandlerArgument: function() { with(this) {
var span = $("span"), count = 0, observer = function() { count++ };
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
span.observe("test:somethingElseHappened", observer);
span.stopObserving("test:somethingHappened");
span.fire("test:somethingHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(0, count);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.fire("test:somethingElseHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(1, count);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.stopObserving("test:somethingElseHappened");
span.fire("test:somethingElseHappened");
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
assertEqual(1, count);
}},
prototype: Make sure event handlers and their wrappers are removed from the cache by Event.stopObserving.
2007-08-09 23:45:59 +00:00
testStopObservingRemovesHandlerFromCache: function() { with(this) {
var span = $("span"), observer = function() { }, eventID;
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
prototype: Make sure event handlers and their wrappers are removed from the cache by Event.stopObserving.
2007-08-09 23:45:59 +00:00
eventID = span._eventID;
assert(Event.cache[eventID]);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
assert(Object.isArray(Event.cache[eventID]["test:somethingHappened"]));
assertEqual(1, Event.cache[eventID]["test:somethingHappened"].length);
prototype: Make sure event handlers and their wrappers are removed from the cache by Event.stopObserving.
2007-08-09 23:45:59 +00:00
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.stopObserving("test:somethingHappened", observer);
prototype: Make sure event handlers and their wrappers are removed from the cache by Event.stopObserving.
2007-08-09 23:45:59 +00:00
assert(Event.cache[eventID]);
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
assert(Object.isArray(Event.cache[eventID]["test:somethingHappened"]));
assertEqual(0, Event.cache[eventID]["test:somethingHappened"].length);
prototype: Make sure event handlers and their wrappers are removed from the cache by Event.stopObserving.
2007-08-09 23:45:59 +00:00
}},
prototype: Make sure Element#observe is always chainable.
2007-08-11 19:53:39 +00:00
testObserveAndStopObservingAreChainable: function() { with(this) {
prototype: Make sure Element#stopObserving is always chainable.
2007-08-11 19:07:21 +00:00
var span = $("span"), observer = function() { };
prototype: Make sure Element#observe is always chainable.
2007-08-11 19:53:39 +00:00
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
assertEqual(span, span.observe("test:somethingHappened", observer));
assertEqual(span, span.stopObserving("test:somethingHappened", observer));
prototype: Make sure Element#observe is always chainable.
2007-08-11 19:53:39 +00:00
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
assertEqual(span, span.stopObserving("test:somethingHappened"));
prototype: Make sure Element#observe is always chainable.
2007-08-11 19:53:39 +00:00
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
prototype: Make sure Element#stopObserving is always chainable.
2007-08-11 19:07:21 +00:00
assertEqual(span, span.stopObserving());
assertEqual(span, span.stopObserving()); // assert it again, after there are no observers
prototype: Make sure Element#observe is always chainable.
2007-08-11 19:53:39 +00:00
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
span.observe("test:somethingHappened", observer);
assertEqual(span, span.observe("test:somethingHappened", observer)); // try to reuse the same observer
prototype: Make sure Element#observe is always chainable.
2007-08-11 19:53:39 +00:00
span.stopObserving();
prototype: Make sure Element#stopObserving is always chainable.
2007-08-11 19:07:21 +00:00
}},
prototype: Add document.loaded, a boolean that is set to true once dom:loaded is fired.
2008-01-04 00:30:53 +00:00
testDocumentLoaded: function() { with(this) {
assert(!documentLoaded);
assert(document.loaded);
}},
prototype: Make sure Element#stopObserving is always chainable.
2007-08-11 19:07:21 +00:00
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
testDocumentContentLoadedEventFiresBeforeWindowLoad: function() { with(this) {
assert(eventResults.contentLoaded, "contentLoaded");
assert(eventResults.contentLoaded.endOfDocument, "contentLoaded.endOfDocument");
assert(!eventResults.contentLoaded.windowLoad, "!contentLoaded.windowLoad");
assert(eventResults.windowLoad, "windowLoad");
assert(eventResults.windowLoad.endOfDocument, "windowLoad.endOfDocument");
assert(eventResults.windowLoad.contentLoaded, "windowLoad.contentLoaded");
Add event.stopped, a boolean that is set to when Event#stop is called.
2007-10-26 19:15:35 +00:00
}},
testEventStopped: function() { with(this) {
var span = $("span"), event;
span.observe("test:somethingHappened", function() { });
event = span.fire("test:somethingHappened");
assert(!event.stopped, "event.stopped should be false with an empty observer");
span.stopObserving("test:somethingHappened");
span.observe("test:somethingHappened", function(e) { e.stop() });
event = span.fire("test:somethingHappened");
assert(event.stopped, "event.stopped should be true for an observer that calls stop");
span.stopObserving("test:somethingHappened");
prototype: Ensure Event#fire always returns an extended event. Make Event#findElement's expression argument optional. Perf optimizations for Event#findElement.
2007-11-13 21:48:09 +00:00
}},
testEventFindElement: function() { with(this) {
var span = $("span"), event;
event = span.fire("test:somethingHappened");
assertEqual(span, event.findElement());
assertEqual(span, event.findElement('span'));
prototype: add a test to event.html.
2007-11-14 12:49:56 +00:00
assertEqual($("inner"), event.findElement('p'));
prototype: Ensure Event#fire always returns an extended event. Make Event#findElement's expression argument optional. Perf optimizations for Event#findElement.
2007-11-13 21:48:09 +00:00
assertEqual(null, event.findElement('div.does_not_exist'));
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
}}
Add event.stopped, a boolean that is set to when Event#stop is called.
2007-10-26 19:15:35 +00:00
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
}, 'testlog');
prototype: Namespace all custom event names to avoid conflicts with native DOM events.
2007-10-11 06:00:45 +00:00
document.observe("dom:loaded", function(event) {
prototype: Merge -r7242:HEAD from ../branches/1-6-0-events. Adds support for DOM-based custom events with Event.fire/Element.Methods.fire, cross-browser DOMContentLoaded support, extended and normalized event objects, and improvements to the observe and stopObserving APIs.
2007-08-04 07:20:45 +00:00
eventResults.contentLoaded = {
endOfDocument: eventResults.endOfDocument,
windowLoad: eventResults.windowLoad
};
});
Event.observe(window, "load", function(event) {
eventResults.windowLoad = {
endOfDocument: eventResults.endOfDocument,
contentLoaded: eventResults.contentLoaded
};
});
// ]]>
</script>
</body>
</html>
<script type="text/javascript">
eventResults.endOfDocument = true;
</script>