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
51namespace blink {
52
53namespace {
54
55class TimingFunctionTest : public ::testing::Test {
56public:
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
69TEST_F(TimingFunctionTest, LinearToString)
70{
71    RefPtr<TimingFunction> linearTiming = LinearTimingFunction::shared();
72    EXPECT_EQ(linearTiming->toString(), "linear");
73}
74
75TEST_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
90TEST_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
111TEST_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
128TEST_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
136TEST_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
166TEST_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
174TEST_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
206TEST_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
214TEST_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
223TEST_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
238TEST_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
254TEST_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
321TEST_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
350TEST_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