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