TransformOperations should be able to blend outside the range [0, 1]

ui/gfx/transform_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // MSVC++ requires this to be set before any other includes to get M_PI.
 #define _USE_MATH_DEFINES
 
 #include "ui/gfx/transform.h"
 
 #include <cmath>
 #include <ostream>
 #include <limits>
 
 #include "base/basictypes.h"
+#include "base/logging.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/point3_f.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/gfx/vector3d_f.h"
 
 namespace gfx {
 
 namespace {
 
@@ skipping 622 matching lines @@
         xform.TransformPointReverse(pt);
         EXPECT_EQ(pt.x(), value.x);
         EXPECT_EQ(pt.y(), value.y);
       }
     }
   }
 }
 
 TEST(XFormTest, BlendTranslate) {
   Transform from;
-  for (int i = 0; i < 10; ++i) {
+  for (int i = -5; i < 15; ++i) {
     Transform to;
     to.Translate3d(1, 1, 1);
     double t = i / 9.0;
     EXPECT_TRUE(to.Blend(from, t));
     EXPECT_FLOAT_EQ(t, to.matrix().get(0, 3));
     EXPECT_FLOAT_EQ(t, to.matrix().get(1, 3));
     EXPECT_FLOAT_EQ(t, to.matrix().get(2, 3));
   }
 }
 
 TEST(XFormTest, BlendRotate) {
   Vector3dF axes[] = {
     Vector3dF(1, 0, 0),
     Vector3dF(0, 1, 0),
     Vector3dF(0, 0, 1),
     Vector3dF(1, 1, 1)
   };
   Transform from;
   for (size_t index = 0; index < ARRAYSIZE_UNSAFE(axes); ++index) {
-    for (int i = 0; i < 10; ++i) {
+    for (int i = -5; i < 15; ++i) {
       Transform to;
       to.RotateAbout(axes[index], 90);
       double t = i / 9.0;
       EXPECT_TRUE(to.Blend(from, t));
 
       Transform expected;
       expected.RotateAbout(axes[index], 90 * t);
 
       EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
     }
   }
 }
 
 TEST(XFormTest, BlendRotateFollowsShortestPath) {
   // Verify that we interpolate along the shortest path regardless of whether
   // this path crosses the 180-degree point.
   Vector3dF axes[] = {
     Vector3dF(1, 0, 0),
     Vector3dF(0, 1, 0),
     Vector3dF(0, 0, 1),
     Vector3dF(1, 1, 1)
   };
   for (size_t index = 0; index < ARRAYSIZE_UNSAFE(axes); ++index) {
-    for (int i = 0; i < 10; ++i) {
+    for (int i = -5; i < 15; ++i) {
       Transform from1;
       from1.RotateAbout(axes[index], 130.0);
       Transform to1;
       to1.RotateAbout(axes[index], 175.0);
 
       Transform from2;
       from2.RotateAbout(axes[index], 140.0);
       Transform to2;
       to2.RotateAbout(axes[index], 185.0);
 
@@ skipping 15 matching lines @@
 
 TEST(XFormTest, CanBlend180DegreeRotation) {
   Vector3dF axes[] = {
     Vector3dF(1, 0, 0),
     Vector3dF(0, 1, 0),
     Vector3dF(0, 0, 1),
     Vector3dF(1, 1, 1)
   };
   Transform from;
   for (size_t index = 0; index < ARRAYSIZE_UNSAFE(axes); ++index) {
-    for (int i = 0; i < 10; ++i) {
+    for (int i = -5; i < 15; ++i) {
       Transform to;
       to.RotateAbout(axes[index], 180);
       double t = i / 9.0;
       EXPECT_TRUE(to.Blend(from, t));
 
       Transform expected;
       expected.RotateAbout(axes[index], 180 * t);
 
       EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
     }
   }
 }
 
 TEST(XFormTest, BlendScale) {
   Transform from;
-  for (int i = 0; i < 10; ++i) {
+  for (int i = -5; i < 15; ++i) {
     Transform to;
     to.Scale3d(5, 4, 3);
     double t = i / 9.0;
     EXPECT_TRUE(to.Blend(from, t));
     EXPECT_FLOAT_EQ(t * 4 + 1, to.matrix().get(0, 0));
     EXPECT_FLOAT_EQ(t * 3 + 1, to.matrix().get(1, 1));
     EXPECT_FLOAT_EQ(t * 2 + 1, to.matrix().get(2, 2));
   }
 }
 
 TEST(XFormTest, BlendSkew) {
   Transform from;
   for (int i = 0; i < 2; ++i) {
     Transform to;
     to.SkewX(20);
     to.SkewY(10);
     double t = i;
     Transform expected;
     expected.SkewX(t * 20);
     expected.SkewY(t * 10);
     EXPECT_TRUE(to.Blend(from, t));
     EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
   }
 }
 
+TEST(XFormTest, ExtrapolateSkew) {
+  Transform from;
+  for (int i = -1; i < 2; ++i) {
+    Transform to;
+    to.SkewX(20);
+    double t = i;
+    Transform expected;
+    expected.SkewX(t * 20);
+    EXPECT_TRUE(to.Blend(from, t));
+    EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
+  }
+}
+
 TEST(XFormTest, BlendPerspective) {
   Transform from;
   from.ApplyPerspectiveDepth(200);
-  for (int i = 0; i < 2; ++i) {
+  for (int i = -1; i < 3; ++i) {
     Transform to;
     to.ApplyPerspectiveDepth(800);
     double t = i;
+    double depth = 1.0 / ((1.0 / 200) * (1.0 - t) + (1.0 / 800) * t);
     Transform expected;
-    expected.ApplyPerspectiveDepth(t * 600 + 200);
+    expected.ApplyPerspectiveDepth(depth);
     EXPECT_TRUE(to.Blend(from, t));
     EXPECT_TRUE(MatricesAreNearlyEqual(expected, to));
   }
 }
 
 TEST(XFormTest, BlendIdentity) {
   Transform from;
   Transform to;
   EXPECT_TRUE(to.Blend(from, 0.5));
   EXPECT_EQ(to, from);
@@ skipping 1461 matching lines @@
   A.FlattenTo2d();
   EXPECT_ROW1_EQ(10.0f, 14.0f, 0.0f, 22.0f, A);
   EXPECT_ROW2_EQ(11.0f, 15.0f, 0.0f, 23.0f, A);
   EXPECT_ROW3_EQ(0.0f,  0.0f,  1.0f, 0.0f,  A);
   EXPECT_ROW4_EQ(13.0f, 17.0f, 0.0f, 25.0f, A);
 }
 
 }  // namespace
 
 }  // namespace gfx