flecs_ecs 0.2.1

Rust API for the C/CPP flecs ECS library <https://github.com/SanderMertens/flecs>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

#![allow(dead_code)]
use crate::common_test::*;

/// test for compilation errors, no forgotten implementation
#[test]
fn entity_eq_test() {
    let world = World::new();

    let a_u64: u64 = 1;

    let e1_entity_view = world.entity();
    let e1_id_view = e1_entity_view.id_view();
    let e1_entity = e1_entity_view.id();
    let e1_id: Id = e1_entity.into();

    let comp1 = world.component::<Position>();
    let comp_untyped1 = world.component_untyped_from(Position::id());

    assert_eq!(e1_id, e1_id);
    assert_eq!(e1_id, e1_entity);
    assert_eq!(e1_id, e1_id_view);
    assert_eq!(e1_id, e1_entity_view);

    assert_eq!(e1_entity, e1_id);
    assert_eq!(e1_entity, e1_entity);
    assert_eq!(e1_entity, e1_id_view);
    assert_eq!(e1_entity, e1_entity_view);

    assert_eq!(e1_id_view, e1_id);
    assert_eq!(e1_id_view, e1_entity);
    assert_eq!(e1_id_view, e1_id_view);
    assert_eq!(e1_id_view, e1_entity_view);

    assert_eq!(e1_entity_view, e1_id);
    assert_eq!(e1_entity_view, e1_entity);
    assert_eq!(e1_entity_view, e1_id_view);
    assert_eq!(e1_entity_view, e1_entity_view);

    let test_equality1 = e1_id == comp1;
    let test_equality2 = e1_entity == comp1;
    let test_equality3 = e1_id_view == comp1;
    let test_equality4 = e1_entity_view == comp1;

    assert!(!test_equality1);
    assert!(!test_equality2);
    assert!(!test_equality3);
    assert!(!test_equality4);

    let test_equality5 = comp1 == e1_id;
    let test_equality6 = comp1 == e1_entity;
    let test_equality7 = comp1 == e1_id_view;
    let test_equality8 = comp1 == e1_entity_view;

    assert!(!test_equality5);
    assert!(!test_equality6);
    assert!(!test_equality7);
    assert!(!test_equality8);

    let test_equality9 = e1_id == comp_untyped1;
    let test_equality10 = e1_entity == comp_untyped1;
    let test_equality11 = e1_id_view == comp_untyped1;
    let test_equality12 = e1_entity_view == comp_untyped1;

    assert!(!test_equality9);
    assert!(!test_equality10);
    assert!(!test_equality11);
    assert!(!test_equality12);

    let test_equality13 = comp_untyped1 == e1_id;
    let test_equality14 = comp_untyped1 == e1_entity;
    let test_equality15 = comp_untyped1 == e1_id_view;
    let test_equality16 = comp_untyped1 == e1_entity_view;

    assert!(!test_equality13);
    assert!(!test_equality14);
    assert!(!test_equality15);
    assert!(!test_equality16);

    let test_equality18 = comp1 == comp1;
    let test_equality17 = comp1 == comp_untyped1;
    let test_equality19 = comp_untyped1 == comp1;
    let test_equality20 = comp_untyped1 == comp_untyped1;

    assert!(test_equality17);
    assert!(test_equality18);
    assert!(test_equality19);
    assert!(test_equality20);

    let test_equality21 = e1_id == a_u64;
    let test_equality22 = e1_entity == a_u64;
    let test_equality23 = e1_id_view == a_u64;
    let test_equality24 = e1_entity_view == a_u64;
    let test_equality25 = comp1 == a_u64;
    let test_equality26 = comp_untyped1 == a_u64;

    assert!(!test_equality21);
    assert!(!test_equality22);
    assert!(!test_equality23);
    assert!(!test_equality24);
    assert!(!test_equality25);
    assert!(!test_equality26);

    let test_equality27 = a_u64 == e1_id;
    let test_equality28 = a_u64 == e1_entity;
    let test_equality29 = a_u64 == e1_id_view;
    let test_equality30 = a_u64 == e1_entity_view;
    let test_equality31 = a_u64 == comp1;
    let test_equality32 = a_u64 == comp_untyped1;

    assert!(!test_equality27);
    assert!(!test_equality28);
    assert!(!test_equality29);
    assert!(!test_equality30);
    assert!(!test_equality31);
    assert!(!test_equality32);
}

#[test]
fn table_eq_test() {
    let world = World::new();

    let ent1 = world.entity().add(Position::id());
    let ent2 = world.entity().add(Position::id());
    let ent3 = world.entity().add(Position::id()).add(Velocity::id());

    let table1 = ent1.table().unwrap();
    let table2 = ent2.table().unwrap();
    let table3 = ent3.table().unwrap();

    assert_eq!(table1, table2);
    assert_ne!(table1, table3);

    ent1.add(Velocity::id());
    let table1 = ent1.table().unwrap();

    assert_ne!(table1, table2);
    assert_eq!(table1, table3);
}