archives/pebble
2
0
Fork 0
mirror of https://github.com/google/pebble.git synced 2025-03-19 18:41:21 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
pebble/tests/fw/ui/test_animation.c

3754 lines
138 KiB
C
Raw Permalink Normal View History

Import of the watch repository from Pebble
2024-12-12 16:43:03 -08:00
/*
* Copyright 2024 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "clar.h"
#include "applib/graphics/gtypes.h"
#include "applib/graphics/gtransform.h"
#include "applib/ui/layer.h"
#include "applib/ui/property_animation.h"
#include "applib/ui/property_animation_private.h"
#include "applib/ui/animation.h"
#include "applib/ui/animation_private.h"
#include "applib/legacy2/ui/animation_private_legacy2.h"
#include "util/math.h"
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
///////////////////////////////////////////////////////////
// Stubs
#include "stubs_logging.h"
#include "stubs_passert.h"
#include "stubs_app_state.h"
#include "stubs_app_timer.h"
#include "stubs_freertos.h"
#include "stubs_heap.h"
#include "stubs_mutex.h"
#include "stubs_resources.h"
#include "stubs_serial.h"
#include "stubs_syscalls.h"
#include "stubs_unobstructed_area.h"
// Fakes
#include "fake_new_timer.h"
#include "fake_pebble_tasks.h"
#include "fake_pbl_malloc.h"
#include "fake_rtc.h"
#include "fake_events.h"
#define TEST_INCLUDE_BASIC
#define TEST_INCLUDE_COMPLEX
#define DEBUG_TEST
#ifdef DEBUG_TEST
#define DPRINTF(fmt, ...) \
do { printf("%s: " fmt , __func__, ## __VA_ARGS__); \
} while (0)
#else
#define DPRINTF(fmt, ...)
#endif
// Use our own macro instead of the abs function to avoid issues with non-int values.
#define ABSOLUTE_VALUE(x) (((x) > 0) ? (x) : -(x))
#define MIN_FRAME_INTERVAL_MS 33
#define TEST_ANIMATION_NORMALIZED_HIGH 50000
#define TEST_ANIMATION_NORMALIZED_LOW 5000
static PebbleEvent s_last_event;
bool process_manager_send_event_to_process(PebbleTask task, PebbleEvent* e) {
s_last_event = *e;
return true;
}
bool process_manager_compiled_with_legacy2_sdk(void) {
return false;
}
GDrawState graphics_context_get_drawing_state(GContext *ctx) {
return (GDrawState) { };
}
bool graphics_release_frame_buffer(GContext *ctx, GBitmap *buffer) {
return false;
}
void graphics_context_set_drawing_state(GContext *ctx, GDrawState draw_state) {
}
void window_schedule_render(struct Window *window) {
}
TimerID animation_service_test_get_timer_id(void);
// --------------------------------------------------------------------------------------
static void cl_assert_equal_point(const GPoint a, const GPoint b) {
cl_assert_equal_i(a.x, b.x);
cl_assert_equal_i(a.y, b.y);
}
// --------------------------------------------------------------------------------------
static void cl_assert_equal_rect(const GRect a, const GRect b) {
cl_assert_equal_point(a.origin, b.origin);
cl_assert_equal_i(a.size.w, b.size.w);
cl_assert_equal_i(a.size.h, b.size.h);
}
// --------------------------------------------------------------------------------------
static void cl_assert_equal_gtransform(const GTransform a, const GTransform b) {
cl_assert_equal_i(a.a.raw_value, b.a.raw_value);
cl_assert_equal_i(a.b.raw_value, b.b.raw_value);
cl_assert_equal_i(a.c.raw_value, b.c.raw_value);
cl_assert_equal_i(a.d.raw_value, b.d.raw_value);
cl_assert_equal_i(a.tx.raw_value, b.tx.raw_value);
cl_assert_equal_i(a.ty.raw_value, b.ty.raw_value);
}
static void cl_assert_close_gtransform(const GTransform a, const GTransform b) {
cl_assert(abs(a.a.integer - b.a.integer) < 10);
cl_assert(abs(a.b.integer - b.b.integer) < 10);
cl_assert(abs(a.c.integer - b.c.integer) < 10);
cl_assert(abs(a.d.integer - b.d.integer) < 10);
cl_assert(abs(a.tx.integer - b.tx.integer) < 10);
cl_assert(abs(a.ty.integer - b.ty.integer) < 10);
}
// --------------------------------------------------------------------------------------
static void cl_assert_equal_fixed_s32_16(const Fixed_S32_16 a, const Fixed_S32_16 b) {
cl_assert_equal_i(a.raw_value, b.raw_value);
}
static void cl_assert_close_fixed_s32_16(const Fixed_S32_16 a, const Fixed_S32_16 b) {
cl_assert(abs(a.integer - b.integer) < 10);
}
// --------------------------------------------------------------------------------------
// Get current time in ms.
static uint64_t prv_now_ms(void) {
RtcTicks ticks = rtc_get_ticks();
return (ticks * 1000 + RTC_TICKS_HZ / 2) / RTC_TICKS_HZ;
}
// --------------------------------------------------------------------------------------
// Advance current time by N ms. This does NOT check to see if the timer should fire
// If you want to advance time and fire all timers that would have fired during that time
// call prv_advance_to_ms_with_timers()
static void prv_advance_by_ms_no_timers(uint64_t ms_delta) {
uint64_t target_ms = prv_now_ms() + ms_delta;
// Comppensate for rounding errors
uint64_t new_ticks = rtc_get_ticks() + (ms_delta * RTC_TICKS_HZ + 500 ) / 1000;
uint64_t new_ms = (new_ticks * 1000 + RTC_TICKS_HZ / 2) / RTC_TICKS_HZ;
if (new_ms == target_ms - 1) {
new_ticks++;
} else if (new_ms == target_ms + 1) {
new_ticks--;
}
new_ms = (new_ticks * 1000 + RTC_TICKS_HZ / 2) / RTC_TICKS_HZ;
cl_assert(new_ms == target_ms);
fake_rtc_set_ticks(new_ticks);
}
// --------------------------------------------------------------------------------------
// Fire the timer used by the animation service. Before doing so, advance the time to when
// the timer would fire next.
static void prv_fire_animation_timer(void) {
TimerID sys_timer_id = animation_service_test_get_timer_id();
if (!sys_timer_id) {
DPRINTF("timer not scheduled\n");
return;
}
if (!stub_new_timer_is_scheduled(sys_timer_id)) {
DPRINTF("timer not scheduled\n");
return;
}
// Advance time
uint32_t ms_delta = stub_new_timer_timeout(sys_timer_id);
prv_advance_by_ms_no_timers(ms_delta);
// This posts a callback event to the KernelMain event queue
stub_new_timer_fire(sys_timer_id);
// Get the callback event and process it
PebbleEvent evt = fake_event_get_last();
cl_assert_equal_i(evt.type, PEBBLE_CALLBACK_EVENT);
evt.callback.callback(evt.callback.data);
}
// --------------------------------------------------------------------------------------
// Advance to the given time, firing all timers that are scheduled along the way
static void prv_advance_to_ms_with_timers(uint64_t dst_time) {
uint64_t now = prv_now_ms();
while (now < dst_time) {
TimerID sys_timer_id = animation_service_test_get_timer_id();
if (!sys_timer_id) {
DPRINTF("timer not created\n");
prv_advance_by_ms_no_timers(dst_time - now);
return;
}
if (!stub_new_timer_is_scheduled(sys_timer_id)) {
DPRINTF("timer not scheduled\n");
prv_advance_by_ms_no_timers(dst_time - now);
return;
}
// Advance time to when timer would fire and fire it
uint32_t ms_delta = stub_new_timer_timeout(sys_timer_id);
if (ms_delta < dst_time - now) {
prv_fire_animation_timer();
} else {
prv_advance_by_ms_no_timers(dst_time - now);
return;
}
now = prv_now_ms();
}
}
// =============================================================================================
// Started. stopped, setup, and teardown handler call histories. Every time a handler runs, we
// append the time animation handle and timestamp to the history list.
typedef struct {
uint64_t fired_time_ms;
uint32_t fire_order;
bool finished; // only applicable for stopped handlers
void *context; // For update handler, this is the distance arg
Animation *animation; // which animation
} AnimTestHandlerEntry;
#define MAX_HANDLER_CALLS 500
typedef struct {
uint32_t num_calls;
AnimTestHandlerEntry entries[MAX_HANDLER_CALLS];
} AnimTestHandlerHistory;
static AnimTestHandlerHistory s_started_handler_calls;
static AnimTestHandlerHistory s_stopped_handler_calls;
static AnimTestHandlerHistory s_setup_handler_calls;
static AnimTestHandlerHistory s_teardown_handler_calls;
static AnimTestHandlerHistory s_update_handler_calls;
static uint32_t s_fire_order_index;
// -------------------------------------------------------------------------
// Clear all handler history
static void prv_clear_handler_histories(void) {
memset(&s_started_handler_calls, 0, sizeof(AnimTestHandlerHistory));
memset(&s_stopped_handler_calls, 0, sizeof(AnimTestHandlerHistory));
memset(&s_setup_handler_calls, 0, sizeof(AnimTestHandlerHistory));
memset(&s_teardown_handler_calls, 0, sizeof(AnimTestHandlerHistory));
memset(&s_update_handler_calls, 0, sizeof(AnimTestHandlerHistory));
}
// -------------------------------------------------------------------------
// Add an entry to the history
static void prv_add_handler_entry(AnimTestHandlerHistory *history, Animation *animation,
bool finished, void *context) {
cl_assert(history->num_calls < MAX_HANDLER_CALLS);
history->entries[history->num_calls++] = (AnimTestHandlerEntry) {
.fired_time_ms = prv_now_ms(),
.fire_order = s_fire_order_index++,
.finished = finished,
.context = context,
.animation = animation
};
}
// -------------------------------------------------------------------------
// Count how many entries were entered for the given animation
static uint32_t prv_count_handler_entries(AnimTestHandlerHistory *history, Animation *animation) {
uint32_t count = 0;
for (int i = 0; i < history->num_calls; i++) {
if (!animation || history->entries[i].animation == animation) {
count++;
}
}
return count;
}
// -------------------------------------------------------------------------
// Get the last entry for the given handle
static AnimTestHandlerEntry *prv_last_handler_entry(AnimTestHandlerHistory *history,
Animation *animation) {
int last_entry=-1;
for (int i = 0; i < history->num_calls; i++) {
if (!animation || history->entries[i].animation == animation) {
last_entry = i;
}
}
if (last_entry == -1) {
return NULL;
} else {
return &history->entries[last_entry];
}
}
// -------------------------------------------------------------------------
// Get the last distance from an update handler
static uint32_t prv_last_update_distance(Animation *animation) {
AnimTestHandlerEntry *entry = prv_last_handler_entry(&s_update_handler_calls, animation);
if (entry) {
return (uint32_t)entry->context;
} else {
return 0;
}
}
// =============================================================================================
// Handlers
// --------------------------------------------------------------------------------------
// Started handler
static void prv_started_handler(Animation *animation, void *context) {
prv_add_handler_entry(&s_started_handler_calls, animation, false, context);
DPRINTF("%"PRIu64" ms: Executing started handler for %d\n", prv_now_ms(), (int)animation);
}
// --------------------------------------------------------------------------------------
// Stopped handler
static void prv_stopped_handler(Animation *animation, bool finished, void *context) {
prv_add_handler_entry(&s_stopped_handler_calls, animation, finished, context);
DPRINTF("%"PRIu64" ms: Executing stopped handler for %d\n", prv_now_ms(), (int)animation);
}
// --------------------------------------------------------------------------------------
// Stopped handler with check for finish
static void prv_stopped_handler_check_finished(Animation *animation, bool finished, void *context) {
prv_add_handler_entry(&s_stopped_handler_calls, animation, finished, context);
DPRINTF("%"PRIu64" ms: Executing stopped handler for %d\n", prv_now_ms(), (int)animation);
cl_assert(finished);
AnimationPrivate *animation_private = animation_private_animation_find(animation);
if (animation_private) {
// Flag should now get reset to false before entering stopped handler
cl_assert(animation_private->is_completed == false);
}
}
// --------------------------------------------------------------------------------------
// Stopped handler that calls reschedule the first time it is called
static void prv_stopped_handler_reschedule(Animation *animation, bool finished, void *context) {
prv_add_handler_entry(&s_stopped_handler_calls, animation, finished, context);
if (s_stopped_handler_calls.num_calls == 1) {
DPRINTF("%"PRIu64" ms: Rescheduling from stopped handler for %d\n", prv_now_ms(),
(int)animation);
animation_schedule(animation);
} else {
DPRINTF("%"PRIu64" ms: NOT rescheduling from stopped handler for %d\n", prv_now_ms(),
(int)animation);
}
}
// --------------------------------------------------------------------------------------
// setup handler
void prv_setup_handler(Animation *animation) {
prv_add_handler_entry(&s_setup_handler_calls, animation, false, NULL);
DPRINTF("%"PRIu64" ms: Executing setup handler for %d\n", prv_now_ms(), (int)animation);
}
// --------------------------------------------------------------------------------------
// teardown handler
void prv_teardown_handler(Animation *animation) {
prv_add_handler_entry(&s_teardown_handler_calls, animation, false, NULL);
DPRINTF("%"PRIu64" ms: Executing teardown handler for %d\n", prv_now_ms(), (int)animation);
}
// --------------------------------------------------------------------------------------
// update handler
// implemented in Animation.c
AnimationPrivate *prv_animation_get_current(void);
void prv_update_handler(Animation *animation, const AnimationProgress distance) {
// always ensure that animation state gives access to the current animation
cl_assert_equal_p(animation_private_animation_find(animation), prv_animation_get_current());
prv_add_handler_entry(&s_update_handler_calls, animation, false,
(void *)(uintptr_t)distance /*context*/);
DPRINTF("%"PRIu64" ms: Executing update handler for %d, distance: %d\n", prv_now_ms(),
(int)animation, (int)distance);
}
// --------------------------------------------------------------------------------------
static int s_custom_curve_call_count;
static AnimationProgress prv_custom_curve(AnimationProgress distance) {
// Input is a value from 0 to 65535 (ANIMATION_NORMALIZED_MAX)
// Output is a value from 0 to 65535
s_custom_curve_call_count++;
return distance;
}
// --------------------------------------------------------------------------------------
// Count how many animations have been allocated
static uint32_t prv_count_animations(void) {
AnimationState *state = kernel_applib_get_animation_state();
return list_count(state->unscheduled_head) + list_count(state->scheduled_head);
}
// --------------------------------------------------------------------------------------
// Count how many animations have been scheduled
static uint32_t prv_count_scheduled_animations(void) {
AnimationState *state = kernel_applib_get_animation_state();
return list_count(state->scheduled_head);
}
// --------------------------------------------------------------------------------------
static void prv_int16_setter(int16_t *p, int16_t value) {
*p = value;
}
static int16_t prv_int16_getter(int16_t *p) {
return *p;
}
// --------------------------------------------------------------------------------------
static void prv_gpoint_setter(GPoint *p, GPoint value) {
*p = value;
}
static GPoint prv_gpoint_getter(GPoint *p) {
return *p;
}
// --------------------------------------------------------------------------------------
static void prv_gtransform_setter(GTransform *p, GTransform value) {
*p = value;
}
static GTransform prv_gtransform_getter(GTransform *p) {
return *p;
}
// --------------------------------------------------------------------------------------
static void prv_gcolor8_setter(GColor8 *p, GColor8 value) {
*p = value;
}
static GColor8 prv_gcolor8_getter(GColor8 *p) {
return *p;
}
// --------------------------------------------------------------------------------------
static void prv_fixed_s32_16_setter(Fixed_S32_16 *p, Fixed_S32_16 value) {
*p = value;
}
static Fixed_S32_16 prv_fixed_s32_16_getter(Fixed_S32_16 *p) {
return *p;
}
// --------------------------------------------------------------------------------------
static void prv_uint32_setter(int32_t *p, uint32_t value) {
*p = value;
}
static uint32_t prv_uint32_getter(uint32_t *p) {
return *p;
}
// --------------------------------------------------------------------------------------
// Helper function for creating a int16 property animation
static Animation *prv_create_test_animation(void) {
Animation *h;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
static const AnimationImplementation implementation = {
.setup = prv_setup_handler,
.update = prv_update_handler,
.teardown = prv_teardown_handler
};
h = animation_create();
cl_assert(h != NULL);
void *context = h;
animation_set_handlers(h, handlers, context);
animation_set_implementation(h, &implementation);
return h;
}
// --------------------------------------------------------------------------------------
// Setup. Called before each of the tests execute
void test_animation__initialize(void) {
fake_rtc_init(1024*200 /*ticks */, 200 /*seconds */);
AnimationState *state = kernel_applib_get_animation_state();
animation_private_state_init(state);
// Insure that at least some time elapsed after init so that state->last_frame_time is
// in the past.
prv_advance_by_ms_no_timers(10);
// Clear handler histories
prv_clear_handler_histories();
}
// -------------------------------------------------------------------------------------
// Cleanup, called after each test executes
void test_animation__cleanup(void) {
// Make sure no animations were left over
cl_assert_equal_i(prv_count_animations(), 0);
}
// --------------------------------------------------------------------------------------
// Test a basic layer_frame property animation
// Test that the started and stopped handlers get called at the right time
void test_animation__property_layer_frame(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Layer layer;
GRect from_r;
GRect to_r;
const int duration = 100;
GRect r;
void *subject;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
memset(&layer, 0, sizeof(layer));
from_r = GRect(0, 0, 100, 200); // x, y, width, height
to_r = GRect(1000, 2000, 100, 200); // x, y, width, height
prop_h = property_animation_create_layer_frame(&layer, &from_r, &to_r);
Animation *h = property_animation_get_animation(prop_h);
void *context = &layer;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
animation_set_auto_destroy(h, false);
// Clone it and make sure the clone is correct
PropertyAnimation *clone_h = (PropertyAnimation *)animation_clone((Animation *)prop_h);
property_animation_get_from_grect(clone_h, &r);
cl_assert_equal_rect(from_r, r);
property_animation_get_to_grect(clone_h, &r);
cl_assert_equal_rect(to_r, r);
property_animation_get_subject(prop_h, &subject);
cl_assert(subject == &layer);
property_animation_destroy(clone_h);
prv_clear_handler_histories();
animation_schedule(h);
int max_loops = 20;
uint64_t start_ms = prv_now_ms();
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls == 0) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure the frame reached the "to" state
cl_assert_equal_point(layer.frame.origin, to_r.origin);
// Make sure our started and stopped handlers got called
cl_assert_equal_i(s_started_handler_calls.num_calls, 1);;
cl_assert(s_started_handler_calls.entries[0].fired_time_ms - start_ms <= 1);
cl_assert(s_started_handler_calls.entries[0].context == context);
cl_assert_equal_i(s_stopped_handler_calls.num_calls, 1);;
cl_assert(s_stopped_handler_calls.entries[0].fired_time_ms - start_ms >= duration);
cl_assert(s_stopped_handler_calls.entries[0].context == context);
cl_assert(s_stopped_handler_calls.entries[0].finished);
// -------------------------------------------------------------------------------------------
// Test the accessor functions
property_animation_get_from_grect(prop_h, &r);
cl_assert_equal_rect(from_r, r);
property_animation_get_to_grect(prop_h, &r);
cl_assert_equal_rect(to_r, r);
property_animation_get_subject(prop_h, &subject);
cl_assert(subject == &layer);
GRect set_r = GRect(1, 2, 3, 4);
property_animation_set_from_grect(prop_h, &set_r);
r = GRect(0, 0, 0, 0);
property_animation_get_from_grect(prop_h, &r);
cl_assert_equal_rect(set_r, r);
set_r = GRect(5, 6, 7, 8);
property_animation_set_to_grect(prop_h, &set_r);
r = GRect(0, 0, 0, 0);
property_animation_get_to_grect(prop_h, &r);
cl_assert_equal_rect(set_r, r);
subject = (void *)0x11223344;
property_animation_set_subject(prop_h, &subject);
subject = NULL;
property_animation_get_subject(prop_h, &subject);
cl_assert(subject == (void *)0x11223344);
// Destroy it
animation_destroy(h);
#endif
}
// --------------------------------------------------------------------------------------
// Test a basic int16 property animation
// Test that the started and stopped handlers get called at the right time
// Test that the setup and teardown handlers get called at the right time
// Test that delay works
// Test that duration works
// Test that custom curve works
void test_animation__property_int16(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
int16_t value = 0;
int16_t start_value = 0, end_value = 100;
const int duration = 200;
const int delay = 25;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
static const PropertyAnimationImplementation implementation = {
.base = {
.setup = prv_setup_handler,
.update = (AnimationUpdateImplementation) property_animation_update_int16,
.teardown = prv_teardown_handler
},
.accessors = {
.setter = { .int16 = (const Int16Setter) prv_int16_setter, },
.getter = { .int16 = (const Int16Getter) prv_int16_getter },
},
};
prop_h = property_animation_create(&implementation, &value, &start_value, &end_value);
Animation *h = property_animation_get_animation(prop_h);
void *context = &value;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
animation_set_delay(h, delay);
animation_set_custom_curve(h, prv_custom_curve);
animation_set_auto_destroy(h, false);
prv_clear_handler_histories();
s_custom_curve_call_count = 0;
animation_schedule(h);
int max_loops = 20;
int num_loops = 0;
uint64_t start_ms = prv_now_ms();
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls == 0) {
num_loops++;
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": value at: %d\n", time_ms - start_ms, value);
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure the frame reached the "to" state
cl_assert_equal_i(value, 100);
// Make sure our started and stopped handlers got called
cl_assert_equal_i(s_started_handler_calls.num_calls, 1);;
cl_assert(ABSOLUTE_VALUE(s_started_handler_calls.entries[0].fired_time_ms - start_ms - delay) <= 1);
cl_assert_equal_i(s_setup_handler_calls.num_calls, 1);;
cl_assert(s_setup_handler_calls.entries[0].fired_time_ms - start_ms <= 1);
cl_assert_equal_i(s_stopped_handler_calls.num_calls, 1);;
cl_assert(s_stopped_handler_calls.entries[0].fired_time_ms - start_ms >= duration);
cl_assert(s_stopped_handler_calls.entries[0].finished);
cl_assert_equal_i(s_teardown_handler_calls.num_calls, 1);;
cl_assert(s_teardown_handler_calls.entries[0].fired_time_ms - start_ms >= duration);
// Make sure the custom curve function got called
cl_assert_equal_i(num_loops, s_custom_curve_call_count);
// -------------------------------------------------------------------------------------------
// Test the int16 accessor functions
int16_t test_value;
property_animation_get_from_int16(prop_h, &test_value);
cl_assert_equal_i(test_value, start_value);
property_animation_get_to_int16(prop_h, &test_value);
cl_assert_equal_i(test_value, end_value);
int16_t set_value;
set_value = 42;
property_animation_set_from_int16(prop_h, &set_value);
property_animation_get_from_int16(prop_h, &test_value);
cl_assert_equal_i(test_value, set_value);
set_value = 43;
property_animation_set_to_int16(prop_h, &set_value);
property_animation_get_to_int16(prop_h, &test_value);
cl_assert_equal_i(test_value, set_value);
// Destroy it
animation_destroy(h);
#endif
}
// --------------------------------------------------------------------------------------
// Test a basic gpoint property animation
void test_animation__property_gpoint(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
GPoint value;
GPoint start_value, end_value;
const int duration = 200;
const int delay = 25;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
static const PropertyAnimationImplementation implementation = {
.base = {
.update = (AnimationUpdateImplementation) property_animation_update_gpoint,
},
.accessors = {
.setter = { .gpoint = (const GPointSetter) prv_gpoint_setter, },
.getter = { .gpoint = (const GPointGetter) prv_gpoint_getter },
},
};
start_value = GPoint(0, 0);
end_value = GPoint(100, 200);
prop_h = property_animation_create(&implementation, &value, &start_value, &end_value);
Animation *h = property_animation_get_animation(prop_h);
void *context = &value;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
animation_set_delay(h, delay);
animation_set_auto_destroy(h, false);
prv_clear_handler_histories();
animation_schedule(h);
int max_loops = 20;
int num_loops = 0;
uint64_t start_ms = prv_now_ms();
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls == 0) {
num_loops++;
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": value at: (%d, %d)\n", time_ms - start_ms, value.x, value.y);
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure the frame reached the "to" state
cl_assert_equal_point(value, end_value);
// -------------------------------------------------------------------------------------------
// Test the GPoint accessor functions
GPoint test_value;
property_animation_get_from_gpoint(prop_h, &test_value);
cl_assert_equal_point(test_value, start_value);
property_animation_get_to_gpoint(prop_h, &test_value);
cl_assert_equal_point(test_value, end_value);
GPoint set_value;
set_value = GPoint(42, 43);
property_animation_set_from_gpoint(prop_h, &set_value);
property_animation_get_from_gpoint(prop_h, &test_value);
cl_assert_equal_point(test_value, set_value);
set_value = GPoint(44, 45);
property_animation_set_to_gpoint(prop_h, &set_value);
property_animation_get_to_gpoint(prop_h, &test_value);
cl_assert_equal_point(test_value, set_value);
// Destroy it
animation_destroy(h);
#endif
}
// --------------------------------------------------------------------------------------
// Test a basic gtransform property animation
void test_animation__property_gtransform(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
GTransform value;
GTransform start_value, end_value, mid_value;
const int duration = 1000;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
// NOTE: We are not exposing the GTransform in the public SDK, so the setter and getter
// must be typecast
static const PropertyAnimationImplementation implementation = {
.base = {
.update = (AnimationUpdateImplementation) property_animation_update_gtransform,
},
.accessors = {
.setter = { .int16 = (const Int16Setter) prv_gtransform_setter, },
.getter = { .int16 = (const Int16Getter) prv_gtransform_getter },
},
};
start_value = GTransformFromNumbers(1, 2, 3, 4, 5, 6);
end_value = GTransformFromNumbers(100, 200, 300, 400, 500, 600);
mid_value = GTransformFromNumbers(50, 101, 151, 202, 252, 303);
value = end_value;
prop_h = property_animation_create(&implementation, &value, &start_value, NULL);
Animation *h = property_animation_get_animation(prop_h);
void *context = &value;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(h);
// Test the accessor functions
GTransform test_value;
property_animation_get_from_gtransform(prop_h, &test_value);
cl_assert_equal_gtransform(test_value, start_value);
property_animation_get_to_gtransform(prop_h, &test_value);
cl_assert_equal_gtransform(test_value, end_value);
GTransform set_value;
set_value = GTransformIdentity();
property_animation_set_from_gtransform(prop_h, &set_value);
property_animation_get_from_gtransform(prop_h, &test_value);
cl_assert_equal_gtransform(test_value, GTransformIdentity());
property_animation_set_from_gtransform(prop_h, &start_value);
// Start, we should start at the start values
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_gtransform(value, start_value);
// Halfway through
prv_advance_to_ms_with_timers(start_ms + duration/2);
cl_assert_close_gtransform(value, mid_value);
// End
prv_advance_to_ms_with_timers(start_ms + duration + MIN_FRAME_INTERVAL_MS*2);
cl_assert_equal_gtransform(value, end_value);
#endif
}
// --------------------------------------------------------------------------------------
// Test a basic Fixed_S32_16 property animation
void test_animation__property_fixed_s32_16(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Fixed_S32_16 value;
Fixed_S32_16 start_value, end_value, mid_value;
const int duration = 1000;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
// NOTE: We are not exposing the GTransform in the public SDK, so the setter and getter
// must be typecast
static const PropertyAnimationImplementation implementation = {
.base = {
.update = (AnimationUpdateImplementation) property_animation_update_fixed_s32_16,
},
.accessors = {
.setter = { .int16 = (const Int16Setter) prv_fixed_s32_16_setter },
.getter = { .int16 = (const Int16Getter) prv_fixed_s32_16_getter },
},
};
start_value = ((Fixed_S32_16){ .integer = 1, .fraction = 0 });
end_value = ((Fixed_S32_16){ .integer = 100, .fraction = 0 });
mid_value = ((Fixed_S32_16){ .integer = 50, .fraction = 0 });
value = end_value;
prop_h = property_animation_create(&implementation, &value, &start_value, NULL);
Animation *h = property_animation_get_animation(prop_h);
void *context = &value;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(h);
// Test the accessor functions
Fixed_S32_16 test_value;
property_animation_get_from_fixed_s32_16(prop_h, &test_value);
cl_assert_equal_fixed_s32_16(test_value, start_value);
property_animation_get_to_fixed_s32_16(prop_h, &test_value);
cl_assert_equal_fixed_s32_16(test_value, end_value);
Fixed_S32_16 set_value;
set_value = FIXED_S32_16_ONE;
property_animation_set_from_fixed_s32_16(prop_h, &set_value);
property_animation_get_from_fixed_s32_16(prop_h, &test_value);
cl_assert_equal_fixed_s32_16(test_value, FIXED_S32_16_ONE);
property_animation_set_from_fixed_s32_16(prop_h, &start_value);
// Start, we should start at the start values
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_fixed_s32_16(value, start_value);
// Halfway through
prv_advance_to_ms_with_timers(start_ms + duration/2);
cl_assert_close_fixed_s32_16(value, mid_value);
// End
prv_advance_to_ms_with_timers(start_ms + duration + MIN_FRAME_INTERVAL_MS*2);
cl_assert_equal_fixed_s32_16(value, end_value);
#endif
}
// --------------------------------------------------------------------------------------
// Test a basic uint32_t property animation
void test_animation__property_uint32(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
uint32_t value;
uint32_t start_value, end_value, mid_value;
const int duration = 1000;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
// NOTE: We are not exposing the GTransform in the public SDK, so the setter and getter
// must be typecast
static const PropertyAnimationImplementation implementation = {
.base = {
.update = (AnimationUpdateImplementation) property_animation_update_uint32,
},
.accessors = {
.setter = { .uint32 = (const UInt32Setter) prv_uint32_setter },
.getter = { .uint32 = (const UInt32Getter) prv_uint32_getter },
},
};
start_value = 1;
end_value = 100;
mid_value = 50;
value = end_value;
prop_h = property_animation_create(&implementation, &value, &start_value, NULL);
Animation *h = property_animation_get_animation(prop_h);
void *context = &value;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(h);
// Test the accessor functions
uint32_t test_value;
property_animation_get_from_uint32(prop_h, &test_value);
cl_assert_equal_i(test_value, start_value);
property_animation_get_to_uint32(prop_h, &test_value);
cl_assert_equal_i(test_value, end_value);
uint32_t set_value = 1;
property_animation_set_from_uint32(prop_h, &set_value);
property_animation_get_from_uint32(prop_h, &test_value);
cl_assert_equal_i(test_value, 1);
property_animation_set_from_uint32(prop_h, &start_value);
// Start, we should start at the start values
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(value, start_value);
// Halfway through
prv_advance_to_ms_with_timers(start_ms + duration/2);
cl_assert(abs((int32_t)value - (int32_t)mid_value) < 10);
// End
prv_advance_to_ms_with_timers(start_ms + duration + MIN_FRAME_INTERVAL_MS*2);
cl_assert_equal_i(value, end_value);
#endif
}
// --------------------------------------------------------------------------------------
// Test a basic gcolor8 property animation
void test_animation__property_gcolor8(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
GColor8 value;
GColor8 start_value, end_value, mid_value;
const int duration = 1000;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
static const PropertyAnimationImplementation implementation = {
.base = {
.update = (AnimationUpdateImplementation) property_animation_update_gcolor8,
},
.accessors = {
.setter = { .gcolor8 = (const GColor8Setter) prv_gcolor8_setter, },
.getter = { .gcolor8 = (const GColor8Getter) prv_gcolor8_getter },
},
};
start_value = (GColor8) {.a=0, .r=0, .g=0, .b=0};
end_value = (GColor8) {.a=3, .r=3, .g=3, .b=3};
mid_value = (GColor8) {.a=1, .r=1, .g=1, .b=1};
value = end_value;
prop_h = property_animation_create(&implementation, &value, &start_value, NULL);
Animation *h = property_animation_get_animation(prop_h);
void *context = &value;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(h);
// Test the accessor functions
GColor8 test_value;
property_animation_get_from_gcolor8(prop_h, &test_value);
cl_assert(gcolor_equal(test_value, start_value));
property_animation_get_to_gcolor8(prop_h, &test_value);
cl_assert(gcolor_equal(test_value, end_value));
GColor8 set_value;
set_value = (GColor8) {.a=0, .r=1, .g=2, .b=3};
property_animation_set_from_gcolor8(prop_h, &set_value);
property_animation_get_from_gcolor8(prop_h, &test_value);
cl_assert(gcolor_equal(test_value, set_value));
property_animation_set_from_gcolor8(prop_h, &start_value);
// Start, we should start at the start values
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert(gcolor_equal(value, start_value));
// Halfway through
prv_advance_to_ms_with_timers(start_ms + duration/2);
cl_assert(gcolor_equal(value, mid_value));
// End
prv_advance_to_ms_with_timers(start_ms + duration + MIN_FRAME_INTERVAL_MS*2);
cl_assert(gcolor_equal(value, end_value));
#endif
}
// --------------------------------------------------------------------------------------
// Test that the schedule/unschedule calls work correctly.
// We should be able to unschedule an amimation parthway through
void test_animation__unschedule(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Layer layer;
GRect from_r;
GRect to_r;
GRect stopped_at_r;
const int duration = 500;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
memset(&layer, 0, sizeof(layer));
from_r = GRect(0, 0, 100, 200); // x, y, width, height
to_r = GRect(1000, 2000, 100, 200); // x, y, width, height
prop_h = property_animation_create_layer_frame(&layer, &from_r, &to_r);
Animation *h = property_animation_get_animation(prop_h);
void *context = &layer;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
animation_set_auto_destroy(h, false);
prv_clear_handler_histories();
animation_schedule(h);
uint64_t start_ms = prv_now_ms();
uint64_t unschedule_time = 0;
uint64_t time_ms;
for (int num_loops = 0; num_loops < 10; num_loops++) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
// Unschedule after 2 iterations
if (num_loops == 2) {
DPRINTF("%"PRIu64": Unscheduling now\n", prv_now_ms());
animation_unschedule(h);
stopped_at_r = layer.frame;
unschedule_time = prv_now_ms();
}
}
// Make sure the frame stopped at the state it was in when we unscheduled it
cl_assert_equal_point(layer.frame.origin, stopped_at_r.origin);
// Make sure our started and stopped handlers got called at
cl_assert_equal_i(s_started_handler_calls.num_calls, 1);;
cl_assert(s_started_handler_calls.entries[0].fired_time_ms - start_ms <= 1);
cl_assert(s_started_handler_calls.entries[0].context == context);
cl_assert_equal_i(s_stopped_handler_calls.num_calls, 1);;
cl_assert(s_stopped_handler_calls.entries[0].fired_time_ms - start_ms < duration);
cl_assert(ABSOLUTE_VALUE(s_stopped_handler_calls.entries[0].fired_time_ms - unschedule_time) < 1);
cl_assert(!s_stopped_handler_calls.entries[0].finished);
// Destroy it
animation_destroy(h);
#endif
}
// --------------------------------------------------------------------------------------
// Test that we can reschedule an animation after it completes and have it run again
void test_animation__reschedule(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Layer layer;
GRect from_r;
GRect to_r;
const int duration = 100;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
memset(&layer, 0, sizeof(layer));
from_r = GRect(0, 0, 100, 200); // x, y, width, height
to_r = GRect(1000, 2000, 100, 200); // x, y, width, height
prop_h = property_animation_create_layer_frame(&layer, &from_r, &to_r);
Animation *h = property_animation_get_animation(prop_h);
void *context = &layer;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
animation_set_auto_destroy(h, false);
prv_clear_handler_histories();
animation_schedule(h);
int max_loops = 20;
uint64_t start_ms = prv_now_ms();
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls == 0) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure the frame reached the "to" state
cl_assert_equal_point(layer.frame.origin, to_r.origin);
// -------------------------------------------------------------------------------
// Now, reschedule it
prv_advance_by_ms_no_timers(10);
prv_clear_handler_histories();
animation_schedule(h);
max_loops = 20;
start_ms = prv_now_ms();
while (s_stopped_handler_calls.num_calls == 0) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure our started and stopped handlers got called
cl_assert_equal_i(s_started_handler_calls.num_calls, 1);;
cl_assert(s_started_handler_calls.entries[0].fired_time_ms - start_ms <= 1);
cl_assert_equal_i(s_stopped_handler_calls.num_calls, 1);;
cl_assert(s_stopped_handler_calls.entries[0].fired_time_ms - start_ms >= duration);
cl_assert(s_stopped_handler_calls.entries[0].finished);
// Destroy it
animation_destroy(h);
#endif
}
// --------------------------------------------------------------------------------------
// Test that we can reschedule an animation from the stopped handler
void test_animation__reschedule_from_stopped_handler(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Layer layer;
GRect from_r;
GRect to_r;
const int duration = 100;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler_reschedule
};
memset(&layer, 0, sizeof(layer));
from_r = GRect(0, 0, 100, 200); // x, y, width, height
to_r = GRect(1000, 2000, 100, 200); // x, y, width, height
prop_h = property_animation_create_layer_frame(&layer, &from_r, &to_r);
Animation *h = property_animation_get_animation(prop_h);
void *context = &layer;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
animation_schedule(h);
int max_loops = 20;
uint64_t start_ms = prv_now_ms();
bool detected_reset_of_elapsed = false;
bool reached_end_elapsed = false;
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls < 2) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("rescheduled count: %d\n", s_stopped_handler_calls.num_calls);
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
if (layer.frame.origin.x == to_r.origin.x && layer.frame.origin.y == to_r.origin.y) {
reached_end_elapsed = true;
}
if (reached_end_elapsed && s_stopped_handler_calls.num_calls == 1
&& layer.frame.origin.x < to_r.origin.x) {
detected_reset_of_elapsed = true;
}
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure we detected a reset of the elapsed after rescheduling
cl_assert(s_stopped_handler_calls.num_calls == 2);
cl_assert(detected_reset_of_elapsed);
// Make sure the frame reached the "to" state
cl_assert_equal_point(layer.frame.origin, to_r.origin);
#endif
}
// --------------------------------------------------------------------------------------
// Test that auto-destroy works correctly
void test_animation__auto_destroy(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Layer layer;
GRect from_r;
GRect to_r;
const int duration = 100;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
memset(&layer, 0, sizeof(layer));
from_r = GRect(0, 0, 100, 200); // x, y, width, height
to_r = GRect(1000, 2000, 100, 200); // x, y, width, height
prop_h = property_animation_create_layer_frame(&layer, &from_r, &to_r);
Animation *h = property_animation_get_animation(prop_h);
void *context = &layer;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
// Before we run, the context should be non NULL
cl_assert(animation_get_context(h) == context);
animation_schedule(h);
int max_loops = 20;
uint64_t start_ms = prv_now_ms();
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls == 0) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
cl_assert(max_loops > 0);
max_loops--;
}
// This should return a NULL context now if the animation got destroyed
cl_assert(animation_get_context(h) == NULL);
// Make sure no animations exist
cl_assert_equal_i(prv_count_animations(), 0);
#endif
}
// --------------------------------------------------------------------------------------
// Test that we can reschedule an animation from the stopped handler that has auto-destroy on
void test_animation__auto_destroy_reschedule(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
Layer layer;
GRect from_r;
GRect to_r;
const int duration = 100;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler_reschedule
};
memset(&layer, 0, sizeof(layer));
from_r = GRect(0, 0, 100, 200); // x, y, width, height
to_r = GRect(1000, 2000, 100, 200); // x, y, width, height
prop_h = property_animation_create_layer_frame(&layer, &from_r, &to_r);
Animation *h = property_animation_get_animation(prop_h);
void *context = &layer;
animation_set_handlers(h, handlers, context);
animation_set_duration(h, duration);
prv_clear_handler_histories();
animation_schedule(h);
int max_loops = 20;
uint64_t start_ms = prv_now_ms();
bool detected_reset_of_elapsed = false;
bool reached_end_elapsed = false;
uint64_t time_ms;
while (s_stopped_handler_calls.num_calls < 2) {
prv_fire_animation_timer();
time_ms = prv_now_ms();
DPRINTF("rescheduled count: %d\n", s_stopped_handler_calls.num_calls);
DPRINTF("%"PRIu64": frame at: %d, %d, %d %d\n", time_ms - start_ms,
layer.frame.origin.x, layer.frame.origin.y,
layer.frame.size.w, layer.frame.size.h);
if (layer.frame.origin.x == to_r.origin.x && layer.frame.origin.y == to_r.origin.y) {
reached_end_elapsed = true;
}
if (reached_end_elapsed && s_stopped_handler_calls.num_calls == 1
&& layer.frame.origin.x < to_r.origin.x) {
detected_reset_of_elapsed = true;
}
cl_assert(max_loops > 0);
max_loops--;
}
// Make sure we detected a reset of the elapsed after rescheduling
cl_assert(s_stopped_handler_calls.num_calls == 2);
cl_assert(detected_reset_of_elapsed);
// Make sure the frame reached the "to" state
cl_assert_equal_point(layer.frame.origin, to_r.origin);
// This should return a NULL context now if the animation got destroyed
cl_assert(animation_get_context(h) == NULL);
// Make sure no animations exist
cl_assert_equal_i(prv_count_animations(), 0);
#endif
}
// --------------------------------------------------------------------------------------
// Stopped handler that calls destroy
static void prv_stopped_handler_destroy(Animation *animation, bool finished, void *context) {
prv_add_handler_entry(&s_stopped_handler_calls, animation, finished, context);
animation_destroy(animation);
}
// --------------------------------------------------------------------------------------
// Test that animation_destroy can be called from the stopped handler
static void prv_test_destroy_from_stopped_handler(bool auto_destroy) {
Animation *h;
const int duration = 100;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler_destroy
};
static const AnimationImplementation implementation = {
.setup = prv_setup_handler,
.update = prv_update_handler,
.teardown = prv_teardown_handler
};
h = animation_create();
cl_assert(h != NULL);
void *context = h;
animation_set_handlers(h, handlers, context);
animation_set_implementation(h, &implementation);
animation_set_duration(h, duration);
animation_set_auto_destroy(h, auto_destroy);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(h);
prv_advance_to_ms_with_timers(start_ms + duration + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, h), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, h), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, h), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, h), 1);
// Make sure the frame reached the "to" state
cl_assert_equal_i(prv_last_update_distance(h), ANIMATION_NORMALIZED_MAX);
// This should return NULL now if the animation got destroyed
cl_assert(animation_private_animation_find(h) == NULL);
// Make sure no animations exist
cl_assert_equal_i(prv_count_animations(), 0);
}
// --------------------------------------------------------------------------------------
// Test that animation_destroy can be called from the stopped handler
void test_animation__destroy_from_stopped_handler_with_auto_destroy(void) {
#ifdef TEST_INCLUDE_BASIC
prv_test_destroy_from_stopped_handler(true);
#endif
}
// --------------------------------------------------------------------------------------
// Test that animation_destroy can be called from the stopped handler
void test_animation__destroy_from_stopped_handler_without_auto_destroy(void) {
#ifdef TEST_INCLUDE_BASIC
prv_test_destroy_from_stopped_handler(false);
#endif
}
// --------------------------------------------------------------------------------------
// Stopped handler that calls unschedule
static void prv_stopped_handler_unschedule(Animation *animation, bool finished, void *context) {
prv_add_handler_entry(&s_stopped_handler_calls, animation, finished, context);
animation_unschedule(animation);
}
// --------------------------------------------------------------------------------------
// Test that animation_unschedule can be called from the stopped handler
void test_animation__unschedule_from_stopped_handler(void) {
Animation *h;
const int duration = 100;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler_unschedule
};
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration);
animation_set_handlers(a, handlers, a);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(a);
prv_advance_to_ms_with_timers(start_ms + duration + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
// Make sure no animations exist
cl_assert_equal_i(prv_count_animations(), 0);
}
// --------------------------------------------------------------------------------------
// Test setting a play count of 0
void test_animation__basic_play_count_0(void) {
#ifdef TEST_INCLUDE_BASIC
const int duration_a = 300;
Animation *a = prv_create_test_animation();
animation_set_play_count(a, 0);
animation_set_duration(a, duration_a);
prv_clear_handler_histories();
animation_schedule(a);
uint64_t start_ms = prv_now_ms();
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
// Should not have run at all
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 0);
// Should have been deleted automatically
cl_assert_equal_i(prv_count_animations(), 0);
#endif
}
// --------------------------------------------------------------------------------------
// Test setting a duration of infinite duration
void test_animation__basic_infinite_duration(void) {
#ifdef TEST_INCLUDE_BASIC
// A long time, but not so long as to use up our 500 capacity callback history limit
const uint32_t test_duration = 10000;
const uint32_t duration_a = ANIMATION_DURATION_INFINITE;
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
prv_clear_handler_histories();
animation_schedule(a);
uint64_t start_ms = prv_now_ms();
prv_advance_to_ms_with_timers(start_ms + test_duration);
// Should still be running
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert(prv_count_handler_entries(&s_update_handler_calls, a)
>= test_duration/MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 0);
// The distance should always be at 0
cl_assert_equal_i(prv_last_update_distance(a), 0);
// Destroy it
animation_destroy(a);
#endif
}
// --------------------------------------------------------------------------------------
// Test a simple sequence animation
void test_animation__simple_sequence(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int play_count_b = 2;
int duration_total = duration_a + play_count_b * duration_b;
// Create 2 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_play_count(b, play_count_b);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
// Setup started/stopped handlers for the sequence
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
animation_set_handlers(seq, handlers, seq);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Start A
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 0);
// Just before A completes
prv_advance_to_ms_with_timers(start_ms + duration_a - 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 0);
// Complete A and start B
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 0);
// The stopped handler for A should fire before the started handler for B
cl_assert(prv_last_handler_entry(&s_stopped_handler_calls, a)->fire_order
< prv_last_handler_entry(&s_started_handler_calls, b)->fire_order);
// Just before B completes the 2nd play
prv_advance_to_ms_with_timers(start_ms + duration_total - 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 0);
// Complete B
prv_advance_to_ms_with_timers(start_ms + duration_total + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 2);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 1);
#endif
}
static Animation *s_parent_for_sequence_unschedule_from_child;
static void prv_unschedule_parent(Animation *animation, bool finished, void *context) {
DPRINTF("%"PRIu64" ms: Executing prv_unschedule_parent handler for %d\n", prv_now_ms(),
(int)animation);
animation_unschedule(s_parent_for_sequence_unschedule_from_child);
}
// --------------------------------------------------------------------------------------
// Test calling unschedule on the sequence from the stopped handler of one of its children
void test_animation__sequence_unschedule_from_child(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int play_count_b = 2;
int duration_total = duration_a + play_count_b * duration_b;
// Create 2 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
// Setup stopped handler for the first child that unschedules the parent
const AnimationHandlers special_handlers = {
.started = NULL,
.stopped = prv_unschedule_parent
};
animation_set_handlers(a, special_handlers, NULL);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_play_count(b, play_count_b);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
animation_set_handlers(seq, handlers, seq);
s_parent_for_sequence_unschedule_from_child = seq;
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Complete A and start B. This should unschedule the parent
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 1);
// Everything should have been freed
cl_assert_equal_i(prv_count_animations(), 0);
#endif
}
// --------------------------------------------------------------------------------------
// Test a seeking in a basic sequence animation
void test_animation__simple_sequence_set_elapsed(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int duration_c = 400;
const int play_count_b = 2;
int duration_total = duration_a + play_count_b * duration_b;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
// Create 2 property animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_play_count(b, play_count_b);
// Create a sequence out of them.
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
// Create a shorter animation to play in parallel
Animation *c = prv_create_test_animation();
cl_assert(c != NULL);
animation_set_duration(c, duration_c);
Animation *complex = animation_spawn_create(seq, c, NULL);
cl_assert(complex != NULL);
animation_set_handlers(complex, handlers, complex);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(complex);
// -------------------------------------------------------------------------------------
// Start A
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 0);
// -------------------------------------------------------------------------------------
// Execute about half of A
prv_advance_to_ms_with_timers(start_ms + duration_a/2);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 0);
// -------------------------------------------------------------------------------------
// Seek to about the middle of B
// Save the current update elapsed
animation_set_elapsed(complex, duration_a + duration_b/2);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 1);
// A should be at the end
int32_t update_a_after = prv_last_update_distance(a);
cl_assert_equal_i(update_a_after, ANIMATION_NORMALIZED_MAX);
// B should be in the middle
int32_t update_b_after = prv_last_update_distance(b);
cl_assert(abs(update_b_after - ANIMATION_NORMALIZED_MAX/2) < 5000);
// C should be at the end
int32_t update_c_after = prv_last_update_distance(c);
cl_assert_equal_i(update_c_after, ANIMATION_NORMALIZED_MAX);
// -------------------------------------------------------------------------------------
// Seek to just before the end of the second B
// Save the current update elapsed
animation_set_elapsed(complex, duration_total - 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 1);
// -------------------------------------------------------------------------------------
// animation a has completed, but it shouldn't be deleted yet until the top-level
// animation is done.
uint32_t duration = animation_get_duration(a, false, false);
cl_assert_equal_i(duration, duration_a);
// -------------------------------------------------------------------------------------
// Advance to the end
animation_set_elapsed(complex, duration_total);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, complex), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 1);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_last_update_distance(c), ANIMATION_NORMALIZED_MAX);
// Make sure each animation got to the end
AnimTestHandlerEntry *entry;
entry = prv_last_handler_entry(&s_update_handler_calls, c);
cl_assert_equal_i((uint32_t)entry->context, ANIMATION_NORMALIZED_MAX);
#endif
}
// --------------------------------------------------------------------------------------
// Test unscheduling a complex animation
void test_animation__sequence_unschedule(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 200;
const int duration_c = 500;
const int repeat_count = 5;
int duration_total = duration_a + MAX(duration_b, duration_c);
// Create 3 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
Animation *c = prv_create_test_animation();
animation_set_duration(c, duration_c);
// Create a spawn out of b and c
Animation *spawn = animation_spawn_create(b, c, NULL);
cl_assert(spawn != NULL);
// Create a sequence by putting a in front
// We now have a -> (b | c)
Animation *seq = animation_sequence_create(a, spawn, NULL);
// Make it repeat
animation_set_play_count(seq, repeat_count);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Start A
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, c), 0);
// Execute to the start of B and C
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 0);
// Execute to the end of B & C
prv_advance_to_ms_with_timers(start_ms + duration_total + 1 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 1);
// If we keep going, we should repeat the whole sequence
prv_advance_to_ms_with_timers(start_ms + 2 * (duration_total + 4 * MIN_FRAME_INTERVAL_MS));
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 3);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 2);
// Unschedule the top-level
animation_unschedule(seq);
// Keep going, nothing new should happen except the stop handler for a (which we started)
prv_advance_to_ms_with_timers(start_ms + 5 * (duration_total + 3 * MIN_FRAME_INTERVAL_MS));
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 3);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 3);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, c), 1);
#endif
}
// --------------------------------------------------------------------------------------
// Test using clone and reverse in a complex animation
void test_animation__complex_reverse(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_total = 2 * duration_a;
const int repeat_count = 2;
uint32_t distance;
// Create animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = animation_clone(a);
animation_set_reverse(b, true);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
animation_set_play_count(seq, repeat_count);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Start A
prv_advance_to_ms_with_timers(start_ms + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// A should start out low
distance = prv_last_update_distance(a);
cl_assert(distance < TEST_ANIMATION_NORMALIZED_LOW);
// Execute to the start of B
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
// A should end high
distance = prv_last_update_distance(a);
cl_assert(distance > TEST_ANIMATION_NORMALIZED_HIGH);
// B should start high
distance = prv_last_update_distance(b);
cl_assert(distance > TEST_ANIMATION_NORMALIZED_HIGH);
// Execute to the end of B
prv_advance_to_ms_with_timers(start_ms + duration_total + 1 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
// B should end low
distance = prv_last_update_distance(b);
cl_assert(distance < TEST_ANIMATION_NORMALIZED_LOW);
// If we keep going, we should repeat the whole sequence
prv_advance_to_ms_with_timers(start_ms + 2 * (duration_total + 10 * MIN_FRAME_INTERVAL_MS));
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 1);
// A should end up at max
// A should end high
distance = prv_last_update_distance(a);
cl_assert_equal_i(distance, ANIMATION_NORMALIZED_MAX);
// B should start high
distance = prv_last_update_distance(b);
cl_assert_equal_i(distance, ANIMATION_NORMALIZED_MIN);
#endif
}
// --------------------------------------------------------------------------------------
// Test cloning complex animation
void test_animation__complex_clone(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 200;
const int duration_c = 500;
const int repeat_count = 5;
int duration_total = duration_a + MAX(duration_b, duration_c);
// Create 3 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
Animation *c = prv_create_test_animation();
animation_set_duration(c, duration_c);
// Create a spawn out of b and c
Animation *spawn = animation_spawn_create(b, c, NULL);
cl_assert(spawn != NULL);
// Create a sequence by putting a in front and repeat it 5 times
// We now have a -> (b | c)
Animation *seq = animation_sequence_create(a, spawn, NULL);
animation_set_play_count(seq, repeat_count);
// Now, clone it
Animation *clone = animation_clone(seq);
// Destroy the original
animation_destroy(seq);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(clone);
// Start A
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, NULL), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, NULL), 0);
// Execute to the start of B and C
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, NULL), 3);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, NULL), 1);
// Execute to the end of B & C
prv_advance_to_ms_with_timers(start_ms + duration_total + 1 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, NULL), 3);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, NULL), 3);
// If we keep going, we should repeat the whole sequence another time
prv_advance_to_ms_with_timers(start_ms + 2 * (duration_total + 4 * MIN_FRAME_INTERVAL_MS));
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, NULL), 7);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, NULL), 6);
// Unschedule the top-level
animation_unschedule(clone);
// Keep going, nothing new should happen except stop handlers for each component
prv_advance_to_ms_with_timers(start_ms + 5 * (duration_total + 3 * MIN_FRAME_INTERVAL_MS));
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, NULL), 7);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, NULL), 7);
#endif
}
// --------------------------------------------------------------------------------------
// Test scheduling a sequence of 2 spawns. Insure that ALL of the primitives in the first spawn,
// finish before the primitives from the 2nd spawn start.
static void prv_test_sequence_of_spawns(int create_order[4]) {
const int duration_a = 150;
const int duration_total = 2 * duration_a;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
// Simulate some delay incurred on every call to rtc_get_ticks()
fake_rtc_auto_increment_ticks(3);
Animation *a0, *a1, *a2, *a3;
Animation *b0, *b1, *b2, *b3;
Animation *spawn_a, *spawn_b;
for (int i=0; i<4; i++) {
switch(create_order[i]) {
case 0:
a0 = prv_create_test_animation();
animation_set_duration(a0, duration_a);
a1 = animation_clone(a0);
a2 = animation_clone(a0);
a3 = animation_clone(a0);
break;
case 1:
b0 = prv_create_test_animation();
animation_set_duration(b0, duration_a);
b1 = animation_clone(b0);
b2 = animation_clone(b0);
b3 = animation_clone(b0);
break;
case 2:
spawn_a = animation_spawn_create(a0, a1, a2, a3, NULL);
animation_set_handlers(spawn_a, handlers, (void *)spawn_a);
break;
case 3:
spawn_b = animation_spawn_create(b0, b1, b2, b3, NULL);
animation_set_handlers(spawn_b, handlers, (void *)spawn_a);
break;
}
}
// Create the sequence
Animation *seq = animation_sequence_create(spawn_a, spawn_b, NULL);
// Schedule it
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
fake_rtc_auto_increment_ticks(0);
// Let the first spawn finish
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a0), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a0), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a1), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a1), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a2), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a2), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a3), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a3), 1);
// None of the b's should finish yet
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b0), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b1), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b2), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b3), 0);
// Let it finish completely
prv_advance_to_ms_with_timers(start_ms + duration_total + 5 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b0), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b1), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b2), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b3), 1);
// Make sure the all the spawn a stopped handlers got called before any of the spawn b
// started handlers
uint32_t last_fire_a = 0;
last_fire_a = MAX(last_fire_a,
prv_last_handler_entry(&s_stopped_handler_calls, a0)->fire_order);
last_fire_a = MAX(last_fire_a,
prv_last_handler_entry(&s_stopped_handler_calls, a1)->fire_order);
last_fire_a = MAX(last_fire_a,
prv_last_handler_entry(&s_stopped_handler_calls, a2)->fire_order);
last_fire_a = MAX(last_fire_a,
prv_last_handler_entry(&s_stopped_handler_calls, a3)->fire_order);
last_fire_a = MAX(last_fire_a,
prv_last_handler_entry(&s_stopped_handler_calls, spawn_a)->fire_order);
uint32_t first_fire_b = prv_last_handler_entry(&s_started_handler_calls, b0)->fire_order;
first_fire_b = MIN(first_fire_b,
prv_last_handler_entry(&s_started_handler_calls, b1)->fire_order);
first_fire_b = MIN(first_fire_b,
prv_last_handler_entry(&s_started_handler_calls, b2)->fire_order);
first_fire_b = MIN(first_fire_b,
prv_last_handler_entry(&s_started_handler_calls, b3)->fire_order);
first_fire_b = MIN(first_fire_b,
prv_last_handler_entry(&s_started_handler_calls, spawn_b)->fire_order);
cl_assert(last_fire_a < first_fire_b);
cl_assert_equal_i(prv_count_animations(), 0);
}
// --------------------------------------------------------------------------------------
// Test scheduling a sequence of 2 spawns. Insure that ALL of the primitives in the first spawn,
// finish before the primitives from the 2nd spawn start.
void test_animation__sequence_of_spawns(void) {
#ifdef TEST_INCLUDE_COMPLEX
int order_a[4] = {0, 1, 2, 3};
prv_test_sequence_of_spawns(order_a);
int order_b[4] = {1, 0, 2, 3};
prv_test_sequence_of_spawns(order_b);
int order_c[4] = {1, 0, 3, 2};
prv_test_sequence_of_spawns(order_c);
#endif
}
// --------------------------------------------------------------------------------------
// Test delays in sequence animation
void test_animation__sequence_delay(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int delay_a = 100;
const int duration_b = 500;
const int delay_b = 200;
const int delay_seq = 150;
int duration_total = duration_a + duration_b + delay_a + delay_b + delay_seq;
// Create 2 test animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
animation_set_delay(seq, delay_seq);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Test the elapsed
int32_t elapsed_ms;
animation_get_elapsed(seq, &elapsed_ms);
cl_assert_equal_i(elapsed_ms, -1 * (delay_seq));
animation_get_elapsed(a, &elapsed_ms);
cl_assert_equal_i(elapsed_ms, -1 * (delay_seq + delay_a));
animation_get_elapsed(b, &elapsed_ms);
cl_assert_equal_i(elapsed_ms, -1 * (delay_seq + delay_a + duration_a + delay_b));
// Start
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Start A after delay
prv_advance_to_ms_with_timers(start_ms + delay_seq + delay_a + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Just before A completes
prv_advance_to_ms_with_timers(start_ms + delay_seq + delay_a + duration_a - 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Complete A and start B
prv_advance_to_ms_with_timers(start_ms + duration_a + delay_seq + delay_a + delay_b
+ 2 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
// Complete B
prv_advance_to_ms_with_timers(start_ms + duration_total + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MAX);
#endif
}
// --------------------------------------------------------------------------------------
// Test delays in spawn animation
void test_animation__spawn_delay(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int delay_a = 100;
const int duration_b = 500;
const int delay_b = 200;
const int delay_spawn = 150;
int duration_total = MAX(duration_a + delay_a, duration_b + delay_b) + delay_spawn;
// Create 2 test animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
// Create a spawn
Animation *spawn = animation_spawn_create(a, b, NULL);
cl_assert(spawn != NULL);
animation_set_delay(spawn, delay_spawn);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(spawn);
// Test the elapsed
int32_t elapsed_ms;
animation_get_elapsed(spawn, &elapsed_ms);
cl_assert_equal_i(elapsed_ms, -1 * (delay_spawn));
animation_get_elapsed(a, &elapsed_ms);
cl_assert_equal_i(elapsed_ms, -1 * (delay_spawn + delay_a));
animation_get_elapsed(b, &elapsed_ms);
cl_assert_equal_i(elapsed_ms, -1 * (delay_spawn + delay_b));
// Start
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Start A
prv_advance_to_ms_with_timers(start_ms + delay_spawn + delay_a + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
// Start B
prv_advance_to_ms_with_timers(start_ms + delay_spawn + MAX(delay_a, delay_b)
+ 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
// Complete A and start B
prv_advance_to_ms_with_timers(start_ms + delay_spawn + duration_a + delay_a
+ 2 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
// Complete B
prv_advance_to_ms_with_timers(start_ms + duration_total + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MAX);
#endif
}
// --------------------------------------------------------------------------------------
// Test a sequence animation with a component that has a play count of 0
void test_animation__sequence_with_0_component(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int play_count_seq = 2;
int duration_total = play_count_seq * duration_a;
// Create 2 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_play_count(b, 0);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
animation_set_play_count(seq, play_count_seq);
// Check the duration
cl_assert_equal_i(animation_get_duration(seq, true, true), play_count_seq * duration_a);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Start A
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Just before A completes
prv_advance_to_ms_with_timers(start_ms + duration_a - 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Complete A the first time
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
// Complete sequence
prv_advance_to_ms_with_timers(start_ms + duration_total + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 0);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
#endif
}
// --------------------------------------------------------------------------------------
// Test a spawn animation with a component that has a play count of 0
void test_animation__spawn_with_0_component(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int play_count_spawn = 2;
int duration_total = play_count_spawn * duration_a;
// Create 2 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_play_count(b, 0);
// Create a spawn that repeats
Animation *spawn = animation_spawn_create(a, b, NULL);
cl_assert(spawn != NULL);
animation_set_play_count(spawn, play_count_spawn);
// Check the duration
cl_assert_equal_i(animation_get_duration(spawn, true, true), play_count_spawn * duration_a);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(spawn);
// Start A
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Just before A completes
prv_advance_to_ms_with_timers(start_ms + duration_a - 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Complete A the first time
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
// Complete spawn
prv_advance_to_ms_with_timers(start_ms + duration_total + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 2);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 0);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
#endif
}
// --------------------------------------------------------------------------------------
// Test a sequence animation with a play count of 0
void test_animation__sequence_with_0_play_count(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int play_count_seq = 0;
// Create 2 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
animation_set_play_count(seq, play_count_seq);
// Check the duration
cl_assert_equal_i(animation_get_duration(seq, true, true), 0);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
// Start
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Complete sequence
prv_advance_to_ms_with_timers(start_ms + duration_a + duration_b + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 0);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MIN);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MIN);
#endif
}
// --------------------------------------------------------------------------------------
// Test a sequence within a sequence where the imbedded one has a play count of 0
void test_animation__nested_sequence_with_0_play_count(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int duration_c = 200;
const int duration_d = 400;
const int total_duration = duration_c + duration_d;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
// Create the inner sequence with a play count of 0
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
Animation *inner_seq = animation_sequence_create(a, b, NULL);
animation_set_play_count(inner_seq, 0);
animation_set_handlers(inner_seq, handlers, inner_seq);
// Create the outer sequence
Animation *c = prv_create_test_animation();
animation_set_duration(c, duration_c);
Animation *d = prv_create_test_animation();
animation_set_duration(d, duration_d);
Animation *seq = animation_sequence_create(inner_seq, c, d, NULL);
animation_set_handlers(seq, handlers, seq);
// Play it
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(seq);
prv_advance_to_ms_with_timers(start_ms + total_duration + 5 * MIN_FRAME_INTERVAL_MS);
// Make sure neither inner_seq, a, nor b played
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, inner_seq), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, inner_seq), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, b), 0);
// Make sure seq, c, and d completed
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, d), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, d), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, d), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, d), 1);
#endif
}
// --------------------------------------------------------------------------------------
// Test a spawn animation with a play count of 0
void test_animation__spawn_with_0_play_count(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int play_count_spawn = 0;
// Create 2 animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
// Create a spawn
Animation *spawn = animation_sequence_create(a, b, NULL);
cl_assert(spawn != NULL);
animation_set_play_count(spawn, play_count_spawn);
// Check the duration
cl_assert_equal_i(animation_get_duration(spawn, true, true), 0);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(spawn);
// Start
prv_advance_to_ms_with_timers(start_ms + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_update_handler_calls, b), 0);
// Complete sequence
prv_advance_to_ms_with_timers(start_ms + duration_a + duration_b + 5 * MIN_FRAME_INTERVAL_MS + 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MIN);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MIN);
#endif
}
// --------------------------------------------------------------------------------------
// Test the get_duration call on a sequence animation
void test_animation__sequence_get_duration(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int delay_a = 100;
const int play_count_a = 1;
const int total_duration_a = play_count_a * (delay_a + duration_a);
const int duration_b = 500;
const int delay_b = 200;
const int play_count_b = 3;
const int total_duration_b = play_count_b * (delay_b + duration_b);
const int delay_seq = 150;
const int play_count_seq = 2;
int duration_total = play_count_seq * (total_duration_a + total_duration_b + delay_seq);
// Create 2 test animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
animation_set_play_count(a, play_count_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
animation_set_play_count(b, play_count_b);
// Create a sequence
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
animation_set_delay(seq, delay_seq);
animation_set_play_count(seq, play_count_seq);
// Check durations
cl_assert_equal_i(animation_get_duration(a, false, false), duration_a);
cl_assert_equal_i(animation_get_duration(a, false, true), play_count_a * duration_a);
cl_assert_equal_i(animation_get_duration(a, true, false), delay_a + duration_a);
cl_assert_equal_i(animation_get_duration(a, true, true), total_duration_a);
cl_assert_equal_i(animation_get_duration(b, false, false), duration_b);
cl_assert_equal_i(animation_get_duration(b, false, true), play_count_b * duration_b);
cl_assert_equal_i(animation_get_duration(b, true, false), delay_b + duration_b);
cl_assert_equal_i(animation_get_duration(b, true, true), total_duration_b);
cl_assert_equal_i(animation_get_duration(seq, false, false), total_duration_a + total_duration_b);
cl_assert_equal_i(animation_get_duration(seq, false, true),
play_count_seq * (total_duration_a + total_duration_b));
cl_assert_equal_i(animation_get_duration(seq, true, false),
delay_seq + total_duration_a + total_duration_b);
cl_assert_equal_i(animation_get_duration(seq, true, true), duration_total);
animation_destroy(seq);
#endif
}
// --------------------------------------------------------------------------------------
// Test the get_duration call on a spawn animation
void test_animation__spawn_get_duration(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int delay_a = 100;
const int play_count_a = 1;
const int total_duration_a = play_count_a * (delay_a + duration_a);
const int duration_b = 500;
const int delay_b = 200;
const int play_count_b = 3;
const int total_duration_b = play_count_b * (delay_b + duration_b);
const int delay_spawn = 150;
const int play_count_spawn = 2;
int duration_total = play_count_spawn * (MAX(total_duration_a, total_duration_b) + delay_spawn);
// Create 2 test animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
animation_set_play_count(a, play_count_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
animation_set_play_count(b, play_count_b);
// Create a spawn
Animation *spawn = animation_spawn_create(a, b, NULL);
cl_assert(spawn != NULL);
animation_set_delay(spawn, delay_spawn);
animation_set_play_count(spawn, play_count_spawn);
// Check durations
cl_assert_equal_i(animation_get_duration(a, false, false), duration_a);
cl_assert_equal_i(animation_get_duration(a, false, true), play_count_a * duration_a);
cl_assert_equal_i(animation_get_duration(a, true, false), delay_a + duration_a);
cl_assert_equal_i(animation_get_duration(a, true, true), total_duration_a);
cl_assert_equal_i(animation_get_duration(b, false, false), duration_b);
cl_assert_equal_i(animation_get_duration(b, false, true), play_count_b * duration_b);
cl_assert_equal_i(animation_get_duration(b, true, false), delay_b + duration_b);
cl_assert_equal_i(animation_get_duration(b, true, true), total_duration_b);
cl_assert_equal_i(animation_get_duration(spawn, false, false),
MAX(total_duration_a, total_duration_b));
cl_assert_equal_i(animation_get_duration(spawn, false, true),
play_count_spawn * (MAX(total_duration_a, total_duration_b)));
cl_assert_equal_i(animation_get_duration(spawn, true, false),
delay_spawn + MAX(total_duration_a, total_duration_b));
cl_assert_equal_i(animation_get_duration(spawn, true, true), duration_total);
animation_destroy(spawn);
#endif
}
// --------------------------------------------------------------------------------------
// Test unschedule all when we have multiple animations, some complex
void test_animation__unschedule_all(void) {
#ifdef TEST_INCLUDE_COMPLEX
// Create animations
// Create a sequence
Animation *a = prv_create_test_animation();
Animation *b = prv_create_test_animation();
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
// Create a spawn
Animation *c = prv_create_test_animation();
Animation *d = prv_create_test_animation();
Animation *spawn = animation_spawn_create(c, d, NULL);
cl_assert(spawn != NULL);
// Create a primitive one
Animation *e = prv_create_test_animation();
// Schedule them all
animation_schedule(seq);
animation_schedule(spawn);
animation_schedule(e);
// Verify count
cl_assert_equal_i(prv_count_scheduled_animations(), 7);
// Unschedule all
animation_unschedule_all();
cl_assert_equal_i(prv_count_scheduled_animations(), 0);
// Make sure just the setup and teardown handlers were called
cl_assert_equal_i(prv_count_handler_entries(&s_setup_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_teardown_handler_calls, a), 1);
#endif
}
// --------------------------------------------------------------------------------------
// Test that we fail if we try and put a component in more than 1 complex animation
void test_animation__reuse_components(void) {
#ifdef TEST_INCLUDE_COMPLEX
// Create animations
// Create a sequence out of a and b
Animation *a = prv_create_test_animation();
Animation *b = prv_create_test_animation();
Animation *seq = animation_sequence_create(a, b, NULL);
cl_assert(seq != NULL);
// Try to create a spawn out of b and c
Animation *c = prv_create_test_animation();
Animation *spawn = animation_spawn_create(c, b, NULL);
cl_assert(spawn == NULL);
// We should be able to create one out of c and d
Animation *d = prv_create_test_animation();
spawn = animation_spawn_create(c, d, NULL);
cl_assert(spawn != NULL);
animation_destroy(seq);
animation_destroy(spawn);
#endif
}
// Test all the accessors
void test_animation__accessors(void) {
#ifdef TEST_INCLUDE_BASIC
PropertyAnimation *prop_h;
int16_t value = 0;
int16_t start_value = 0, end_value = 100;
const int duration = 200;
const int delay = 25;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
static const PropertyAnimationImplementation implementation = {
.base = {
.setup = prv_setup_handler,
.update = (AnimationUpdateImplementation) property_animation_update_int16,
.teardown = prv_teardown_handler
},
.accessors = {
.setter = { .int16 = (const Int16Setter) prv_int16_setter, },
.getter = { .int16 = (const Int16Getter) prv_int16_getter },
},
};
prop_h = property_animation_create(&implementation, &value, &start_value, &end_value);
Animation *h = property_animation_get_animation(prop_h);
cl_assert(animation_set_auto_destroy(h, false) == true);
// Handlers
void *context = &value;
animation_set_handlers(h, handlers, context);
AnimationHandlers c_handlers = animation_get_handlers(h);
cl_assert(memcmp(&c_handlers, &handlers, sizeof(AnimationHandlers)) == 0);
// Context
cl_assert(animation_get_context(h) == context);
// Duration
cl_assert(animation_get_duration(h, true, true) == 250); // default value
animation_set_duration(h, duration);
cl_assert(animation_get_duration(h, true, true) == duration);
// Delay
cl_assert(animation_get_delay(h) == 0);
animation_set_delay(h, delay);
cl_assert(animation_get_delay(h) == delay);
cl_assert(animation_get_duration(h, true, true) == (duration + delay));
// Play count
cl_assert_equal_i(animation_get_play_count(h), 1);
animation_set_play_count(h, 2);
cl_assert_equal_i(animation_get_play_count(h), 2);
cl_assert(animation_get_duration(h, true, true) == 2*(duration + delay));
// Curve
cl_assert(animation_get_curve(h) == AnimationCurveDefault);
animation_set_curve(h, AnimationCurveEaseOut);
cl_assert(animation_get_curve(h) == AnimationCurveEaseOut);
static const PropertyAnimationImplementation implementation2 = {
.base = {
.setup = prv_setup_handler,
.update = (AnimationUpdateImplementation) property_animation_update_gpoint,
.teardown = prv_teardown_handler
},
.accessors = {
.setter = { .int16 = (const Int16Setter) prv_gpoint_setter, },
.getter = { .int16 = (const Int16Getter) prv_gpoint_getter },
},
};
// Implementation
cl_assert(animation_get_implementation(h) == &implementation.base);
animation_set_implementation(h, &implementation2.base);
cl_assert(animation_get_implementation(h) != &implementation.base);
cl_assert(animation_get_implementation(h) == &implementation2.base);
// Custom Curve
cl_assert(animation_get_custom_curve(h) != prv_custom_curve);
animation_set_custom_curve(h, prv_custom_curve);
cl_assert(animation_get_custom_curve(h) == prv_custom_curve);
// Reverse
cl_assert(animation_get_reverse(h) == false);
animation_set_reverse(h, true);
cl_assert(animation_get_reverse(h) == true);
animation_set_reverse(h, false);
// Position
int32_t elapsed_ms = 0;
AnimationProgress progress = 0;
animation_schedule(h);
cl_must_pass(animation_get_elapsed(h, &elapsed_ms));
cl_assert_equal_i(elapsed_ms, -delay);
cl_assert_passert(animation_get_progress(h, &progress));
animation_set_elapsed(h, 0);
cl_must_pass(animation_get_elapsed(h, &elapsed_ms));
cl_assert_equal_i(elapsed_ms, 0);
cl_must_pass(animation_get_progress(h, &progress));
cl_assert_equal_i(progress, 0);
animation_set_elapsed(h, duration / 2);
cl_must_pass(animation_get_elapsed(h, &elapsed_ms));
cl_assert_equal_i(elapsed_ms, duration / 2);
cl_must_pass(animation_get_progress(h, &progress));
cl_assert_equal_i(progress, 32768); // Rounding occurs within, this is close to MAX / 2
animation_destroy(h);
#endif
}
void test_animation__completed(void) {
#ifdef TEST_INCLUDE_BASIC
const int duration_a = 300;
// Create 1 property animations
Animation *a = prv_create_test_animation();
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler_check_finished
};
animation_set_handlers(a, handlers, animation_get_context(a));
animation_set_duration(a, duration_a);
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
animation_schedule(a);
// Seek to just after the end of the second A
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
#endif
}
// --------------------------------------------------------------------------------------
// Test creating a sequence where the first argument is already scheduled and started
//
// Here's a graph of what we are doing
//
// 0 60 310 360 380 880
// | | | | | |
// -----------------------------------------------------------------------------------
// delay_a | duration_a |
// | delay_b | duration_b |
// | seq scheduled
//
void test_animation__sequence_of_already_scheduled_started(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int delay_a = 60;
const int leftover_a = 50;
const int duration_b = 500;
const int delay_b = 20;
const int leftover_seq = 40;
const int delay_seq = 30;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
// Create a property animation and advance it
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
animation_schedule(a);
// -------------------------------------------------------------------------------------
// Start A and advance it
prv_advance_to_ms_with_timers(start_ms + delay_a + MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
animation_set_elapsed(a, duration_a - leftover_a);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
// -------------------------------------------------------------------------------------
// Build up a sequence out of the leftover a + b
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
// Should be an error trying to use a scheduled animation not in the first position
Animation *seq = animation_sequence_create(b, a, NULL);
cl_assert(seq == NULL);
seq = animation_sequence_create(a, b, NULL);
animation_set_delay(seq, delay_seq); // This delay not applicable since a was already scheduled
animation_set_handlers(seq, handlers, seq);
animation_schedule(seq);
// The duration of seq should include all of a and b
uint32_t duration = animation_get_duration(seq, true, true);
cl_assert_equal_i(duration, duration_a + delay_a + duration_b + delay_b);
// The position of seq should be the amount we already played of a, including the 'a' delay
// since a is embedded within seq
int32_t position;
animation_get_elapsed(seq, &position);
cl_assert_equal_i(position, duration_a + delay_a - leftover_a);
// Now, advance sequence to almost the end of seq. Positions don't include the delay, so
// pass false for 'include_delay'
animation_set_elapsed(seq, animation_get_duration(seq, false /*delay*/, true /*play_count*/)
- leftover_seq);
// Verify that a finished and that a's stop handler got called before B's start handler
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 0);
cl_assert(prv_last_handler_entry(&s_stopped_handler_calls, a)->fire_order
< prv_last_handler_entry(&s_started_handler_calls, b)->fire_order);
// Finish the sequence
prv_advance_to_ms_with_timers(prv_now_ms() + leftover_seq + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 1);
#endif
}
// --------------------------------------------------------------------------------------
// Test creating a sequence where the first argument is already scheduled, but not started
// yet (still in the delay portion).
//
// Here's a graph of what we are doing
//
// 0 100 200 360 380 880
// | | | | | |
// -----------------------------------------------------------------------------------
// delay_a | duration_a |
// | delay_b | duration_b |
// | seq scheduled
//
void test_animation__sequence_of_already_scheduled_not_started(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 160;
const int delay_a = 200;
const int duration_b = 500;
const int delay_b = 20;
const int leftover_seq = 50;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
prv_clear_handler_histories();
// Create a property animation and advance it
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
uint64_t start_ms = prv_now_ms();
animation_schedule(a);
// -------------------------------------------------------------------------------------
// Got partway through the delayof a
prv_advance_to_ms_with_timers(start_ms + 100);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 0);
// -------------------------------------------------------------------------------------
// Build up a sequence out of the leftover a + b
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
Animation *seq = animation_sequence_create(a, b, NULL);
animation_set_handlers(seq, handlers, seq);
animation_schedule(seq);
// The duration of seq should include all of a and b
uint32_t duration = animation_get_duration(seq, true, true);
cl_assert_equal_i(duration, duration_a + delay_a + duration_b + delay_b);
// The position of seq should be the amount we already played of a, including the 'a' delay
// since a is embedded within seq
int32_t position;
animation_get_elapsed(seq, &position);
cl_assert_equal_i(position, 100);
// Now, advance sequence to almost the end of seq. Positions don't include the delay, so
// pass false for 'include_delay'
animation_set_elapsed(seq, animation_get_duration(seq, false /*delay*/, true /*play_count*/)
- leftover_seq);
// Verify that a finished and that a's stop handler got called before B's start handler
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 0);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, seq), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 0);
cl_assert(prv_last_handler_entry(&s_stopped_handler_calls, a)->fire_order
< prv_last_handler_entry(&s_started_handler_calls, b)->fire_order);
// Finish the sequence
prv_advance_to_ms_with_timers(prv_now_ms() + leftover_seq + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 1);
#endif
}
// --------------------------------------------------------------------------------------
// Test creating a sequence where the first argument is already completed.
// We will first create animation 'a' and run it to the end
// We will then create a sequence out of 'a' + 'b' and verify that if we advance that 'b' runs
// correctly.
void test_animation__sequence_of_already_completed(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300;
const int duration_b = 500;
const int delay_b = 20;
const int delay_seq = 30;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
// Create a property animation and play it to the end
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_schedule(a);
// -------------------------------------------------------------------------------------
// Start A and play to the end
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_last_update_distance(a), ANIMATION_NORMALIZED_MAX);
// -------------------------------------------------------------------------------------
// Build up a sequence out of a + b
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
Animation *seq = animation_sequence_create(a, b, NULL);
animation_set_delay(seq, delay_seq);
animation_set_handlers(seq, handlers, seq);
animation_schedule(seq);
// The duration of seq should include all of b
uint32_t duration = animation_get_duration(seq, true, true);
cl_assert_equal_i(duration, duration_b + delay_b + delay_seq);
// The position of seq should be at -delay_seq
int32_t position;
animation_get_elapsed(seq, &position);
cl_assert_equal_i(position, -delay_seq);
// Finish the sequence
prv_advance_to_ms_with_timers(prv_now_ms() + delay_b + duration_b + delay_seq
+ 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_last_update_distance(b), ANIMATION_NORMALIZED_MAX);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, seq), 1);
#endif
}
// --------------------------------------------------------------------------------------
// Test creating a spawn where where some children are already scheduled and some have
// already completed.
//
// Here's a graph of what we are doing
//
// 0 10 310 320 330 500 680 730 850 950 1080 1300
// | | | | | | | | | | | |
// -----------------------------------------------------------------------------------
// delay_a | duration a | |
// | delay_b | duration_b |
// | delay_c | duration_c |
// | delay_s | delay_d | duration_d |
// -----------------------------------------------------------------------------------
// | spawn scheduled here
void test_animation__spawn_of_already_scheduled(void) {
#ifdef TEST_INCLUDE_COMPLEX
const int duration_a = 300; // This one will complete
const int delay_a = 10;
const int duration_b = 400; // This one will have 50 ms left on it
const int delay_b = 20;
const int duration_c = 350;
const int delay_c = 230;
const int duration_d = 220; // This one won't be scheduled yet
const int delay_d = 230;
const int delay_spawn = 170;
const AnimationHandlers handlers = {
.started = prv_started_handler,
.stopped = prv_stopped_handler
};
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
// Create the animations
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_b);
animation_set_delay(b, delay_b);
Animation *c = prv_create_test_animation();
animation_set_duration(c, duration_c);
animation_set_delay(c, delay_c);
Animation *d = prv_create_test_animation();
animation_set_duration(d, duration_d);
animation_set_delay(d, delay_d);
// -------------------------------------------------------------------------------------
// Run A to completion
animation_schedule(a);
prv_advance_to_ms_with_timers(start_ms + 20);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, a), 1);
prv_advance_to_ms_with_timers(start_ms + 310);
// Schedule B now and run for a little
animation_schedule(b);
prv_advance_to_ms_with_timers(start_ms + 330);
// Schedule C now and run for a while
prv_advance_to_ms_with_timers(start_ms + 500);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, a), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, b), 1);
animation_schedule(c);
// Create the spawn using a, b, c, and d
prv_advance_to_ms_with_timers(start_ms + 680);
Animation *spawn = animation_spawn_create(a, b, c, d, NULL);
animation_set_delay(spawn, delay_spawn);
animation_set_handlers(spawn, handlers, spawn);
animation_schedule(spawn);
// Check the duration and position of the spawn
uint32_t duration = animation_get_duration(spawn, true /*delay*/, true /*play_count*/);
cl_assert_equal_i(duration, 1300 - 310);
int32_t position;
animation_get_elapsed(spawn, &position);
cl_assert_equal_i(position, (680 - 310));
// Run to the completion of B, start of C
prv_advance_to_ms_with_timers(start_ms + 730 + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, b), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, spawn), 1);
// Run to the completion of C, start of D
prv_advance_to_ms_with_timers(start_ms + 1080 + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, c), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_started_handler_calls, d), 1);
// Run to the completion of D
prv_advance_to_ms_with_timers(start_ms + 1300 + 2 * MIN_FRAME_INTERVAL_MS);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, d), 1);
cl_assert_equal_i(prv_count_handler_entries(&s_stopped_handler_calls, spawn), 1);
#endif
}
void prv_update_unschedule_all_handler(Animation *animation, const AnimationProgress distance) {
prv_add_handler_entry(&s_update_handler_calls, animation, false,
(void *)(uintptr_t)distance /*context*/);
DPRINTF("%"PRIu64" ms: Executing update handler for %d, distance: %d\n", prv_now_ms(),
(int)animation, (int)distance);
if (distance > ANIMATION_NORMALIZED_MAX / 2) {
animation_unschedule_all();
}
}
// --------------------------------------------------------------------------------------
// Test unscheduling animations arbitrarily in an update handler.
static void prv_unschedule_all_in_update_handler(bool auto_destroy) {
const int duration_a = 300; // This one will complete
const int delay_a = 10;
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
static const AnimationImplementation implementation = {
.setup = prv_setup_handler,
.update = prv_update_unschedule_all_handler,
.teardown = prv_teardown_handler
};
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
animation_set_auto_destroy(a, auto_destroy);
animation_schedule(a);
Animation *b = prv_create_test_animation();
animation_set_implementation(b, &implementation);
animation_set_duration(b, duration_a);
animation_set_delay(b, delay_a);
animation_set_auto_destroy(b, auto_destroy);
animation_schedule(b);
Animation *c = prv_create_test_animation();
animation_set_duration(c, duration_a);
animation_set_delay(c, delay_a);
animation_set_auto_destroy(c, auto_destroy);
animation_schedule(c);
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
animation_destroy(a);
animation_destroy(b);
animation_destroy(c);
}
// --------------------------------------------------------------------------------------
// Test unscheduling animations arbitrarily in an update handler with auto destroy.
void test_animation__unschedule_all_in_update_handler_with_auto_destroy(void) {
prv_unschedule_all_in_update_handler(true);
}
// --------------------------------------------------------------------------------------
// Test unscheduling animations arbitrarily in an update handler without auto destroy.
void test_animation__unschedule_all_in_update_handler_without_auto_destroy(void) {
prv_unschedule_all_in_update_handler(false);
}
static void prv_stopped_unschedule_all_handler(Animation *animation, bool finished, void *context) {
prv_add_handler_entry(&s_stopped_handler_calls, animation, finished, context);
DPRINTF("%"PRIu64" ms: Executing stopped handler for %d\n", prv_now_ms(), (int)animation);
animation_unschedule_all();
}
// --------------------------------------------------------------------------------------
// Test unscheduling animations arbitrarily in a stopped handler with/without auto destroy.
void prv_test_unschedule_all_in_stopped_handler(bool auto_destroy) {
const int duration_a = 300; // This one will complete
const int delay_a = 10;
prv_clear_handler_histories();
uint64_t start_ms = prv_now_ms();
const AnimationHandlers handlers = {
.stopped = prv_stopped_unschedule_all_handler,
};
void *context = NULL;
Animation *a = prv_create_test_animation();
animation_set_duration(a, duration_a);
animation_set_delay(a, delay_a);
animation_set_handlers(a, handlers, context);
animation_set_auto_destroy(a, auto_destroy);
animation_schedule(a);
Animation *b = prv_create_test_animation();
animation_set_duration(b, duration_a);
animation_set_delay(b, delay_a);
animation_set_handlers(b, handlers, context);
animation_set_auto_destroy(b, auto_destroy);
animation_schedule(b);
Animation *c = prv_create_test_animation();
animation_set_duration(c, duration_a);
animation_set_delay(c, delay_a);
animation_set_handlers(c, handlers, context);
animation_set_auto_destroy(c, auto_destroy);
animation_schedule(c);
prv_advance_to_ms_with_timers(start_ms + duration_a + 2 * MIN_FRAME_INTERVAL_MS);
animation_destroy(a);
animation_destroy(b);
animation_destroy(c);
}
// --------------------------------------------------------------------------------------
// Test unscheduling animations arbitrarily in a stopped handler with auto destroy.
void test_animation__unschedule_all_in_stopped_handler_with_auto_destroy(void) {
prv_test_unschedule_all_in_stopped_handler(true);
}
// --------------------------------------------------------------------------------------
// Test unscheduling animations arbitrarily in a stopped handler without auto destroy.
void test_animation__unschedule_all_in_stopped_handler_without_auto_destroy(void) {
prv_test_unschedule_all_in_stopped_handler(false);
}
void test_animation__custom_functions(void) {
// just some pointer to compare against
AnimationCurveFunction curve = (void*)1;
InterpolateInt64Function interpolation = (void*)2;
Animation *a = prv_create_test_animation();
cl_assert_equal_p(animation_get_custom_curve(a), NULL);
cl_assert_equal_p(animation_get_custom_interpolation(a), NULL);
cl_assert_equal_i(animation_get_curve(a), AnimationCurveDefault);
animation_set_custom_curve(a, curve);
cl_assert_equal_p(animation_get_custom_curve(a), curve);
cl_assert_equal_p(animation_get_custom_interpolation(a), NULL);
cl_assert_equal_i(animation_get_curve(a), AnimationCurveCustomFunction);
animation_set_custom_interpolation(a, interpolation);
cl_assert_equal_p(animation_get_custom_curve(a), NULL);
cl_assert_equal_p(animation_get_custom_interpolation(a), interpolation);
cl_assert_equal_i(animation_get_curve(a), AnimationCurveCustomInterpolationFunction);
animation_set_curve(a, AnimationCurveDefault);
cl_assert_equal_p(animation_get_custom_curve(a), NULL);
cl_assert_equal_p(animation_get_custom_interpolation(a), NULL);
cl_assert_equal_i(animation_get_curve(a), AnimationCurveDefault);
animation_destroy(a);
}
void test_animation__current_interpolate_override(void) {
// just some pointer to compare against
AnimationCurveFunction curve = (void*)1;
InterpolateInt64Function interpolation = (void*)2;
AnimationState *state = kernel_applib_get_animation_state();
cl_assert_equal_p(state->aux->current_animation, NULL);
cl_assert_equal_p(animation_private_current_interpolate_override(), NULL);
Animation *a = prv_create_test_animation();
AnimationPrivate *a_p = animation_private_animation_find(a);
state->aux->current_animation = a_p;
cl_assert_equal_p(animation_private_current_interpolate_override(), NULL);
animation_set_custom_interpolation(a, interpolation);
cl_assert_equal_p(animation_private_current_interpolate_override(), interpolation);
animation_set_custom_curve(a, curve);
cl_assert_equal_p(animation_private_current_interpolate_override(), NULL);
animation_destroy(a);
}
Reference in a new issue Copy permalink