#include <addons.h>

static
int32_t dummy_invoked = false;

static
void Dummy(ecs_iter_t *it) {
    dummy_invoked = true;
    probe_iter(it);
}

void SystemMisc_invalid_not_without_id(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, !);

    ecs_fini(world);
}

void SystemMisc_invalid_optional_without_id(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, ?);

    ecs_fini(world);
}

void SystemMisc_invalid_entity_without_id(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_ENTITY(world, Foo, 0);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, FOO.);

    ecs_fini(world);
}

void SystemMisc_invalid_empty_without_id(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, $This);

    test_assert(true);

    ecs_fini(world);
}

void SystemMisc_invalid_empty_element(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate,, Position);

    ecs_fini(world);
}

void SystemMisc_invalid_empty_element_w_space(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, , Position);

    ecs_fini(world);
}

void SystemMisc_invalid_empty_or(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, || Position);

    ecs_fini(world);
}

void SystemMisc_invalid_empty_or_w_space(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate,|| Position);

    ecs_fini(world);
}

void SystemMisc_invalid_or_w_not(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position || !Velocity);

    ecs_fini(world);
}

void SystemMisc_invalid_not_w_or(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, !Position || Velocity);

    ecs_fini(world);
}

void SystemMisc_invalid_0_w_and(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, 0, Position);

    ecs_fini(world);
}

void SystemMisc_invalid_0_w_from_entity(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();
    
    ECS_ENTITY(world, Foo, 0);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Foo.0);

    ecs_fini(world);
}

void SystemMisc_invalid_component_id(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);

    ecs_fini(world);
}

void SystemMisc_invalid_entity_id(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    test_expect_abort();

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position(NotValid));

    ecs_fini(world);
}

void SystemMisc_invalid_null_string(void) {
    ecs_world_t *world = ecs_init();

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "Dummy", .add = {ecs_dependson(EcsOnUpdate)}}),
        .callback = Dummy
    });

    ecs_progress(world, 0);

    test_assert(dummy_invoked == true);

    ecs_fini(world);
}

void SystemMisc_invalid_empty_string(void) {
    ecs_world_t *world = ecs_init();

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "Dummy", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "",
        .callback = Dummy
    });

    ecs_progress(world, 0);

    test_assert(dummy_invoked == true);    

    ecs_fini(world);
}

void SystemMisc_invalid_empty_string_w_space(void) {
    ecs_world_t *world = ecs_init();

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "Dummy", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "  ",
        .callback = Dummy
    });

    ecs_progress(world, 0);

    test_assert(dummy_invoked == true);    

    ecs_fini(world);
}

void SystemMisc_redefine_row_system(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_entity_t s;
    {
        ECS_OBSERVER(world, Dummy, EcsOnAdd, Position);
        s = Dummy;
    }

    ECS_OBSERVER(world, Dummy, EcsOnAdd, Position);

    test_assert(s == Dummy);

    ecs_fini(world);
}

static int is_invoked;

static
void IsInvoked(ecs_iter_t *it) {
    is_invoked ++;
}

void SystemMisc_system_w_or_prefab(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_PREFAB(world, Prefab, Position);

    ECS_SYSTEM(world, IsInvoked, EcsOnUpdate, Position, flecs.core.Prefab || Disabled);

    test_int(is_invoked, 0);

    ecs_progress(world, 1);

    test_int(is_invoked, 1);

    ecs_fini(world);
}

void SystemMisc_system_w_or_disabled(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_ENTITY(world, Entity, Position, Disabled);

    ECS_SYSTEM(world, IsInvoked, EcsOnUpdate, Position, Prefab || Disabled);

    test_int(is_invoked, 0);

    ecs_progress(world, 1);

    test_int(is_invoked, 1);

    ecs_fini(world);
}

void SystemMisc_system_w_or_disabled_and_prefab(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_PREFAB(world, Prefab, Position);
    ECS_ENTITY(world, Entity, Position, Disabled);

    ECS_SYSTEM(world, IsInvoked, EcsOnUpdate, Position, flecs.core.Prefab || Disabled);

    test_int(is_invoked, 0);

    ecs_progress(world, 1);

    test_int(is_invoked, 2);
    is_invoked = false;

    ecs_fini(world);
}

static
void TableColumns(ecs_iter_t *it) {
    Position *p = ecs_field(it, Position, 1);
    Velocity *v = ecs_field(it, Velocity, 2);

    ecs_id_t ecs_id(Position) = ecs_field_id(it, 1);
    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);

    const ecs_type_t *type = ecs_table_get_type(it->table);
    test_int(2, type->count);

    ecs_entity_t *components = type->array;
    test_int(components[0], ecs_id(Position));
    test_int(components[1], ecs_id(Velocity));

    void *column_0 = ecs_table_get(it->real_world, it->table, Position, 0);
    test_assert(column_0 == p);

    void *column_1 = ecs_table_get(it->real_world, it->table, Velocity, 0);
    test_assert(column_1 == v);

    is_invoked ++;
}

void SystemMisc_table_columns_access(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_entity_t e = ecs_new(world, 0);
    ecs_add(world, e, Position);
    ecs_add(world, e, Velocity);

    ECS_SYSTEM(world, TableColumns, EcsOnUpdate, Position, Velocity);

    test_int(is_invoked, 0);

    ecs_progress(world, 1);

    test_int(is_invoked, 1);
    is_invoked = false;

    ecs_fini(world);
}

void SystemMisc_dont_enable_after_rematch(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position(self|up), Velocity(self|up));

    /* Create an entity that is watched. Whenever components are added/removed
     * to and/or from watched entities, a rematch is triggered. */
    ECS_PREFAB(world, Prefab, Position);

    ECS_ENTITY(world, Entity, (IsA, Prefab));

    Probe ctx = {0};
    ecs_set_ctx(world, &ctx, NULL);

    /* System is enabled but doesn't match with any entities */
    
    test_bool(ecs_has_id(world, Dummy, EcsDisabled), false);
    ecs_progress(world, 1);
    test_int(ctx.count, 0);

    /* Explicitly disable system before triggering a rematch */
    ecs_enable(world, Dummy, false);
    test_bool(ecs_has_id(world, Dummy, EcsDisabled), true);

    /* Trigger a rematch. System should still be disabled after this */
    ecs_add(world, Prefab, Velocity);
    test_bool(ecs_has_id(world, Dummy, EcsDisabled), true);

    ecs_progress(world, 1);
    test_int(ctx.count, 0);

    /* Enable system. It is matched, so should now be invoked */
    ecs_enable(world, Dummy, true);
    test_bool(ecs_has_id(world, Dummy, EcsDisabled), false);

    ecs_progress(world, 1);
    test_int(ctx.count, 1);

    ecs_fini(world);
}

static void SysA(ecs_iter_t *it)
{
    ecs_id_t ecs_id(Velocity) = ecs_field_id(it, 2);
    ecs_add(it->world, it->entities[0], Velocity);
}

static int b_invoked;
static ecs_entity_t b_entity;

static void SysB(ecs_iter_t *it)
{
    b_invoked ++;
    b_entity = it->entities[0];
}

void SystemMisc_ensure_single_merge(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ECS_SYSTEM(world, SysA, EcsOnLoad, Position, [out] !Velocity);
    ECS_SYSTEM(world, SysB, EcsPostLoad, Velocity);

    ECS_ENTITY(world, MyEntity, Position);

    ecs_progress(world, 0);

    test_assert(b_invoked == 1);

    ecs_fini(world);
}

static int test_table_count_invoked;

static void TestTableCount(ecs_iter_t *it) {
    test_int(it->table_count, 2);

    test_table_count_invoked ++;
}

void SystemMisc_table_count(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);
    ECS_COMPONENT(world, Mass);

    ECS_SYSTEM(world, TestTableCount, EcsOnUpdate, Position);

    // Create two active tables
    ecs_new(world, Position);
    ecs_entity_t e2 = ecs_new(world, Position);
    ecs_add(world, e2, Velocity);

    // Create one inactive table
    ecs_entity_t e3 = ecs_new(world, Position);
    ecs_add(world, e3, Velocity);
    ecs_add(world, e3, Mass);
    ecs_delete(world, e3);

    ecs_progress(world, 0);

    test_int(test_table_count_invoked, 2);

    ecs_fini(world);
}

void SystemMisc_match_system(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ECS_SYSTEM(world, SysA, 0, Position(SysA));
    ECS_SYSTEM(world, SysB, 0, Position);

    ecs_run(world, SysB, 0, NULL);

    test_assert(b_invoked != 0);
    test_assert(b_entity == SysA);
    
    ecs_fini(world);
}

void SystemMisc_system_initial_state(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_SYSTEM(world, SysA, 0, Position);

    test_assert( ecs_has_id(world, SysA, EcsEmpty));
    test_assert( !ecs_has_id(world, SysA, EcsDisabled));

    ecs_fini(world);
}

static
void FooSystem(ecs_iter_t *it) { }

static
void BarSystem(ecs_iter_t *it) { }

void SystemMisc_add_own_component(void) {
    ecs_world_t * world = ecs_init();
    
    ECS_COMPONENT(world, Position);
    ECS_SYSTEM(world, FooSystem, 0, Position);
    ECS_SYSTEM(world, BarSystem, 0, Position);

    ecs_set_ptr(world, BarSystem, Position, NULL);

    /* Make sure code didn't assert */
    test_assert(true);

    ecs_fini(world);
}

static bool action_a_invoked;
static bool action_b_invoked;

static
void ActionA(ecs_iter_t *it) {
    action_a_invoked = true;
}

static
void ActionB(ecs_iter_t *it) {
    action_b_invoked = true;
}

void SystemMisc_change_system_action(void) {
    ecs_world_t * world = ecs_init();
    
    ECS_COMPONENT(world, Position);
    
    ecs_entity_t sys = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "Sys", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "Position",
        .callback = ActionA
    });

    ecs_new(world, Position);

    test_bool(action_a_invoked, false);
    test_bool(action_b_invoked, false);

    ecs_progress(world, 0);

    test_bool(action_a_invoked, true);
    test_bool(action_b_invoked, false);

    action_a_invoked = false;

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = sys,
        .callback = ActionB
    });

    ecs_progress(world, 0);

    test_bool(action_a_invoked, false);
    test_bool(action_b_invoked, true);

    ecs_fini(world);
}

void SystemMisc_system_readeactivate(void) {
    ecs_world_t * world = ecs_init();
    
    ECS_COMPONENT(world, Position);
    
    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);

    /* No entities, system should be deactivated */
    test_assert( ecs_has_id(world, Dummy, EcsEmpty));

    ecs_entity_t e = ecs_new(world, Position);
    ecs_run_aperiodic(world, 0);

    /* System should be active, one entity is matched */
    test_assert( !ecs_has_id(world, Dummy, EcsEmpty));

    ecs_delete(world, e);
    ecs_run_aperiodic(world, 0);

    /* System is not automatically deactivated */
    test_assert( !ecs_has_id(world, Dummy, EcsEmpty));

    /* Manually deactivate system that aren't matched with entities */
    ecs_run_aperiodic(world, EcsAperiodicEmptyQueries);

    /* System should be deactivated */
    test_assert( ecs_has_id(world, Dummy, EcsEmpty));

    ecs_fini(world);
}

static
void Dummy1(ecs_iter_t *it) { }

static
void Dummy2(ecs_iter_t *it) { }

void SystemMisc_system_readeactivate_w_2_systems(void) {
    ecs_world_t * world = ecs_init();
    
    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Mass);
    
    ECS_SYSTEM(world, Dummy1, EcsOnUpdate, Position);
    ECS_SYSTEM(world, Dummy2, EcsOnUpdate, Mass);

    /* No entities, system should be deactivated */
    test_assert( ecs_has_id(world, Dummy1, EcsEmpty));
    test_assert( ecs_has_id(world, Dummy2, EcsEmpty));

    ecs_entity_t e1 = ecs_new(world, Position);
    ecs_new(world, Mass);
    ecs_run_aperiodic(world, 0);

    /* Systems should be active, one entity is matched */
    test_assert( !ecs_has_id(world, Dummy1, EcsEmpty));
    test_assert( !ecs_has_id(world, Dummy2, EcsEmpty));

    ecs_delete(world, e1);
    ecs_run_aperiodic(world, 0);

    /* System is not automatically deactivated */
    test_assert( !ecs_has_id(world, Dummy1, EcsEmpty));
    test_assert( !ecs_has_id(world, Dummy2, EcsEmpty));

    /* Manually deactivate system that aren't matched with entities */
    ecs_run_aperiodic(world, EcsAperiodicEmptyQueries);

    /* System should be deactivated */
    test_assert( ecs_has_id(world, Dummy1, EcsEmpty));
    test_assert( !ecs_has_id(world, Dummy2, EcsEmpty));

    ecs_fini(world);
}

void SystemMisc_add_to_system_in_progress(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_TAG(world, Tag);

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);

    ecs_new(world, Position);

    ecs_defer_begin(world);

    ecs_add(world, Dummy, Tag);

    ecs_defer_end(world);

    ecs_progress(world, 0);
    test_assert(dummy_invoked == true);

    ecs_fini(world);
}

static
void Action(ecs_iter_t *it) { }

void SystemMisc_redefine_null_signature(void) {
    ecs_world_t *world = ecs_init();

    ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = NULL,
        .callback = Action
    });

    ecs_entity_t s_2 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = NULL,
        .callback = Action
    });      

    test_assert(s_1 == s_2);

    ecs_fini(world);
}

void SystemMisc_redefine_0_signature(void) {
    ecs_world_t *world = ecs_init();

    ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "0",
        .callback = Action
    });

    ecs_entity_t s_2 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, { .name = "System", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "0",
        .callback = Action
    }); 

    test_assert(s_1 == s_2);

    ecs_fini(world);
}

void SystemMisc_one_named_column_of_two(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_filter_t f = ECS_FILTER_INIT;
    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
        .storage = &f, .terms = {
        { ecs_id(Position), .name = "pos" },
        { ecs_id(Velocity) }
    }}));

    test_int(f.term_count, 2);
    test_int(f.field_count, 2);

    ecs_term_t *
    term = &f.terms[0];
    test_assert(term->oper == EcsAnd);
    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
    test_assert(term->src.id == EcsThis);
    test_assert(term->inout == EcsInOutDefault);
    test_assert(term->id == ecs_id(Position));
    test_str(term->name, "pos");

    term = &f.terms[1];
    test_assert(term->oper == EcsAnd);
    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
    test_assert(term->src.id == EcsThis);
    test_assert(term->inout == EcsInOutDefault);
    test_assert(term->id == ecs_id(Velocity));
    test_str(term->name, NULL);

    ecs_filter_fini(&f);

    ecs_fini(world);
}

void SystemMisc_two_named_columns_of_two(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_filter_t f = ECS_FILTER_INIT;
    test_assert(NULL != ecs_filter_init(world, &(ecs_filter_desc_t){
        .storage = &f, .terms = {
        { ecs_id(Position), .name = "pos" },
        { ecs_id(Velocity), .name = "vel" }
    }}));    

    test_int(f.term_count, 2);
    test_int(f.field_count, 2);

    ecs_term_t *
    term = &f.terms[0];
    test_assert(term->oper == EcsAnd);
    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
    test_assert(term->src.id == EcsThis);
    test_assert(term->inout == EcsInOutDefault);
    test_assert(term->id == ecs_id(Position));
    test_str(term->name, "pos");

    term = &f.terms[1];
    test_assert(term->oper == EcsAnd);
    test_assert(term->src.flags == (EcsSelf|EcsUp|EcsIsVariable));
    test_assert(term->src.id == EcsThis);
    test_assert(term->inout == EcsInOutDefault);
    test_assert(term->id == ecs_id(Velocity));
    test_str(term->name, "vel");

    ecs_filter_fini(&f);

    ecs_fini(world);
}

void SystemMisc_redeclare_system_explicit_id(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}), 
        .query.filter.expr = "Position, Velocity", 
        .callback = Dummy
    });

    ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = s1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "Position, Velocity", 
        .callback = Dummy
    });

    test_assert(s1 == s2);

    ecs_fini(world);
}

void SystemMisc_redeclare_system_explicit_id_null_expr(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}), 
        .query.filter.expr = NULL, 
        .callback = Dummy
    });

    ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = s1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = NULL, 
        .callback = Dummy
    });

    test_assert(s1 == s2);

    ecs_fini(world);
}

void SystemMisc_redeclare_system_explicit_id_no_name(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_entity_t s1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}), 
        .query.filter.expr = "Position, Velocity", 
        .callback = Dummy
    });

    ecs_entity_t s2 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = s1, .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "Position, Velocity", 
        .callback = Dummy
    });

    test_assert(s1 == s2);
    test_str(ecs_get_name(world, s1), "Move");

    ecs_fini(world);
}

void SystemMisc_declare_different_id_same_name(void) {
    install_test_abort();

    ecs_world_t *world = ecs_init();

    ecs_entity_t e1 = ecs_new(world, 0);
    ecs_entity_t e2 = ecs_new(world, 0);

    ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = e1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "0", 
        .callback = Dummy
    });
    test_assert(e1 == s_1);

    test_expect_abort();

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = e2, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "0", 
        .callback = Dummy
    });
}

void SystemMisc_declare_different_id_same_name_w_scope(void) {
    install_test_abort();
    
    ecs_world_t *world = ecs_init();

    ecs_entity_t scope = ecs_new(world, 0);
    ecs_set_scope(world, scope);

    ecs_entity_t e1 = ecs_new(world, 0);
    ecs_entity_t e2 = ecs_new(world, 0);

    ecs_entity_t s_1 = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = e1, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "0", 
        .callback = Dummy
    });
    test_assert(e1 == s_1);

    test_expect_abort();

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.id = e2, .name = "Move", .add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.expr = "0", 
        .callback = Dummy
    });
}

void SystemMisc_rw_in_implicit_any(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, Velocity(self|up)");

    ecs_entity_t e = ecs_new(world, Position);
    ecs_add(world, e, Velocity);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == false);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_in_implicit_shared(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, Velocity(up)");

    ecs_entity_t base = ecs_new(world, Velocity);
    ecs_entity_t e = ecs_new(world, Position);
    ecs_add_pair(world, e, EcsIsA, base);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == true);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_in_implicit_from_empty(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, Velocity()");

    ecs_entity_t e = ecs_new(world, Position);
    ecs_add(world, e, Velocity);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == true);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_in_implicit_from_entity(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);
    ECS_ENTITY(world, f, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, Velocity(f)");

    ecs_entity_t e = ecs_new(world, Position);
    ecs_add(world, e, Velocity);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == true);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_out_explicit_any(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity(self|up)");

    ecs_entity_t e = ecs_new(world, Position);
    ecs_add(world, e, Velocity);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == false);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_out_explicit_shared(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity(up)");

    ecs_entity_t base = ecs_new(world, Velocity);
    ecs_entity_t e = ecs_new(world, Position);
    ecs_add_pair(world, e, EcsIsA, base);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == false);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_out_explicit_from_empty(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity()");

    ecs_entity_t e = ecs_new(world, Position);
    ecs_add(world, e, Velocity);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == false);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_rw_out_explicit_from_entity(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);
    ECS_COMPONENT(world, Velocity);
    ECS_ENTITY(world, f, Velocity);

    ecs_query_t *q = ecs_query_new(world, "Position, [out] Velocity(f)");

    ecs_entity_t e = ecs_new(world, Position);
    ecs_add(world, e, Velocity);

    ecs_iter_t it = ecs_query_iter(world, q);
    test_assert(ecs_query_next(&it) == true);
    test_assert(ecs_field_is_readonly(&it, 1) == false);
    test_assert(ecs_field_is_readonly(&it, 2) == false);
    test_assert(ecs_query_next(&it) == false);

    ecs_fini(world);
}

void SystemMisc_activate_system_for_table_w_n_pairs(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Pair);
    ECS_SYSTEM(world, Dummy, EcsOnUpdate, (Pair, *));

    ECS_TAG(world, TagA);
    ECS_TAG(world, TagB);

    Probe ctx = {0};
    ecs_set_ctx(world, &ctx, NULL);    

    ECS_ENTITY(world, e, (Pair, TagA), (Pair, TagB));
    test_assert(e != 0);

    ecs_progress(world, 0);

    test_int(ctx.count, 2);
    test_int(ctx.invoked, 2);

    test_int(ctx.e[0], e);
    test_int(ctx.e[1], e);

    test_int(ctx.c[0][0], ecs_pair(Pair, TagA));
    test_int(ctx.s[0][0], 0);
    test_int(ctx.c[1][0], ecs_pair(Pair, TagB));
    test_int(ctx.s[1][0], 0);    

    ecs_fini(world);
}

void SystemMisc_get_query(void) {
    ecs_world_t *world = ecs_init();

    ECS_COMPONENT(world, Position);

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Position);

    ecs_set(world, 0, Position, {0, 0});
    ecs_set(world, 0, Position, {1, 0});
    ecs_set(world, 0, Position, {2, 0});

    ecs_query_t *q = ecs_system_get_query(world, Dummy);
    test_assert(q != NULL);

    int32_t count = 0;

    ecs_iter_t it = ecs_query_iter(world, q);
    while (ecs_query_next(&it)) {
        Position *p = ecs_field(&it, Position, 1);
        test_assert(p != NULL);

        int i;
        for (i = 0; i < it.count; i ++) {
            test_int(p[i].x, i);
            count ++;
        }
    }

    test_int(count, 3);

    ecs_fini(world);
}

void SystemMisc_set_get_context(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    int32_t ctx_a, ctx_b;

    ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.name = "MySystem"}),
        .query.filter.terms = {{Tag}},
        .callback = Dummy,
        .ctx = &ctx_a
    });
    test_assert(s != 0);

    test_assert(ecs_system_get_ctx(world, s) == &ctx_a);

    test_assert(ecs_system_init(world, &(ecs_system_desc_t){
        .entity = s,
        .ctx = &ctx_b
    }) == s);

    test_assert(ecs_system_get_ctx(world, s) == &ctx_b);

    ecs_fini(world);
}

void SystemMisc_set_get_binding_context(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    int32_t ctx_a, ctx_b;

    ecs_entity_t s = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.name = "MySystem"}),
        .query.filter.terms = {{Tag}},
        .callback = Dummy,
        .binding_ctx = &ctx_a
    });
    test_assert(s != 0);

    test_assert(ecs_system_get_binding_ctx(world, s) == &ctx_a);

    test_assert(ecs_system_init(world, &(ecs_system_desc_t){
        .entity = s,
        .binding_ctx = &ctx_b
    }) == s);

    test_assert(ecs_system_get_binding_ctx(world, s) == &ctx_b);

    ecs_fini(world);
}

void SystemMisc_deactivate_after_disable(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    ECS_SYSTEM(world, Dummy, EcsOnUpdate, Tag);

    ecs_entity_t e = ecs_new_w_id(world, Tag);
    ecs_run_aperiodic(world, 0);
    
    test_assert(!ecs_has_id(world, Dummy, EcsEmpty));

    ecs_enable(world, Dummy, false);
    test_assert(!ecs_has_id(world, Dummy, EcsEmpty));
    test_assert(ecs_has_id(world, Dummy, EcsDisabled));

    ecs_delete(world, e);
    ecs_run_aperiodic(world, 0);

    test_assert(!ecs_has_id(world, Dummy, EcsEmpty));
    test_assert(ecs_has_id(world, Dummy, EcsDisabled));

    ecs_fini(world);
}

void SystemMisc_delete_system(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.name = "Foo"}),
        .query.filter.terms = {{.id = Tag}},
        .callback = Dummy
    });
    test_assert(system != 0);

    ecs_set_ctx(world, &ctx, NULL);

    ecs_entity_t e = ecs_new_id(world);
    ecs_add_id(world, e, Tag);

    ecs_run(world, system, 0, NULL);
    test_int(ctx.count, 1);
    test_assert(ctx.system == system);

    ecs_delete(world, system);
    test_assert(!ecs_is_alive(world, system));

    ecs_fini(world);
}

void SystemMisc_delete_pipeline_system(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    Probe ctx = {0};

    // Create system before
    test_assert(ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.terms = {{.id = Tag}},
        .callback = Dummy
    }) != 0);

    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.terms = {{.id = Tag}},
        .callback = Dummy
    });
    test_assert(system != 0);

    // Create system after
    test_assert(ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.terms = {{.id = Tag}},
        .callback = Dummy
    }) != 0);

    ecs_set_ctx(world, &ctx, NULL);

    ecs_entity_t e = ecs_new_id(world);
    ecs_add_id(world, e, Tag);

    ecs_progress(world, 0);
    test_int(ctx.count, 3);

    ctx.count = 0;

    ecs_delete(world, system);

    ecs_progress(world, 0);
    test_int(ctx.count, 2);

    ecs_fini(world);
}

static int ctx_value;
static
void ctx_free(void *ctx) {
    test_assert(&ctx_value == ctx);
    ctx_value ++;
}

static int binding_ctx_value;
static
void binding_ctx_free(void *ctx) {
    test_assert(&binding_ctx_value == ctx);
    binding_ctx_value ++;
}

static int ctx_value_2;
static
void ctx_free_2(void *ctx) {
    test_assert(&ctx_value_2 == ctx);
    ctx_value_2 ++;
}

static int binding_ctx_value_2;
static
void binding_ctx_free_2(void *ctx) {
    test_assert(&binding_ctx_value_2 == ctx);
    binding_ctx_value_2 ++;
}

void SystemMisc_delete_system_w_ctx(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .query.filter.terms = {{.id = Tag}},
        .callback = Dummy,
        .ctx = &ctx_value,
        .ctx_free = ctx_free,
        .binding_ctx = &binding_ctx_value,
        .binding_ctx_free = binding_ctx_free
    });
    test_assert(system != 0);

    test_assert(ecs_system_get_ctx(world, system) == &ctx_value);
    test_assert(ecs_system_get_binding_ctx(world, system) 
        == &binding_ctx_value);

    ecs_set_ctx(world, &ctx, NULL);

    ecs_entity_t e = ecs_new_id(world);
    ecs_add_id(world, e, Tag);

    ecs_run(world, system, 0, NULL);
    test_int(ctx.count, 1);
    test_assert(ctx.system == system);

    ecs_delete(world, system);
    test_assert(!ecs_is_alive(world, system));

    ecs_fini(world);
}

void SystemMisc_update_ctx(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .query.filter.terms = {{.id = Tag}},
        .callback = Dummy,
        .ctx = &ctx_value,
        .ctx_free = ctx_free,
        .binding_ctx = &binding_ctx_value,
        .binding_ctx_free = binding_ctx_free
    });
    test_assert(system != 0);

    test_assert(ecs_system_get_ctx(world, system) == &ctx_value);
    test_assert(ecs_system_get_binding_ctx(world, system) 
        == &binding_ctx_value);

    ecs_system(world, {
        .entity = system,
        .ctx = &ctx_value,
        .ctx_free = ctx_free,
        .binding_ctx = &binding_ctx_value,
        .binding_ctx_free = binding_ctx_free
    });

    test_int(ctx_value, 0);
    test_int(binding_ctx_value, 0);
    test_int(ctx_value_2, 0);
    test_int(binding_ctx_value_2, 0);

    ecs_system(world, {
        .entity = system,
        .ctx = &ctx_value_2,
        .ctx_free = ctx_free_2,
        .binding_ctx = &binding_ctx_value_2,
        .binding_ctx_free = binding_ctx_free_2
    });

    test_int(ctx_value, 1);
    test_int(binding_ctx_value, 1);
    test_int(ctx_value_2, 0);
    test_int(binding_ctx_value_2, 0);

    ecs_delete(world, system);

    test_int(ctx_value, 1);
    test_int(binding_ctx_value, 1);
    test_int(ctx_value_2, 1);
    test_int(binding_ctx_value_2, 1);

    ecs_fini(world);
}

static int run_invoked = 0;

static void Run(ecs_iter_t *it) {
    while (ecs_iter_next(it)) {
        probe_iter(it);
    }

    run_invoked ++;
}

static int run_2_invoked = 0;

static void Run2(ecs_iter_t *it) {
    run_2_invoked ++;
    ecs_iter_fini(it);
}

static void Run_call_callback(ecs_iter_t *it) {
    run_invoked ++;
    
    test_assert(it != NULL);
    test_assert(it->next != NULL);
    test_assert(it->callback != NULL);

    while (ecs_iter_next(it)) {
        it->callback(it);
    }
}

void SystemMisc_run_custom_run_action(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, TagA);
    ECS_TAG(world, TagB);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .query.filter.terms = {{ .id = TagA }},
        .run = Run,
        .callback = Dummy,
        .ctx = &ctx,
    });
    test_assert(system != 0);

    ecs_entity_t e1 = ecs_new(world, TagA);
    ecs_entity_t e2 = ecs_new(world, TagA);
    ecs_entity_t e3 = ecs_new(world, TagA);
    ecs_add(world, e3, TagB); // 2 tables

    ecs_run(world, system, 0, NULL);

    test_bool(dummy_invoked, false);
    test_int(run_invoked, 1);

    test_int(ctx.invoked, 2);
    test_int(ctx.count, 3);
    test_int(ctx.e[0], e1);
    test_int(ctx.e[1], e2);
    test_int(ctx.e[2], e3);

    ecs_fini(world);
}

void SystemMisc_run_w_offset_limit_custom_run_action(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, TagA);
    ECS_TAG(world, TagB);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .query.filter.terms = {{ .id = TagA }},
        .run = Run,
        .callback = Dummy,
        .ctx = &ctx,
    });
    test_assert(system != 0);

    ecs_new(world, TagA);
    ecs_entity_t e2 = ecs_new(world, TagA);
    ecs_entity_t e3 = ecs_new(world, TagA);
    ecs_add(world, e3, TagB); // 2 tables

    ecs_run_w_filter(world, system, 0, 1, 1, NULL);

    test_bool(dummy_invoked, false);
    test_int(run_invoked, 1);

    test_int(ctx.invoked, 1);
    test_int(ctx.count, 1);
    test_int(ctx.e[0], e2);

    ecs_fini(world);
}

void SystemMisc_pipeline_custom_run_action(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, TagA);
    ECS_TAG(world, TagB);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}}),
        .query.filter.terms = {{ .id = TagA }},
        .run = Run,
        .callback = Dummy,
        .ctx = &ctx
    });
    test_assert(system != 0);

    ecs_entity_t e1 = ecs_new(world, TagA);
    ecs_entity_t e2 = ecs_new(world, TagA);
    ecs_entity_t e3 = ecs_new(world, TagA);
    ecs_add(world, e3, TagB); // 2 tables

    ecs_progress(world, 0);

    test_bool(dummy_invoked, false);
    test_int(run_invoked, 1);

    test_int(ctx.invoked, 2);
    test_int(ctx.count, 3);
    test_int(ctx.e[0], e1);
    test_int(ctx.e[1], e2);
    test_int(ctx.e[2], e3);

    ecs_fini(world);
}

void SystemMisc_change_custom_run_action(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, TagA);
    ECS_TAG(world, TagB);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .query.filter.terms = {{ .id = TagA }},
        .run = Run,
        .callback = Dummy,
        .ctx = &ctx,
    });
    test_assert(system != 0);

    ecs_new(world, TagA);

    ecs_run(world, system, 0, NULL);
    test_bool(dummy_invoked, false);
    test_int(run_invoked, 1);
    test_int(run_2_invoked, 0);

    ecs_system_init(world, &(ecs_system_desc_t){
        .entity = system,
        .run = Run2
    });

    ecs_run(world, system, 0, NULL);
    test_bool(dummy_invoked, false);
    test_int(run_invoked, 1);
    test_int(run_2_invoked, 1);

    ecs_fini(world);
}

void SystemMisc_custom_run_action_call_next(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, TagA);
    ECS_TAG(world, TagB);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system_init(world, &(ecs_system_desc_t){
        .query.filter.terms = {{ .id = TagA }},
        .run = Run_call_callback,
        .callback = Dummy,
        .ctx = &ctx,
        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}})
    });
    test_assert(system != 0);

    ecs_entity_t e1 = ecs_new(world, TagA);
    ecs_entity_t e2 = ecs_new(world, TagA);
    ecs_entity_t e3 = ecs_new(world, TagA);
    ecs_add(world, e3, TagB); // 2 tables

    ecs_progress(world, 0);

    test_bool(dummy_invoked, true);
    test_int(run_invoked, 1);

    test_int(ctx.invoked, 2);
    test_int(ctx.count, 3);
    test_int(ctx.e[0], e1);
    test_int(ctx.e[1], e2);
    test_int(ctx.e[2], e3);

    ecs_fini(world);
}

void SystemMisc_system_w_short_notation(void) {
    ecs_world_t *world = ecs_init();

    ECS_TAG(world, Tag);

    Probe ctx = {0};
    ecs_entity_t system = ecs_system(world, {
        .query.filter.terms = {{ .id = Tag }},
        .callback = Dummy,
        .ctx = &ctx,
        .entity = ecs_entity(world, {.add = {ecs_dependson(EcsOnUpdate)}})
    });
    test_assert(system != 0);

    ecs_entity_t e = ecs_new(world, Tag);

    ecs_progress(world, 0);

    test_bool(dummy_invoked, true);
    test_int(ctx.invoked, 1);
    test_int(ctx.count, 1);
    test_int(ctx.e[0], e);

    ecs_fini(world);
}

void SystemMisc_update_interval_w_system_init(void) {
    ecs_world_t *world = ecs_init();

    ecs_entity_t system = ecs_system(world, {
        .callback = Dummy,
    });
    test_assert(system != 0);
    test_int(ecs_get_interval(world, system), 0);

    ecs_system(world, {
        .entity = system,
        .interval = 1.0
    });

    test_int(ecs_get_interval(world, system), 1.0);

    ecs_fini(world);
}

void SystemMisc_update_rate_w_system_init(void) {
    ecs_world_t *world = ecs_init();

    ecs_entity_t system = ecs_system(world, {
        .callback = Dummy,
    });
    test_assert(system != 0);
    test_assert(ecs_get(world, system, EcsRateFilter) == NULL);

    ecs_system(world, {
        .entity = system,
        .rate = 2.0
    });

    const EcsRateFilter *r = ecs_get(world, system, EcsRateFilter);
    test_assert(r != NULL);
    test_int(r->rate, 2.0);

    ecs_fini(world);
}

void SystemMisc_system_w_interval_rate_stop_timer(void) {
    ecs_world_t *world = ecs_init();

    ecs_entity_t system = ecs_system(world, {
        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
        .interval = 1.0,
        .rate = 3.0,
        .callback = Dummy
    });

    for (int i = 0; i < 5; i ++) {
        ecs_progress(world, 0.5);
        test_assert(dummy_invoked == 0);
    }

    ecs_progress(world, 0.5);

    test_assert(dummy_invoked == 1);
    dummy_invoked = 0;

    ecs_stop_timer(world, system);

    for (int i = 0; i < 5; i ++) {
        ecs_progress(world, 0.5);
        test_assert(dummy_invoked == 0);
    }

    ecs_progress(world, 0.5);

    test_assert(dummy_invoked == 0);

    ecs_fini(world);
}

static
int32_t sys_a_invoked = false;

static
void SA(ecs_iter_t *it) {
    sys_a_invoked = true;
}

static
int32_t sys_b_invoked = false;

static
void SB(ecs_iter_t *it) {
    sys_b_invoked = true;
}

static
int32_t sys_c_invoked = false;

static
void SC(ecs_iter_t *it) {
    sys_c_invoked = true;
}

void SystemMisc_system_same_interval_same_tick(void) {
    ecs_world_t *world = ecs_init();

    ecs_system(world, {
        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
        .interval = 1.0,
        .callback = SA
    });

    ecs_system(world, {
        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
        .interval = 1.0,
        .callback = SB
    });

    ecs_system(world, {
        .entity = ecs_entity(world, { .add = {ecs_dependson(EcsOnUpdate)} }),
        .interval = 1.0,
        .callback = SC
    });

    while (!sys_a_invoked) {
        test_assert(!sys_b_invoked);
        test_assert(!sys_c_invoked);
        ecs_progress(world, 0.0001);
    }

    test_assert(sys_b_invoked);
    test_assert(sys_c_invoked);

    ecs_fini(world);
}