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
26using namespace testing;
27using namespace testing::ext;
28namespace OHOS::Ace {
29class NodeAnimateTest : public testing::Test {
30public:
31    static void SetUpTestCase() {};
32    static void TearDownTestCase() {};
33};
34
35float InterpolateCallback(float fraction, void* userData)
36{
37    return fraction;
38}
39
40void AnimationCallback(void* userData)
41{
42}
43
44void AnimatorOnFrameEventCallback(ArkUI_AnimatorOnFrameEvent* event)
45{
46}
47
48void AnimatorEventCallback(ArkUI_AnimatorEvent* event)
49{
50}
51
52/**
53 * @tc.name: NodeAnimateTest001
54 * @tc.desc: Test AnimateOption function.
55 * @tc.type: FUNC
56 */
57HWTEST_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 */
105HWTEST_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 */
161HWTEST_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 */
201HWTEST_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 */
258HWTEST_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 */
310HWTEST_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 */
331HWTEST_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 */
354HWTEST_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