1638 lines
44 KiB
C
1638 lines
44 KiB
C
#include <meta.h>
|
|
#include <stdio.h>
|
|
#include <limits.h>
|
|
#include <math.h>
|
|
|
|
void SerializeEntityToJson_serialize_empty(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
|
|
char *str = ecs_os_strdup("{\"path\":\"446\", \"ids\":[]}");
|
|
ecs_os_sprintf(
|
|
str, "{\"path\":\"%u\", \"ids\":[]}", (uint32_t)e);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, str);
|
|
ecs_os_free(json);
|
|
ecs_os_free(str);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{\"path\":\"Foo\", \"ids\":[]}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_name_1_tag(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{\"path\":\"Foo\", \"ids\":[[\"Tag\"]]}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_name_2_tags(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, TagA);
|
|
ecs_add(world, e, TagB);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json,
|
|
"{\"path\":\"Foo\", \"ids\":[[\"TagA\"], [\"TagB\"]]}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_name_1_pair(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
ECS_TAG(world, Obj);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, Rel, Obj);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json,
|
|
"{\"path\":\"Foo\", \"ids\":[[\"Rel\", \"Obj\"]]}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_base(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
|
|
ecs_entity_t base = ecs_new_entity(world, "Base");
|
|
ecs_add(world, base, TagA);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, EcsIsA, base);
|
|
ecs_add(world, e, TagB);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"is_a\":[{\"path\":\"Base\", \"ids\":[[\"TagA\"]]}], "
|
|
"\"ids\":[[\"TagB\"]]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_base_override(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
|
|
ecs_entity_t base = ecs_new_entity(world, "Base");
|
|
ecs_add(world, base, TagA);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, EcsIsA, base);
|
|
ecs_add(world, e, TagA);
|
|
ecs_add(world, e, TagB);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_hidden = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"is_a\":[{\"path\":\"Base\", \"ids\":[[\"TagA\"]], \"hidden\":[true]}], "
|
|
"\"ids\":["
|
|
"[\"TagA\"], [\"TagB\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_2_base(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
|
|
ecs_entity_t base_a = ecs_new_entity(world, "BaseA");
|
|
ecs_entity_t base_b = ecs_new_entity(world, "BaseB");
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, EcsIsA, base_a);
|
|
ecs_add_pair(world, e, EcsIsA, base_b);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"is_a\":[{\"path\":\"BaseA\", \"ids\":[]}, "
|
|
"{\"path\":\"BaseB\", \"ids\":[]}], "
|
|
"\"ids\":[]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_nested_base(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
|
|
ecs_entity_t base_of_base = ecs_new_entity(world, "BaseOfBase");
|
|
ecs_entity_t base = ecs_new_entity(world, "Base");
|
|
ecs_add_pair(world, base, EcsIsA, base_of_base);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, EcsIsA, base);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"is_a\":[{\"path\":\"BaseOfBase\", \"ids\":[]}, "
|
|
"{\"path\":\"Base\", \"ids\":[]}], "
|
|
"\"ids\":[]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_1_component(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Position"}),
|
|
.members = {
|
|
{"x", ecs_id(ecs_i32_t)},
|
|
{"y", ecs_id(ecs_i32_t)}
|
|
}
|
|
});
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, Position, {10, 20});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"Position\"]], "
|
|
"\"values\":[{\"x\":10, \"y\":20}]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_2_components(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Position"}),
|
|
.members = {
|
|
{"x", ecs_id(ecs_i32_t)},
|
|
{"y", ecs_id(ecs_i32_t)}
|
|
}
|
|
});
|
|
|
|
ecs_entity_t ecs_id(Mass) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Mass"}),
|
|
.members = {
|
|
{"value", ecs_id(ecs_i32_t)}
|
|
}
|
|
});
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, Position, {10, 20});
|
|
ecs_set(world, e, Mass, {1234});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"Position\"], [\"Mass\"]], "
|
|
"\"values\":[{\"x\":10, \"y\":20}, {\"value\":1234}]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_primitive_component(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, ecs_i32_t, {10});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"flecs.meta.i32\"]], "
|
|
"\"values\":[10]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_enum_component(void) {
|
|
typedef enum {
|
|
Red, Green, Blue
|
|
} Color;
|
|
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ecs_id(Color) = ecs_enum_init(world, &(ecs_enum_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Color"}),
|
|
.constants = {
|
|
{"Red"}, {"Blue"}, {"Green"}
|
|
}
|
|
});
|
|
|
|
test_assert(ecs_id(Color) != 0);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, Color, {1});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"Color\"]], "
|
|
"\"values\":[\"Blue\"]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_struct_and_enum_component(void) {
|
|
typedef enum {
|
|
Red, Green, Blue
|
|
} Color;
|
|
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Position"}),
|
|
.members = {
|
|
{"x", ecs_id(ecs_i32_t)},
|
|
{"y", ecs_id(ecs_i32_t)}
|
|
}
|
|
});
|
|
|
|
test_assert(ecs_id(Position) != 0);
|
|
|
|
ecs_entity_t ecs_id(Color) = ecs_enum_init(world, &(ecs_enum_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Color"}),
|
|
.constants = {
|
|
{"Red"}, {"Blue"}, {"Green"}
|
|
}
|
|
});
|
|
|
|
test_assert(ecs_id(Color) != 0);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, Color, {1});
|
|
ecs_set(world, e, Position, {10, 20});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"Position\"], [\"Color\"]], "
|
|
"\"values\":[{\"x\":10, \"y\":20}, \"Blue\"]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_invalid_enum_component(void) {
|
|
typedef enum {
|
|
Red, Green, Blue
|
|
} Color;
|
|
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ecs_id(Color) = ecs_enum_init(world, &(ecs_enum_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Color"}),
|
|
.constants = {
|
|
{"Red"}, {"Blue"}, {"Green"}
|
|
}
|
|
});
|
|
|
|
test_assert(ecs_id(Color) != 0);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, Color, {100});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
|
|
ecs_log_set_level(-4);
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json == NULL);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_type_info(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t ecs_id(Position) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "Position"}),
|
|
.members = {
|
|
{"x", ecs_id(ecs_i32_t)},
|
|
{"y", ecs_id(ecs_i32_t)}
|
|
}
|
|
});
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, Position, {10, 20});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
desc.serialize_type_info = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"Position\"]], "
|
|
"\"values\":[{\"x\":10, \"y\":20}], "
|
|
"\"type_info\":[{\"x\":[\"int\"], \"y\":[\"int\"]}]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_type_info_unit(void) {
|
|
typedef struct {
|
|
ecs_i32_t value;
|
|
} T;
|
|
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t u = ecs_unit_init(world, &(ecs_unit_desc_t){
|
|
.entity = ecs_entity(world, {.name = "celsius"}),
|
|
.symbol = "°"
|
|
});
|
|
test_assert(u != 0);
|
|
|
|
ecs_entity_t ecs_id(T) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "T"}),
|
|
.members = {
|
|
{"value", ecs_id(ecs_i32_t), .unit = u}
|
|
}
|
|
});
|
|
test_assert(ecs_id(T) != 0);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, T, {24});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
desc.serialize_type_info = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"T\"]], "
|
|
"\"values\":[{\"value\":24}], "
|
|
"\"type_info\":[{\"value\":[\"int\", {"
|
|
"\"unit\":\"celsius\", \"symbol\":\"°\"}]"
|
|
"}]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_type_info_unit_quantity(void) {
|
|
typedef struct {
|
|
ecs_i32_t value;
|
|
} T;
|
|
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t q = ecs_quantity_init(world, &(ecs_entity_desc_t){
|
|
.name = "temperature"
|
|
});
|
|
test_assert(q != 0);
|
|
|
|
ecs_entity_t u = ecs_unit_init(world, &(ecs_unit_desc_t){
|
|
.entity = ecs_entity(world, {.name = "celsius"}),
|
|
.symbol = "°",
|
|
.quantity = q
|
|
});
|
|
test_assert(u != 0);
|
|
|
|
ecs_entity_t ecs_id(T) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "T"}),
|
|
.members = {
|
|
{"value", ecs_id(ecs_i32_t), .unit = u}
|
|
}
|
|
});
|
|
test_assert(ecs_id(T) != 0);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, T, {24});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
desc.serialize_type_info = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"T\"]], "
|
|
"\"values\":[{\"value\":24}], "
|
|
"\"type_info\":[{\"value\":[\"int\", {"
|
|
"\"unit\":\"celsius\", \"symbol\":\"°\", \"quantity\":\"temperature\"}]"
|
|
"}]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_type_info_unit_over(void) {
|
|
typedef struct {
|
|
ecs_i32_t value;
|
|
} T;
|
|
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ecs_entity_t u_1 = ecs_unit_init(world, &(ecs_unit_desc_t){
|
|
.entity = ecs_entity(world, {.name = "seconds"}),
|
|
.symbol = "s"
|
|
});
|
|
test_assert(u_1 != 0);
|
|
|
|
ecs_entity_t u_2 = ecs_unit_init(world, &(ecs_unit_desc_t){
|
|
.entity = ecs_entity(world, {.name = "meters"}),
|
|
.symbol = "m"
|
|
});
|
|
test_assert(u_2 != 0);
|
|
|
|
ecs_entity_t u_3 = ecs_unit_init(world, &(ecs_unit_desc_t){
|
|
.entity = ecs_entity(world, {.name = "meters_per_second"}),
|
|
.symbol = "m/s",
|
|
.base = u_2,
|
|
.over = u_1
|
|
});
|
|
test_assert(u_3 != 0);
|
|
|
|
ecs_entity_t ecs_id(T) = ecs_struct_init(world, &(ecs_struct_desc_t){
|
|
.entity = ecs_entity(world, {.name = "T"}),
|
|
.members = {
|
|
{"value", ecs_id(ecs_i32_t), .unit = u_3}
|
|
}
|
|
});
|
|
test_assert(ecs_id(T) != 0);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_set(world, e, T, {24});
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_values = true;
|
|
desc.serialize_type_info = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"T\"]], "
|
|
"\"values\":[{\"value\":24}], "
|
|
"\"type_info\":[{\"value\":[\"int\", {"
|
|
"\"unit\":\"meters_per_second\", \"symbol\":\"m/s\"}]"
|
|
"}]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_wo_private(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_add_id(world, Tag, EcsPrivate);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
|
|
char *json = ecs_entity_to_json(world, e, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_private(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_add_id(world, Tag, EcsPrivate);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_private = true;
|
|
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[[\"Tag\"], [\"flecs.core.Identifier\", \"flecs.core.Name\"]]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_label(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
ecs_doc_set_name(world, e, "My name");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_label = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"label\":\"My name\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_label_no_name(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_id(world);
|
|
ecs_add(world, e, Tag);
|
|
|
|
char *str = ecs_os_malloc(
|
|
ecs_os_strlen(
|
|
"{"
|
|
"\"path\":\"000\", "
|
|
"\"label\":\"000\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}"
|
|
) + 1
|
|
);
|
|
|
|
ecs_os_sprintf(str,
|
|
"{"
|
|
"\"path\":\"%u\", "
|
|
"\"label\":\"%u\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}", (uint32_t)e, (uint32_t)e);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_label = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, str);
|
|
|
|
ecs_os_free(json);
|
|
ecs_os_free(str);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_id_labels(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
ecs_doc_set_name(world, Tag, "My tag");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_id_labels = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"], "
|
|
"\"id_labels\":["
|
|
"[\"My tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_brief(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
ecs_doc_set_brief(world, e, "Brief description");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_brief = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"brief\":\"Brief description\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_brief_no_brief(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_brief = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_link(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
ecs_doc_set_link(world, e, "Link");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_link = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"link\":\"Link\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_link_no_link(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_link = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_color(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
ecs_doc_set_color(world, e, "#47B576");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_color = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"color\":\"#47B576\", "
|
|
"\"ids\":["
|
|
"[\"Tag\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_union_relationship(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_ENTITY(world, Movement, Union);
|
|
ECS_TAG(world, Running);
|
|
ECS_TAG(world, Walking);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, Movement, Running);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":["
|
|
"[\"Movement\", \"Running\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_union_relationship_invalid_entity(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_ENTITY(world, Movement, Union);
|
|
ecs_entity_t Running = ecs_new_entity(world, "Running");
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, Movement, Running);
|
|
ecs_delete(world, Running);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_union_relationship_invalid_entity_w_labels(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_ENTITY(world, Movement, Union);
|
|
ecs_entity_t Running = ecs_new_entity(world, "Running");
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, Movement, Running);
|
|
ecs_delete(world, Running);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_id_labels = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":[], "
|
|
"\"id_labels\":[]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_union_property(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_ENTITY(world, Movement, Union);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
char *json = ecs_entity_to_json(world, Movement, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Movement\", "
|
|
"\"ids\":["
|
|
"[\"flecs.core.Union\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_union_relationship_w_labels(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_ENTITY(world, Movement, Union);
|
|
ECS_TAG(world, Running);
|
|
ECS_TAG(world, Walking);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add_pair(world, e, Movement, Running);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_id_labels = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Foo\", "
|
|
"\"ids\":["
|
|
"[\"Movement\", \"Running\"]"
|
|
"], "
|
|
"\"id_labels\":["
|
|
"[\"Movement\", \"Running\"]"
|
|
"]}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_doc_w_quotes(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t p = ecs_new_entity(world, "Parent");
|
|
ecs_entity_t e = ecs_new_entity(world, "Child");
|
|
ecs_add(world, e, Tag);
|
|
ecs_add_pair(world, e, EcsChildOf, p);
|
|
ecs_doc_set_name(world, e, "Doc \"name\"");
|
|
ecs_doc_set_brief(world, e, "Doc \"brief\"");
|
|
ecs_doc_set_link(world, e, "Doc \"link\"");
|
|
ecs_doc_set_color(world, e, "Doc \"color\"");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_label = true;
|
|
desc.serialize_brief = true;
|
|
desc.serialize_color = true;
|
|
desc.serialize_link = true;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"Parent.Child\", "
|
|
"\"label\":\"Doc \\\"name\\\"\", "
|
|
"\"brief\":\"Doc \\\"brief\\\"\", "
|
|
"\"link\":\"Doc \\\"link\\\"\", "
|
|
"\"color\":\"Doc \\\"color\\\"\", "
|
|
"\"ids\":[[\"Tag\"]]"
|
|
"}");
|
|
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_from_core(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
char *json = ecs_entity_to_json(world, EcsWorld, NULL);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{\"path\":\"flecs.core.World\", \"ids\":[]}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_1_alert(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, FlecsAlerts);
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t alert = ecs_alert(world, {
|
|
.entity = ecs_new_entity(world, "position_without_velocity"),
|
|
.filter.expr = "Position, !Velocity",
|
|
.message = "$this has Position but not Velocity"
|
|
});
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_set(world, e1, Position, {10, 20});
|
|
|
|
ecs_progress(world, 1.0); /* Evaluate alert logic */
|
|
|
|
/* Give alert instance name so we don't have to test unstable entity ids */
|
|
ecs_entity_t ai = ecs_get_alert(world, e1, alert);
|
|
test_assert(ai != 0);
|
|
ecs_set_name(world, ai, "e1_alert");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_alerts = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"Position\"]], "
|
|
"\"alerts\":[{"
|
|
"\"alert\":\"position_without_velocity.e1_alert\", "
|
|
"\"message\":\"e1 has Position but not Velocity\", "
|
|
"\"severity\":\"Error\""
|
|
"}]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_2_alerts(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, FlecsAlerts);
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_COMPONENT(world, Mass);
|
|
|
|
ecs_entity_t alert_1 = ecs_alert(world, {
|
|
.entity = ecs_new_entity(world, "position_without_velocity"),
|
|
.filter.expr = "Position, !Velocity",
|
|
.message = "$this has Position but not Velocity"
|
|
});
|
|
|
|
ecs_entity_t alert_2 = ecs_alert(world, {
|
|
.entity = ecs_new_entity(world, "position_without_mass"),
|
|
.filter.expr = "Position, !Mass",
|
|
.message = "$this has Position but not Mass"
|
|
});
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_set(world, e1, Position, {10, 20});
|
|
|
|
ecs_progress(world, 1.0); /* Evaluate alert logic */
|
|
|
|
/* Give alert instance name so we don't have to test unstable entity ids */
|
|
ecs_entity_t ai = ecs_get_alert(world, e1, alert_1);
|
|
test_assert(ai != 0);
|
|
ecs_set_name(world, ai, "e1_alert_1");
|
|
|
|
ai = ecs_get_alert(world, e1, alert_2);
|
|
test_assert(ai != 0);
|
|
ecs_set_name(world, ai, "e1_alert_2");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_alerts = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"Position\"]], "
|
|
"\"alerts\":[{"
|
|
"\"alert\":\"position_without_mass.e1_alert_2\", "
|
|
"\"message\":\"e1 has Position but not Mass\", "
|
|
"\"severity\":\"Error\""
|
|
"}, {"
|
|
"\"alert\":\"position_without_velocity.e1_alert_1\", "
|
|
"\"message\":\"e1 has Position but not Velocity\", "
|
|
"\"severity\":\"Error\""
|
|
"}]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_child_alerts(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, FlecsAlerts);
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
|
|
ecs_entity_t alert = ecs_alert(world, {
|
|
.entity = ecs_new_entity(world, "position_without_velocity"),
|
|
.filter.expr = "Position, !Velocity",
|
|
.message = "$this has Position but not Velocity"
|
|
});
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_set(world, e1, Position, {10, 20});
|
|
|
|
ecs_entity_t child_1 = ecs_new_entity(world, "child1");
|
|
ecs_set(world, child_1, Position, {10, 20});
|
|
ecs_add_pair(world, child_1, EcsChildOf, e1);
|
|
|
|
ecs_entity_t child_2 = ecs_new_entity(world, "child2");
|
|
ecs_set(world, child_2, Position, {10, 20});
|
|
ecs_add_pair(world, child_2, EcsChildOf, e1);
|
|
|
|
ecs_entity_t grandchild_1 = ecs_new_entity(world, "grandchild1");
|
|
ecs_set(world, grandchild_1, Position, {10, 20});
|
|
ecs_add_pair(world, grandchild_1, EcsChildOf, child_1);
|
|
|
|
ecs_progress(world, 1.0); /* Evaluate alert logic */
|
|
|
|
/* Give alert instances name so we don't have to test unstable entity ids */
|
|
ecs_entity_t e1_ai = ecs_get_alert(world, e1, alert);
|
|
test_assert(e1_ai != 0);
|
|
ecs_set_name(world, e1_ai, "e1_alert");
|
|
|
|
ecs_entity_t child1_ai = ecs_get_alert(world, child_1, alert);
|
|
test_assert(child1_ai != 0);
|
|
ecs_set_name(world, child1_ai, "child1_alert");
|
|
|
|
ecs_entity_t child2_ai = ecs_get_alert(world, child_2, alert);
|
|
test_assert(child2_ai != 0);
|
|
ecs_set_name(world, child2_ai, "child2_alert");
|
|
|
|
ecs_entity_t grandchild1_ai = ecs_get_alert(world, grandchild_1, alert);
|
|
test_assert(grandchild1_ai != 0);
|
|
ecs_set_name(world, grandchild1_ai, "grandchild1_alert");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_alerts = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"Position\"]], "
|
|
"\"alerts\":[{"
|
|
"\"alert\":\"position_without_velocity.e1_alert\", "
|
|
"\"message\":\"e1 has Position but not Velocity\", "
|
|
"\"severity\":\"Error\""
|
|
"}, {"
|
|
"\"alert\":\"position_without_velocity.child1_alert\", "
|
|
"\"message\":\"e1.child1 has Position but not Velocity\", "
|
|
"\"severity\":\"Error\", "
|
|
"\"path\":\"e1.child1\""
|
|
"}, {"
|
|
"\"alert\":\"position_without_velocity.grandchild1_alert\", "
|
|
"\"message\":\"e1.child1.grandchild1 has Position but not Velocity\", "
|
|
"\"severity\":\"Error\", "
|
|
"\"path\":\"e1.child1.grandchild1\""
|
|
"}, {"
|
|
"\"alert\":\"position_without_velocity.child2_alert\", "
|
|
"\"message\":\"e1.child2 has Position but not Velocity\", "
|
|
"\"severity\":\"Error\", "
|
|
"\"path\":\"e1.child2\""
|
|
"}]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_severity_filter_alert(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, FlecsAlerts);
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t alert = ecs_alert(world, {
|
|
.entity = ecs_new_entity(world, "position_without_velocity"),
|
|
.filter.expr = "Position, !Velocity",
|
|
.message = "$this has Position but not Velocity",
|
|
.severity_filters[0] = {
|
|
.severity = EcsAlertWarning,
|
|
.with = Tag
|
|
}
|
|
});
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_set(world, e1, Position, {10, 20});
|
|
ecs_add(world, e1, Tag);
|
|
|
|
ecs_progress(world, 1.0); /* Evaluate alert logic */
|
|
|
|
/* Give alert instance name so we don't have to test unstable entity ids */
|
|
ecs_entity_t ai = ecs_get_alert(world, e1, alert);
|
|
test_assert(ai != 0);
|
|
ecs_set_name(world, ai, "e1_alert");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_alerts = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"Position\"], [\"Tag\"]], "
|
|
"\"alerts\":[{"
|
|
"\"alert\":\"position_without_velocity.e1_alert\", "
|
|
"\"message\":\"e1 has Position but not Velocity\", "
|
|
"\"severity\":\"Warning\""
|
|
"}]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_alerts_not_imported(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_set(world, e1, Position, {10, 20});
|
|
ecs_new_w_pair(world, EcsChildOf, e1);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_alerts = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"Position\"]]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_w_alerts_no_message(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_IMPORT(world, FlecsAlerts);
|
|
|
|
ECS_COMPONENT(world, Position);
|
|
ECS_COMPONENT(world, Velocity);
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t alert = ecs_alert(world, {
|
|
.entity = ecs_new_entity(world, "position_without_velocity"),
|
|
.filter.expr = "Position, !Velocity"
|
|
});
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_set(world, e1, Position, {10, 20});
|
|
ecs_add(world, e1, Tag);
|
|
|
|
ecs_progress(world, 1.0); /* Evaluate alert logic */
|
|
|
|
/* Give alert instance name so we don't have to test unstable entity ids */
|
|
ecs_entity_t ai = ecs_get_alert(world, e1, alert);
|
|
test_assert(ai != 0);
|
|
ecs_set_name(world, ai, "e1_alert");
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_alerts = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"Position\"], [\"Tag\"]], "
|
|
"\"alerts\":[{"
|
|
"\"alert\":\"position_without_velocity.e1_alert\", "
|
|
"\"severity\":\"Error\""
|
|
"}]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_refs_childof(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
|
|
ecs_entity_t child_1 = ecs_new_entity(world, "child1");
|
|
ecs_add_pair(world, child_1, EcsChildOf, e1);
|
|
|
|
ecs_entity_t child_2 = ecs_new_entity(world, "child2");
|
|
ecs_add_pair(world, child_2, EcsChildOf, e1);
|
|
|
|
ecs_entity_t child_3 = ecs_new_entity(world, "child3");
|
|
ecs_add_pair(world, child_3, Rel, e1);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_refs = EcsChildOf;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[], "
|
|
"\"refs\":{"
|
|
"\"ChildOf\":["
|
|
"\"e1.child1\", "
|
|
"\"e1.child2\""
|
|
"]"
|
|
"}"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_refs_custom(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
|
|
ecs_entity_t child_1 = ecs_new_entity(world, "child1");
|
|
ecs_add_pair(world, child_1, Rel, e1);
|
|
|
|
ecs_entity_t child_2 = ecs_new_entity(world, "child2");
|
|
ecs_add_pair(world, child_2, Rel, e1);
|
|
|
|
ecs_entity_t child_3 = ecs_new_entity(world, "child3");
|
|
ecs_add_pair(world, child_3, EcsChildOf, e1);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_refs = Rel;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[], "
|
|
"\"refs\":{"
|
|
"\"Rel\":["
|
|
"\"child1\", "
|
|
"\"child2\""
|
|
"]"
|
|
"}"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_refs_wildcard(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Rel);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
|
|
ecs_entity_t child_1 = ecs_new_entity(world, "child1");
|
|
ecs_add_pair(world, child_1, Rel, e1);
|
|
|
|
ecs_entity_t child_2 = ecs_new_entity(world, "child2");
|
|
ecs_add_pair(world, child_2, Rel, e1);
|
|
|
|
ecs_entity_t child_3 = ecs_new_entity(world, "child3");
|
|
ecs_add_pair(world, child_3, EcsChildOf, e1);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_refs = EcsWildcard;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[], "
|
|
"\"refs\":{"
|
|
"\"ChildOf\":["
|
|
"\"e1.child3\""
|
|
"], "
|
|
"\"Rel\":["
|
|
"\"child1\", "
|
|
"\"child2\""
|
|
"]"
|
|
"}"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_no_ids(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, Tag);
|
|
|
|
ecs_entity_t e = ecs_new_entity(world, "Foo");
|
|
ecs_add(world, e, Tag);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_ids = false;
|
|
char *json = ecs_entity_to_json(world, e, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{\"path\":\"Foo\"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_matches_filter(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
ECS_TAG(world, TagC);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_add(world, e1, TagA);
|
|
ecs_entity_t e2 = ecs_new_entity(world, "e2");
|
|
ecs_add(world, e2, TagB);
|
|
|
|
ecs_filter_t *f_a = ecs_filter(world, {
|
|
.entity = ecs_entity(world, { .name = "f_a"} ),
|
|
.terms = {{ TagA }}
|
|
});
|
|
test_assert(f_a != NULL);
|
|
|
|
ecs_filter_t *f_b = ecs_filter(world, {
|
|
.entity = ecs_entity(world, { .name = "f_b"} ),
|
|
.terms = {{ TagB }}
|
|
});
|
|
test_assert(f_b != NULL);
|
|
|
|
ecs_filter_t *f_c = ecs_filter(world, {
|
|
.entity = ecs_entity(world, { .name = "f_c"} ),
|
|
.terms = {{ TagC }}
|
|
});
|
|
test_assert(f_c != NULL);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_matches = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"TagA\"]], "
|
|
"\"matches\":["
|
|
"\"f_a\""
|
|
"]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_filter_fini(f_a);
|
|
ecs_filter_fini(f_b);
|
|
ecs_filter_fini(f_c);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_matches_query(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
ECS_TAG(world, TagC);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_add(world, e1, TagA);
|
|
ecs_entity_t e2 = ecs_new_entity(world, "e2");
|
|
ecs_add(world, e2, TagB);
|
|
|
|
ecs_query_t *f_a = ecs_query(world, {
|
|
.filter.entity = ecs_entity(world, { .name = "f_a"} ),
|
|
.filter.terms = {{ TagA }}
|
|
});
|
|
test_assert(f_a != NULL);
|
|
|
|
ecs_query_t *f_b = ecs_query(world, {
|
|
.filter.entity = ecs_entity(world, { .name = "f_b"} ),
|
|
.filter.terms = {{ TagB }}
|
|
});
|
|
test_assert(f_b != NULL);
|
|
|
|
ecs_query_t *f_c = ecs_query(world, {
|
|
.filter.entity = ecs_entity(world, { .name = "f_c"} ),
|
|
.filter.terms = {{ TagC }}
|
|
});
|
|
test_assert(f_c != NULL);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_matches = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"TagA\"]], "
|
|
"\"matches\":["
|
|
"\"f_a\""
|
|
"]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_query_fini(f_a);
|
|
ecs_query_fini(f_b);
|
|
ecs_query_fini(f_c);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_matches_rule(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
ECS_TAG(world, TagC);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_add(world, e1, TagA);
|
|
ecs_entity_t e2 = ecs_new_entity(world, "e2");
|
|
ecs_add(world, e2, TagB);
|
|
|
|
ecs_rule_t *f_a = ecs_rule(world, {
|
|
.entity = ecs_entity(world, { .name = "f_a"} ),
|
|
.terms = {{ TagA }}
|
|
});
|
|
test_assert(f_a != NULL);
|
|
|
|
ecs_rule_t *f_b = ecs_rule(world, {
|
|
.entity = ecs_entity(world, { .name = "f_b"} ),
|
|
.terms = {{ TagB }}
|
|
});
|
|
test_assert(f_b != NULL);
|
|
|
|
ecs_rule_t *f_c = ecs_rule(world, {
|
|
.entity = ecs_entity(world, { .name = "f_c"} ),
|
|
.terms = {{ TagC }}
|
|
});
|
|
test_assert(f_c != NULL);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_matches = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"TagA\"]], "
|
|
"\"matches\":["
|
|
"\"f_a\""
|
|
"]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_rule_fini(f_a);
|
|
ecs_rule_fini(f_b);
|
|
ecs_rule_fini(f_c);
|
|
|
|
ecs_fini(world);
|
|
}
|
|
|
|
void SerializeEntityToJson_serialize_no_matches(void) {
|
|
ecs_world_t *world = ecs_init();
|
|
|
|
ECS_TAG(world, TagA);
|
|
ECS_TAG(world, TagB);
|
|
ECS_TAG(world, TagC);
|
|
|
|
ecs_entity_t e1 = ecs_new_entity(world, "e1");
|
|
ecs_add(world, e1, TagA);
|
|
ecs_entity_t e2 = ecs_new_entity(world, "e2");
|
|
ecs_add(world, e2, TagB);
|
|
|
|
ecs_filter_t *f_b = ecs_filter(world, {
|
|
.entity = ecs_entity(world, { .name = "f_b"} ),
|
|
.terms = {{ TagB }}
|
|
});
|
|
test_assert(f_b != NULL);
|
|
|
|
ecs_filter_t *f_c = ecs_filter(world, {
|
|
.entity = ecs_entity(world, { .name = "f_c"} ),
|
|
.terms = {{ TagC }}
|
|
});
|
|
test_assert(f_c != NULL);
|
|
|
|
ecs_entity_to_json_desc_t desc = ECS_ENTITY_TO_JSON_INIT;
|
|
desc.serialize_matches = true;
|
|
char *json = ecs_entity_to_json(world, e1, &desc);
|
|
test_assert(json != NULL);
|
|
test_str(json, "{"
|
|
"\"path\":\"e1\", "
|
|
"\"ids\":[[\"TagA\"]], "
|
|
"\"matches\":["
|
|
"]"
|
|
"}");
|
|
ecs_os_free(json);
|
|
|
|
ecs_filter_fini(f_b);
|
|
ecs_filter_fini(f_c);
|
|
|
|
ecs_fini(world);
|
|
}
|