2137 lines
60 KiB
C++
2137 lines
60 KiB
C++
#include <cpp_api.h>
|
|
|
|
enum Color {
|
|
Red, Green, Blue
|
|
};
|
|
|
|
void Misc_setup(void) {
|
|
ecs_os_set_api_defaults();
|
|
}
|
|
|
|
void Misc_string_compare_w_char_ptr(void) {
|
|
const char *ptr_1 = "foo";
|
|
const char *ptr_2 = "foo";
|
|
const char *ptr_3 = "bar";
|
|
|
|
flecs::string str = flecs::string(ecs_os_strdup(ptr_1));
|
|
|
|
test_assert(str == ptr_1);
|
|
test_assert(str == ptr_2);
|
|
test_assert(str != ptr_3);
|
|
}
|
|
|
|
void Misc_string_view_compare_w_char_ptr(void) {
|
|
const char *ptr_1 = "foo";
|
|
const char *ptr_2 = "foo";
|
|
const char *ptr_3 = "bar";
|
|
|
|
flecs::string str = flecs::string_view(ptr_1);
|
|
|
|
test_assert(str == ptr_1);
|
|
test_assert(str == ptr_2);
|
|
test_assert(str != ptr_3);
|
|
}
|
|
|
|
void Misc_string_compare_w_char_ptr_length_diff(void) {
|
|
const char *ptr_1 = "foo";
|
|
const char *ptr_2 = "foo";
|
|
const char *ptr_3 = "barrr";
|
|
const char *ptr_4 = "ba";
|
|
|
|
flecs::string str = flecs::string_view(ptr_1);
|
|
|
|
test_assert(str == ptr_1);
|
|
test_assert(str == ptr_2);
|
|
test_assert(str != ptr_3);
|
|
test_assert(str != ptr_4);
|
|
}
|
|
|
|
void Misc_string_compare_w_string(void) {
|
|
const char *ptr_1 = "foo";
|
|
const char *ptr_2 = "bar";
|
|
|
|
flecs::string str_1 = flecs::string(ecs_os_strdup(ptr_1));
|
|
flecs::string str_2 = flecs::string(ecs_os_strdup(ptr_2));
|
|
|
|
flecs::string str_3 = flecs::string(ecs_os_strdup(ptr_1));
|
|
flecs::string str_4 = flecs::string(ecs_os_strdup(ptr_2));
|
|
|
|
test_assert(str_1 == str_1);
|
|
test_assert(str_1 == str_3);
|
|
|
|
test_assert(str_2 == str_2);
|
|
test_assert(str_2 == str_4);
|
|
|
|
test_assert(str_1 != str_2);
|
|
test_assert(str_2 != str_1);
|
|
}
|
|
|
|
void Misc_string_view_compare_w_string(void) {
|
|
const char *ptr_1 = "foo";
|
|
const char *ptr_2 = "bar";
|
|
|
|
flecs::string str_1 = flecs::string_view(ptr_1);
|
|
flecs::string str_2 = flecs::string_view(ptr_2);
|
|
|
|
flecs::string str_3 = flecs::string(ecs_os_strdup(ptr_1));
|
|
flecs::string str_4 = flecs::string(ecs_os_strdup(ptr_2));
|
|
|
|
test_assert(str_1 == str_1);
|
|
test_assert(str_1 == str_3);
|
|
|
|
test_assert(str_2 == str_2);
|
|
test_assert(str_2 == str_4);
|
|
|
|
test_assert(str_1 != str_2);
|
|
test_assert(str_2 != str_1);
|
|
}
|
|
|
|
void Misc_string_compare_nullptr(void) {
|
|
const char *ptr_1 = "foo";
|
|
|
|
flecs::string str = flecs::string_view(ptr_1);
|
|
|
|
test_assert(str != nullptr);
|
|
}
|
|
|
|
void Misc_nullptr_string_compare(void) {
|
|
const char *ptr = "foo";
|
|
|
|
flecs::string str_1 = flecs::string_view(nullptr);
|
|
flecs::string str_2 = flecs::string_view(ptr);
|
|
|
|
test_assert(str_1 == "");
|
|
test_assert(str_1 != ptr);
|
|
test_assert(str_1 != str_2);
|
|
}
|
|
|
|
void Misc_nullptr_string_compare_nullptr(void) {
|
|
const char *ptr_1 = "foo";
|
|
|
|
flecs::string str = flecs::string_view(nullptr);
|
|
|
|
test_assert(str == "");
|
|
test_assert(str != ptr_1);
|
|
}
|
|
|
|
static ECS_COMPONENT_DECLARE(Velocity);
|
|
static ECS_DECLARE(TagB);
|
|
static ECS_DECLARE(E2);
|
|
static int sys_invoked_count = 0;
|
|
static int obs_invoked_count = 0;
|
|
static int trig_invoked_count = 0;
|
|
|
|
void Sys(ecs_iter_t *it) {
|
|
Position *p = ecs_field(it, Position, 1);
|
|
Velocity *v = ecs_field(it, Velocity, 2);
|
|
|
|
test_assert(p != NULL);
|
|
test_assert(v != NULL);
|
|
|
|
sys_invoked_count += it->count;
|
|
}
|
|
|
|
void Obs(ecs_iter_t *it) {
|
|
Position *p = ecs_field(it, Position, 1);
|
|
Velocity *v = ecs_field(it, Velocity, 2);
|
|
|
|
test_assert(p != NULL);
|
|
test_assert(v != NULL);
|
|
|
|
obs_invoked_count += it->count;
|
|
}
|
|
|
|
void Trig(ecs_iter_t *it) {
|
|
Position *p = ecs_field(it, Position, 1);
|
|
|
|
test_assert(p != NULL);
|
|
|
|
trig_invoked_count += it->count;
|
|
}
|
|
|
|
void Misc_c_macros(void) {
|
|
flecs::world world;
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT_DEFINE(world, Velocity);
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG_DEFINE(world, TagB);
|
|
|
|
ECS_ENTITY(world, E1, 0);
|
|
ECS_ENTITY_DEFINE(world, E2, 0);
|
|
|
|
ECS_MODULE(world, MyModule);
|
|
ECS_SYSTEM(world, Sys, EcsOnUpdate, Position, Velocity);
|
|
ECS_OBSERVER(world, Obs, EcsOnAdd, Position, Velocity);
|
|
ECS_OBSERVER(world, Trig, EcsOnAdd, Position);
|
|
ECS_PIPELINE(world, Pip, flecs.system.System, TagA);
|
|
|
|
test_assert(ecs_id(Position) != 0);
|
|
test_assert(ecs_id(Velocity) != 0);
|
|
|
|
test_assert(TagA != 0);
|
|
test_assert(TagB != 0);
|
|
|
|
test_assert(E1 != 0);
|
|
test_assert(E2 != 0);
|
|
|
|
test_assert(ecs_id(MyModule) != 0);
|
|
test_assert(ecs_id(Sys) != 0);
|
|
test_assert(ecs_id(Obs) != 0);
|
|
test_assert(ecs_id(Trig) != 0);
|
|
test_assert(Pip != 0);
|
|
|
|
ecs_add(world, E1, TagA);
|
|
ecs_add(world, E1, TagB);
|
|
|
|
test_assert( ecs_has(world, E1, TagA));
|
|
test_assert( ecs_has(world, E1, TagB));
|
|
|
|
ecs_add(world, E1, Position);
|
|
test_int(obs_invoked_count, 0);
|
|
test_int(trig_invoked_count, 1);
|
|
ecs_add(world, E1, Velocity);
|
|
test_int(obs_invoked_count, 1);
|
|
|
|
test_assert( ecs_has(world, E1, Position));
|
|
test_assert( ecs_has(world, E1, Velocity));
|
|
|
|
test_assert( ecs_has_id(world, ecs_id(MyModule), EcsModule));
|
|
test_assert( ecs_has(world, Pip, EcsPipeline));
|
|
|
|
ecs_progress(world, 0);
|
|
|
|
test_int(sys_invoked_count, 1);
|
|
}
|
|
|
|
void Misc_app_run(void) {
|
|
flecs::world ecs;
|
|
|
|
bool system_ran = false;
|
|
ecs.system().iter([&](flecs::iter& it) {
|
|
system_ran = true;
|
|
it.world().quit();
|
|
});
|
|
|
|
test_int(ecs.app().run(), 0);
|
|
test_bool(system_ran, true);
|
|
}
|
|
|
|
void Misc_app_run_target_fps(void) {
|
|
flecs::world ecs;
|
|
|
|
int32_t count = 0;
|
|
ecs.system().iter([&](flecs::iter& it) {
|
|
count ++;
|
|
test_int(it.world().get_info()->target_fps, 10);
|
|
it.world().quit();
|
|
});
|
|
|
|
ecs.set_target_fps(10);
|
|
|
|
ecs.app().run();
|
|
|
|
test_int(count, 1);
|
|
}
|
|
|
|
void Misc_app_run_set_frames(void) {
|
|
flecs::world ecs;
|
|
|
|
int32_t count = 0;
|
|
ecs.system().iter([&](flecs::iter& it) {
|
|
count ++;
|
|
});
|
|
|
|
ecs.app().frames(100).run();
|
|
|
|
test_int(count, 100);
|
|
}
|
|
|
|
void Misc_app_on_remove_on_fini(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.entity().set<Position>({10, 20});
|
|
|
|
int invoked = 0;
|
|
ecs.observer<Position>()
|
|
.event(flecs::OnRemove)
|
|
.each([&](Position& p) {
|
|
invoked ++;
|
|
test_int(p.x, 10);
|
|
test_int(p.y, 20);
|
|
});
|
|
|
|
test_int(invoked, 0);
|
|
ecs.app().frames(1).run();
|
|
test_int(invoked, 1);
|
|
}
|
|
|
|
void Misc_member_gauge_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Position>()
|
|
.member<float>("x")
|
|
.member<float>("y");
|
|
|
|
ecs.metric("metrics::position_y")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.member<Position>("y");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Position>({10, 20});
|
|
flecs::entity e2 = ecs.entity().set<Position>({20, 30});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 20);
|
|
test_int(i[1].value, 30);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_id_gauge_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.metric("metrics::has_foo")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.id<Tag>();
|
|
|
|
flecs::entity e1 = ecs.entity().add<Tag>();
|
|
flecs::entity e2 = ecs.entity().add<Tag>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 1);
|
|
test_int(i[1].value, 1);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
ecs.progress(1.0);
|
|
test_int(count, 2);
|
|
count = 0;
|
|
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 1);
|
|
test_int(i[1].value, 1);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_oneof_gauge_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
struct ColorMetric {
|
|
double value[3];
|
|
};
|
|
|
|
flecs::entity m = ecs.metric("metrics::has_oneof")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.id<Color>(flecs::Wildcard)
|
|
.targets();
|
|
|
|
flecs::entity e1 = ecs.entity().add(Color::Red);
|
|
flecs::entity e2 = ecs.entity().add(Color::Green);
|
|
flecs::entity e3 = ecs.entity().add(Color::Blue);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s) {
|
|
ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
|
|
test_assert(i != nullptr);
|
|
|
|
count += it.count();
|
|
test_int(count, 3);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
test_uint(s[2].entity, e3);
|
|
|
|
test_str(ecs.to_json(m, &i[0]), "{\"blue\":0, \"green\":0, \"red\":1}");
|
|
test_str(ecs.to_json(m, &i[1]), "{\"blue\":0, \"green\":1, \"red\":0}");
|
|
test_str(ecs.to_json(m, &i[2]), "{\"blue\":1, \"green\":0, \"red\":0}");
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(2).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 3);
|
|
count = 0;
|
|
|
|
ecs.filter<flecs::metrics::Source>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s) {
|
|
ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
|
|
test_assert(i != nullptr);
|
|
|
|
count += it.count();
|
|
test_int(count, 3);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
test_uint(s[2].entity, e3);
|
|
|
|
test_str(ecs.to_json(m, &i[0]), "{\"blue\":0, \"green\":0, \"red\":1}");
|
|
test_str(ecs.to_json(m, &i[1]), "{\"blue\":0, \"green\":1, \"red\":0}");
|
|
test_str(ecs.to_json(m, &i[2]), "{\"blue\":1, \"green\":0, \"red\":0}");
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(2).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 3);
|
|
}
|
|
|
|
void Misc_id_counter_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.metric("metrics::has_foo")
|
|
.kind<flecs::metrics::Counter>()
|
|
.id<Tag>();
|
|
|
|
flecs::entity e1 = ecs.entity().add<Tag>();
|
|
flecs::entity e2 = ecs.entity().add<Tag>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 1);
|
|
test_int(i[1].value, 1);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
ecs.progress(1.0);
|
|
test_int(count, 2);
|
|
count = 0;
|
|
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 2);
|
|
test_int(i[1].value, 2);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_oneof_counter_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
struct ColorMetric {
|
|
double value[3];
|
|
};
|
|
|
|
flecs::entity m = ecs.metric("metrics::has_oneof")
|
|
.kind<flecs::metrics::Counter>()
|
|
.id<Color>(flecs::Wildcard)
|
|
.targets();
|
|
|
|
flecs::entity e1 = ecs.entity().add(Color::Red);
|
|
flecs::entity e2 = ecs.entity().add(Color::Green);
|
|
flecs::entity e3 = ecs.entity().add(Color::Blue);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s) {
|
|
ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
|
|
test_assert(i != nullptr);
|
|
|
|
count += it.count();
|
|
test_int(count, 3);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
test_uint(s[2].entity, e3);
|
|
|
|
test_str(ecs.to_json(m, &i[0]), "{\"blue\":0, \"green\":0, \"red\":1}");
|
|
test_str(ecs.to_json(m, &i[1]), "{\"blue\":0, \"green\":1, \"red\":0}");
|
|
test_str(ecs.to_json(m, &i[2]), "{\"blue\":1, \"green\":0, \"red\":0}");
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(2).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 3);
|
|
ecs.progress(1.0);
|
|
count = 0;
|
|
|
|
ecs.filter<flecs::metrics::Source>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s) {
|
|
ColorMetric *i = static_cast<ColorMetric*>(it.range().get(m, ecs.id<flecs::metrics::Value>()));
|
|
test_assert(i != nullptr);
|
|
|
|
count += it.count();
|
|
test_int(count, 3);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
test_uint(s[2].entity, e3);
|
|
|
|
test_str(ecs.to_json(m, &i[0]), "{\"blue\":0, \"green\":0, \"red\":2}");
|
|
test_str(ecs.to_json(m, &i[1]), "{\"blue\":0, \"green\":2, \"red\":0}");
|
|
test_str(ecs.to_json(m, &i[2]), "{\"blue\":2, \"green\":0, \"red\":0}");
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(2).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 3);
|
|
}
|
|
|
|
void Misc_component_mixin_member_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Position>()
|
|
.member<float>("x")
|
|
.member<float>("y").metric<flecs::metrics::Gauge>();
|
|
|
|
flecs::entity e1 = ecs.entity().set<Position>({10, 20});
|
|
flecs::entity e2 = ecs.entity().set<Position>({20, 30});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 20);
|
|
test_int(i[1].value, 30);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_component_mixin_member_metric_custom_parent_entity(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
flecs::entity parent = ecs.entity();
|
|
|
|
ecs.component<Position>()
|
|
.member<float>("x")
|
|
.member<float>("y").metric<flecs::metrics::Gauge>(parent);
|
|
|
|
test_assert(parent.lookup("y") != 0);
|
|
|
|
flecs::entity e1 = ecs.entity().set<Position>({10, 20});
|
|
flecs::entity e2 = ecs.entity().set<Position>({20, 30});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 20);
|
|
test_int(i[1].value, 30);
|
|
|
|
test_assert(it.entity(0).parent().parent() == parent);
|
|
test_assert(it.entity(1).parent().parent() == parent);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_metric_description(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Position>()
|
|
.member<float>("x")
|
|
.member<float>("y");
|
|
|
|
flecs::entity m = ecs.metric("metrics::position_y")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.member<Position>("y")
|
|
.brief("Position y");
|
|
|
|
test_str(m.doc_brief(), "Position y");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Position>({10, 20});
|
|
flecs::entity e2 = ecs.entity().set<Position>({20, 30});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 20);
|
|
test_int(i[1].value, 30);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_component_mixin_member_metric_description(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Position>()
|
|
.member<float>("x")
|
|
.member<float>("y").metric<flecs::metrics::Gauge>(0, "Position y");
|
|
|
|
flecs::entity m = ecs.entity("Position::y");
|
|
test_str(m.doc_brief(), "Position y");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Position>({10, 20});
|
|
flecs::entity e2 = ecs.entity().set<Position>({20, 30});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 20);
|
|
test_int(i[1].value, 30);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_member_metric_w_value_name(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
flecs::entity parent = ecs.entity();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value").metric<flecs::metrics::Gauge>(parent);
|
|
|
|
test_assert(parent.lookup("value") == 0);
|
|
test_assert(parent.lookup("mass") != 0);
|
|
|
|
flecs::entity e1 = ecs.entity().set<Mass>({10});
|
|
flecs::entity e2 = ecs.entity().set<Mass>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent().parent() == parent);
|
|
test_assert(it.entity(1).parent().parent() == parent);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
struct FooBar {
|
|
float value;
|
|
};
|
|
|
|
void Misc_member_metric_w_value_name_camel_case_type(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
flecs::entity parent = ecs.entity();
|
|
|
|
ecs.component<FooBar>()
|
|
.member<float>("value").metric<flecs::metrics::Gauge>(parent);
|
|
|
|
test_assert(parent.lookup("value") == 0);
|
|
test_assert(parent.lookup("foo_bar") != 0);
|
|
|
|
flecs::entity e1 = ecs.entity().set<FooBar>({10});
|
|
flecs::entity e2 = ecs.entity().set<FooBar>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent().parent() == parent);
|
|
test_assert(it.entity(1).parent().parent() == parent);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_member_metric_w_custom_name(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
flecs::entity parent = ecs.entity();
|
|
|
|
ecs.component<FooBar>()
|
|
.member<float>("value").metric<flecs::metrics::Gauge>(parent, nullptr, "custom_name");
|
|
|
|
test_assert(parent.lookup("value") == 0);
|
|
test_assert(parent.lookup("custom_name") != 0);
|
|
|
|
flecs::entity e1 = ecs.entity().set<FooBar>({10});
|
|
flecs::entity e2 = ecs.entity().set<FooBar>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent().parent() == parent);
|
|
test_assert(it.entity(1).parent().parent() == parent);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_dotmember_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
struct Point {
|
|
float x;
|
|
float y;
|
|
};
|
|
|
|
struct Position {
|
|
float dummy;
|
|
Point position;
|
|
};
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Point>()
|
|
.member<float>("x")
|
|
.member<float>("y");
|
|
|
|
ecs.component<Position>()
|
|
.member<float>("dummy")
|
|
.member<Point>("position");
|
|
|
|
ecs.metric("metrics::position_y")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.dotmember<Position>("position.y");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Position>({10, {20, 30}});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 1);
|
|
test_uint(s[0].entity, e1);
|
|
|
|
test_int(i[0].value, 30);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 1);
|
|
}
|
|
|
|
void Misc_counter_id_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
flecs::entity m = ecs.metric("metrics.position")
|
|
.kind<flecs::metrics::CounterId>()
|
|
.id<Position>();
|
|
|
|
ecs.entity().set<Position>({10, 20});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
const flecs::metrics::Value *v = m.get<flecs::metrics::Value>();
|
|
test_assert(v != nullptr);
|
|
test_int(v->value, 1);
|
|
}
|
|
|
|
ecs.entity().set<Position>({10, 20});
|
|
ecs.entity().set<Position>({10, 20});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
const flecs::metrics::Value *v = m.get<flecs::metrics::Value>();
|
|
test_assert(v != nullptr);
|
|
test_int(v->value, 4);
|
|
}
|
|
}
|
|
|
|
void Misc_counter_target_metric(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
flecs::entity m = ecs.metric("metrics::color")
|
|
.kind<flecs::metrics::CounterId>()
|
|
.id<Color>(flecs::Wildcard)
|
|
.targets();
|
|
test_assert(m != 0);
|
|
|
|
ecs.entity().add(Color::Red);
|
|
ecs.entity().add(Color::Green);
|
|
ecs.entity().add(Color::Blue);
|
|
ecs.entity().add(Color::Blue);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
flecs::entity red = ecs.lookup("metrics::color::Red");
|
|
test_assert(red != 0);
|
|
const flecs::metrics::Value *v = red.get<flecs::metrics::Value>();
|
|
test_assert(v != nullptr);
|
|
test_int(v->value, 1);
|
|
}
|
|
|
|
{
|
|
flecs::entity green = ecs.lookup("metrics::color::Green");
|
|
test_assert(green != 0);
|
|
const flecs::metrics::Value *v = green.get<flecs::metrics::Value>();
|
|
test_assert(v != nullptr);
|
|
test_int(v->value, 1);
|
|
}
|
|
|
|
{
|
|
flecs::entity blue = ecs.lookup("metrics::color::Blue");
|
|
test_assert(blue != 0);
|
|
const flecs::metrics::Value *v = blue.get<flecs::metrics::Value>();
|
|
test_assert(v != nullptr);
|
|
test_int(v->value, 2);
|
|
}
|
|
}
|
|
|
|
void Misc_alert(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
auto e2 = ecs.entity("e2").set<Position>({10, 20});
|
|
e1.set<Velocity>({1, 2});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
test_assert(e2.has<flecs::alerts::AlertsActive>());
|
|
test_int(e2.alert_count(), 1);
|
|
test_int(e2.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e2);
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e2.add<Velocity>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai == 0);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_message(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.message("$this has position but not velocity")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
auto e2 = ecs.entity("e2").set<Position>({10, 20});
|
|
e1.set<Velocity>({1, 2});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
test_assert(e2.has<flecs::alerts::AlertsActive>());
|
|
test_int(e2.alert_count(), 1);
|
|
test_int(e2.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e2);
|
|
test_assert(ai.parent() == a);
|
|
test_str(ai.get<flecs::alerts::Instance>()->message,
|
|
"e2 has position but not velocity");
|
|
}
|
|
|
|
e2.add<Velocity>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai == 0);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_brief(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("has_position")
|
|
.with<Position>()
|
|
.brief("Entity has Position")
|
|
.build();
|
|
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "has_position");
|
|
test_str(a.doc_brief(), "Entity has Position");
|
|
}
|
|
|
|
void Misc_alert_doc_name(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("has_position")
|
|
.with<Position>()
|
|
.doc_name("Has Position")
|
|
.build();
|
|
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "has_position");
|
|
test_str(a.doc_name(), "Has Position");
|
|
}
|
|
|
|
void Misc_alert_severity_info(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("has_position")
|
|
.with<Position>()
|
|
.severity<flecs::alerts::Info>()
|
|
.build();
|
|
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "has_position");
|
|
test_assert(a.target<flecs::alerts::Alert>() == ecs.id<flecs::alerts::Info>());
|
|
}
|
|
|
|
void Misc_alert_severity_warning(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("has_position")
|
|
.with<Position>()
|
|
.severity<flecs::alerts::Warning>()
|
|
.build();
|
|
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "has_position");
|
|
test_assert(a.target<flecs::alerts::Alert>() == ecs.id<flecs::alerts::Warning>());
|
|
}
|
|
|
|
void Misc_alert_severity_error(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("has_position")
|
|
.with<Position>()
|
|
.severity<flecs::alerts::Error>()
|
|
.build();
|
|
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "has_position");
|
|
test_assert(a.target<flecs::alerts::Alert>() == ecs.id<flecs::alerts::Error>());
|
|
}
|
|
|
|
void Misc_alert_severity_implicit(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("has_position")
|
|
.with<Position>()
|
|
.build();
|
|
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "has_position");
|
|
test_assert(a.target<flecs::alerts::Alert>() == ecs.id<flecs::alerts::Error>());
|
|
}
|
|
|
|
void Misc_alert_w_retain_period(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.retain_period(1.0)
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
auto e2 = ecs.entity("e2").set<Position>({10, 20});
|
|
e1.set<Velocity>({1, 2});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
test_assert(e2.has<flecs::alerts::AlertsActive>());
|
|
test_int(e2.alert_count(), 1);
|
|
test_int(e2.alert_count(a), 1);
|
|
|
|
flecs::entity ai;
|
|
{
|
|
ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e2);
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e2.add<Velocity>();
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(ai.is_alive());
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
test_assert(!e2.has<flecs::alerts::AlertsActive>());
|
|
test_int(e2.alert_count(), 0);
|
|
test_int(e2.alert_count(a), 0);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(!ai.is_alive());
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
test_assert(!e2.has<flecs::alerts::AlertsActive>());
|
|
test_int(e2.alert_count(), 0);
|
|
test_int(e2.alert_count(a), 0);
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.severity_filter(ecs.id<flecs::alerts::Warning>(), ecs.id<Mass>())
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.add<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.remove<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_severity_type(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.severity_filter<flecs::alerts::Warning>(ecs.id<Mass>())
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.add<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.remove<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_severity_type_id_type(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.severity_filter<flecs::alerts::Warning, Mass>()
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.add<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.remove<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_severity_type_enum_constant(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.severity_filter<flecs::alerts::Warning>(Green)
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.add(Green);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.add(Blue);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
e1.remove<Color>(flecs::Wildcard);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_w_var(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.with(flecs::ChildOf).second("$parent")
|
|
.severity_filter(ecs.id<flecs::alerts::Warning>(), ecs.id<Mass>(), "parent")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto p = ecs.entity();
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20}).add<Mass>().child_of(p);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.add<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.remove<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_severity_type_w_var(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.with(flecs::ChildOf).second("$parent")
|
|
.severity_filter<flecs::alerts::Warning>(ecs.id<Mass>(), "parent")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto p = ecs.entity();
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20}).add<Mass>().child_of(p);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.add<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.remove<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_severity_type_id_type_w_var(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.with(flecs::ChildOf).second("$parent")
|
|
.severity_filter<flecs::alerts::Warning, Mass>("parent")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto p = ecs.entity();
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20}).add<Mass>().child_of(p);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.add<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.remove<Mass>();
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_severity_filter_severity_type_enum_constant_w_var(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
flecs::entity a = ecs.alert("position_without_velocity")
|
|
.with<Position>()
|
|
.without<Velocity>()
|
|
.with(flecs::ChildOf).second("$parent")
|
|
.severity_filter<flecs::alerts::Warning>(Color::Green, "parent")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "position_without_velocity");
|
|
|
|
auto p = ecs.entity();
|
|
auto e1 = ecs.entity("e1").set<Position>({10, 20}).add(Color::Green).child_of(p);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.add(Color::Green);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Warning>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.remove<Color>(flecs::Wildcard);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert((ai.has<flecs::alerts::Alert, flecs::alerts::Error>()));
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_for_member_range(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value")
|
|
.error_range(0, 100);
|
|
|
|
flecs::entity a = ecs.alert("high_mass")
|
|
.with<Mass>()
|
|
.message("$this has high mass")
|
|
.member<Mass>("value")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "high_mass");
|
|
|
|
auto e1 = ecs.entity("e1").set<Mass>({25});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
|
|
e1.set<Mass>({150});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert(ai.parent() == a);
|
|
test_str(ai.get<flecs::alerts::Instance>()->message,
|
|
"e1 has high mass");
|
|
}
|
|
|
|
e1.set<Mass>({0});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai == 0);
|
|
}
|
|
}
|
|
|
|
void Misc_alert_w_member_range_from_var(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::alerts>();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value")
|
|
.error_range(0, 100);
|
|
|
|
flecs::entity a = ecs.alert("high_parent_mass")
|
|
.with(flecs::ChildOf).second("$parent")
|
|
.with<Mass>().src("$parent")
|
|
.message("$this has high mass")
|
|
.member<Mass>("value", "parent")
|
|
.build();
|
|
test_assert(a != 0);
|
|
test_str(a.name().c_str(), "high_parent_mass");
|
|
|
|
auto p = ecs.entity().set<Mass>({25});
|
|
auto e1 = ecs.entity("e1").child_of(p);
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(!e1.has<flecs::alerts::AlertsActive>());
|
|
|
|
p.set<Mass>({150});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
test_assert(e1.has<flecs::alerts::AlertsActive>());
|
|
test_int(e1.alert_count(), 1);
|
|
test_int(e1.alert_count(a), 1);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai != 0);
|
|
test_assert(ai.has<flecs::alerts::Instance>());
|
|
test_assert(ai.has<flecs::metrics::Source>());
|
|
test_assert(ai.get<flecs::metrics::Source>()->entity == e1);
|
|
test_assert(ai.parent() == a);
|
|
}
|
|
|
|
p.set<Mass>({0});
|
|
|
|
ecs.progress(1.0);
|
|
|
|
{
|
|
flecs::entity ai = ecs.filter_builder()
|
|
.with<flecs::alerts::Instance>()
|
|
.build()
|
|
.first();
|
|
test_assert(ai == 0);
|
|
}
|
|
}
|
|
|
|
void Misc_map_api(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs_map_t m;
|
|
ecs_map_init(&m, 0);
|
|
test_int(0, ecs_map_count(&m));
|
|
|
|
int32_t *v = ecs_map_insert_alloc_t(&m, int32_t, 10);
|
|
test_assert(v != NULL);
|
|
|
|
test_assert(ecs_map_ensure_alloc_t(&m, int32_t, 10) == v);
|
|
test_assert(ecs_map_get_deref(&m, int32_t, 10) == v);
|
|
|
|
int32_t w;
|
|
ecs_map_insert_ptr(&m, 20, &w);
|
|
test_assert(ecs_map_ensure_alloc_t(&m, int32_t, 20) == &w);
|
|
test_assert(ecs_map_get_deref(&m, int32_t, 20) == &w);
|
|
|
|
test_assert(ecs_map_count(&m) == 2);
|
|
|
|
ecs_map_iter_t it = ecs_map_iter(&m);
|
|
test_bool(true, ecs_map_next(&it));
|
|
test_uint(20, ecs_map_key(&it));
|
|
test_assert(&w == ecs_map_ptr(&it));
|
|
|
|
test_bool(true, ecs_map_next(&it));
|
|
test_uint(10, ecs_map_key(&it));
|
|
test_assert(v == ecs_map_ptr(&it));
|
|
test_bool(false, ecs_map_next(&it));
|
|
|
|
test_assert(ecs_map_remove_ptr(&m, 10) == v);
|
|
test_assert(ecs_map_remove_ptr(&m, 20) == &w);
|
|
|
|
ecs_os_free(v);
|
|
|
|
ecs_map_fini(&m);
|
|
}
|
|
|
|
void Misc_member_metric_w_pair_R_T(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value");
|
|
|
|
flecs::entity m = ecs.metric("mass")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.id<Mass, Tag>()
|
|
.member("value");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Mass, Tag>({10});
|
|
flecs::entity e2 = ecs.entity().set<Mass, Tag>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent() == m);
|
|
test_assert(it.entity(1).parent() == m);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_member_metric_w_pair_R_t(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value");
|
|
|
|
flecs::entity m = ecs.metric("mass")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.id<Mass>(ecs.id<Tag>())
|
|
.member("value");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Mass, Tag>({10});
|
|
flecs::entity e2 = ecs.entity().set<Mass, Tag>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent() == m);
|
|
test_assert(it.entity(1).parent() == m);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_member_metric_w_pair_r_t(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value");
|
|
|
|
flecs::entity m = ecs.metric("mass")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.id(ecs.id<Mass>(), ecs.id<Tag>())
|
|
.member("value");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Mass, Tag>({10});
|
|
flecs::entity e2 = ecs.entity().set<Mass, Tag>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent() == m);
|
|
test_assert(it.entity(1).parent() == m);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|
|
|
|
void Misc_member_metric_w_pair_r_T(void) {
|
|
flecs::world ecs;
|
|
|
|
ecs.import<flecs::metrics>();
|
|
|
|
ecs.component<Mass>()
|
|
.member<float>("value");
|
|
|
|
flecs::entity m = ecs.metric("mass")
|
|
.kind<flecs::metrics::Gauge>()
|
|
.id_second<Tag>(ecs.id<Mass>())
|
|
.member("value");
|
|
|
|
flecs::entity e1 = ecs.entity().set<Mass, Tag>({10});
|
|
flecs::entity e2 = ecs.entity().set<Mass, Tag>({20});
|
|
|
|
ecs.progress();
|
|
|
|
int32_t count = 0;
|
|
ecs.filter<flecs::metrics::Source, flecs::metrics::Value>()
|
|
.iter([&](flecs::iter& it, flecs::metrics::Source *s, flecs::metrics::Value *i) {
|
|
count += it.count();
|
|
|
|
test_int(count, 2);
|
|
test_uint(s[0].entity, e1);
|
|
test_uint(s[1].entity, e2);
|
|
|
|
test_int(i[0].value, 10);
|
|
test_int(i[1].value, 20);
|
|
|
|
test_assert(it.entity(0).parent() == m);
|
|
test_assert(it.entity(1).parent() == m);
|
|
|
|
test_assert(it.entity(0).has<flecs::metrics::Instance>());
|
|
test_assert(it.entity(1).has<flecs::metrics::Instance>());
|
|
});
|
|
|
|
test_int(count, 2);
|
|
}
|