1 /* 2 * Copyright (c) 2013, Google Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions are 6 * met: 7 * 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above 11 * copyright notice, this list of conditions and the following disclaimer 12 * in the documentation and/or other materials provided with the 13 * distribution. 14 * * Neither the name of Google Inc. nor the names of its 15 * contributors may be used to endorse or promote products derived from 16 * this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 20 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 21 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 22 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 23 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 24 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include "config.h" 32 #include "platform/animation/TimingFunction.h" 33 34 #include "wtf/text/WTFString.h" 35 #include <gmock/gmock.h> 36 #include <gtest/gtest.h> 37 #include <sstream> 38 #include <string> 39 40 // Macro is only used to allow the use of streams. 41 // Can be removed if a pretty failure message isn't needed. 42 #define EXPECT_NE_WITH_MESSAGE(a, b) \ 43 EXPECT_NE(*a.second, *b.second) \ 44 << a.first \ 45 << " (" << a.second->toString().latin1().data() << ")" \ 46 << " == " \ 47 << b.first \ 48 << " (" << b.second->toString().latin1().data() << ")" \ 49 << "\n"; 50 51 namespace blink { 52 53 namespace { 54 55 class TimingFunctionTest : public ::testing::Test { 56 public: 57 void notEqualHelperLoop(Vector<std::pair<std::string, RefPtr<TimingFunction> > >& v) 58 { 59 for (size_t i = 0; i < v.size(); ++i) { 60 for (size_t j = 0; j < v.size(); ++j) { 61 if (i == j) 62 continue; 63 EXPECT_NE_WITH_MESSAGE(v[i], v[j]); 64 } 65 } 66 } 67 }; 68 69 TEST_F(TimingFunctionTest, LinearToString) 70 { 71 RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared(); 72 EXPECT_EQ(linearTiming->toString(), "linear"); 73 } 74 75 TEST_F(TimingFunctionTest, CubicToString) 76 { 77 RefPtr<TimingFunction> cubicEaseTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease); 78 EXPECT_EQ("ease", cubicEaseTiming->toString()); 79 RefPtr<TimingFunction> cubicEaseInTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 80 EXPECT_EQ("ease-in", cubicEaseInTiming->toString()); 81 RefPtr<TimingFunction> cubicEaseOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut); 82 EXPECT_EQ("ease-out", cubicEaseOutTiming->toString()); 83 RefPtr<TimingFunction> cubicEaseInOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut); 84 EXPECT_EQ("ease-in-out", cubicEaseInOutTiming->toString()); 85 86 RefPtr<TimingFunction> cubicCustomTiming = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73); 87 EXPECT_EQ("cubic-bezier(0.17, 0.67, 1, -1.73)", cubicCustomTiming->toString()); 88 } 89 90 TEST_F(TimingFunctionTest, StepToString) 91 { 92 RefPtr<TimingFunction> stepTimingStart = StepsTimingFunction::preset(StepsTimingFunction::Start); 93 EXPECT_EQ("step-start", stepTimingStart->toString()); 94 95 RefPtr<TimingFunction> stepTimingMiddle = StepsTimingFunction::preset(StepsTimingFunction::Middle); 96 EXPECT_EQ("step-middle", stepTimingMiddle->toString()); 97 98 RefPtr<TimingFunction> stepTimingEnd = StepsTimingFunction::preset(StepsTimingFunction::End); 99 EXPECT_EQ("step-end", stepTimingEnd->toString()); 100 101 RefPtr<TimingFunction> stepTimingCustomStart = StepsTimingFunction::create(3, StepsTimingFunction::Start); 102 EXPECT_EQ("steps(3, start)", stepTimingCustomStart->toString()); 103 104 RefPtr<TimingFunction> stepTimingCustomMiddle = StepsTimingFunction::create(4, StepsTimingFunction::Middle); 105 EXPECT_EQ("steps(4, middle)", stepTimingCustomMiddle->toString()); 106 107 RefPtr<TimingFunction> stepTimingCustomEnd = StepsTimingFunction::create(5, StepsTimingFunction::End); 108 EXPECT_EQ("steps(5, end)", stepTimingCustomEnd->toString()); 109 } 110 111 TEST_F(TimingFunctionTest, BaseOperatorEq) 112 { 113 RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared(); 114 RefPtr<TimingFunction> cubicTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 115 RefPtr<TimingFunction> cubicTiming2 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73); 116 RefPtr<TimingFunction> stepsTiming1 = StepsTimingFunction::preset(StepsTimingFunction::End); 117 RefPtr<TimingFunction> stepsTiming2 = StepsTimingFunction::create(5, StepsTimingFunction::Start); 118 119 Vector<std::pair<std::string, RefPtr<TimingFunction> > > v; 120 v.append(std::make_pair("linearTiming", linearTiming)); 121 v.append(std::make_pair("cubicTiming1", cubicTiming1)); 122 v.append(std::make_pair("cubicTiming2", cubicTiming2)); 123 v.append(std::make_pair("stepsTiming1", stepsTiming1)); 124 v.append(std::make_pair("stepsTiming2", stepsTiming2)); 125 notEqualHelperLoop(v); 126 } 127 128 TEST_F(TimingFunctionTest, LinearOperatorEq) 129 { 130 RefPtr<TimingFunction> linearTiming1 = LinearTimingFunction::shared(); 131 RefPtr<TimingFunction> linearTiming2 = LinearTimingFunction::shared(); 132 EXPECT_EQ(*linearTiming1, *linearTiming1); 133 EXPECT_EQ(*linearTiming1, *linearTiming2); 134 } 135 136 TEST_F(TimingFunctionTest, CubicOperatorEq) 137 { 138 RefPtr<TimingFunction> cubicEaseInTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 139 RefPtr<TimingFunction> cubicEaseInTiming2 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 140 EXPECT_EQ(*cubicEaseInTiming1, *cubicEaseInTiming1); 141 EXPECT_EQ(*cubicEaseInTiming1, *cubicEaseInTiming2); 142 143 RefPtr<TimingFunction> cubicEaseOutTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut); 144 RefPtr<TimingFunction> cubicEaseOutTiming2 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut); 145 EXPECT_EQ(*cubicEaseOutTiming1, *cubicEaseOutTiming1); 146 EXPECT_EQ(*cubicEaseOutTiming1, *cubicEaseOutTiming2); 147 148 RefPtr<TimingFunction> cubicEaseInOutTiming1 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut); 149 RefPtr<TimingFunction> cubicEaseInOutTiming2 = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut); 150 EXPECT_EQ(*cubicEaseInOutTiming1, *cubicEaseInOutTiming1); 151 EXPECT_EQ(*cubicEaseInOutTiming1, *cubicEaseInOutTiming2); 152 153 RefPtr<TimingFunction> cubicCustomTiming1 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73); 154 RefPtr<TimingFunction> cubicCustomTiming2 = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73); 155 EXPECT_EQ(*cubicCustomTiming1, *cubicCustomTiming1); 156 EXPECT_EQ(*cubicCustomTiming1, *cubicCustomTiming2); 157 158 Vector<std::pair<std::string, RefPtr<TimingFunction> > > v; 159 v.append(std::make_pair("cubicEaseInTiming1", cubicEaseInTiming1)); 160 v.append(std::make_pair("cubicEaseOutTiming1", cubicEaseOutTiming1)); 161 v.append(std::make_pair("cubicEaseInOutTiming1", cubicEaseInOutTiming1)); 162 v.append(std::make_pair("cubicCustomTiming1", cubicCustomTiming1)); 163 notEqualHelperLoop(v); 164 } 165 166 TEST_F(TimingFunctionTest, CubicOperatorEqReflectivity) 167 { 168 RefPtr<TimingFunction> cubicA = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 169 RefPtr<TimingFunction> cubicB = CubicBezierTimingFunction::create(0.42, 0.0, 1.0, 1.0); 170 EXPECT_NE(*cubicA, *cubicB); 171 EXPECT_NE(*cubicB, *cubicA); 172 } 173 174 TEST_F(TimingFunctionTest, StepsOperatorEq) 175 { 176 RefPtr<TimingFunction> stepsTimingStart1 = StepsTimingFunction::preset(StepsTimingFunction::Start); 177 RefPtr<TimingFunction> stepsTimingStart2 = StepsTimingFunction::preset(StepsTimingFunction::Start); 178 EXPECT_EQ(*stepsTimingStart1, *stepsTimingStart1); 179 EXPECT_EQ(*stepsTimingStart1, *stepsTimingStart2); 180 181 RefPtr<TimingFunction> stepsTimingEnd1 = StepsTimingFunction::preset(StepsTimingFunction::End); 182 RefPtr<TimingFunction> stepsTimingEnd2 = StepsTimingFunction::preset(StepsTimingFunction::End); 183 EXPECT_EQ(*stepsTimingEnd1, *stepsTimingEnd1); 184 EXPECT_EQ(*stepsTimingEnd1, *stepsTimingEnd2); 185 186 RefPtr<TimingFunction> stepsTimingCustom1 = StepsTimingFunction::create(5, StepsTimingFunction::Start); 187 RefPtr<TimingFunction> stepsTimingCustom2 = StepsTimingFunction::create(5, StepsTimingFunction::End); 188 RefPtr<TimingFunction> stepsTimingCustom3 = StepsTimingFunction::create(7, StepsTimingFunction::Start); 189 RefPtr<TimingFunction> stepsTimingCustom4 = StepsTimingFunction::create(7, StepsTimingFunction::End); 190 191 EXPECT_EQ(*StepsTimingFunction::create(5, StepsTimingFunction::Start), *stepsTimingCustom1); 192 EXPECT_EQ(*StepsTimingFunction::create(5, StepsTimingFunction::End), *stepsTimingCustom2); 193 EXPECT_EQ(*StepsTimingFunction::create(7, StepsTimingFunction::Start), *stepsTimingCustom3); 194 EXPECT_EQ(*StepsTimingFunction::create(7, StepsTimingFunction::End), *stepsTimingCustom4); 195 196 Vector<std::pair<std::string, RefPtr<TimingFunction> > > v; 197 v.append(std::make_pair("stepsTimingStart1", stepsTimingStart1)); 198 v.append(std::make_pair("stepsTimingEnd1", stepsTimingEnd1)); 199 v.append(std::make_pair("stepsTimingCustom1", stepsTimingCustom1)); 200 v.append(std::make_pair("stepsTimingCustom2", stepsTimingCustom2)); 201 v.append(std::make_pair("stepsTimingCustom3", stepsTimingCustom3)); 202 v.append(std::make_pair("stepsTimingCustom4", stepsTimingCustom4)); 203 notEqualHelperLoop(v); 204 } 205 206 TEST_F(TimingFunctionTest, StepsOperatorEqPreset) 207 { 208 RefPtr<TimingFunction> stepsA = StepsTimingFunction::preset(StepsTimingFunction::Start); 209 RefPtr<TimingFunction> stepsB = StepsTimingFunction::create(1, StepsTimingFunction::Start); 210 EXPECT_EQ(*stepsA, *stepsB); 211 EXPECT_EQ(*stepsB, *stepsA); 212 } 213 214 TEST_F(TimingFunctionTest, LinearEvaluate) 215 { 216 RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared(); 217 EXPECT_EQ(0.2, linearTiming->evaluate(0.2, 0)); 218 EXPECT_EQ(0.6, linearTiming->evaluate(0.6, 0)); 219 EXPECT_EQ(-0.2, linearTiming->evaluate(-0.2, 0)); 220 EXPECT_EQ(1.6, linearTiming->evaluate(1.6, 0)); 221 } 222 223 TEST_F(TimingFunctionTest, LinearRange) 224 { 225 double start = 0; 226 double end = 1; 227 RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared(); 228 linearTiming->range(&start, &end); 229 EXPECT_NEAR(0, start, 0.01); 230 EXPECT_NEAR(1, end, 0.01); 231 start = -1; 232 end = 10; 233 linearTiming->range(&start, &end); 234 EXPECT_NEAR(-1, start, 0.01); 235 EXPECT_NEAR(10, end, 0.01); 236 } 237 238 TEST_F(TimingFunctionTest, StepRange) 239 { 240 double start = 0; 241 double end = 1; 242 RefPtr<TimingFunction> steps = StepsTimingFunction::preset(StepsTimingFunction::Start); 243 steps->range(&start, &end); 244 EXPECT_NEAR(0, start, 0.01); 245 EXPECT_NEAR(1, end, 0.01); 246 247 start = -1; 248 end = 10; 249 steps->range(&start, &end); 250 EXPECT_NEAR(0, start, 0.01); 251 EXPECT_NEAR(1, end, 0.01); 252 } 253 254 TEST_F(TimingFunctionTest, CubicRange) 255 { 256 double start = 0; 257 double end = 1; 258 259 RefPtr<TimingFunction> cubicEaseTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease); 260 start = 0; 261 end = 1; 262 cubicEaseTiming->range(&start, &end); 263 EXPECT_NEAR(0, start, 0.01); 264 EXPECT_NEAR(1, end, 0.01); 265 start = -1; 266 end = 10; 267 cubicEaseTiming->range(&start, &end); 268 EXPECT_NEAR(-0.4, start, 0.01); 269 EXPECT_NEAR(1, end, 0.01); 270 271 RefPtr<TimingFunction> cubicEaseInTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 272 start = 0; 273 end = 1; 274 cubicEaseInTiming->range(&start, &end); 275 EXPECT_NEAR(0, start, 0.01); 276 EXPECT_NEAR(1, end, 0.01); 277 start = -1; 278 end = 10; 279 cubicEaseInTiming->range(&start, &end); 280 EXPECT_NEAR(0.0, start, 0.01); 281 EXPECT_NEAR(16.51, end, 0.01); 282 283 RefPtr<TimingFunction> cubicEaseOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut); 284 start = 0; 285 end = 1; 286 cubicEaseOutTiming->range(&start, &end); 287 EXPECT_NEAR(0, start, 0.01); 288 EXPECT_NEAR(1, end, 0.01); 289 start = -1; 290 end = 10; 291 cubicEaseOutTiming->range(&start, &end); 292 EXPECT_NEAR(-1.72, start, 0.01); 293 EXPECT_NEAR(1.0, end, 0.01); 294 295 RefPtr<TimingFunction> cubicEaseInOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut); 296 start = 0; 297 end = 1; 298 cubicEaseInOutTiming->range(&start, &end); 299 EXPECT_NEAR(0, start, 0.01); 300 EXPECT_NEAR(1, end, 0.01); 301 start = -1; 302 end = 10; 303 cubicEaseInOutTiming->range(&start, &end); 304 EXPECT_NEAR(0.0, start, 0.01); 305 EXPECT_NEAR(1.0, end, 0.01); 306 307 RefPtr<TimingFunction> cubicCustomTiming = CubicBezierTimingFunction::create(0.17, 0.67, 1.0, -1.73); 308 start = 0; 309 end = 1; 310 cubicCustomTiming->range(&start, &end); 311 EXPECT_NEAR(-0.33, start, 0.01); 312 EXPECT_NEAR(1.0, end, 0.01); 313 314 start = -1; 315 end = 10; 316 cubicCustomTiming->range(&start, &end); 317 EXPECT_NEAR(-3.94, start, 0.01); 318 EXPECT_NEAR(4.578, end, 0.01); 319 } 320 321 TEST_F(TimingFunctionTest, CubicEvaluate) 322 { 323 double tolerance = 0.01; 324 RefPtr<TimingFunction> cubicEaseTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::Ease); 325 EXPECT_NEAR(0.418, cubicEaseTiming->evaluate(0.25, tolerance), tolerance); 326 EXPECT_NEAR(0.805, cubicEaseTiming->evaluate(0.50, tolerance), tolerance); 327 EXPECT_NEAR(0.960, cubicEaseTiming->evaluate(0.75, tolerance), tolerance); 328 329 RefPtr<TimingFunction> cubicEaseInTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseIn); 330 EXPECT_NEAR(0.093, cubicEaseInTiming->evaluate(0.25, tolerance), tolerance); 331 EXPECT_NEAR(0.305, cubicEaseInTiming->evaluate(0.50, tolerance), tolerance); 332 EXPECT_NEAR(0.620, cubicEaseInTiming->evaluate(0.75, tolerance), tolerance); 333 334 RefPtr<TimingFunction> cubicEaseOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseOut); 335 EXPECT_NEAR(0.379, cubicEaseOutTiming->evaluate(0.25, tolerance), tolerance); 336 EXPECT_NEAR(0.694, cubicEaseOutTiming->evaluate(0.50, tolerance), tolerance); 337 EXPECT_NEAR(0.906, cubicEaseOutTiming->evaluate(0.75, tolerance), tolerance); 338 339 RefPtr<TimingFunction> cubicEaseInOutTiming = CubicBezierTimingFunction::preset(CubicBezierTimingFunction::EaseInOut); 340 EXPECT_NEAR(0.128, cubicEaseInOutTiming->evaluate(0.25, tolerance), tolerance); 341 EXPECT_NEAR(0.500, cubicEaseInOutTiming->evaluate(0.50, tolerance), tolerance); 342 EXPECT_NEAR(0.871, cubicEaseInOutTiming->evaluate(0.75, tolerance), tolerance); 343 344 RefPtr<TimingFunction> cubicCustomTiming = CubicBezierTimingFunction::create(0.17, 0.67, 1, -1.73); 345 EXPECT_NEAR(0.034, cubicCustomTiming->evaluate(0.25, tolerance), tolerance); 346 EXPECT_NEAR(-0.217, cubicCustomTiming->evaluate(0.50, tolerance), tolerance); 347 EXPECT_NEAR(-0.335, cubicCustomTiming->evaluate(0.75, tolerance), tolerance); 348 } 349 350 TEST_F(TimingFunctionTest, StepsEvaluate) 351 { 352 RefPtr<TimingFunction> stepsTimingStart = StepsTimingFunction::preset(StepsTimingFunction::Start); 353 EXPECT_EQ(0.00, stepsTimingStart->evaluate(-1.10, 0)); 354 EXPECT_EQ(0.00, stepsTimingStart->evaluate(-0.10, 0)); 355 EXPECT_EQ(1.00, stepsTimingStart->evaluate(0.00, 0)); 356 EXPECT_EQ(1.00, stepsTimingStart->evaluate(0.20, 0)); 357 EXPECT_EQ(1.00, stepsTimingStart->evaluate(0.60, 0)); 358 EXPECT_EQ(1.00, stepsTimingStart->evaluate(1.00, 0)); 359 EXPECT_EQ(1.00, stepsTimingStart->evaluate(2.00, 0)); 360 361 RefPtr<TimingFunction> stepsTimingMiddle = StepsTimingFunction::preset(StepsTimingFunction::Middle); 362 EXPECT_EQ(0.00, stepsTimingMiddle->evaluate(-2.50, 0)); 363 EXPECT_EQ(0.00, stepsTimingMiddle->evaluate(0.00, 0)); 364 EXPECT_EQ(0.00, stepsTimingMiddle->evaluate(0.49, 0)); 365 EXPECT_EQ(1.00, stepsTimingMiddle->evaluate(0.50, 0)); 366 EXPECT_EQ(1.00, stepsTimingMiddle->evaluate(1.00, 0)); 367 EXPECT_EQ(1.00, stepsTimingMiddle->evaluate(2.50, 0)); 368 369 RefPtr<TimingFunction> stepsTimingEnd = StepsTimingFunction::preset(StepsTimingFunction::End); 370 EXPECT_EQ(0.00, stepsTimingEnd->evaluate(-2.00, 0)); 371 EXPECT_EQ(0.00, stepsTimingEnd->evaluate(0.00, 0)); 372 EXPECT_EQ(0.00, stepsTimingEnd->evaluate(0.20, 0)); 373 EXPECT_EQ(0.00, stepsTimingEnd->evaluate(0.60, 0)); 374 EXPECT_EQ(1.00, stepsTimingEnd->evaluate(1.00, 0)); 375 EXPECT_EQ(1.00, stepsTimingEnd->evaluate(2.00, 0)); 376 377 RefPtr<TimingFunction> stepsTimingCustomStart = StepsTimingFunction::create(4, StepsTimingFunction::Start); 378 EXPECT_EQ(0.00, stepsTimingCustomStart->evaluate(-0.50, 0)); 379 EXPECT_EQ(0.25, stepsTimingCustomStart->evaluate(0.00, 0)); 380 EXPECT_EQ(0.25, stepsTimingCustomStart->evaluate(0.24, 0)); 381 EXPECT_EQ(0.50, stepsTimingCustomStart->evaluate(0.25, 0)); 382 EXPECT_EQ(0.50, stepsTimingCustomStart->evaluate(0.49, 0)); 383 EXPECT_EQ(0.75, stepsTimingCustomStart->evaluate(0.50, 0)); 384 EXPECT_EQ(0.75, stepsTimingCustomStart->evaluate(0.74, 0)); 385 EXPECT_EQ(1.00, stepsTimingCustomStart->evaluate(0.75, 0)); 386 EXPECT_EQ(1.00, stepsTimingCustomStart->evaluate(1.00, 0)); 387 EXPECT_EQ(1.00, stepsTimingCustomStart->evaluate(1.50, 0)); 388 389 RefPtr<TimingFunction> stepsTimingCustomMiddle = StepsTimingFunction::create(4, StepsTimingFunction::Middle); 390 EXPECT_EQ(0.00, stepsTimingCustomMiddle->evaluate(-2.00, 0)); 391 EXPECT_EQ(0.00, stepsTimingCustomMiddle->evaluate(0.00, 0)); 392 EXPECT_EQ(0.00, stepsTimingCustomMiddle->evaluate(0.12, 0)); 393 EXPECT_EQ(0.25, stepsTimingCustomMiddle->evaluate(0.13, 0)); 394 EXPECT_EQ(0.25, stepsTimingCustomMiddle->evaluate(0.37, 0)); 395 EXPECT_EQ(0.50, stepsTimingCustomMiddle->evaluate(0.38, 0)); 396 EXPECT_EQ(0.50, stepsTimingCustomMiddle->evaluate(0.62, 0)); 397 EXPECT_EQ(0.75, stepsTimingCustomMiddle->evaluate(0.63, 0)); 398 EXPECT_EQ(0.75, stepsTimingCustomMiddle->evaluate(0.87, 0)); 399 EXPECT_EQ(1.00, stepsTimingCustomMiddle->evaluate(0.88, 0)); 400 EXPECT_EQ(1.00, stepsTimingCustomMiddle->evaluate(1.00, 0)); 401 EXPECT_EQ(1.00, stepsTimingCustomMiddle->evaluate(3.00, 0)); 402 403 RefPtr<TimingFunction> stepsTimingCustomEnd = StepsTimingFunction::create(4, StepsTimingFunction::End); 404 EXPECT_EQ(0.00, stepsTimingCustomEnd->evaluate(-2.00, 0)); 405 EXPECT_EQ(0.00, stepsTimingCustomEnd->evaluate(0.00, 0)); 406 EXPECT_EQ(0.00, stepsTimingCustomEnd->evaluate(0.24, 0)); 407 EXPECT_EQ(0.25, stepsTimingCustomEnd->evaluate(0.25, 0)); 408 EXPECT_EQ(0.25, stepsTimingCustomEnd->evaluate(0.49, 0)); 409 EXPECT_EQ(0.50, stepsTimingCustomEnd->evaluate(0.50, 0)); 410 EXPECT_EQ(0.50, stepsTimingCustomEnd->evaluate(0.74, 0)); 411 EXPECT_EQ(0.75, stepsTimingCustomEnd->evaluate(0.75, 0)); 412 EXPECT_EQ(0.75, stepsTimingCustomEnd->evaluate(0.99, 0)); 413 EXPECT_EQ(1.00, stepsTimingCustomEnd->evaluate(1.00, 0)); 414 EXPECT_EQ(1.00, stepsTimingCustomEnd->evaluate(2.00, 0)); 415 } 416 417 } // namespace 418 419 } // namespace blink 420
