The Tor Browser: comparison image/test/mochitest/animationPolling.js

comparison: image/test/mochitest/animationPolling.js

image/test/mochitest/animationPolling.js

branch: TOR_BUG_9701
changeset 14: 925c144e1f1f

equal deleted inserted replaced

--1:000000000000
+:c1fd1fc770aa
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+var currentTest;
+var gIsRefImageLoaded = false;
+const gShouldOutputDebugInfo = false;
+function pollForSuccess()
+{
+if (!currentTest.isTestFinished) {
+if (!currentTest.reusingReferenceImage || (currentTest.reusingReferenceImage
+&& gRefImageLoaded)) {
+currentTest.checkImage();
+}
+setTimeout(pollForSuccess, currentTest.pollFreq);
+}
+};
+function referencePoller()
+{
+currentTest.takeReferenceSnapshot();
+}
+function reuseImageCallback()
+{
+gIsRefImageLoaded = true;
+}
+function failTest()
+{
+if (currentTest.isTestFinished || currentTest.closeFunc) {
+return;
+}
+ok(false, "timing out after " + currentTest.timeout + "ms.  "
++ "Animated image still doesn't look correct, after poll #"
++ currentTest.pollCounter);
+currentTest.wereFailures = true;
+if (currentTest.currentSnapshotDataURI) {
+currentTest.outputDebugInfo("Snapshot #" + currentTest.pollCounter,
+"snapNum" + currentTest.pollCounter,
+currentTest.currentSnapshotDataURI);
+}
+currentTest.enableDisplay(document.getElementById(currentTest.debugElementId));
+currentTest.cleanUpAndFinish();
+};
+/**
+* Create a new AnimationTest object.
+*
+* @param pollFreq The amount of time (in ms) to wait between consecutive
+*        snapshots if the reference image and the test image don't match.
+* @param timeout The total amount of time (in ms) to wait before declaring the
+*        test as failed.
+* @param referenceElementId The id attribute of the reference image element, or
+*        the source of the image to change to, once the reference snapshot has
+*        been successfully taken. This latter option could be used if you don't
+*        want the image to become invisible at any time during the test.
+* @param imageElementId The id attribute of the test image element.
+* @param debugElementId The id attribute of the div where links should be
+*        appended if the test fails.
+* @param cleanId The id attribute of the div or element to use as the 'clean'
+*        test. This element is only enabled when we are testing to verify that
+*        the reference image has been loaded. It can be undefined.
+* @param srcAttr The location of the source of the image, for preloading. This
+*        is usually not required, but it useful for preloading reference
+*        images.
+* @param xulTest A boolean value indicating whether or not this is a XUL test
+*        (uses hidden=true/false rather than display: none to hide/show
+*        elements).
+* @param closeFunc A function that should be called when this test is finished.
+*        If null, then cleanUpAndFinish() will be called. This can be used to
+*        chain tests together, so they are all finished exactly once.
+* @returns {AnimationTest}
+*/
+function AnimationTest(pollFreq, timeout, referenceElementId, imageElementId,
+debugElementId, cleanId, srcAttr, xulTest, closeFunc)
+{
+// We want to test the cold loading behavior, so clear cache in case an
+// earlier test got our image in there already.
+clearImageCache();
+this.wereFailures = false;
+this.pollFreq = pollFreq;
+this.timeout = timeout;
+this.imageElementId = imageElementId;
+this.referenceElementId = referenceElementId;
+if (!document.getElementById(referenceElementId)) {
+// In this case, we're assuming the user passed in a string that
+// indicates the source of the image they want to change to,
+// after the reference image has been taken.
+this.reusingImageAsReference = true;
+}
+this.srcAttr = srcAttr;
+this.debugElementId = debugElementId;
+this.referenceSnapshot = ""; // value will be set in takeReferenceSnapshot()
+this.pollCounter = 0;
+this.isTestFinished = false;
+this.numRefsTaken = 0;
+this.blankWaitTime = 0;
+this.cleanId = cleanId ? cleanId : '';
+this.xulTest = xulTest ? xulTest : '';
+this.closeFunc = closeFunc ? closeFunc : '';
+};
+AnimationTest.prototype.preloadImage = function()
+{
+if (this.srcAttr) {
+this.myImage = new Image();
+this.myImage.onload = function() { currentTest.continueTest(); };
+this.myImage.src = this.srcAttr;
+} else {
+this.continueTest();
+}
+};
+AnimationTest.prototype.outputDebugInfo = function(message, id, dataUri)
+{
+if (!gShouldOutputDebugInfo) {
+return;
+}
+var debugElement = document.getElementById(this.debugElementId);
+var newDataUriElement = document.createElement("a");
+newDataUriElement.setAttribute("id", id);
+newDataUriElement.setAttribute("href", dataUri);
+newDataUriElement.appendChild(document.createTextNode(message));
+debugElement.appendChild(newDataUriElement);
+var brElement = document.createElement("br");
+debugElement.appendChild(brElement);
+todo(false, "Debug (" + id + "): " + message + " " + dataUri);
+};
+AnimationTest.prototype.isFinished = function()
+{
+return this.isTestFinished;
+};
+AnimationTest.prototype.takeCleanSnapshot = function()
+{
+var cleanElement;
+if (this.cleanId) {
+cleanElement = document.getElementById(this.cleanId);
+}
+// Enable clean page comparison element
+if (cleanElement) {
+this.enableDisplay(cleanElement);
+}
+// Take a snapshot of the initial (clean) page
+this.cleanSnapshot = snapshotWindow(window, false);
+// Disable the clean page comparison element
+if (cleanElement) {
+this.disableDisplay(cleanElement);
+}
+var dataString1 = "Clean Snapshot";
+this.outputDebugInfo(dataString1, 'cleanSnap',
+this.cleanSnapshot.toDataURL());
+};
+AnimationTest.prototype.takeBlankSnapshot = function()
+{
+// Take a snapshot of the initial (essentially blank) page
+this.blankSnapshot = snapshotWindow(window, false);
+var dataString1 = "Initial Blank Snapshot";
+this.outputDebugInfo(dataString1, 'blank1Snap',
+this.blankSnapshot.toDataURL());
+};
+/**
+* Begin the AnimationTest. This will utilize the information provided in the
+* constructor to invoke a mochitest on animated images. It will automatically
+* fail if allowed to run past the timeout. This will attempt to preload an
+* image, if applicable, and then asynchronously call continueTest(), or if not
+* applicable, synchronously trigger a call to continueTest().
+*/
+AnimationTest.prototype.beginTest = function()
+{
+SimpleTest.waitForExplicitFinish();
+currentTest = this;
+this.preloadImage();
+};
+/**
+* This is the second part of the test. It is triggered (eventually) from
+* beginTest() either synchronously or asynchronously, as an image load
+* callback.
+*/
+AnimationTest.prototype.continueTest = function()
+{
+// In case something goes wrong, fail earlier than mochitest timeout,
+// and with more information.
+setTimeout(failTest, this.timeout);
+if (!this.reusingImageAsReference) {
+this.disableDisplay(document.getElementById(this.imageElementId));
+}
+this.takeReferenceSnapshot();
+this.setupPolledImage();
+SimpleTest.executeSoon(pollForSuccess);
+};
+AnimationTest.prototype.setupPolledImage = function ()
+{
+// Make sure the image is visible
+if (!this.reusingImageAsReference) {
+this.enableDisplay(document.getElementById(this.imageElementId));
+var currentSnapshot = snapshotWindow(window, false);
+var result = compareSnapshots(currentSnapshot,
+this.referenceSnapshot, true);
+this.currentSnapshotDataURI = currentSnapshot.toDataURL();
+if (result[0]) {
+// SUCCESS!
+ok(true, "Animated image looks correct, at poll #"
++ this.pollCounter);
+this.cleanUpAndFinish();
+}
+} else {
+if (!gIsRefImageLoaded) {
+this.myImage = new Image();
+this.myImage.onload = reuseImageCallback;
+document.getElementById(this.imageElementId).setAttribute('src',
+this.referenceElementId);
+}
+}
+}
+AnimationTest.prototype.checkImage = function ()
+{
+if (this.isTestFinished) {
+return;
+}
+this.pollCounter++;
+// We need this for some tests, because we need to force the
+// test image to be visible.
+if (!this.reusingImageAsReference) {
+this.enableDisplay(document.getElementById(this.imageElementId));
+}
+var currentSnapshot = snapshotWindow(window, false);
+var result = compareSnapshots(currentSnapshot, this.referenceSnapshot, true);
+this.currentSnapshotDataURI = currentSnapshot.toDataURL();
+if (result[0]) {
+// SUCCESS!
+ok(true, "Animated image looks correct, at poll #"
++ this.pollCounter);
+this.cleanUpAndFinish();
+}
+};
+AnimationTest.prototype.takeReferenceSnapshot = function ()
+{
+this.numRefsTaken++;
+// Test to make sure the reference image doesn't match a clean snapshot
+if (!this.cleanSnapshot) {
+this.takeCleanSnapshot();
+}
+// Used later to verify that the reference div disappeared
+if (!this.blankSnapshot) {
+this.takeBlankSnapshot();
+}
+if (this.reusingImageAsReference) {
+// Show reference elem (which is actually our image), & take a snapshot
+var referenceElem = document.getElementById(this.imageElementId);
+this.enableDisplay(referenceElem);
+this.referenceSnapshot = snapshotWindow(window, false);
+var snapResult = compareSnapshots(this.cleanSnapshot,
+this.referenceSnapshot, false);
+if (!snapResult[0]) {
+if (this.blankWaitTime > 2000) {
+// if it took longer than two seconds to load the image, we probably
+// have a problem.
+this.wereFailures = true;
+ok(snapResult[0],
+"Reference snapshot shouldn't match clean (non-image) snapshot");
+} else {
+this.blankWaitTime += currentTest.pollFreq;
+// let's wait a bit and see if it clears up
+setTimeout(referencePoller, currentTest.pollFreq);
+return;
+}
+}
+ok(snapResult[0],
+"Reference snapshot shouldn't match clean (non-image) snapshot");
+var dataString = "Reference Snapshot #" + this.numRefsTaken;
+this.outputDebugInfo(dataString, 'refSnapId',
+this.referenceSnapshot.toDataURL());
+} else {
+// Make sure the animation section is hidden
+this.disableDisplay(document.getElementById(this.imageElementId));
+// Show reference div, & take a snapshot
+var referenceDiv = document.getElementById(this.referenceElementId);
+this.enableDisplay(referenceDiv);
+this.referenceSnapshot = snapshotWindow(window, false);
+var snapResult = compareSnapshots(this.cleanSnapshot,
+this.referenceSnapshot, false);
+if (!snapResult[0]) {
+if (this.blankWaitTime > 2000) {
+// if it took longer than two seconds to load the image, we probably
+// have a problem.
+this.wereFailures = true;
+ok(snapResult[0],
+"Reference snapshot shouldn't match clean (non-image) snapshot");
+} else {
+this.blankWaitTime += 20;
+// let's wait a bit and see if it clears up
+setTimeout(referencePoller, 20);
+return;
+}
+}
+ok(snapResult[0],
+"Reference snapshot shouldn't match clean (non-image) snapshot");
+var dataString = "Reference Snapshot #" + this.numRefsTaken;
+this.outputDebugInfo(dataString, 'refSnapId',
+this.referenceSnapshot.toDataURL());
+// Re-hide reference div, and take another snapshot to be sure it's gone
+this.disableDisplay(referenceDiv);
+this.testBlankCameBack();
+}
+};
+AnimationTest.prototype.enableDisplay = function(element)
+{
+if (!element) {
+return;
+}
+if (!this.xulTest) {
+element.style.display = '';
+} else {
+element.setAttribute('hidden', 'false');
+}
+};
+AnimationTest.prototype.disableDisplay = function(element)
+{
+if (!element) {
+return;
+}
+if (!this.xulTest) {
+element.style.display = 'none';
+} else {
+element.setAttribute('hidden', 'true');
+}
+};
+AnimationTest.prototype.testBlankCameBack = function()
+{
+var blankSnapshot2 = snapshotWindow(window, false);
+var result = compareSnapshots(this.blankSnapshot, blankSnapshot2, true);
+ok(result[0], "Reference image should disappear when it becomes display:none");
+if (!result[0]) {
+this.wereFailures = true;
+var dataString = "Second Blank Snapshot";
+this.outputDebugInfo(dataString, 'blank2SnapId', result[2]);
+}
+};
+AnimationTest.prototype.cleanUpAndFinish = function ()
+{
+// On the off chance that failTest and checkImage are triggered
+// back-to-back, use a flag to prevent multiple calls to SimpleTest.finish.
+if (this.isTestFinished) {
+return;
+}
+this.isTestFinished = true;
+// Call our closing function, if one exists
+if (this.closeFunc) {
+this.closeFunc();
+return;
+}
+if (this.wereFailures) {
+document.getElementById(this.debugElementId).style.display = 'block';
+}
+SimpleTest.finish();
+document.getElementById(this.debugElementId).style.display = "";
+};