Test-suite reference
Section titled “Test-suite reference”Choose the behavior under test, then inspect the relevant suite’s environment and source assertions. Validate an engine change explains the shared planning and execution workflow. The validation planner uses actual project relationships; this navigation is not an executable selection table.
When writing a new case, start with reusable test support and fixtures for content, process, source-input and native Editor ownership.
Foundation contracts
Section titled “Foundation contracts”- Collection indexes and dependency tests: Verify mutable indexes and deterministic dependency snapshots.
- Coroutine scheduling tests: Verify tick-based waits, predicates and explicit cancellation.
- Diagnostic ownership tests: Verify replacement, clearing, severity and independent report owners.
- Event routing and observation tests: Verify consumption scopes, delivery order and observation boundaries.
- Execution and retirement tests: Verify owner-thread contexts, admission and retryable resource retirement.
- Graph document and validation tests: Verify graph lookup, connection compatibility and recoverable missing definitions.
- Persistent and runtime identity tests: Verify detached identities, explicit registration and runtime domain isolation.
- File ownership and publication tests: Verify protected readers, atomic replacement, path boundaries and rollback.
- Job admission and scheduling tests: Verify bounded scheduling, callbacks, determinism and measured worker behavior.
- Layer ordering and rollback tests: Verify stack ordering, event precedence and reverse-order frame cleanup.
- Log delivery and file sink tests: Verify delivery ordering, fault quarantine, flush barriers and file rotation.
- Vector and matrix tests: Verify geometric identities and compound rotation conventions.
- Serialization and generation tests: Verify identity rewriting, registry lifetime and retained generation snapshots.
Asset, scene and generation contracts
Section titled “Asset, scene and generation contracts”- Asset import and settings tests: Verify source changes, importer discovery, sidecars and last-good artifacts.
- Asset ownership and residency tests: Verify canonical ownership, retained resources and pending release.
- Content-pack admission and reader tests: Verify portable keys, immutable indexes and independently retained readers.
- Module generation and unload tests: Verify collectible generations, rollback and retained dependencies.
- Generation admission and retirement tests: Verify publication ordering, read protection and terminal unload failures.
- Type discovery and registry retirement tests: Verify classification, candidate rollback and generation-bound resources.
- Plugin source and snapshot tests: Verify immutable plugin publication, cache validation and activation.
- Reference intent and recovery tests: Verify generation capture, Missing intent and compensating recovery.
- Scene, prefab and transform tests: Verify scene identity, deterministic ordering and recoverable plugin state.
- Filesystem content cache: cross-process generation publication, repair and stream protection.
Editor workflows
Section titled “Editor workflows”- Graph transactions: managed document history and Missing recovery.
- History and navigation: managed undo/redo and pointer capture.
- Conditional inspection: predicate selection and ambiguity.
- Panel and presentation: canvas geometry, Workbench lifecycle, asset history and Console discovery.
- Viewport and native context: window metrics, fonts and acknowledged retirement.
- Play Mode and Console: compilation transitions, game input, retained diagnostics and native layout.
- Audio preview: independent Edit/Play lifetimes.
- Startup and script projection: early rejection and the actual product API surfaces.
- Scripting and authoring: Inspector, viewport and Shader Editor workflows.
- Scale and interaction performance: large scene/asset workloads with real input and retained samples.
Managed domain success does not stand in for native presentation or scale evidence. Each page states the relevant distinction.
Rendering and shaders
Section titled “Rendering and shaders”- Render graph and portable artifacts: transactional edits, immutable values and scheduling.
- Rendering asset contracts: logical material values and persistent identities.
- Import and shader authoring: candidate includes and runtime export boundaries.
- Rendering runtime publication: frame owners, artifact scopes and complete shader replacement.
- Shader languages and native compiler: typed IR, lowering and actual offline Metal compilation.
- BGFX backend and surfaces: device commands, target shaders and real window lifetimes.
- BGFX deployment smoke test: deployed Noop initialization and shutdown.
Input and UI boundaries
Section titled “Input and UI boundaries”- Input and shell lifecycle: managed routing, frame scheduling and suspension.
- UI frame context: backend-neutral input and script-facade binding.
- SDL windows and native surfaces: real host integration and lifetime rules.
- SDL loading and ABI: generated import and library-owner behavior.
- RmlUi documents and native lifecycle: actual imports, fonts, events and stale-handle rejection.
- ImGui deployment and ABI: context lifetime, symbol loading and layouts.
- ImGuizmo borrowed state: owned style retirement and parent-state restoration.
Content and runtime services
Section titled “Content and runtime services”- Animation playback and binding: admission, sampling, markers and Missing recovery.
- Audio contracts and script API: values, mixer topology and actual script compilation.
- Audio runtime lifecycle: suspension, rollback and retained resources.
- Audio importing: encoded formats and failed publication.
- Storage admission and persistence: portable keys, writes and cancellation ownership.
- Text importing and native shaping: font metadata, encoded artifacts and real glyph output.
- Runtime startup and sessions: capability admission, memory content, static deployment and retirement.
- Runtime and serialization generators: compiled metadata, factories and accessors.
- Script compiler and cache: language/IDE parity and protected publication.
Native audio
Section titled “Native audio”See the native and process requirements before selecting a local diagnostic.
- MiniAudio adapter behavior: native graph execution, content preparation and voice completion.
- MiniAudio loading and initialization: function-table loading and headless engine initialization.
Native preparation remains required even when a suite uses a headless backend. These pages describe specific tests; they do not claim hardware, platform or current-run certification.
Development tools and execution protocols
Section titled “Development tools and execution protocols”- Command boundaries: early rejection and managed authoring without product preparation.
- Build inputs and cache protocols: neutral SDK graphs, exact identities and retirement.
- Binding generation integration: real SDK generation with independent product requirements.
- Product build and publication: actual composition, native deployment and support packs.
- Native preparation costs: Windows product measurements with cold/warm separation.
- Validation planning and evidence: scope, real builds, immutable inputs and explicit completion.
- Architecture and API boundaries: source rules, compiled symbols, project references and examples.
- Documentation snapshots and queries: publication, exact reads, ambiguity, freshness and concurrency.
- Child-process execution: output draining, failure diagnostics and descendant termination.
All test and fixture owners
Section titled “All test and fixture owners”Test and fixture project guides provide the complete owner inventory beyond these common validation tasks.