Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(21)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: cc/blink/web_float_animation_curve_unittest.cc

Issue 1616653002: CC Animation: Move files from cc_blink to Source/platform/animation (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Rebase. Fix copyrights and years. Created 4 years, 10 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « cc/blink/web_float_animation_curve_impl.cc ('k') | cc/blink/web_layer_impl.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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 "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
OLDNEW
« no previous file with comments | « cc/blink/web_float_animation_curve_impl.cc ('k') | cc/blink/web_layer_impl.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698