545 lines
12 KiB
C
545 lines
12 KiB
C
#include <meta.h>
|
|
|
|
ECS_STRUCT(Struct_2_i32, {
|
|
int32_t x;
|
|
int32_t y;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_bool, {
|
|
bool x;
|
|
bool y;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_char, {
|
|
char x;
|
|
char y;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_string, {
|
|
char *x;
|
|
char *y;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_f32, {
|
|
float x;
|
|
float y;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_f64, {
|
|
double x;
|
|
double y;
|
|
});
|
|
|
|
ECS_STRUCT(_Struct_w_underscore, {
|
|
double value;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_w_underscore_member_name, {
|
|
double _value;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_w_underscore_member_type, {
|
|
_Struct_w_underscore value;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_w_ptrs, {
|
|
void *ptr_a;
|
|
void* ptr_b;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_w_private, {
|
|
double x;
|
|
double y;
|
|
ECS_PRIVATE
|
|
double z;
|
|
});
|
|
|
|
ECS_ENUM(Enum_Default, {
|
|
Red, Green, Blue
|
|
});
|
|
|
|
ECS_ENUM(Enum_Default_Multiline, {
|
|
Red_1,
|
|
Green_1,
|
|
Blue_1
|
|
});
|
|
|
|
ECS_ENUM(Enum_Assign, {
|
|
Red_2 = 1, Green_2 = 3, Blue_2 = 6
|
|
});
|
|
|
|
ECS_BITMASK(Bitmask, {
|
|
Bacon = 1, Lettuce = 2, Tomato = 4, Blt = 7
|
|
});
|
|
|
|
ECS_ENUM(Enum_Nospace, {EnumNospace_A,EnumNospace_B,EnumNospace_C});
|
|
ECS_STRUCT(Struct_Nospace, {float x;float y;});
|
|
|
|
ECS_ENUM(TestNamePrefix, {
|
|
TestA,
|
|
TestB,
|
|
TestC
|
|
});
|
|
|
|
ECS_ENUM(TestTypePrefix, {
|
|
TestTypePrefixA,
|
|
TestTypePrefixB,
|
|
TestTypePrefixC
|
|
});
|
|
|
|
ECS_ENUM(TestNameTypePrefix, {
|
|
TestNameTypePrefixA,
|
|
TestNameTypePrefixB,
|
|
TestNameTypePrefixC
|
|
});
|
|
|
|
ECS_STRUCT(Struct_3_enum, {
|
|
Enum_Default one;
|
|
Enum_Default two;
|
|
Enum_Default three;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_3_enum_multiline, {
|
|
Enum_Default_Multiline one;
|
|
Enum_Default_Multiline two;
|
|
Enum_Default_Multiline three;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_3_enum_assign, {
|
|
Enum_Assign one;
|
|
Enum_Assign two;
|
|
Enum_Assign three;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_3_bitmask, {
|
|
Bitmask one;
|
|
Bitmask two;
|
|
Bitmask three;
|
|
Bitmask four;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_3_entities, {
|
|
ecs_entity_t one;
|
|
ecs_entity_t two;
|
|
ecs_entity_t three;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_array_3_i32, {
|
|
int32_t one[3];
|
|
int32_t two[3];
|
|
});
|
|
|
|
ECS_STRUCT(Struct_nested, {
|
|
Struct_2_i32 one;
|
|
});
|
|
|
|
ECS_STRUCT(Struct_2_nested, {
|
|
Struct_2_i32 one;
|
|
Struct_2_i32 two;
|
|
});
|
|
|
|
void MetaUtils_struct_w_2_i32(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_i32);
|
|
|
|
Struct_2_i32 v = {10, 20};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_i32), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{x: 10, y: 20}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_bool(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_bool);
|
|
|
|
Struct_2_bool v = {true, false};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_bool), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{x: true, y: false}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_char(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_char);
|
|
|
|
Struct_2_char v = {'a', 'b'};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_char), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{x: \"a\", y: \"b\"}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_string(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_string);
|
|
|
|
Struct_2_string v = {"Hello", "World"};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_string), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{x: \"Hello\", y: \"World\"}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_f32(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_f32);
|
|
|
|
Struct_2_f32 v = {10.5, 20.5};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_f32), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{x: 10.5, y: 20.5}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_f64(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_f64);
|
|
|
|
Struct_2_f64 v = {10.5, 20.5};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_f64), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{x: 10.5, y: 20.5}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_3_enum(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Enum_Default);
|
|
ECS_META_COMPONENT(world, Struct_3_enum);
|
|
|
|
Struct_3_enum v = {Red, Green, Blue};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_3_enum), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: Red, two: Green, three: Blue}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_3_enum_multiline(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Enum_Default_Multiline);
|
|
ECS_META_COMPONENT(world, Struct_3_enum_multiline);
|
|
|
|
Struct_3_enum_multiline v = {Red_1, Green_1, Blue_1};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_3_enum_multiline), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: Red_1, two: Green_1, three: Blue_1}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_3_enum_w_assignment(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Enum_Assign);
|
|
ECS_META_COMPONENT(world, Struct_3_enum_assign);
|
|
|
|
Struct_3_enum_assign v = {Red_2, Green_2, Blue_2};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_3_enum_assign), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: Red_2, two: Green_2, three: Blue_2}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_4_bitmask(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Bitmask);
|
|
ECS_META_COMPONENT(world, Struct_3_bitmask);
|
|
|
|
Struct_3_bitmask v = {0, Tomato, Bacon | Tomato, Blt};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_3_bitmask), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: 0, two: Tomato, three: Tomato|Bacon, four: Lettuce|Tomato|Bacon}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_3_entities(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_3_entities);
|
|
|
|
Struct_3_entities v = {0, EcsFlecs, EcsFlecsCore};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_3_entities), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: 0, two: flecs, three: flecs.core}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_array_3_i32(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_array_3_i32);
|
|
|
|
Struct_2_array_3_i32 v = {{1, 2, 3}, {6, 5, 4}};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_array_3_i32), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: [1, 2, 3], two: [6, 5, 4]}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_nested(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_i32);
|
|
ECS_META_COMPONENT(world, Struct_nested);
|
|
|
|
Struct_nested v = {{1, 2}};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_nested), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: {x: 1, y: 2}}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_2_nested(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_2_i32);
|
|
ECS_META_COMPONENT(world, Struct_2_nested);
|
|
|
|
Struct_2_nested v = {{1, 2}, {4, 3}};
|
|
char *expr = ecs_ptr_to_expr(world, ecs_id(Struct_2_nested), &v);
|
|
test_assert(expr != NULL);
|
|
test_str(expr, "{one: {x: 1, y: 2}, two: {x: 4, y: 3}}");
|
|
ecs_os_free(expr);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_enum_nospace(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Enum_Nospace);
|
|
|
|
ecs_entity_t e = ecs_id(Enum_Nospace);
|
|
test_assert(e != 0);
|
|
test_str(ecs_get_name(world, e), "Enum_Nospace");
|
|
test_assert(ecs_has(world, e, EcsEnum));
|
|
|
|
ecs_entity_t c_a = ecs_lookup_child(world, e, "EnumNospace_A");
|
|
test_assert(c_a != 0);
|
|
|
|
ecs_entity_t c_b = ecs_lookup_child(world, e, "EnumNospace_B");
|
|
test_assert(c_b != 0);
|
|
|
|
ecs_entity_t c_c = ecs_lookup_child(world, e, "EnumNospace_C");
|
|
test_assert(c_c != 0);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_nospace(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_Nospace);
|
|
|
|
ecs_entity_t e = ecs_id(Struct_Nospace);
|
|
test_assert(e != 0);
|
|
test_str(ecs_get_name(world, e), "Struct_Nospace");
|
|
test_assert(ecs_has(world, e, EcsStruct));
|
|
|
|
ecs_entity_t c_a = ecs_lookup_child(world, e, "x");
|
|
test_assert(c_a != 0);
|
|
|
|
ecs_entity_t c_b = ecs_lookup_child(world, e, "y");
|
|
test_assert(c_b != 0);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_identifier_w_underscore(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, _Struct_w_underscore);
|
|
ECS_META_COMPONENT(world, Struct_w_underscore_member_name);
|
|
ECS_META_COMPONENT(world, Struct_w_underscore_member_type);
|
|
|
|
test_assert(ecs_id(_Struct_w_underscore) != 0);
|
|
test_assert(ecs_id(Struct_w_underscore_member_name) != 0);
|
|
test_assert(ecs_id(Struct_w_underscore_member_type) != 0);
|
|
|
|
{
|
|
ecs_entity_t s = ecs_id(_Struct_w_underscore);
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "value");
|
|
test_assert(m != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t s = ecs_id(Struct_w_underscore_member_name);
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "_value");
|
|
test_assert(m != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t s = ecs_id(Struct_w_underscore_member_type);
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "value");
|
|
test_assert(m != 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_struct_w_ptr(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_w_ptrs);
|
|
|
|
test_assert(ecs_id(Struct_w_ptrs) != 0);
|
|
ecs_entity_t s = ecs_id(Struct_w_ptrs);
|
|
|
|
{
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "ptr_a");
|
|
test_assert(m != 0);
|
|
}
|
|
{
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "ptr_b");
|
|
test_assert(m != 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_private_members(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, Struct_w_private);
|
|
|
|
test_assert(ecs_id(Struct_w_private) != 0);
|
|
ecs_entity_t s = ecs_id(Struct_w_private);
|
|
|
|
{
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "x");
|
|
test_assert(m != 0);
|
|
}
|
|
{
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "y");
|
|
test_assert(m != 0);
|
|
}
|
|
{
|
|
ecs_entity_t m = ecs_lookup_child(world, s, "z");
|
|
test_assert(m == 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_enum_constant_w_name_prefix(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_set_name_prefix(world, "Test");
|
|
|
|
ECS_META_COMPONENT(world, TestNamePrefix);
|
|
|
|
test_assert(ecs_id(TestNamePrefix) != 0);
|
|
ecs_entity_t e = ecs_id(TestNamePrefix);
|
|
|
|
test_str(ecs_get_name(world, e), "NamePrefix");
|
|
|
|
{
|
|
ecs_entity_t c_a = ecs_lookup_child(world, e, "A");
|
|
test_assert(c_a != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t c_b = ecs_lookup_child(world, e, "B");
|
|
test_assert(c_b != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t c_c = ecs_lookup_child(world, e, "C");
|
|
test_assert(c_c != 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_enum_constant_w_type_prefix(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_META_COMPONENT(world, TestTypePrefix);
|
|
|
|
test_assert(ecs_id(TestTypePrefix) != 0);
|
|
ecs_entity_t e = ecs_id(TestTypePrefix);
|
|
|
|
{
|
|
ecs_entity_t c_a = ecs_lookup_child(world, e, "A");
|
|
test_assert(c_a != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t c_b = ecs_lookup_child(world, e, "B");
|
|
test_assert(c_b != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t c_c = ecs_lookup_child(world, e, "C");
|
|
test_assert(c_c != 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void MetaUtils_enum_constant_w_name_type_prefix(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_set_name_prefix(world, "Test");
|
|
|
|
ECS_META_COMPONENT(world, TestNameTypePrefix);
|
|
|
|
test_assert(ecs_id(TestNameTypePrefix) != 0);
|
|
ecs_entity_t e = ecs_id(TestNameTypePrefix);
|
|
|
|
test_str(ecs_get_name(world, e), "NameTypePrefix");
|
|
|
|
{
|
|
ecs_entity_t c_a = ecs_lookup_child(world, e, "A");
|
|
test_assert(c_a != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t c_b = ecs_lookup_child(world, e, "B");
|
|
test_assert(c_b != 0);
|
|
}
|
|
|
|
{
|
|
ecs_entity_t c_c = ecs_lookup_child(world, e, "C");
|
|
test_assert(c_c != 0);
|
|
}
|
|
|
|
ecs_fini(world);
|
|
}
|