<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><!-- webkit-test-runner [ enableCSSAnimationsAndCSSTransitionsBackedByWebAnimations=true ] -->

<html lang="en">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>Animation using matrix()</title>
  <style type="text/css" media="screen">
    #box {
      height: 100px;
      width: 100px;
      background-color: blue;
      -webkit-animation-duration: 1s;
      -webkit-animation-timing-function: linear;
      -webkit-animation-name: "anim";
    }
    @-webkit-keyframes "anim" {
        from { -webkit-transform: matrix(0.707, -0.707, 0.707, 0.707, 0, 0); }
        to   { -webkit-transform: matrix(0.707, 0.707, -0.707, 0.707, 0, 0); }
    }
  </style>
  <script src="resources/animation-test-helpers.js" type="text/javascript" charset="utf-8"></script>
  <script type="text/javascript" charset="utf-8">
    
    
    const expectedValues = [
      // [animation-name, time, element-id, property, expected-value, tolerance]
      ["anim", 0.5, "box", "webkitTransform", [1,0,0,1], 0.1],
    ];
    
    runAnimationTest(expectedValues);
    
  </script>
</head>
<body>
This test performs an animation of the matrix operator. It animates over 2 seconds.
At 1 second it takes a snapshot and expects the result to be within range.
<div id="box">
</div>
<div id="result">
</div>
</body>
</html>
