tests(flecs): add equality test cases between C and Rust component id…

…'s for builtin types

flecs_ecs/src/core/c_types.rs

@@ -304,11 +304,14 @@ pub(crate) const TRANSITIVE: u64 = 1 << 2;
 pub(crate) const REFLEXIVE: u64 = 1 << 3;
 pub(crate) const ID_INHERITED: u64 = 1 << 4;
 pub(crate) const IS_TRIVIAL: u64 = 1 << 5;
-pub(crate) const NO_DATA: u64 = 1 << 6;
 pub(crate) const IS_CACHEABLE: u64 = 1 << 7;
 pub(crate) const IS_SCOPE: u64 = 1 << 8;
 pub(crate) const IS_MEMBER: u64 = 1 << 9;
 pub(crate) const IS_TOGGLE: u64 = 1 << 10;
+pub(crate) const KEEP_ALIVE: u64 = 1 << 11;
+pub(crate) const IS_SPARSE: u64 = 1 << 12;
+pub(crate) const IS_UNION: u64 = 1 << 13;
+pub(crate) const IS_OR: u64 = 1 << 14;
 
 // Query flags
 // Query flags discovered & set during query creation.

flecs_ecs/src/core/flecs.rs

@@ -150,11 +150,14 @@ pub mod term_flags {
     create_pre_registered_component!(Reflexive, REFLEXIVE);
     create_pre_registered_component!(IdInherited, ID_INHERITED);
     create_pre_registered_component!(IsTrivial, IS_TRIVIAL);
-    create_pre_registered_component!(NoData, NO_DATA);
     create_pre_registered_component!(IsCacheable, IS_CACHEABLE);
     create_pre_registered_component!(IsScope, IS_SCOPE);
     create_pre_registered_component!(IsMember, IS_MEMBER);
     create_pre_registered_component!(IsToggle, IS_TOGGLE);
+    create_pre_registered_component!(KeepAlive, KEEP_ALIVE);
+    create_pre_registered_component!(IsSparse, IS_SPARSE);
+    create_pre_registered_component!(IsUnion, IS_UNION);
+    create_pre_registered_component!(IsOr, IS_OR);
 }
 
 /// Query flags discovered & set during query creation.
@@ -433,8 +436,8 @@ create_pre_registered_component!(PredLookup, ECS_PRED_LOOKUP);
 create_pre_registered_component!(ScopeOpen, ECS_SCOPE_OPEN);
 create_pre_registered_component!(ScopeClose, ECS_SCOPE_CLOSE);
 
-// Systems
-#[cfg(feature = "flecs_system")]
+// Pipeline
+#[cfg(feature = "flecs_pipeline")]
 pub mod pipeline {
     use super::*;
     create_pre_registered_component!(Pipeline, ECS_PIPELINE);
@@ -506,6 +509,7 @@ pub mod meta {
 }
 
 // Doc module components
+#[cfg(feature = "flecs_doc")]
 pub mod doc {
     use super::*;
     create_pre_registered_component!(Description, ECS_DOC_DESCRIPTION);
@@ -596,3 +600,338 @@ impl flecs_ecs::core::component_registration::registration_traits::ComponentId f
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_c_vs_rust_ids() {
+        let world = flecs_ecs::core::World::new();
+
+        unsafe {
+            assert_eq!(Self_, sys::EcsSelf as u64, "EcsSelf (C) != Self_ (Rust)");
+            assert_eq!(Up, sys::EcsUp, "EcsUp (C) != Up (Rust)");
+            assert_eq!(Trav, sys::EcsTrav, "EcsTrav (C) != Trav (Rust)");
+            assert_eq!(Cascade, sys::EcsCascade, "EcsCascade (C) != Cascade (Rust)");
+            assert_eq!(Desc, sys::EcsDesc, "EcsDesc (C) != Desc (Rust)");
+            assert_eq!(
+                IsVariable,
+                sys::EcsIsVariable,
+                "EcsIsVariable (C) != IsVariable (Rust)"
+            );
+            assert_eq!(
+                IsEntity,
+                sys::EcsIsEntity,
+                "EcsIsEntity (C) != IsEntity (Rust)"
+            );
+            assert_eq!(IsName, sys::EcsIsName, "EcsIsName (C) != IsName (Rust)");
+            assert_eq!(
+                TraverseFlags,
+                sys::EcsTraverseFlags as u64,
+                "EcsTraverseFlags (C) != TraverseFlags (Rust)"
+            );
+            assert_eq!(
+                TermRefFlags,
+                sys::EcsTermRefFlags as u64,
+                "EcsTermRefFlags (C) != TermRefFlags (Rust)"
+            );
+
+            // Term flags
+            assert_eq!(
+                term_flags::MatchAny,
+                sys::EcsTermMatchAny as u64,
+                "EcsTermMatchAny (C) != MatchAny (Rust)"
+            );
+            assert_eq!(
+                term_flags::MatchAnySrc,
+                sys::EcsTermMatchAnySrc as u64,
+                "EcsTermMatchAnySrc (C) != MatchAnySrc (Rust)"
+            );
+            assert_eq!(
+                term_flags::Transitive,
+                sys::EcsTermTransitive as u64,
+                "EcsTermTransitive (C) != Transitive (Rust)"
+            );
+            assert_eq!(
+                term_flags::Reflexive,
+                sys::EcsTermReflexive as u64,
+                "EcsTermReflexive (C) != Reflexive (Rust)"
+            );
+            assert_eq!(
+                term_flags::IdInherited,
+                sys::EcsTermIdInherited as u64,
+                "EcsTermIdInherited (C) != IdInherited (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsTrivial,
+                sys::EcsTermIsTrivial as u64,
+                "EcsTermIsTrivial (C) != IsTrivial (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsCacheable,
+                sys::EcsTermIsCacheable as u64,
+                "EcsTermIsCacheable (C) != IsCacheable (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsScope,
+                sys::EcsTermIsScope as u64,
+                "EcsTermIsScope (C) != IsScope (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsMember,
+                sys::EcsTermIsMember as u64,
+                "EcsTermIsMember (C) != IsMember (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsToggle,
+                sys::EcsTermIsToggle as u64,
+                "EcsTermIsToggle (C) != IsToggle (Rust)"
+            );
+            assert_eq!(
+                term_flags::KeepAlive,
+                sys::EcsTermKeepAlive as u64,
+                "EcsTermKeepAlive (C) != KeepAlive (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsSparse,
+                sys::EcsTermIsSparse as u64,
+                "EcsTermIsSparse (C) != IsSparse (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsUnion,
+                sys::EcsTermIsUnion as u64,
+                "EcsTermIsUnion (C) != IsUnion (Rust)"
+            );
+            assert_eq!(
+                term_flags::IsOr,
+                sys::EcsTermIsOr as u64,
+                "EcsTermIsOr (C) != IsOr (Rust)"
+            );
+
+            // Query flags
+            assert_eq!(
+                query_flags::MatchPrefab,
+                sys::EcsQueryMatchPrefab as u64,
+                "EcsQueryMatchPrefab (C) != MatchPrefab (Rust)"
+            );
+            assert_eq!(
+                query_flags::MatchDisabled,
+                sys::EcsQueryMatchDisabled as u64,
+                "EcsQueryMatchDisabled (C) != MatchDisabled (Rust)"
+            );
+            assert_eq!(
+                query_flags::MatchEmptyTables,
+                sys::EcsQueryMatchEmptyTables as u64,
+                "EcsQueryMatchEmptyTables (C) != MatchEmptyTables (Rust)"
+            );
+            assert_eq!(
+                query_flags::AllowUnresolvedByName,
+                sys::EcsQueryAllowUnresolvedByName as u64,
+                "EcsQueryAllowUnresolvedByName (C) != AllowUnresolvedByName (Rust)"
+            );
+            assert_eq!(
+                query_flags::TableOnly,
+                sys::EcsQueryTableOnly as u64,
+                "EcsQueryTableOnly (C) != TableOnly (Rust)"
+            );
+
+            assert_eq!(flecs::Component::ID, sys::FLECS_IDEcsComponentID_);
+            assert_eq!(flecs::Identifier::ID, sys::FLECS_IDEcsIdentifierID_);
+            assert_eq!(flecs::Poly::ID, sys::FLECS_IDEcsPolyID_);
+            assert_eq!(
+                flecs::DefaultChildComponent::ID,
+                sys::FLECS_IDEcsDefaultChildComponentID_
+            );
+
+            // Poly target components
+            assert_eq!(flecs::Query, sys::EcsQuery);
+            assert_eq!(flecs::Observer, sys::EcsObserver);
+
+            // Core scopes & entities
+            assert_eq!(flecs::EcsWorld, sys::EcsWorld);
+            assert_eq!(flecs::Flecs, sys::EcsFlecs);
+            assert_eq!(flecs::FlecsCore, sys::EcsFlecsCore);
+            //assert_eq!(flecs::FlecsInternals, sys::EcsFlecsInternals);
+            assert_eq!(flecs::Module, sys::EcsModule);
+            assert_eq!(flecs::Private, sys::EcsPrivate);
+            assert_eq!(flecs::Prefab, sys::EcsPrefab);
+            assert_eq!(flecs::Disabled, sys::EcsDisabled);
+            assert_eq!(flecs::NotQueryable, sys::EcsNotQueryable);
+            assert_eq!(flecs::SlotOf, sys::EcsSlotOf);
+            //assert_eq!(flecs::Flag, sys::EcsFlag);
+            assert_eq!(flecs::Monitor, sys::EcsMonitor);
+            assert_eq!(flecs::Empty, sys::EcsEmpty);
+
+            // Component traits
+            assert_eq!(flecs::Wildcard, sys::EcsWildcard);
+            assert_eq!(flecs::Any, sys::EcsAny);
+            assert_eq!(flecs::This_, sys::EcsThis);
+            assert_eq!(flecs::Variable, sys::EcsVariable);
+            assert_eq!(flecs::Singleton, sys::EcsVariable);
+            assert_eq!(flecs::Transitive, sys::EcsTransitive);
+            assert_eq!(flecs::Reflexive, sys::EcsReflexive);
+            assert_eq!(flecs::Symmetric, sys::EcsSymmetric);
+            assert_eq!(flecs::Final, sys::EcsFinal);
+            assert_eq!(flecs::PairIsTag, sys::EcsPairIsTag);
+            assert_eq!(flecs::Exclusive, sys::EcsExclusive);
+            assert_eq!(flecs::Acyclic, sys::EcsAcyclic);
+            assert_eq!(flecs::Traversable, sys::EcsTraversable);
+            assert_eq!(flecs::With, sys::EcsWith);
+            assert_eq!(flecs::OneOf, sys::EcsOneOf);
+            assert_eq!(flecs::CanToggle, sys::EcsCanToggle);
+            assert_eq!(flecs::Trait, sys::EcsTrait);
+            assert_eq!(flecs::Relationship, sys::EcsRelationship);
+            assert_eq!(flecs::Target, sys::EcsTarget);
+
+            // OnInstantiate traits
+            assert_eq!(flecs::OnInstantiate, sys::EcsOnInstantiate);
+            assert_eq!(flecs::Override, sys::EcsOverride);
+            assert_eq!(flecs::Inherit, sys::EcsInherit);
+            assert_eq!(flecs::DontInherit, sys::EcsDontInherit);
+
+            // OnDelete/OnDeleteTarget traits
+            assert_eq!(flecs::OnDelete, sys::EcsOnDelete);
+            assert_eq!(flecs::OnDeleteTarget, sys::EcsOnDeleteTarget);
+            assert_eq!(flecs::Remove, sys::EcsRemove);
+            assert_eq!(flecs::Delete, sys::EcsDelete);
+            assert_eq!(flecs::Panic, sys::EcsPanic);
+
+            // Builtin relationships
+            assert_eq!(flecs::ChildOf, sys::EcsChildOf);
+            assert_eq!(flecs::IsA, sys::EcsIsA);
+            assert_eq!(flecs::DependsOn, sys::EcsDependsOn);
+
+            // Identifier tags
+            assert_eq!(flecs::Name, sys::EcsName);
+            assert_eq!(flecs::Symbol, sys::EcsSymbol);
+            assert_eq!(flecs::Alias, sys::EcsAlias);
+
+            // Events
+            assert_eq!(flecs::OnAdd, sys::EcsOnAdd);
+            assert_eq!(flecs::OnRemove, sys::EcsOnRemove);
+            assert_eq!(flecs::OnSet, sys::EcsOnSet);
+            assert_eq!(flecs::OnTableCreate, sys::EcsOnTableCreate);
+            assert_eq!(flecs::OnTableDelete, sys::EcsOnTableDelete);
+            assert_eq!(flecs::OnTableEmpty, sys::EcsOnTableEmpty);
+            assert_eq!(flecs::OnTableFill, sys::EcsOnTableFill);
+
+            // System
+            #[cfg(feature = "flecs_system")]
+            {
+                assert_eq!(flecs::system::TickSource::ID, sys::FLECS_IDEcsTickSourceID_);
+                assert_eq!(flecs::system::System, sys::EcsSystem);
+            }
+
+            // Timer
+            #[cfg(feature = "flecs_timer")]
+            {
+                assert_eq!(flecs::timer::Timer::ID, sys::FLECS_IDEcsTimerID_);
+                assert_eq!(flecs::timer::RateFilter::ID, sys::FLECS_IDEcsRateFilterID_);
+            }
+
+            // Script
+            #[allow(static_mut_refs)]
+            #[cfg(feature = "flecs_script")]
+            {
+                assert_eq!(
+                    flecs::script::Script::__register_or_get_id::<false>(&world),
+                    sys::FLECS_IDEcsScriptID_
+                );
+            }
+
+            assert_eq!(
+                flecs::Sparse,
+                sys::EcsSparse,
+                "EcsSparse (C) != Sparse (Rust)",
+            );
+            assert_eq!(flecs::Union, sys::EcsUnion, "EcsUnion (C) != Union (Rust)");
+
+            // Builtin predicate for comparing entity ids
+            assert_eq!(flecs::PredEq, sys::EcsPredEq);
+            assert_eq!(flecs::PredMatch, sys::EcsPredMatch);
+            assert_eq!(flecs::PredLookup, sys::EcsPredLookup);
+
+            // builtin marker entities for query scopes
+            assert_eq!(flecs::ScopeOpen, sys::EcsScopeOpen);
+            assert_eq!(flecs::ScopeClose, sys::EcsScopeClose);
+
+            // Pipeline
+            #[cfg(feature = "flecs_pipeline")]
+            {
+                assert_eq!(flecs::pipeline::Pipeline, sys::FLECS_IDEcsPipelineID_);
+                assert_eq!(flecs::pipeline::OnStart, sys::EcsOnStart);
+                assert_eq!(flecs::pipeline::OnLoad, sys::EcsOnLoad);
+                assert_eq!(flecs::pipeline::PostLoad, sys::EcsPostLoad);
+                assert_eq!(flecs::pipeline::PreUpdate, sys::EcsPreUpdate);
+                assert_eq!(flecs::pipeline::OnUpdate, sys::EcsOnUpdate);
+                assert_eq!(flecs::pipeline::OnValidate, sys::EcsOnValidate);
+                assert_eq!(flecs::pipeline::PostUpdate, sys::EcsPostUpdate);
+                assert_eq!(flecs::pipeline::PreStore, sys::EcsPreStore);
+                assert_eq!(flecs::pipeline::OnStore, sys::EcsOnStore);
+                assert_eq!(flecs::pipeline::Phase, sys::EcsPhase);
+            }
+
+            // Meta
+            #[cfg(feature = "flecs_meta")]
+            {
+                assert_eq!(flecs::meta::Bool, sys::FLECS_IDecs_bool_tID_);
+                assert_eq!(flecs::meta::Char, sys::FLECS_IDecs_char_tID_);
+                assert_eq!(flecs::meta::Byte, sys::FLECS_IDecs_byte_tID_);
+                assert_eq!(flecs::meta::U8, sys::FLECS_IDecs_u8_tID_);
+                assert_eq!(flecs::meta::U16, sys::FLECS_IDecs_u16_tID_);
+                assert_eq!(flecs::meta::U32, sys::FLECS_IDecs_u32_tID_);
+                assert_eq!(flecs::meta::U64, sys::FLECS_IDecs_u64_tID_);
+                assert_eq!(flecs::meta::UPtr, sys::FLECS_IDecs_uptr_tID_);
+                assert_eq!(flecs::meta::I8, sys::FLECS_IDecs_i8_tID_);
+                assert_eq!(flecs::meta::I16, sys::FLECS_IDecs_i16_tID_);
+                assert_eq!(flecs::meta::I32, sys::FLECS_IDecs_i32_tID_);
+                assert_eq!(flecs::meta::I64, sys::FLECS_IDecs_i64_tID_);
+                assert_eq!(flecs::meta::IPtr, sys::FLECS_IDecs_iptr_tID_);
+                assert_eq!(flecs::meta::F32, sys::FLECS_IDecs_f32_tID_);
+                assert_eq!(flecs::meta::F64, sys::FLECS_IDecs_f64_tID_);
+                assert_eq!(flecs::meta::String, sys::FLECS_IDecs_string_tID_);
+                assert_eq!(flecs::meta::Entity, sys::FLECS_IDecs_entity_tID_);
+                assert_eq!(flecs::meta::Constant, sys::EcsConstant);
+                assert_eq!(flecs::meta::Quantity, sys::EcsQuantity);
+                assert_eq!(flecs::meta::EcsOpaque, sys::FLECS_IDEcsOpaqueID_);
+
+                assert_eq!(flecs::meta::Type::ID, sys::FLECS_IDEcsTypeID_);
+                assert_eq!(
+                    flecs::meta::TypeSerializer::ID,
+                    sys::FLECS_IDEcsTypeSerializerID_
+                );
+                assert_eq!(flecs::meta::Primitive::ID, sys::FLECS_IDEcsPrimitiveID_);
+                assert_eq!(flecs::meta::EcsEnum::ID, sys::FLECS_IDEcsEnumID_);
+                assert_eq!(flecs::meta::Bitmask::ID, sys::FLECS_IDEcsBitmaskID_);
+                assert_eq!(flecs::meta::Member::ID, sys::FLECS_IDEcsMemberID_);
+                assert_eq!(
+                    flecs::meta::MemberRanges::ID,
+                    sys::FLECS_IDEcsMemberRangesID_
+                );
+                assert_eq!(flecs::meta::EcsStruct::ID, sys::FLECS_IDEcsStructID_);
+                assert_eq!(flecs::meta::Array::ID, sys::FLECS_IDEcsArrayID_);
+                assert_eq!(flecs::meta::Vector::ID, sys::FLECS_IDEcsVectorID_);
+                assert_eq!(flecs::meta::Unit::ID, sys::FLECS_IDEcsUnitID_);
+                assert_eq!(flecs::meta::UnitPrefix::ID, sys::FLECS_IDEcsUnitPrefixID_);
+            }
+
+            // Doc
+            #[cfg(feature = "flecs_doc")]
+            {
+                assert_eq!(flecs::doc::Description, sys::FLECS_IDEcsDocDescriptionID_);
+                assert_eq!(flecs::doc::Brief, sys::EcsDocBrief);
+                assert_eq!(flecs::doc::Detail, sys::EcsDocDetail);
+                assert_eq!(flecs::doc::Link, sys::EcsDocLink);
+                assert_eq!(flecs::doc::Color, sys::EcsDocColor);
+                assert_eq!(flecs::doc::UUID, sys::EcsDocUuid);
+            }
+
+            // Rest
+            #[cfg(feature = "flecs_rest")]
+            {
+                assert_eq!(flecs::rest::Rest::ID, sys::FLECS_IDEcsRestID_);
+            }
+        }
+    }
+}