1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <cstdint>
17 #include "gtest/gtest.h"
18 #include "native_animate.h"
19 #include "native_node.h"
20 #include "native_type.h"
21 #include "node_model.h"
22 #include "native_interface.h"
23 #include "error_code.h"
24 #include "core/interfaces/arkoala/arkoala_api.h"
25
26 using namespace testing;
27 using namespace testing::ext;
28 namespace OHOS::Ace {
29 class NodeAnimateTest : public testing::Test {
30 public:
SetUpTestCase()31 static void SetUpTestCase() {};
TearDownTestCase()32 static void TearDownTestCase() {};
33 };
34
InterpolateCallback(float fraction,void * userData)35 float InterpolateCallback(float fraction, void* userData)
36 {
37 return fraction;
38 }
39
AnimationCallback(void * userData)40 void AnimationCallback(void* userData)
41 {
42 }
43
AnimatorOnFrameEventCallback(ArkUI_AnimatorOnFrameEvent * event)44 void AnimatorOnFrameEventCallback(ArkUI_AnimatorOnFrameEvent* event)
45 {
46 }
47
AnimatorEventCallback(ArkUI_AnimatorEvent * event)48 void AnimatorEventCallback(ArkUI_AnimatorEvent* event)
49 {
50 }
51
52 /**
53 * @tc.name: NodeAnimateTest001
54 * @tc.desc: Test AnimateOption function.
55 * @tc.type: FUNC
56 */
57 HWTEST_F(NodeAnimateTest, NodeAnimateTest001, TestSize.Level1)
58 {
59 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
60 ArkUI_AnimateOption* animation = OH_ArkUI_AnimateOption_Create();
61 ASSERT_NE(animation, nullptr);
62
63 float negativeFloat = -1.0f;
64 float normalFloat = 1.0f;
65 int32_t negativeInt = -2;
66 int32_t normalInt = 1;
67 int32_t largeInt = 1000;
68 OH_ArkUI_AnimateOption_SetDuration(animation, negativeInt);
69 OH_ArkUI_AnimateOption_SetDuration(animation, normalInt);
70 OH_ArkUI_AnimateOption_SetTempo(animation, negativeFloat);
71 OH_ArkUI_AnimateOption_SetTempo(animation, normalFloat);
72 OH_ArkUI_AnimateOption_SetCurve(animation, static_cast<ArkUI_AnimationCurve>(negativeInt));
73 OH_ArkUI_AnimateOption_SetCurve(animation, static_cast<ArkUI_AnimationCurve>(largeInt));
74 OH_ArkUI_AnimateOption_SetCurve(animation, ArkUI_AnimationCurve::ARKUI_CURVE_LINEAR);
75 OH_ArkUI_AnimateOption_SetDelay(animation, normalInt);
76 OH_ArkUI_AnimateOption_SetIterations(animation, negativeInt);
77 OH_ArkUI_AnimateOption_SetIterations(animation, normalInt);
78 OH_ArkUI_AnimateOption_SetPlayMode(animation, static_cast<ArkUI_AnimationPlayMode>(negativeInt));
79 OH_ArkUI_AnimateOption_SetPlayMode(animation, static_cast<ArkUI_AnimationPlayMode>(largeInt));
80 OH_ArkUI_AnimateOption_SetPlayMode(animation, ArkUI_AnimationPlayMode::ARKUI_ANIMATION_PLAY_MODE_NORMAL);
81 EXPECT_EQ(OH_ArkUI_AnimateOption_GetDuration(nullptr), 0);
82 EXPECT_EQ(OH_ArkUI_AnimateOption_GetDuration(animation), normalInt);
83 EXPECT_EQ(OH_ArkUI_AnimateOption_GetTempo(nullptr), 0.0f);
84 EXPECT_EQ(OH_ArkUI_AnimateOption_GetTempo(animation), normalFloat);
85 EXPECT_EQ(OH_ArkUI_AnimateOption_GetCurve(nullptr), static_cast<ArkUI_AnimationCurve>(-1));
86 EXPECT_EQ(OH_ArkUI_AnimateOption_GetCurve(animation), ArkUI_AnimationCurve::ARKUI_CURVE_LINEAR);
87 EXPECT_EQ(OH_ArkUI_AnimateOption_GetDelay(nullptr), 0);
88 EXPECT_EQ(OH_ArkUI_AnimateOption_GetDelay(animation), normalInt);
89 EXPECT_EQ(OH_ArkUI_AnimateOption_GetIterations(nullptr), 0);
90 EXPECT_EQ(OH_ArkUI_AnimateOption_GetIterations(animation), normalInt);
91 EXPECT_EQ(OH_ArkUI_AnimateOption_GetPlayMode(nullptr), static_cast<ArkUI_AnimationPlayMode>(-1));
92 EXPECT_EQ(OH_ArkUI_AnimateOption_GetPlayMode(animation), ArkUI_AnimationPlayMode::ARKUI_ANIMATION_PLAY_MODE_NORMAL);
93 EXPECT_EQ(OH_ArkUI_AnimateOption_GetExpectedFrameRateRange(nullptr), nullptr);
94 EXPECT_EQ(OH_ArkUI_AnimateOption_GetExpectedFrameRateRange(animation), nullptr);
95
96 OH_ArkUI_AnimateOption_Dispose(nullptr);
97 OH_ArkUI_AnimateOption_Dispose(animation);
98 }
99
100 /**
101 * @tc.name: NodeAnimateTest002
102 * @tc.desc: Test ICurve function.
103 * @tc.type: FUNC
104 */
105 HWTEST_F(NodeAnimateTest, NodeAnimateTest002, TestSize.Level1)
106 {
107 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
108 ArkUI_AnimateOption* animation = OH_ArkUI_AnimateOption_Create();
109 ASSERT_NE(animation, nullptr);
110 auto icurve = OH_ArkUI_Curve_CreateCurveByType(ArkUI_AnimationCurve::ARKUI_CURVE_LINEAR);
111 auto stepCurve = OH_ArkUI_Curve_CreateStepsCurve(1, true);
112 auto cubicBezierCurve = OH_ArkUI_Curve_CreateCubicBezierCurve(0.0f, 0.0f, 0.0f, 0.0f);
113 auto springCurve = OH_ArkUI_Curve_CreateSpringCurve(0.0f, 0.0f, 0.0f, 0.0f);
114 auto springMotion = OH_ArkUI_Curve_CreateSpringMotion(0.5f, 0.5f, 0.5f);
115 auto responsiveSpringMotion = OH_ArkUI_Curve_CreateResponsiveSpringMotion(0.5f, 0.5f, 0.5f);
116 auto interpolatingSpring = OH_ArkUI_Curve_CreateInterpolatingSpring(0.5f, 0.5f, 0.5f, 0.5f);
117 auto customCurve = OH_ArkUI_Curve_CreateCustomCurve(nullptr, InterpolateCallback);
118 ASSERT_NE(icurve, nullptr);
119 ASSERT_NE(stepCurve, nullptr);
120 ASSERT_NE(cubicBezierCurve, nullptr);
121 ASSERT_NE(springCurve, nullptr);
122 ASSERT_NE(springMotion, nullptr);
123 ASSERT_NE(responsiveSpringMotion, nullptr);
124 ASSERT_NE(interpolatingSpring, nullptr);
125 ASSERT_NE(customCurve, nullptr);
126 OH_ArkUI_AnimateOption_SetICurve(animation, icurve);
127 EXPECT_EQ(OH_ArkUI_AnimateOption_GetICurve(nullptr), nullptr);
128 ASSERT_NE(OH_ArkUI_AnimateOption_GetICurve(animation), nullptr);
129 ArkUI_KeyframeAnimateOption* animateOption = OH_ArkUI_KeyframeAnimateOption_Create(1);
130 ASSERT_NE(animateOption, nullptr);
131 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(nullptr, icurve, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
132 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, icurve, -1), ARKUI_ERROR_CODE_PARAM_INVALID);
133 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, icurve, 1), ARKUI_ERROR_CODE_PARAM_INVALID);
134 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, nullptr, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
135 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, springMotion, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
136 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, responsiveSpringMotion, 0),
137 ARKUI_ERROR_CODE_PARAM_INVALID);
138 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, interpolatingSpring, 0),
139 ARKUI_ERROR_CODE_PARAM_INVALID);
140 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetCurve(animateOption, icurve, 0), ARKUI_ERROR_CODE_NO_ERROR);
141 EXPECT_NE(OH_ArkUI_KeyframeAnimateOption_GetCurve(animateOption, 0), nullptr);
142 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetCurve(nullptr, 0), nullptr);
143 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetCurve(animateOption, -1), nullptr);
144 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetCurve(animateOption, 1), nullptr);
145 OH_ArkUI_AnimateOption_Dispose(animation);
146 OH_ArkUI_KeyframeAnimateOption_Dispose(animateOption);
147 OH_ArkUI_Curve_DisposeCurve(icurve);
148 OH_ArkUI_Curve_DisposeCurve(stepCurve);
149 OH_ArkUI_Curve_DisposeCurve(cubicBezierCurve);
150 OH_ArkUI_Curve_DisposeCurve(springCurve);
151 OH_ArkUI_Curve_DisposeCurve(springMotion);
152 OH_ArkUI_Curve_DisposeCurve(responsiveSpringMotion);
153 OH_ArkUI_Curve_DisposeCurve(customCurve);
154 }
155
156 /**
157 * @tc.name: NodeAnimateTest003
158 * @tc.desc: Test KeyframeAnimateOption normalfunction.
159 * @tc.type: FUNC
160 */
161 HWTEST_F(NodeAnimateTest, NodeAnimateTest003, TestSize.Level1)
162 {
163 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
164 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_Create(-1), nullptr);
165 ArkUI_KeyframeAnimateOption* animateOption = OH_ArkUI_KeyframeAnimateOption_Create(1);
166 ASSERT_NE(animateOption, nullptr);
167 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDelay(nullptr, 1), ARKUI_ERROR_CODE_PARAM_INVALID);
168 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDelay(animateOption, 1), ARKUI_ERROR_CODE_NO_ERROR);
169 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetDelay(animateOption), 1);
170 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetIterations(nullptr, 1), ARKUI_ERROR_CODE_PARAM_INVALID);
171 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetIterations(animateOption, -2), ARKUI_ERROR_CODE_PARAM_INVALID);
172 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetIterations(animateOption, 1), ARKUI_ERROR_CODE_NO_ERROR);
173 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetIterations(animateOption), 1);
174 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDuration(nullptr, 1, 1), ARKUI_ERROR_CODE_PARAM_INVALID);
175 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDuration(animateOption, 1, -1), ARKUI_ERROR_CODE_PARAM_INVALID);
176 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDuration(animateOption, 1, 1), ARKUI_ERROR_CODE_PARAM_INVALID);
177 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDuration(animateOption, -1, 0), ARKUI_ERROR_CODE_NO_ERROR);
178 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_SetDuration(animateOption, 1, 0), ARKUI_ERROR_CODE_NO_ERROR);
179 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetDuration(animateOption, 0), 1);
180 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetDuration(nullptr, 0), 0);
181 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetDuration(animateOption, -1), 0);
182 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_GetDuration(animateOption, 1), 0);
183 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_RegisterOnFinishCallback(animateOption, nullptr, AnimationCallback),
184 ARKUI_ERROR_CODE_NO_ERROR);
185 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_RegisterOnEventCallback(nullptr, nullptr, AnimationCallback, 0),
186 ARKUI_ERROR_CODE_PARAM_INVALID);
187 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_RegisterOnEventCallback(animateOption, nullptr, AnimationCallback, -1),
188 ARKUI_ERROR_CODE_PARAM_INVALID);
189 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_RegisterOnEventCallback(animateOption, nullptr, AnimationCallback, 1),
190 ARKUI_ERROR_CODE_PARAM_INVALID);
191 EXPECT_EQ(OH_ArkUI_KeyframeAnimateOption_RegisterOnEventCallback(animateOption, nullptr, AnimationCallback, 0),
192 ARKUI_ERROR_CODE_NO_ERROR);
193 OH_ArkUI_KeyframeAnimateOption_Dispose(animateOption);
194 }
195
196 /**
197 * @tc.name: NodeAnimateTest004
198 * @tc.desc: Test AnimatorOption function.
199 * @tc.type: FUNC
200 */
201 HWTEST_F(NodeAnimateTest, NodeAnimateTest004, TestSize.Level1)
202 {
203 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
204 EXPECT_EQ(OH_ArkUI_AnimatorOption_Create(-1), nullptr);
205 ArkUI_AnimatorOption* animatorOption = OH_ArkUI_AnimatorOption_Create(0);
206 ASSERT_NE(animatorOption, nullptr);
207 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetDuration(animatorOption, -1), ARKUI_ERROR_CODE_PARAM_INVALID);
208 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetDuration(animatorOption, 1), ARKUI_ERROR_CODE_NO_ERROR);
209 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetDuration(nullptr), -1);
210 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetDuration(animatorOption), 1);
211 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetDelay(animatorOption, 1), ARKUI_ERROR_CODE_NO_ERROR);
212 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetDelay(nullptr), -1);
213 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetDelay(animatorOption), 1);
214 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetIterations(animatorOption, -2), ARKUI_ERROR_CODE_NO_ERROR);
215 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetIterations(animatorOption, 1), ARKUI_ERROR_CODE_NO_ERROR);
216 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetIterations(nullptr), -1);
217 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetIterations(animatorOption), 1);
218 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetFill(animatorOption, static_cast<ArkUI_AnimationFillMode>(-1)),
219 ARKUI_ERROR_CODE_PARAM_INVALID);
220 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetFill(animatorOption, static_cast<ArkUI_AnimationFillMode>(1000)),
221 ARKUI_ERROR_CODE_PARAM_INVALID);
222 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetFill(animatorOption, ARKUI_ANIMATION_FILL_MODE_NONE),
223 ARKUI_ERROR_CODE_NO_ERROR);
224 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetFill(nullptr), static_cast<ArkUI_AnimationFillMode>(-1));
225 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetFill(animatorOption), ARKUI_ANIMATION_FILL_MODE_NONE);
226 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetDirection(animatorOption, static_cast<ArkUI_AnimationDirection>(-1)),
227 ARKUI_ERROR_CODE_PARAM_INVALID);
228 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetDirection(animatorOption, static_cast<ArkUI_AnimationDirection>(1000)),
229 ARKUI_ERROR_CODE_PARAM_INVALID);
230 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetDirection(animatorOption, ARKUI_ANIMATION_DIRECTION_NORMAL),
231 ARKUI_ERROR_CODE_NO_ERROR);
232 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetDirection(nullptr), static_cast<ArkUI_AnimationDirection>(-1));
233 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetDirection(animatorOption), ARKUI_ANIMATION_DIRECTION_NORMAL);
234 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetBegin(animatorOption, 0.0f), ARKUI_ERROR_CODE_NO_ERROR);
235 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetBegin(nullptr), 0.0f);
236 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetBegin(animatorOption), 0.0f);
237 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetEnd(animatorOption, 1.0f), ARKUI_ERROR_CODE_NO_ERROR);
238 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetEnd(nullptr), 1.0f);
239 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetEnd(animatorOption), 1.0f);
240 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, -1.0f, 0.0f, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
241 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 2.0f, 0.0f, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
242 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5f, 0.0f, -1), ARKUI_ERROR_CODE_PARAM_INVALID);
243 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5f, 0.0f, 0), ARKUI_ERROR_CODE_PARAM_INVALID);
244 auto range = new ArkUI_ExpectedFrameRateRange({1, 100, 50});
245 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetExpectedFrameRateRange(animatorOption, range), ARKUI_ERROR_CODE_NO_ERROR);
246 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetExpectedFrameRateRange(nullptr), nullptr);
247 EXPECT_NE(OH_ArkUI_AnimatorOption_GetExpectedFrameRateRange(animatorOption), nullptr);
248 OH_ArkUI_AnimatorOption_Dispose(animatorOption);
249 delete range;
250 range = nullptr;
251 }
252
253 /**
254 * @tc.name: NodeAnimateTest005
255 * @tc.desc: Test AnimatorOption Curve function.
256 * @tc.type: FUNC
257 */
258 HWTEST_F(NodeAnimateTest, NodeAnimateTest005, TestSize.Level1)
259 {
260 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
261 ArkUI_AnimatorOption* animatorOption = OH_ArkUI_AnimatorOption_Create(0);
262 ArkUI_AnimatorOption* animatorKeyFrameOption = OH_ArkUI_AnimatorOption_Create(1);
263 ASSERT_NE(animatorOption, nullptr);
264 ASSERT_NE(animatorKeyFrameOption, nullptr);
265 auto icurve = OH_ArkUI_Curve_CreateCurveByType(ArkUI_AnimationCurve::ARKUI_CURVE_LINEAR);
266 auto springCurve = OH_ArkUI_Curve_CreateSpringCurve(0.0f, 0.0f, 0.0f, 0.0f);
267 auto springMotion = OH_ArkUI_Curve_CreateSpringMotion(0.5f, 0.5f, 0.5f);
268 auto responsiveSpringMotion = OH_ArkUI_Curve_CreateResponsiveSpringMotion(0.5f, 0.5f, 0.5f);
269 auto interpolatingSpring = OH_ArkUI_Curve_CreateInterpolatingSpring(0.5f, 0.5f, 0.5f, 0.5f);
270 auto customCurve = OH_ArkUI_Curve_CreateCustomCurve(nullptr, InterpolateCallback);
271 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetCurve(animatorOption, springCurve), ARKUI_ERROR_CODE_PARAM_INVALID);
272 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetCurve(animatorOption, springMotion), ARKUI_ERROR_CODE_PARAM_INVALID);
273 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetCurve(animatorOption, responsiveSpringMotion), ARKUI_ERROR_CODE_PARAM_INVALID);
274 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetCurve(animatorOption, interpolatingSpring), ARKUI_ERROR_CODE_PARAM_INVALID);
275 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetCurve(animatorOption, customCurve), ARKUI_ERROR_CODE_PARAM_INVALID);
276 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetCurve(animatorOption, icurve), ARKUI_ERROR_CODE_NO_ERROR);
277 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetCurve(nullptr), nullptr);
278 EXPECT_NE(OH_ArkUI_AnimatorOption_GetCurve(animatorOption), nullptr);
279 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, springCurve, 0),
280 ARKUI_ERROR_CODE_PARAM_INVALID);
281 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, springMotion, 0),
282 ARKUI_ERROR_CODE_PARAM_INVALID);
283 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, responsiveSpringMotion, 0),
284 ARKUI_ERROR_CODE_PARAM_INVALID);
285 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, interpolatingSpring, 0),
286 ARKUI_ERROR_CODE_PARAM_INVALID);
287 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, customCurve, 0),
288 ARKUI_ERROR_CODE_PARAM_INVALID);
289 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, nullptr, -1),
290 ARKUI_ERROR_CODE_PARAM_INVALID);
291 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, nullptr, 1),
292 ARKUI_ERROR_CODE_PARAM_INVALID);
293 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframeCurve(animatorKeyFrameOption, icurve, 0), ARKUI_ERROR_CODE_NO_ERROR);
294 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeCurve(nullptr, 0), nullptr);
295 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeCurve(nullptr, -1), nullptr);
296 OH_ArkUI_Curve_DisposeCurve(icurve);
297 OH_ArkUI_Curve_DisposeCurve(springCurve);
298 OH_ArkUI_Curve_DisposeCurve(springMotion);
299 OH_ArkUI_Curve_DisposeCurve(responsiveSpringMotion);
300 OH_ArkUI_Curve_DisposeCurve(customCurve);
301 OH_ArkUI_AnimatorOption_Dispose(animatorOption);
302 OH_ArkUI_AnimatorOption_Dispose(animatorKeyFrameOption);
303 }
304
305 /**
306 * @tc.name: NodeAnimateTest006
307 * @tc.desc: Test AnimatorOption Keyframe function.
308 * @tc.type: FUNC
309 */
310 HWTEST_F(NodeAnimateTest, NodeAnimateTest006, TestSize.Level1)
311 {
312 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
313 ArkUI_AnimatorOption* animatorOption = OH_ArkUI_AnimatorOption_Create(1);
314 EXPECT_EQ(OH_ArkUI_AnimatorOption_SetKeyframe(animatorOption, 0.5f, 0.0f, 0), ARKUI_ERROR_CODE_NO_ERROR);
315 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeTime(nullptr, 0), -1.0f);
316 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, -1), -1.0f);
317 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 1), -1.0f);
318 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeTime(animatorOption, 0), 0.5f);
319 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeValue(nullptr, 0), -1.0f);
320 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, -1), -1.0f);
321 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 1), -1.0f);
322 EXPECT_EQ(OH_ArkUI_AnimatorOption_GetKeyframeValue(animatorOption, 0), 0.0f);
323 OH_ArkUI_AnimatorOption_Dispose(animatorOption);
324 }
325
326 /**
327 * @tc.name: NodeAnimateTest007
328 * @tc.desc: Test Animator function.
329 * @tc.type: FUNC
330 */
331 HWTEST_F(NodeAnimateTest, NodeAnimateTest007, TestSize.Level1)
332 {
333 auto animateAPI = reinterpret_cast<ArkUI_NativeAnimateAPI_1*>(
334 OH_ArkUI_QueryModuleInterfaceByName(ARKUI_NATIVE_ANIMATE, "ArkUI_NativeAnimateAPI_1"));
335 struct ArkUI_Context context= {1};
336 ArkUI_AnimatorOption* animatorOption = OH_ArkUI_AnimatorOption_Create(1);
337 auto handle = animateAPI->createAnimator(&context, animatorOption);
338 ASSERT_NE(handle, nullptr);
339 EXPECT_EQ(OH_ArkUI_Animator_ResetAnimatorOption(handle, animatorOption), ARKUI_ERROR_CODE_PARAM_INVALID);
340 EXPECT_EQ(OH_ArkUI_Animator_Play(handle), ARKUI_ERROR_CODE_PARAM_INVALID);
341 EXPECT_EQ(OH_ArkUI_Animator_Finish(handle), ARKUI_ERROR_CODE_PARAM_INVALID);
342 EXPECT_EQ(OH_ArkUI_Animator_Pause(handle), ARKUI_ERROR_CODE_PARAM_INVALID);
343 EXPECT_EQ(OH_ArkUI_Animator_Cancel(handle), ARKUI_ERROR_CODE_PARAM_INVALID);
344 EXPECT_EQ(OH_ArkUI_Animator_Reverse(handle), ARKUI_ERROR_CODE_PARAM_INVALID);
345 OH_ArkUI_AnimatorOption_Dispose(animatorOption);
346 animateAPI->disposeAnimator(handle);
347 }
348
349 /**
350 * @tc.name: NodeAnimateTest008
351 * @tc.desc: Test AnimatorEvent function.
352 * @tc.type: FUNC
353 */
354 HWTEST_F(NodeAnimateTest, NodeAnimateTest008, TestSize.Level1)
355 {
356 ASSERT_TRUE(OHOS::Ace::NodeModel::InitialFullImpl());
357 ArkUI_AnimatorOption* animatorOption = OH_ArkUI_AnimatorOption_Create(1);
358 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(nullptr, nullptr, nullptr),
359 ARKUI_ERROR_CODE_PARAM_INVALID);
360 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr, nullptr),
361 ARKUI_ERROR_CODE_PARAM_INVALID);
362 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnFrameCallback(animatorOption, nullptr, AnimatorOnFrameEventCallback),
363 ARKUI_ERROR_CODE_NO_ERROR);
364 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnFinishCallback(nullptr, nullptr, nullptr),
365 ARKUI_ERROR_CODE_PARAM_INVALID);
366 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnFinishCallback(animatorOption, nullptr, nullptr),
367 ARKUI_ERROR_CODE_PARAM_INVALID);
368 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnFinishCallback(animatorOption, nullptr, AnimatorEventCallback),
369 ARKUI_ERROR_CODE_NO_ERROR);
370 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnCancelCallback(nullptr, nullptr, nullptr),
371 ARKUI_ERROR_CODE_PARAM_INVALID);
372 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnCancelCallback(animatorOption, nullptr, nullptr),
373 ARKUI_ERROR_CODE_PARAM_INVALID);
374 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnCancelCallback(animatorOption, nullptr, AnimatorEventCallback),
375 ARKUI_ERROR_CODE_NO_ERROR);
376 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnRepeatCallback(nullptr, nullptr, nullptr),
377 ARKUI_ERROR_CODE_PARAM_INVALID);
378 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnRepeatCallback(animatorOption, nullptr, nullptr),
379 ARKUI_ERROR_CODE_PARAM_INVALID);
380 EXPECT_EQ(OH_ArkUI_AnimatorOption_RegisterOnRepeatCallback(animatorOption, nullptr, AnimatorEventCallback),
381 ARKUI_ERROR_CODE_NO_ERROR);
382 OH_ArkUI_AnimatorOption_Dispose(animatorOption);
383 }
384 } // namespace OHOS::Ace