2866 lines
78 KiB
C
2866 lines
78 KiB
C
#include <addons.h>
|
|
|
|
void RulesBuiltinPredicates_this_eq_id(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ent = ecs_new_entity(world, "ent");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this == ent"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent, it.entities[0]);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ent = ecs_new_entity(world, "ent");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this == \"ent\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent, it.entities[0]);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_var(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_log_set_level(-4);
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this == $x"
|
|
});
|
|
|
|
test_assert(r == NULL);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this == ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, it.entities[0]);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_id_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($this), $this == ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this == \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, it.entities[0]);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_name_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($this), $this == \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_eq_var_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add_pair(world, ent_1, RelA, ent_2);
|
|
ecs_add_pair(world, ent_2, RelA, ent_2);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add_pair(world, ent_3, RelA, ent_2);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this, $x), $this == $x"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
test_uint(ent_2, it.entities[0]);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_id(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ent = ecs_new_entity(world, "ent");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == ent"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ent = ecs_new_entity(world, "ent");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == \"ent\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_var(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_log_set_level(-4);
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == $y"
|
|
});
|
|
|
|
test_assert(r == NULL);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x == ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_id_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($x), $x == ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x == \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_name_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($x), $x == \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_var_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add_pair(world, ent_1, RelA, ent_2);
|
|
ecs_add_pair(world, ent_2, RelA, ent_2);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add_pair(world, ent_3, RelA, ent_2);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x, $y), $x == $y"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
int y_var = ecs_rule_find_var(r, "y");
|
|
test_assert(y_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, y_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_id(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this != ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_3_found = false;
|
|
bool ent_4_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_2);
|
|
if (it.entities[i] == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (it.entities[i] == ent_3) {
|
|
ent_3_found = true;
|
|
}
|
|
if (it.entities[i] == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_3_found, true);
|
|
test_bool(ent_4_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_name(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this != \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_3_found = false;
|
|
bool ent_4_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_2);
|
|
if (it.entities[i] == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (it.entities[i] == ent_3) {
|
|
ent_3_found = true;
|
|
}
|
|
if (it.entities[i] == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_3_found, true);
|
|
test_bool(ent_4_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_var(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_log_set_level(-4);
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this != $x"
|
|
});
|
|
|
|
test_assert(r == NULL);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this != ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_id_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($this), $this != ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelB, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this != \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_name_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($this), $this != \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelB, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_neq_var_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add_pair(world, ent_1, RelA, ent_2);
|
|
ecs_add_pair(world, ent_2, RelA, ent_2);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add_pair(world, ent_3, RelA, ent_2);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this, $x), $this != $x"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_id(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x != ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_3_found = false;
|
|
bool ent_4_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
test_uint(it.count, 0);
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_2);
|
|
if (e == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (e == ent_3) {
|
|
ent_3_found = true;
|
|
}
|
|
if (e == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_3_found, true);
|
|
test_bool(ent_4_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_name(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x != \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_3_found = false;
|
|
bool ent_4_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
test_uint(it.count, 0);
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_2);
|
|
if (e == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (e == ent_3) {
|
|
ent_3_found = true;
|
|
}
|
|
if (e == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_3_found, true);
|
|
test_bool(ent_4_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_var(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_log_set_level(-4);
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x != $y"
|
|
});
|
|
|
|
test_assert(r == NULL);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x != ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_id_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($x), $x != ent_2"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelB, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x != \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_name_written_no_match(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
ECS_TAG(world, RelB);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelB);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelB($x), $x != \"ent_2\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelB, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_neq_var_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add_pair(world, ent_1, RelA, ent_2);
|
|
ecs_add_pair(world, ent_2, RelA, ent_2);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add_pair(world, ent_3, RelA, ent_2);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x, $y), $x != $y"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
int y_var = ecs_rule_find_var(r, "y");
|
|
test_assert(y_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, y_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(ecs_pair(RelA, ent_2), ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, y_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_neq_id(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this != ent_2, $this != ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_4_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_2);
|
|
test_assert(it.entities[i] != ent_3);
|
|
if (it.entities[i] == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (it.entities[i] == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
if (it.entities[i] == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_4_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_neq_name(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this != \"ent_2\", $this != \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_4_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_2);
|
|
test_assert(it.entities[i] != ent_3);
|
|
if (it.entities[i] == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (it.entities[i] == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
if (it.entities[i] == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_4_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_neq_id(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x != ent_2, $x != ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_4_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
test_uint(it.count, 0);
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_2);
|
|
test_assert(e != ent_3);
|
|
if (e == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (e == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
if (e == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_4_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_neq_name(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x != \"ent_2\", $x != \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_1_found = false;
|
|
bool ent_4_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
test_uint(it.count, 0);
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_2);
|
|
test_assert(e != ent_3);
|
|
if (e == ent_1) {
|
|
ent_1_found = true;
|
|
}
|
|
if (e == ent_4) {
|
|
ent_4_found = true;
|
|
}
|
|
if (e == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_1_found, true);
|
|
test_bool(ent_4_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_neq_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this != ent_2, $this != ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(2, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, it.entities[0]);
|
|
test_uint(ent_5, it.entities[1]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_neq_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this != \"ent_2\", $this != \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(2, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, it.entities[0]);
|
|
test_uint(ent_5, it.entities[1]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_neq_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x != ent_2, $x != ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_5, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_neq_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x != \"ent_2\", $x != \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_5, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_or_id(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
/* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
/* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
|
|
/* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this == ent_2 || $this == ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_2, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_or_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
/* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
/* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
|
|
/* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this == \"ent_2\" || $this == \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_2, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_or_id(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
/* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
/* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
|
|
/* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == ent_2 || $x == ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_or_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
/* ecs_entity_t ent_1 = */ ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
/* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
|
|
/* ecs_entity_t ent_5 = */ ecs_new_entity(world, "ent_5");
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == \"ent_2\" || $x == \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_or_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this == ent_2 || $this == ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_2_or_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this == \"ent_2\" || $this == \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_or_id_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x == ent_2 || $x == ent_3"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_2_or_name_written(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent_2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "ent_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent_5");
|
|
ecs_add(world, ent_5, RelA);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x == \"ent_2\" || $x == \"ent_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_2, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(RelA, ecs_field_id(&it, 1));
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_eq(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
/* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this ~= \"nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(2, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, it.entities[0]);
|
|
test_uint(ent_4, it.entities[1]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_6, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_match_eq(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
/* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x ~= \"nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_4, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_6, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_eq_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this ~= \"nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(2, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
test_uint(ent_4, it.entities[1]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_6, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_match_eq_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x ~= \"nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_4, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_6, ecs_iter_get_var(&it, x_var));
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_neq(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this ~= \"!nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_1);
|
|
test_assert(it.entities[i] != ent_3);
|
|
test_assert(it.entities[i] != ent_4);
|
|
test_assert(it.entities[i] != ent_6);
|
|
if (it.entities[i] == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (it.entities[i] == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_match_neq(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x ~= \"!nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
test_uint(it.count, 0);
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_1);
|
|
test_assert(e != ent_3);
|
|
test_assert(e != ent_4);
|
|
test_assert(e != ent_6);
|
|
if (e == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (e == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_neq_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this ~= \"!nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_1);
|
|
test_assert(it.entities[i] != ent_3);
|
|
test_assert(it.entities[i] != ent_4);
|
|
test_assert(it.entities[i] != ent_6);
|
|
if (it.entities[i] == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (it.entities[i] == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_match_neq_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x ~= \"!nt_\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
test_uint(it.count, 0);
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_1);
|
|
test_assert(e != ent_3);
|
|
test_assert(e != ent_4);
|
|
test_assert(e != ent_6);
|
|
if (e == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (e == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_2_neq(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this ~= \"!nt_\", $this ~= \"!_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_1);
|
|
test_assert(it.entities[i] != ent_3);
|
|
test_assert(it.entities[i] != ent_4);
|
|
test_assert(it.entities[i] != ent_6);
|
|
if (it.entities[i] == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (it.entities[i] == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_match_2_neq(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x ~= \"!nt_\", $x ~= \"!_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_1);
|
|
test_assert(e != ent_3);
|
|
test_assert(e != ent_4);
|
|
test_assert(e != ent_6);
|
|
if (e == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (e == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_2_neq_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this ~= \"!nt_\", $this ~= \"!_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
for (int i = 0; i < it.count; i ++) {
|
|
test_assert(it.entities[i] != ent_1);
|
|
test_assert(it.entities[i] != ent_3);
|
|
test_assert(it.entities[i] != ent_4);
|
|
test_assert(it.entities[i] != ent_6);
|
|
if (it.entities[i] == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (it.entities[i] == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_match_2_neq_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($x), $x ~= \"!nt_\", $x ~= \"!_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
bool ent_2_found = false;
|
|
bool ent_5_found = false;
|
|
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
while (ecs_rule_next(&it)) {
|
|
ecs_entity_t e = ecs_iter_get_var(&it, x_var);
|
|
test_assert(e != ent_1);
|
|
test_assert(e != ent_3);
|
|
test_assert(e != ent_4);
|
|
test_assert(e != ent_6);
|
|
if (e == ent_2) {
|
|
ent_2_found = true;
|
|
}
|
|
if (e == ent_5) {
|
|
ent_5_found = true;
|
|
}
|
|
}
|
|
|
|
test_bool(ent_2_found, true);
|
|
test_bool(ent_5_found, true);
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_2_or(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
/* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
/* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this ~= \"1\" || $this ~= \"_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_2_or_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this ~= \"1\" || $this ~= \"_3\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_3_or(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
/* ecs_entity_t ent_2 = */ ecs_new_entity(world, "ent2");
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
/* ecs_entity_t ent_4 = */ ecs_new_entity(world, "ent_4");
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, Tag);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this ~= \"1\" || $this ~= \"_3\" || $this ~= \"nt_6\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent_6, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_this_match_3_or_written(void) {
|
|
ecs_world_t *world = ecs_mini();
|
|
|
|
ECS_TAG(world, Tag);
|
|
ECS_TAG(world, RelA);
|
|
|
|
ecs_entity_t ent_1 = ecs_new_entity(world, "ent_1");
|
|
ecs_add(world, ent_1, RelA);
|
|
ecs_entity_t ent_2 = ecs_new_entity(world, "ent2");
|
|
ecs_add(world, ent_2, RelA);
|
|
ecs_entity_t ent_3 = ecs_new_entity(world, "nt_3");
|
|
ecs_add(world, ent_3, RelA);
|
|
ecs_entity_t ent_4 = ecs_new_entity(world, "ent_4");
|
|
ecs_add(world, ent_4, RelA);
|
|
ecs_entity_t ent_5 = ecs_new_entity(world, "ent5");
|
|
ecs_add(world, ent_5, RelA);
|
|
ecs_entity_t ent_6 = ecs_new_entity(world, "ent_6");
|
|
ecs_add(world, ent_6, RelA);
|
|
ecs_add(world, ent_6, Tag);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "RelA($this), $this ~= \"1\" || $this ~= \"_3\" || $this ~= \"nt_6\""
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_1, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_3, it.entities[0]);
|
|
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(true, ecs_field_is_set(&it, 1));
|
|
test_uint(false, ecs_field_is_set(&it, 2));
|
|
test_uint(ent_6, it.entities[0]);
|
|
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_unresolved_by_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$this == ent",
|
|
.flags = EcsFilterUnresolvedByName
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_entity_t ent = ecs_new_entity(world, "ent");
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(false, ecs_field_is_set(&it, 1));
|
|
test_uint(ent, it.entities[0]);
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_wildcard(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t tgt = ecs_new_id(world);
|
|
ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == *, (Rel, $x)"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(e, it.entities[0]);
|
|
test_uint(tgt, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_any(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t tgt = ecs_new_id(world);
|
|
ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x == _, (Rel, $x)"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(e, it.entities[0]);
|
|
test_uint(tgt, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_wildcard_after_write(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t tgt = ecs_new_id(world);
|
|
ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "(Rel, $x), $x == *"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(e, it.entities[0]);
|
|
test_uint(tgt, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_any_after_write(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t tgt = ecs_new_id(world);
|
|
ecs_entity_t e = ecs_new_w_pair(world, Rel, tgt);
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "(Rel, $x), $x == _"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(1, it.count);
|
|
test_uint(e, it.entities[0]);
|
|
test_uint(tgt, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void RulesBuiltinPredicates_var_eq_after_var_0_src(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_rule_t *r = ecs_rule(world, {
|
|
.expr = "$x(), $x == flecs"
|
|
});
|
|
|
|
test_assert(r != NULL);
|
|
|
|
int x_var = ecs_rule_find_var(r, "x");
|
|
test_assert(x_var != -1);
|
|
|
|
{
|
|
ecs_iter_t it = ecs_rule_iter(world, r);
|
|
test_bool(true, ecs_rule_next(&it));
|
|
test_uint(0, it.count);
|
|
test_uint(EcsFlecs, ecs_iter_get_var(&it, x_var));
|
|
test_bool(false, ecs_rule_next(&it));
|
|
}
|
|
|
|
ecs_rule_fini(r);
|
|
|
|
ecs_fini(world);
|
|
}
|