cc/blink/web_float_animation_curve_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "cc/animation/timing_function.h"
   7 #include "cc/blink/web_float_animation_curve_impl.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 using blink::WebCompositorAnimationCurve;
  11 using blink::WebFloatAnimationCurve;
  12 using blink::WebFloatKeyframe;
  13
  14 namespace cc_blink {
  15 namespace {
  16
  17 // Tests that a float animation with one keyframe works as expected.
  18 TEST(WebFloatAnimationCurveTest, OneFloatKeyframe) {
  19   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
  20   curve->add(WebFloatKeyframe(0, 2),
  21              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  22   EXPECT_FLOAT_EQ(2, curve->getValue(-1));
  23   EXPECT_FLOAT_EQ(2, curve->getValue(0));
  24   EXPECT_FLOAT_EQ(2, curve->getValue(0.5));
  25   EXPECT_FLOAT_EQ(2, curve->getValue(1));
  26   EXPECT_FLOAT_EQ(2, curve->getValue(2));
  27 }
  28
  29 // Tests that a float animation with two keyframes works as expected.
  30 TEST(WebFloatAnimationCurveTest, TwoFloatKeyframe) {
  31   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
  32   curve->add(WebFloatKeyframe(0, 2),
  33              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  34   curve->add(WebFloatKeyframe(1, 4),
  35              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  36   EXPECT_FLOAT_EQ(2, curve->getValue(-1));
  37   EXPECT_FLOAT_EQ(2, curve->getValue(0));
  38   EXPECT_FLOAT_EQ(3, curve->getValue(0.5));
  39   EXPECT_FLOAT_EQ(4, curve->getValue(1));
  40   EXPECT_FLOAT_EQ(4, curve->getValue(2));
  41 }
  42
  43 // Tests that a float animation with three keyframes works as expected.
  44 TEST(WebFloatAnimationCurveTest, ThreeFloatKeyframe) {
  45   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
  46   curve->add(WebFloatKeyframe(0, 2),
  47              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  48   curve->add(WebFloatKeyframe(1, 4),
  49              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  50   curve->add(WebFloatKeyframe(2, 8),
  51              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  52   EXPECT_FLOAT_EQ(2, curve->getValue(-1));
  53   EXPECT_FLOAT_EQ(2, curve->getValue(0));
  54   EXPECT_FLOAT_EQ(3, curve->getValue(0.5));
  55   EXPECT_FLOAT_EQ(4, curve->getValue(1));
  56   EXPECT_FLOAT_EQ(6, curve->getValue(1.5));
  57   EXPECT_FLOAT_EQ(8, curve->getValue(2));
  58   EXPECT_FLOAT_EQ(8, curve->getValue(3));
  59 }
  60
  61 // Tests that a float animation with multiple keys at a given time works sanely.
  62 TEST(WebFloatAnimationCurveTest, RepeatedFloatKeyTimes) {
  63   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
  64   curve->add(WebFloatKeyframe(0, 4),
  65              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  66   curve->add(WebFloatKeyframe(1, 4),
  67              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  68   curve->add(WebFloatKeyframe(1, 6),
  69              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  70   curve->add(WebFloatKeyframe(2, 6),
  71              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  72
  73   EXPECT_FLOAT_EQ(4, curve->getValue(-1));
  74   EXPECT_FLOAT_EQ(4, curve->getValue(0));
  75   EXPECT_FLOAT_EQ(4, curve->getValue(0.5));
  76
  77   // There is a discontinuity at 1. Any value between 4 and 6 is valid.
  78   float value = curve->getValue(1);
  79   EXPECT_TRUE(value >= 4 && value <= 6);
  80
  81   EXPECT_FLOAT_EQ(6, curve->getValue(1.5));
  82   EXPECT_FLOAT_EQ(6, curve->getValue(2));
  83   EXPECT_FLOAT_EQ(6, curve->getValue(3));
  84 }
  85
  86 // Tests that the keyframes may be added out of order.
  87 TEST(WebFloatAnimationCurveTest, UnsortedKeyframes) {
  88   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
  89   curve->add(WebFloatKeyframe(2, 8),
  90              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  91   curve->add(WebFloatKeyframe(0, 2),
  92              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  93   curve->add(WebFloatKeyframe(1, 4),
  94              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
  95
  96   EXPECT_FLOAT_EQ(2, curve->getValue(-1));
  97   EXPECT_FLOAT_EQ(2, curve->getValue(0));
  98   EXPECT_FLOAT_EQ(3, curve->getValue(0.5));
  99   EXPECT_FLOAT_EQ(4, curve->getValue(1));
 100   EXPECT_FLOAT_EQ(6, curve->getValue(1.5));
 101   EXPECT_FLOAT_EQ(8, curve->getValue(2));
 102   EXPECT_FLOAT_EQ(8, curve->getValue(3));
 103 }
 104
 105 // Tests that a cubic bezier timing function works as expected.
 106 TEST(WebFloatAnimationCurveTest, CubicBezierTimingFunction) {
 107   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 108   curve->add(WebFloatKeyframe(0, 0), 0.25, 0, 0.75, 1);
 109   curve->add(WebFloatKeyframe(1, 1),
 110              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 111
 112   EXPECT_FLOAT_EQ(0, curve->getValue(0));
 113   EXPECT_LT(0, curve->getValue(0.25));
 114   EXPECT_GT(0.25, curve->getValue(0.25));
 115   EXPECT_NEAR(curve->getValue(0.5), 0.5, 0.00015);
 116   EXPECT_LT(0.75, curve->getValue(0.75));
 117   EXPECT_GT(1, curve->getValue(0.75));
 118   EXPECT_FLOAT_EQ(1, curve->getValue(1));
 119 }
 120
 121 // Tests that an ease timing function works as expected.
 122 TEST(WebFloatAnimationCurveTest, EaseTimingFunction) {
 123   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 124   curve->add(WebFloatKeyframe(0, 0),
 125              WebCompositorAnimationCurve::TimingFunctionTypeEase);
 126   curve->add(WebFloatKeyframe(1, 1),
 127              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 128
 129   scoped_ptr<cc::TimingFunction> timing_function(
 130       cc::EaseTimingFunction::Create());
 131   for (int i = 0; i <= 4; ++i) {
 132     const double time = i * 0.25;
 133     EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->getValue(time));
 134   }
 135 }
 136
 137 // Tests using a linear timing function.
 138 TEST(WebFloatAnimationCurveTest, LinearTimingFunction) {
 139   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 140   curve->add(WebFloatKeyframe(0, 0),
 141              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 142   curve->add(WebFloatKeyframe(1, 1),
 143              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 144
 145   for (int i = 0; i <= 4; ++i) {
 146     const double time = i * 0.25;
 147     EXPECT_FLOAT_EQ(time, curve->getValue(time));
 148   }
 149 }
 150
 151 // Tests that an ease in timing function works as expected.
 152 TEST(WebFloatAnimationCurveTest, EaseInTimingFunction) {
 153   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 154   curve->add(WebFloatKeyframe(0, 0),
 155              WebCompositorAnimationCurve::TimingFunctionTypeEaseIn);
 156   curve->add(WebFloatKeyframe(1, 1),
 157              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 158
 159   scoped_ptr<cc::TimingFunction> timing_function(
 160       cc::EaseInTimingFunction::Create());
 161   for (int i = 0; i <= 4; ++i) {
 162     const double time = i * 0.25;
 163     EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->getValue(time));
 164   }
 165 }
 166
 167 // Tests that an ease in timing function works as expected.
 168 TEST(WebFloatAnimationCurveTest, EaseOutTimingFunction) {
 169   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 170   curve->add(WebFloatKeyframe(0, 0),
 171              WebCompositorAnimationCurve::TimingFunctionTypeEaseOut);
 172   curve->add(WebFloatKeyframe(1, 1),
 173              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 174
 175   scoped_ptr<cc::TimingFunction> timing_function(
 176       cc::EaseOutTimingFunction::Create());
 177   for (int i = 0; i <= 4; ++i) {
 178     const double time = i * 0.25;
 179     EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->getValue(time));
 180   }
 181 }
 182
 183 // Tests that an ease in timing function works as expected.
 184 TEST(WebFloatAnimationCurveTest, EaseInOutTimingFunction) {
 185   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 186   curve->add(WebFloatKeyframe(0, 0),
 187              WebCompositorAnimationCurve::TimingFunctionTypeEaseInOut);
 188   curve->add(WebFloatKeyframe(1, 1),
 189              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 190
 191   scoped_ptr<cc::TimingFunction> timing_function(
 192       cc::EaseInOutTimingFunction::Create());
 193   for (int i = 0; i <= 4; ++i) {
 194     const double time = i * 0.25;
 195     EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->getValue(time));
 196   }
 197 }
 198
 199 // Tests that an ease in timing function works as expected.
 200 TEST(WebFloatAnimationCurveTest, CustomBezierTimingFunction) {
 201   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 202   double x1 = 0.3;
 203   double y1 = 0.2;
 204   double x2 = 0.8;
 205   double y2 = 0.7;
 206   curve->add(WebFloatKeyframe(0, 0), x1, y1, x2, y2);
 207   curve->add(WebFloatKeyframe(1, 1),
 208              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 209
 210   scoped_ptr<cc::TimingFunction> timing_function(
 211       cc::CubicBezierTimingFunction::Create(x1, y1, x2, y2));
 212   for (int i = 0; i <= 4; ++i) {
 213     const double time = i * 0.25;
 214     EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->getValue(time));
 215   }
 216 }
 217
 218 // Tests that the default timing function is indeed ease.
 219 TEST(WebFloatAnimationCurveTest, DefaultTimingFunction) {
 220   scoped_ptr<WebFloatAnimationCurve> curve(new WebFloatAnimationCurveImpl);
 221   curve->add(WebFloatKeyframe(0, 0));
 222   curve->add(WebFloatKeyframe(1, 1),
 223              WebCompositorAnimationCurve::TimingFunctionTypeLinear);
 224
 225   scoped_ptr<cc::TimingFunction> timing_function(
 226       cc::EaseTimingFunction::Create());
 227   for (int i = 0; i <= 4; ++i) {
 228     const double time = i * 0.25;
 229     EXPECT_FLOAT_EQ(timing_function->GetValue(time), curve->getValue(time));
 230   }
 231 }
 232
 233 }  // namespace
 234 }  // namespace cc_blink