npm_modules: Fork bower_components into Polymer 0.4.0 and 0.5.0 versions

polymer_0.5.0/bower_components/web-animations-js/test/blink/interpolation/resources/interpolation-test.js

+/*
+ * Copyright (C) 2013 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * This script is intended to be used for constructing layout tests which
+ * exercise the interpolation functionaltiy of the animation system.
+ * Tests which run using this script should be portable across browsers.
+ *
+ * The following function is exported:
+ *  * assertInterpolation({property: x, from: y, to: z}, [{at: fraction, is: value}])
+ *    Constructs a test case which for each fraction will output a PASS
+ *    or FAIL depending on whether the interpolated result matches
+ *    'value'. Replica elements are constructed to aid eyeballing test
+ *    results.
+ */
+'use strict';
+(function() {
+  var endEvent = 'animationend';
+  var testCount = 0;
+  var animationEventCount = 0;
+  var durationSeconds = 0;
+  var iterationCount = 0.5;
+  var delaySeconds = 0;
+  var fragment = document.createDocumentFragment();
+  var fragmentAttachedListeners = [];
+  var style = document.createElement('style');
+  var afterTestCallback = null;
+  fragment.appendChild(style);
+
+  var tests = document.createElement('div');
+  tests.id = 'interpolation-tests';
+  tests.textContent = 'Interpolation Tests:';
+  fragment.appendChild(tests);
+
+  var updateScheduled = false;
+  function maybeScheduleUpdate() {
+    if (updateScheduled) {
+      return;
+    }
+    updateScheduled = true;
+    setTimeout(function() {
+      updateScheduled = false;
+      document.body.appendChild(fragment);
+      fragmentAttachedListeners.forEach(function(listener) {listener();});
+    }, 0);
+  }
+
+  function evaluateTests() {
+    var targets = document.querySelectorAll('.target.active');
+    for (var i = 0; i < targets.length; i++) {
+      targets[i].evaluate();
+    }
+  }
+
+  function afterTest(callback) {
+    afterTestCallback = callback;
+  }
+
+  // Constructs a timing function which produces 'y' at x = 0.5
+  function createEasing(y) {
+    // FIXME: if 'y' is > 0 and < 1 use a linear timing function and allow
+    // 'x' to vary. Use a bezier only for values < 0 or > 1.
+    if (y == 0) {
+      return 'steps(1, end)';
+    }
+    if (y == 1) {
+      return 'steps(1, start)';
+    }
+    if (y == 0.5) {
+      return 'steps(2, end)';
+    }
+    // Approximate using a bezier.
+    var b = (8 * y - 1) / 6;
+    return 'cubic-bezier(0, ' + b + ', 1, ' + b + ')';
+  }
+
+  function createTestContainer(description, className) {
+    var testContainer = document.createElement('div');
+    testContainer.setAttribute('description', description);
+    testContainer.classList.add('test');
+    if (className) {
+      testContainer.classList.add(className);
+    }
+    return testContainer;
+  }
+
+  function convertPropertyToCamelCase(property) {
+    return property.replace(/^-/, '').replace(/-\w/g, function(m) {return m[1].toUpperCase();});
+  }
+
+  function describeTest(params) {
+    return convertPropertyToCamelCase(params.property) + ': from [' + params.from + '] to [' + params.to + ']';
+  }
+
+  var nextKeyframeId = 0;
+  function assertInterpolation(params, expectations) {
+    var testId = 'test-' + ++nextKeyframeId;
+    var nextCaseId = 0;
+    var testContainer = createTestContainer(describeTest(params), testId);
+    tests.appendChild(testContainer);
+    expectations.forEach(function(expectation) {
+        testContainer.appendChild(makeInterpolationTest(
+            expectation.at, testId, 'case-' + ++nextCaseId, params, expectation.is));
+    });
+    maybeScheduleUpdate();
+  }
+
+  function roundNumbers(value) {
+    // Round numbers to two decimal places.
+    return value.replace(/-?\d*\.\d+/g, function(n) {
+        return (parseFloat(n).toFixed(2)).
+            replace(/\.\d+/, function(m) {
+              return m.replace(/0+$/, '');
+            }).
+            replace(/\.$/, '').
+            replace(/^-0$/, '0');
+      });
+  }
+
+  function normalizeValue(value) {
+    return roundNumbers(value).
+        // Place whitespace between tokens.
+        replace(/([\w\d.]+|[^\s])/g, '$1 ').
+        replace(/\s+/g, ' ');
+  }
+
+  function createTargetContainer(id) {
+    var targetContainer = document.createElement('div');
+    var template = document.querySelector('#target-template');
+    if (template) {
+      if (template.content)
+        targetContainer.appendChild(template.content.cloneNode(true));
+      else if (template.querySelector('div'))
+        targetContainer.appendChild(template.querySelector('div').cloneNode(true));
+      else
+        targetContainer.appendChild(template.cloneNode(true));
+      // Remove whitespace text nodes at start / end.
+      while (targetContainer.firstChild.nodeType != Node.ELEMENT_NODE && !/\S/.test(targetContainer.firstChild.nodeValue)) {
+        targetContainer.removeChild(targetContainer.firstChild);
+      }
+      while (targetContainer.lastChild.nodeType != Node.ELEMENT_NODE && !/\S/.test(targetContainer.lastChild.nodeValue)) {
+        targetContainer.removeChild(targetContainer.lastChild);
+      }
+      // If the template contains just one element, use that rather than a wrapper div.
+      if (targetContainer.children.length == 1 && targetContainer.childNodes.length == 1) {
+        targetContainer = targetContainer.firstChild;
+        targetContainer.parentNode.removeChild(targetContainer);
+      }
+    }
+    var target = targetContainer.querySelector('.target') || targetContainer;
+    target.classList.add('target');
+    target.classList.add(id);
+    return targetContainer;
+  }
+
+  function sanitizeUrls(value) {
+    var matches = value.match(/url\([^\)]*\)/g);
+    if (matches !== null) {
+      for (var i = 0; i < matches.length; ++i) {
+        var url = /url\(([^\)]*)\)/g.exec(matches[i])[1];
+        var anchor = document.createElement('a');
+        anchor.href = url;
+        anchor.pathname = '...' + anchor.pathname.substring(anchor.pathname.lastIndexOf('/'));
+        value = value.replace(matches[i], 'url(' + anchor.href + ')');
+      }
+    }
+    return value;
+  }
+
+  function makeInterpolationTest(fraction, testId, caseId, params, expectation) {
+    var t = async_test(describeTest(params) + ' at ' + fraction);
+    var targetContainer = createTargetContainer(caseId);
+    var target = targetContainer.querySelector('.target') || targetContainer;
+    target.classList.add('active');
+    var replicaContainer, replica;
+    replicaContainer = createTargetContainer(caseId);
+    replica = replicaContainer.querySelector('.target') || replicaContainer;
+    replica.classList.add('replica');
+    replica.style.setProperty(params.property, expectation);
+    if (params.prefixedProperty) {
+      for (var i = 0; i < params.prefixedProperty.length; i++) {
+        replica.style.setProperty(params.prefixedProperty[i], expectation);
+      }
+    }
+
+    target.evaluate = function() {
+      var target = this;
+      t.step(function() {
+        window.CSS && assert_true(CSS.supports(params.property, expectation));
+        var value = getComputedStyle(target).getPropertyValue(params.property);
+        var property = params.property;
+        if (params.prefixedProperty) {
+          var i = 0;
+          while (i < params.prefixedProperty.length && !value) {
+            property = params.prefixedProperty[i++];
+            value = getComputedStyle(target).getPropertyValue(property)
+          }
+        }
+        if (!value) {
+          assert_false(params.property + ' not supported by this browser');
+        }
+        var originalValue = value;
+        var parsedExpectation = getComputedStyle(replica).getPropertyValue(property);
+        assert_equals(normalizeValue(originalValue), normalizeValue(parsedExpectation));
+        t.done();
+      });
+    };
+
+    var easing = createEasing(fraction);
+    testCount++;
+    var keyframes = [{}, {}];
+    keyframes[0][convertPropertyToCamelCase(params.property)] = params.from;
+    keyframes[1][convertPropertyToCamelCase(params.property)] = params.to;
+    fragmentAttachedListeners.push(function() {
+      target.animate(keyframes, {
+          fill: 'forwards',
+          duration: 1,
+          easing: easing,
+          delay: -0.5,
+          iterations: 0.5,
+        });
+      animationEnded();
+    });
+    var testFragment = document.createDocumentFragment();
+    testFragment.appendChild(targetContainer);
+    replica && testFragment.appendChild(replicaContainer);
+    testFragment.appendChild(document.createTextNode('\n'));
+    return testFragment;
+  }
+
+  var finished = false;
+  function finishTest() {
+    finished = true;
+    evaluateTests();
+    if (afterTestCallback) {
+      afterTestCallback();
+    }
+    if (window.testRunner) {
+      var results = document.querySelector('#results');
+      document.documentElement.textContent = '';
+      document.documentElement.appendChild(results);
+      testRunner.dumpAsText();
+      testRunner.notifyDone();
+    }
+  }
+
+  if (window.testRunner) {
+    testRunner.waitUntilDone();
+  }
+
+  function isLastAnimationEvent() {
+    return !finished && animationEventCount === testCount;
+  }
+
+  function animationEnded() {
+    animationEventCount++;
+    if (!isLastAnimationEvent()) {
+      return;
+    }
+    finishTest();
+  }
+
+  document.documentElement.addEventListener(endEvent, animationEnded);
+
+  if (!window.testRunner) {
+    setTimeout(function() {
+      if (finished) {
+        return;
+      }
+      finishTest();
+    }, 10000);
+  }
+
+  window.assertInterpolation = assertInterpolation;
+  window.afterTest = afterTest;
+})();