OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "config.h" | 5 #include "config.h" |
6 #include "core/animation/InterpolableValue.h" | 6 #include "core/animation/InterpolableValue.h" |
7 | 7 |
8 #include "core/animation/Interpolation.h" | 8 #include "core/animation/Interpolation.h" |
9 #include "core/animation/PropertyHandle.h" | 9 #include "core/animation/PropertyHandle.h" |
10 | 10 |
11 #include <gtest/gtest.h> | 11 #include <gtest/gtest.h> |
12 | 12 |
13 namespace blink { | 13 namespace blink { |
14 | 14 |
15 namespace { | 15 namespace { |
16 | 16 |
17 class SampleInterpolation : public Interpolation { | 17 class SampleInterpolation : public Interpolation { |
18 public: | 18 public: |
19 static PassRefPtrWillBeRawPtr<Interpolation> create(PassOwnPtrWillBeRawPtr<I
nterpolableValue> start, PassOwnPtrWillBeRawPtr<InterpolableValue> end) | 19 static Interpolation* create(InterpolableValue* start, InterpolableValue* en
d) |
20 { | 20 { |
21 return adoptRefWillBeNoop(new SampleInterpolation(start, end)); | 21 return new SampleInterpolation(start, end); |
22 } | 22 } |
23 | 23 |
24 virtual PropertyHandle property() const override | 24 virtual PropertyHandle property() const override |
25 { | 25 { |
26 return PropertyHandle(CSSPropertyBackgroundColor); | 26 return PropertyHandle(CSSPropertyBackgroundColor); |
27 } | 27 } |
28 private: | 28 private: |
29 SampleInterpolation(PassOwnPtrWillBeRawPtr<InterpolableValue> start, PassOwn
PtrWillBeRawPtr<InterpolableValue> end) | 29 SampleInterpolation(InterpolableValue* start, InterpolableValue* end) |
30 : Interpolation(start, end) | 30 : Interpolation(start, end) |
31 { | 31 { |
32 } | 32 } |
33 }; | 33 }; |
34 | 34 |
35 } // namespace | 35 } // namespace |
36 | 36 |
37 class AnimationInterpolableValueTest : public ::testing::Test { | 37 class AnimationInterpolableValueTest : public ::testing::Test { |
38 protected: | 38 protected: |
39 InterpolableValue* interpolationValue(Interpolation& interpolation) | 39 InterpolableValue* interpolationValue(Interpolation& interpolation) |
40 { | 40 { |
41 return interpolation.getCachedValueForTesting(); | 41 return interpolation.getCachedValueForTesting(); |
42 } | 42 } |
43 | 43 |
44 double interpolateNumbers(double a, double b, double progress) | 44 double interpolateNumbers(double a, double b, double progress) |
45 { | 45 { |
46 RefPtrWillBeRawPtr<Interpolation> i = SampleInterpolation::create(Interp
olableNumber::create(a), InterpolableNumber::create(b)); | 46 Interpolation* i = SampleInterpolation::create(InterpolableNumber::creat
e(a), InterpolableNumber::create(b)); |
47 i->interpolate(0, progress); | 47 i->interpolate(0, progress); |
48 return toInterpolableNumber(interpolationValue(*i.get()))->value(); | 48 return toInterpolableNumber(interpolationValue(*i))->value(); |
49 } | 49 } |
50 | 50 |
51 bool interpolateBools(bool a, bool b, double progress) | 51 bool interpolateBools(bool a, bool b, double progress) |
52 { | 52 { |
53 RefPtrWillBeRawPtr<Interpolation> i = SampleInterpolation::create(Interp
olableBool::create(a), InterpolableBool::create(b)); | 53 Interpolation* i = SampleInterpolation::create(InterpolableBool::create(
a), InterpolableBool::create(b)); |
54 i->interpolate(0, progress); | 54 i->interpolate(0, progress); |
55 return toInterpolableBool(interpolationValue(*i.get()))->value(); | 55 return toInterpolableBool(interpolationValue(*i))->value(); |
56 } | 56 } |
57 | 57 |
58 PassRefPtrWillBeRawPtr<Interpolation> interpolateLists(PassOwnPtrWillBeRawPt
r<InterpolableList> listA, PassOwnPtrWillBeRawPtr<InterpolableList> listB, doubl
e progress) | 58 Interpolation* interpolateLists(InterpolableList* listA, InterpolableList* l
istB, double progress) |
59 { | 59 { |
60 RefPtrWillBeRawPtr<Interpolation> i = SampleInterpolation::create(listA,
listB); | 60 Interpolation* i = SampleInterpolation::create(listA, listB); |
61 i->interpolate(0, progress); | 61 i->interpolate(0, progress); |
62 return i; | 62 return i; |
63 } | 63 } |
64 | 64 |
65 double addNumbers(double a, double b) | 65 double addNumbers(double a, double b) |
66 { | 66 { |
67 OwnPtrWillBeRawPtr<InterpolableValue> numA = InterpolableNumber::create(
a); | 67 InterpolableValue* numA = InterpolableNumber::create(a); |
68 OwnPtrWillBeRawPtr<InterpolableValue> numB = InterpolableNumber::create(
b); | 68 InterpolableValue* numB = InterpolableNumber::create(b); |
69 | 69 |
70 OwnPtrWillBeRawPtr<InterpolableValue> resultNumber = InterpolableNumber:
:create(0); | 70 InterpolableValue* resultNumber = InterpolableNumber::create(0); |
71 | 71 |
72 numA->add(*numB, *resultNumber); | 72 numA->add(*numB, *resultNumber); |
73 | 73 |
74 return toInterpolableNumber(resultNumber.get())->value(); | 74 return toInterpolableNumber(resultNumber)->value(); |
75 } | 75 } |
76 | 76 |
77 bool addBools(bool a, bool b) | 77 bool addBools(bool a, bool b) |
78 { | 78 { |
79 OwnPtrWillBeRawPtr<InterpolableValue> boolA = InterpolableBool::create(a
); | 79 InterpolableValue* boolA = InterpolableBool::create(a); |
80 OwnPtrWillBeRawPtr<InterpolableValue> boolB = InterpolableBool::create(b
); | 80 InterpolableValue* boolB = InterpolableBool::create(b); |
81 | 81 |
82 OwnPtrWillBeRawPtr<InterpolableValue> resultBool = InterpolableBool::cre
ate(false); | 82 InterpolableValue* resultBool = InterpolableBool::create(false); |
83 | 83 |
84 boolA->add(*boolB, *resultBool); | 84 boolA->add(*boolB, *resultBool); |
85 | 85 |
86 return toInterpolableBool(resultBool.get())->value(); | 86 return toInterpolableBool(resultBool)->value(); |
87 } | 87 } |
88 | 88 |
89 PassOwnPtrWillBeRawPtr<InterpolableList> addLists(PassOwnPtrWillBeRawPtr<Int
erpolableValue> listA, PassOwnPtrWillBeRawPtr<InterpolableValue> listB) | 89 InterpolableList* addLists(InterpolableValue* listA, InterpolableValue* list
B) |
90 { | 90 { |
91 OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(t
oInterpolableList(*listA)); | 91 InterpolableList* result = InterpolableList::create(toInterpolableList(*
listA)); |
92 | 92 |
93 listA->add(*listB, *result); | 93 listA->add(*listB, *result); |
94 | 94 |
95 return result.release(); | 95 return result; |
96 } | 96 } |
97 | 97 |
98 double multiplyNumber(double scalar, double n) | 98 double multiplyNumber(double scalar, double n) |
99 { | 99 { |
100 OwnPtrWillBeRawPtr<InterpolableValue> num = InterpolableNumber::create(n
); | 100 InterpolableValue* num = InterpolableNumber::create(n); |
101 OwnPtrWillBeRawPtr<InterpolableValue> result = InterpolableNumber::creat
e(0); | 101 InterpolableValue* result = InterpolableNumber::create(0); |
102 | 102 |
103 num->multiply(scalar, *result); | 103 num->multiply(scalar, *result); |
104 | 104 |
105 return toInterpolableNumber(result.get())->value(); | 105 return toInterpolableNumber(result)->value(); |
106 } | 106 } |
107 | 107 |
108 PassOwnPtrWillBeRawPtr<InterpolableList> multiplyList(double scalar, PassOwn
PtrWillBeRawPtr<InterpolableValue> list) | 108 InterpolableList* multiplyList(double scalar, InterpolableValue* list) |
109 { | 109 { |
110 OwnPtrWillBeRawPtr<InterpolableList> result = InterpolableList::create(t
oInterpolableList(*list)); | 110 InterpolableList* result = InterpolableList::create(toInterpolableList(*
list)); |
111 | 111 |
112 list->multiply(scalar, *result); | 112 list->multiply(scalar, *result); |
113 | 113 |
114 return result.release(); | 114 return result; |
115 } | 115 } |
116 }; | 116 }; |
117 | 117 |
118 TEST_F(AnimationInterpolableValueTest, InterpolateNumbers) | 118 TEST_F(AnimationInterpolableValueTest, InterpolateNumbers) |
119 { | 119 { |
120 EXPECT_FLOAT_EQ(126, interpolateNumbers(42, 0, -2)); | 120 EXPECT_FLOAT_EQ(126, interpolateNumbers(42, 0, -2)); |
121 EXPECT_FLOAT_EQ(42, interpolateNumbers(42, 0, 0)); | 121 EXPECT_FLOAT_EQ(42, interpolateNumbers(42, 0, 0)); |
122 EXPECT_FLOAT_EQ(29.4f, interpolateNumbers(42, 0, 0.3)); | 122 EXPECT_FLOAT_EQ(29.4f, interpolateNumbers(42, 0, 0.3)); |
123 EXPECT_FLOAT_EQ(21, interpolateNumbers(42, 0, 0.5)); | 123 EXPECT_FLOAT_EQ(21, interpolateNumbers(42, 0, 0.5)); |
124 EXPECT_FLOAT_EQ(0, interpolateNumbers(42, 0, 1)); | 124 EXPECT_FLOAT_EQ(0, interpolateNumbers(42, 0, 1)); |
125 EXPECT_FLOAT_EQ(-21, interpolateNumbers(42, 0, 1.5)); | 125 EXPECT_FLOAT_EQ(-21, interpolateNumbers(42, 0, 1.5)); |
126 } | 126 } |
127 | 127 |
128 TEST_F(AnimationInterpolableValueTest, InterpolateBools) | 128 TEST_F(AnimationInterpolableValueTest, InterpolateBools) |
129 { | 129 { |
130 EXPECT_FALSE(interpolateBools(false, true, -1)); | 130 EXPECT_FALSE(interpolateBools(false, true, -1)); |
131 EXPECT_FALSE(interpolateBools(false, true, 0)); | 131 EXPECT_FALSE(interpolateBools(false, true, 0)); |
132 EXPECT_FALSE(interpolateBools(false, true, 0.3)); | 132 EXPECT_FALSE(interpolateBools(false, true, 0.3)); |
133 EXPECT_TRUE(interpolateBools(false, true, 0.5)); | 133 EXPECT_TRUE(interpolateBools(false, true, 0.5)); |
134 EXPECT_TRUE(interpolateBools(false, true, 1)); | 134 EXPECT_TRUE(interpolateBools(false, true, 1)); |
135 EXPECT_TRUE(interpolateBools(false, true, 2)); | 135 EXPECT_TRUE(interpolateBools(false, true, 2)); |
136 } | 136 } |
137 | 137 |
138 TEST_F(AnimationInterpolableValueTest, SimpleList) | 138 TEST_F(AnimationInterpolableValueTest, SimpleList) |
139 { | 139 { |
140 OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3); | 140 InterpolableList* listA = InterpolableList::create(3); |
141 listA->set(0, InterpolableNumber::create(0)); | 141 listA->set(0, InterpolableNumber::create(0)); |
142 listA->set(1, InterpolableNumber::create(42)); | 142 listA->set(1, InterpolableNumber::create(42)); |
143 listA->set(2, InterpolableNumber::create(20.5)); | 143 listA->set(2, InterpolableNumber::create(20.5)); |
144 | 144 |
145 OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3); | 145 InterpolableList* listB = InterpolableList::create(3); |
146 listB->set(0, InterpolableNumber::create(100)); | 146 listB->set(0, InterpolableNumber::create(100)); |
147 listB->set(1, InterpolableNumber::create(-200)); | 147 listB->set(1, InterpolableNumber::create(-200)); |
148 listB->set(2, InterpolableNumber::create(300)); | 148 listB->set(2, InterpolableNumber::create(300)); |
149 | 149 |
150 RefPtrWillBeRawPtr<Interpolation> i = interpolateLists(listA.release(), list
B.release(), 0.3); | 150 Interpolation* i = interpolateLists(listA, listB, 0.3); |
151 InterpolableList* outList = toInterpolableList(interpolationValue(*i.get()))
; | 151 InterpolableList* outList = toInterpolableList(interpolationValue(*i)); |
152 EXPECT_FLOAT_EQ(30, toInterpolableNumber(outList->get(0))->value()); | 152 EXPECT_FLOAT_EQ(30, toInterpolableNumber(outList->get(0))->value()); |
153 EXPECT_FLOAT_EQ(-30.6f, toInterpolableNumber(outList->get(1))->value()); | 153 EXPECT_FLOAT_EQ(-30.6f, toInterpolableNumber(outList->get(1))->value()); |
154 EXPECT_FLOAT_EQ(104.35f, toInterpolableNumber(outList->get(2))->value()); | 154 EXPECT_FLOAT_EQ(104.35f, toInterpolableNumber(outList->get(2))->value()); |
155 } | 155 } |
156 | 156 |
157 TEST_F(AnimationInterpolableValueTest, NestedList) | 157 TEST_F(AnimationInterpolableValueTest, NestedList) |
158 { | 158 { |
159 OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3); | 159 InterpolableList* listA = InterpolableList::create(3); |
160 listA->set(0, InterpolableNumber::create(0)); | 160 listA->set(0, InterpolableNumber::create(0)); |
161 OwnPtrWillBeRawPtr<InterpolableList> subListA = InterpolableList::create(1); | 161 InterpolableList* subListA = InterpolableList::create(1); |
162 subListA->set(0, InterpolableNumber::create(100)); | 162 subListA->set(0, InterpolableNumber::create(100)); |
163 listA->set(1, subListA.release()); | 163 listA->set(1, subListA); |
164 listA->set(2, InterpolableBool::create(false)); | 164 listA->set(2, InterpolableBool::create(false)); |
165 | 165 |
166 OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3); | 166 InterpolableList* listB = InterpolableList::create(3); |
167 listB->set(0, InterpolableNumber::create(100)); | 167 listB->set(0, InterpolableNumber::create(100)); |
168 OwnPtrWillBeRawPtr<InterpolableList> subListB = InterpolableList::create(1); | 168 InterpolableList* subListB = InterpolableList::create(1); |
169 subListB->set(0, InterpolableNumber::create(50)); | 169 subListB->set(0, InterpolableNumber::create(50)); |
170 listB->set(1, subListB.release()); | 170 listB->set(1, subListB); |
171 listB->set(2, InterpolableBool::create(true)); | 171 listB->set(2, InterpolableBool::create(true)); |
172 | 172 |
173 RefPtrWillBeRawPtr<Interpolation> i = interpolateLists(listA.release(), list
B.release(), 0.5); | 173 Interpolation* i = interpolateLists(listA, listB, 0.5); |
174 InterpolableList* outList = toInterpolableList(interpolationValue(*i.get()))
; | 174 InterpolableList* outList = toInterpolableList(interpolationValue(*i)); |
175 EXPECT_FLOAT_EQ(50, toInterpolableNumber(outList->get(0))->value()); | 175 EXPECT_FLOAT_EQ(50, toInterpolableNumber(outList->get(0))->value()); |
176 EXPECT_FLOAT_EQ(75, toInterpolableNumber(toInterpolableList(outList->get(1))
->get(0))->value()); | 176 EXPECT_FLOAT_EQ(75, toInterpolableNumber(toInterpolableList(outList->get(1))
->get(0))->value()); |
177 EXPECT_TRUE(toInterpolableBool(outList->get(2))->value()); | 177 EXPECT_TRUE(toInterpolableBool(outList->get(2))->value()); |
178 } | 178 } |
179 | 179 |
180 TEST_F(AnimationInterpolableValueTest, AddNumbers) | 180 TEST_F(AnimationInterpolableValueTest, AddNumbers) |
181 { | 181 { |
182 EXPECT_FLOAT_EQ(42, addNumbers(20, 22)); | 182 EXPECT_FLOAT_EQ(42, addNumbers(20, 22)); |
183 EXPECT_FLOAT_EQ(42, addNumbers(22, 20)); | 183 EXPECT_FLOAT_EQ(42, addNumbers(22, 20)); |
184 EXPECT_FLOAT_EQ(50, addNumbers(0, 50)); | 184 EXPECT_FLOAT_EQ(50, addNumbers(0, 50)); |
185 EXPECT_FLOAT_EQ(50, addNumbers(50, 0)); | 185 EXPECT_FLOAT_EQ(50, addNumbers(50, 0)); |
186 EXPECT_FLOAT_EQ(32, addNumbers(42, -10)); | 186 EXPECT_FLOAT_EQ(32, addNumbers(42, -10)); |
187 EXPECT_FLOAT_EQ(32, addNumbers(-10, 42)); | 187 EXPECT_FLOAT_EQ(32, addNumbers(-10, 42)); |
188 EXPECT_FLOAT_EQ(-32, addNumbers(-42, 10)); | 188 EXPECT_FLOAT_EQ(-32, addNumbers(-42, 10)); |
189 EXPECT_FLOAT_EQ(-32, addNumbers(10, -42)); | 189 EXPECT_FLOAT_EQ(-32, addNumbers(10, -42)); |
190 } | 190 } |
191 | 191 |
192 TEST_F(AnimationInterpolableValueTest, AddBools) | 192 TEST_F(AnimationInterpolableValueTest, AddBools) |
193 { | 193 { |
194 EXPECT_FALSE(addBools(false, false)); | 194 EXPECT_FALSE(addBools(false, false)); |
195 EXPECT_TRUE(addBools(true, false)); | 195 EXPECT_TRUE(addBools(true, false)); |
196 EXPECT_TRUE(addBools(false, true)); | 196 EXPECT_TRUE(addBools(false, true)); |
197 EXPECT_TRUE(addBools(true, true)); | 197 EXPECT_TRUE(addBools(true, true)); |
198 } | 198 } |
199 | 199 |
200 TEST_F(AnimationInterpolableValueTest, AddLists) | 200 TEST_F(AnimationInterpolableValueTest, AddLists) |
201 { | 201 { |
202 OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3); | 202 InterpolableList* listA = InterpolableList::create(3); |
203 listA->set(0, InterpolableNumber::create(31)); | 203 listA->set(0, InterpolableNumber::create(31)); |
204 listA->set(1, InterpolableNumber::create(-20)); | 204 listA->set(1, InterpolableNumber::create(-20)); |
205 listA->set(2, InterpolableNumber::create(42)); | 205 listA->set(2, InterpolableNumber::create(42)); |
206 | 206 |
207 OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3); | 207 InterpolableList* listB = InterpolableList::create(3); |
208 listB->set(0, InterpolableNumber::create(20)); | 208 listB->set(0, InterpolableNumber::create(20)); |
209 listB->set(1, InterpolableNumber::create(43)); | 209 listB->set(1, InterpolableNumber::create(43)); |
210 listB->set(2, InterpolableNumber::create(-60)); | 210 listB->set(2, InterpolableNumber::create(-60)); |
211 | 211 |
212 OwnPtrWillBeRawPtr<InterpolableList> result = addLists(listA.release(), list
B.release()); | 212 InterpolableList* result = addLists(listA, listB); |
213 EXPECT_FLOAT_EQ(51, toInterpolableNumber(result->get(0))->value()); | 213 EXPECT_FLOAT_EQ(51, toInterpolableNumber(result->get(0))->value()); |
214 EXPECT_FLOAT_EQ(23, toInterpolableNumber(result->get(1))->value()); | 214 EXPECT_FLOAT_EQ(23, toInterpolableNumber(result->get(1))->value()); |
215 EXPECT_FLOAT_EQ(-18, toInterpolableNumber(result->get(2))->value()); | 215 EXPECT_FLOAT_EQ(-18, toInterpolableNumber(result->get(2))->value()); |
216 } | 216 } |
217 | 217 |
218 TEST_F(AnimationInterpolableValueTest, AddNestedLists) | 218 TEST_F(AnimationInterpolableValueTest, AddNestedLists) |
219 { | 219 { |
220 OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3); | 220 InterpolableList* listA = InterpolableList::create(3); |
221 listA->set(0, InterpolableNumber::create(19)); | 221 listA->set(0, InterpolableNumber::create(19)); |
222 OwnPtrWillBeRawPtr<InterpolableList> subListA = InterpolableList::create(1); | 222 InterpolableList* subListA = InterpolableList::create(1); |
223 subListA->set(0, InterpolableNumber::create(67)); | 223 subListA->set(0, InterpolableNumber::create(67)); |
224 listA->set(1, subListA.release()); | 224 listA->set(1, subListA); |
225 listA->set(2, InterpolableBool::create(false)); | 225 listA->set(2, InterpolableBool::create(false)); |
226 | 226 |
227 OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3); | 227 InterpolableList* listB = InterpolableList::create(3); |
228 listB->set(0, InterpolableNumber::create(21)); | 228 listB->set(0, InterpolableNumber::create(21)); |
229 OwnPtrWillBeRawPtr<InterpolableList> subListB = InterpolableList::create(1); | 229 InterpolableList* subListB = InterpolableList::create(1); |
230 subListB->set(0, InterpolableNumber::create(31)); | 230 subListB->set(0, InterpolableNumber::create(31)); |
231 listB->set(1, subListB.release()); | 231 listB->set(1, subListB); |
232 listB->set(2, InterpolableBool::create(true)); | 232 listB->set(2, InterpolableBool::create(true)); |
233 | 233 |
234 OwnPtrWillBeRawPtr<InterpolableList> result = addLists(listA.release(), list
B.release()); | 234 InterpolableList* result = addLists(listA, listB); |
235 EXPECT_FLOAT_EQ(40, toInterpolableNumber(result->get(0))->value()); | 235 EXPECT_FLOAT_EQ(40, toInterpolableNumber(result->get(0))->value()); |
236 EXPECT_FLOAT_EQ(98, toInterpolableNumber(toInterpolableList(result->get(1))-
>get(0))->value()); | 236 EXPECT_FLOAT_EQ(98, toInterpolableNumber(toInterpolableList(result->get(1))-
>get(0))->value()); |
237 EXPECT_TRUE(toInterpolableBool(result->get(2))->value()); | 237 EXPECT_TRUE(toInterpolableBool(result->get(2))->value()); |
238 } | 238 } |
239 | 239 |
240 TEST_F(AnimationInterpolableValueTest, NumberScalarMultiplication) | 240 TEST_F(AnimationInterpolableValueTest, NumberScalarMultiplication) |
241 { | 241 { |
242 EXPECT_FLOAT_EQ(42, multiplyNumber(6, 7)); | 242 EXPECT_FLOAT_EQ(42, multiplyNumber(6, 7)); |
243 EXPECT_FLOAT_EQ(-20, multiplyNumber(-2, 10)); | 243 EXPECT_FLOAT_EQ(-20, multiplyNumber(-2, 10)); |
244 EXPECT_FLOAT_EQ(-42, multiplyNumber(21, -2)); | 244 EXPECT_FLOAT_EQ(-42, multiplyNumber(21, -2)); |
245 EXPECT_FLOAT_EQ(20, multiplyNumber(-4, -5)); | 245 EXPECT_FLOAT_EQ(20, multiplyNumber(-4, -5)); |
246 | 246 |
247 EXPECT_FLOAT_EQ(0, multiplyNumber(0, 10)); | 247 EXPECT_FLOAT_EQ(0, multiplyNumber(0, 10)); |
248 EXPECT_FLOAT_EQ(0, multiplyNumber(10, 0)); | 248 EXPECT_FLOAT_EQ(0, multiplyNumber(10, 0)); |
249 } | 249 } |
250 | 250 |
251 TEST_F(AnimationInterpolableValueTest, ListScalarMultiplication) | 251 TEST_F(AnimationInterpolableValueTest, ListScalarMultiplication) |
252 { | 252 { |
253 OwnPtrWillBeRawPtr<InterpolableList> listA = InterpolableList::create(3); | 253 InterpolableList* listA = InterpolableList::create(3); |
254 listA->set(0, InterpolableNumber::create(5)); | 254 listA->set(0, InterpolableNumber::create(5)); |
255 OwnPtrWillBeRawPtr<InterpolableList> subListA = InterpolableList::create(2); | 255 InterpolableList* subListA = InterpolableList::create(2); |
256 subListA->set(0, InterpolableNumber::create(4)); | 256 subListA->set(0, InterpolableNumber::create(4)); |
257 subListA->set(1, InterpolableNumber::create(7)); | 257 subListA->set(1, InterpolableNumber::create(7)); |
258 listA->set(1, subListA.release()); | 258 listA->set(1, subListA); |
259 listA->set(2, InterpolableNumber::create(3)); | 259 listA->set(2, InterpolableNumber::create(3)); |
260 | 260 |
261 OwnPtrWillBeRawPtr<InterpolableList> resultA = multiplyList(6, listA.release
()); | 261 InterpolableList* resultA = multiplyList(6, listA); |
262 EXPECT_FLOAT_EQ(30, toInterpolableNumber(resultA->get(0))->value()); | 262 EXPECT_FLOAT_EQ(30, toInterpolableNumber(resultA->get(0))->value()); |
263 EXPECT_FLOAT_EQ(24, toInterpolableNumber(toInterpolableList(resultA->get(1))
->get(0))->value()); | 263 EXPECT_FLOAT_EQ(24, toInterpolableNumber(toInterpolableList(resultA->get(1))
->get(0))->value()); |
264 EXPECT_FLOAT_EQ(42, toInterpolableNumber(toInterpolableList(resultA->get(1))
->get(1))->value()); | 264 EXPECT_FLOAT_EQ(42, toInterpolableNumber(toInterpolableList(resultA->get(1))
->get(1))->value()); |
265 EXPECT_FLOAT_EQ(18, toInterpolableNumber(resultA->get(2))->value()); | 265 EXPECT_FLOAT_EQ(18, toInterpolableNumber(resultA->get(2))->value()); |
266 | 266 |
267 OwnPtrWillBeRawPtr<InterpolableList> listB = InterpolableList::create(3); | 267 InterpolableList* listB = InterpolableList::create(3); |
268 listB->set(0, InterpolableNumber::create(8)); | 268 listB->set(0, InterpolableNumber::create(8)); |
269 listB->set(1, InterpolableNumber::create(-10)); | 269 listB->set(1, InterpolableNumber::create(-10)); |
270 listB->set(2, InterpolableNumber::create(9)); | 270 listB->set(2, InterpolableNumber::create(9)); |
271 | 271 |
272 OwnPtrWillBeRawPtr<InterpolableList> resultB = multiplyList(0, listB.release
()); | 272 InterpolableList* resultB = multiplyList(0, listB); |
273 EXPECT_FLOAT_EQ(0, toInterpolableNumber(resultB->get(0))->value()); | 273 EXPECT_FLOAT_EQ(0, toInterpolableNumber(resultB->get(0))->value()); |
274 EXPECT_FLOAT_EQ(0, toInterpolableNumber(resultB->get(1))->value()); | 274 EXPECT_FLOAT_EQ(0, toInterpolableNumber(resultB->get(1))->value()); |
275 EXPECT_FLOAT_EQ(0, toInterpolableNumber(resultB->get(2))->value()); | 275 EXPECT_FLOAT_EQ(0, toInterpolableNumber(resultB->get(2))->value()); |
276 } | 276 } |
277 | 277 |
278 } | 278 } |
OLD | NEW |