Namespace Serenity.CreateGame.Tests.Editor

Classes

AdoptAllRootRulesTests

Pure EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.AdoptAllRootRules — the root-set decision behind Serenity.CreateGame.Infrastructure.Editor.Steps.SettingsAdoptionFlow.AdoptAll(System.Collections.Generic.IReadOnlyList{Serenity.CreateGame.Infrastructure.Editor.Systems.SerenitySystemConfigurationRow},System.String,System.Boolean,System.Action), resolved purely from a row's state.

AdoptedLocalizationCollectionTests

Adopting the shipped localization settings must leave every table the adopted settings bind a member of a collection the project owns — never a byte-for-byte copy of a table that no collection holds. An orphan table is invisible to the Localization Settings wizard (its binding reads as unresolved, and an untouched Update used to unlink it) and to the runtime, which loads tables through their collection's name.

AdoptedReferenceBackfillScopeTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Adoption.AdoptedReferenceBackfillScope.IsInScope(System.String,System.String,System.Collections.Generic.IReadOnlyCollection{System.String}) — covers the fold onto FoundationReferenceWalker.ShouldWalk: an AssetKey-only holder (an [AssetPathField] string field, never an IFoundationSettings) must be in scope too, not only a foundation-settings asset with its own declared contract row.

AdoptedReferenceEndToEndTests

End-to-end EditMode tests adopting REAL shipped systems (never hand-built fixtures) into a shared scratch output root, proving invariant 3 — adopting a later system repairs references an EARLIER adoption run left pointing at package content — through the full SystemAdoptionRunner pipeline: planner, cloner, Id rename, forward remap pass, and back-fill pass, exactly as SettingsAdoptionFlow drives them.

AdoptedReferenceRemapperTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Adoption.AdoptedReferenceRemapper: the write side of FoundationReferenceContracts, mirroring SerenityAdoptedReferenceValidatorTests's shipped/adopted scratch-root split, but asserting the VALUE after a rewrite rather than a report entry. A "shipped" fixture lives under Serenity.Global.Infrastructure.Editor.SerenityEditorPaths.AssetsRoot; an "adopted" one lives outside it, already carrying the Id an adoption run would have renamed it to — the state Serenity.CreateGame.Infrastructure.Editor.Adoption.AdoptedReferenceRemapper.Remap(System.Collections.Generic.IReadOnlyList{System.String},Serenity.Global.Infrastructure.Editor.Validation.FoundationReferenceIndex,Serenity.Global.Infrastructure.Editor.Validation.AdoptedAssetKeyIndex,System.Action{System.String}) actually sees, since it always runs after the Id-rename pass.

BootSceneRepointTests

EditMode tests for the boot scene's pipeline-profile repoint: a PLANNED deliverable (BootSceneRepoint) executed by Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringRunner.Run(Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringPlan,Serenity.ProjectRecipe.Infrastructure.Editor.SetupAssistant.MinimalLoopOptions,Serenity.CreateGame.Infrastructure.Editor.CreateGameScenesOptions,System.Collections.Generic.IReadOnlyList{Serenity.CreateGame.Infrastructure.Editor.Systems.SerenityInstallableSystem},Serenity.Global.Infrastructure.Editor.SerenityWizardActivityLog) itself, not only reachable through the Create step's separate "Wire installer settings" button. Covers the plan reading an existing boot scene's currently-referenced profile (Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringPlanner), the runner's automatic repoint (Serenity.CreateGame.Infrastructure.Editor.Wiring.ExistingBootSceneSettingsWiring.TryRepointForCreate(System.String,System.String,System.Boolean@,System.String@)), and its editor-state safety — refusing on a dirty open boot scene, and restoring whatever scene setup was open before it ran.

BootTaskAdoptionTranslationTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.BootTaskAdoptionTranslation.ToAdoptedPaths(System.Collections.Generic.IReadOnlyList{System.String},Serenity.CreateGame.Infrastructure.Editor.Adoption.SystemAdoptionPlan) — a pure lookup over a hand-built SystemAdoptionPlan, so no real assets or adoption run is needed to exercise it.

BootTaskCanonicalOrderTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.BootTaskCanonicalOrder: read-only checks against the real shipped task assets and profiles — no asset is created, modified or deleted.

BootTaskGuidArgumentRootsTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.BootTaskGuidArgumentRoots.ResolveReferencedAssetPaths(System.Collections.Generic.IReadOnlyList{System.String}) — the piece that lets a boot task's opaque stringArgs[0] Guid argument (e.g. a splash cutscene a PlayInitSplashScreen task plays) become an extra adoption root, since UnityEditor.AssetDatabase.GetDependencies(System.String,System.Boolean) can never see a plain string reference.

BootTaskRequirementsTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.BootTaskRequirements — the declared "this task needs that system" table. Two of them are guards rather than behavior checks: a requirement naming something outside SerenityInstallableSystemCatalog would silently never gate anything, and a requiring task with no Serenity.CreateGame.Infrastructure.Editor.BootTaskCanonicalOrder slot could never be placed back into a profile.

BootTaskSelectionRulesTests

Pure unit tests for FilterBySelection(IReadOnlyList<string>, Func<string, string>, IReadOnlyCollection<string>, IReadOnlyCollection<string>, Func<string, string>) — no AssetDatabase, a fake path-to-method-name resolver stands in for Serenity.Global.Infrastructure.Editor.InitializationPipeline.InstallTaskAuthoring.InstallMethodNameForShippedTaskPath(System.String) and a fake requirement resolver for Serenity.CreateGame.Infrastructure.Editor.BootTaskRequirements.RequiredInstallMethodFor(System.String).

BootTaskSequenceRulesTests

Pure unit tests for InsertMissingSelectedTasks(IReadOnlyList<string>, IReadOnlyList<SerenityInstallableSystem>, Func<string, string>, Func<SerenityInstallableSystem, string>, IReadOnlyList<string>) — no AssetDatabase; a synthetic sequence, a synthetic canonical order template and fake path/method-name resolvers stand in for Serenity.CreateGame.Infrastructure.Editor.BootTaskCanonicalOrder and the real project scan SerenityBootTaskCatalog performs in production.

CreateGameCollectionSettingsEndToEndTests

Create run end to end on a project that adopted Localization and its two language settings, measured against the set the generated boot scene's installer will actually LOAD — the union of nothing: a pinned list is taken as authored, an empty one loads everything by label with adopted twins shadowing their origins. Fixture shape copied from ProjectWiringRunnerHappyPathTests.

CreateGameInstallerWiringCollectionReportTests

What the wiring SAYS about a collection field it re-points. The messages are read through the production constants, never retyped, so a reworded message is not a failing test — what is asserted is which report an author gets, and that "asks for label discovery" means the same thing here as it does in the runtime lookup: a field whose every slot is empty pins nothing.

CreateGameThemeCatalogTests

EditMode test for Serenity.CreateGame.Infrastructure.Editor.CreateGameThemeCatalog: read-only against the project's real shipped themes under Assets/Serenity/Media/Ui/Themes — no temp folder needed, nothing is written or cleaned up.

CreateGameWizardCreateFlowTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.CreateGameWizardCreateFlow.PrepareSceneGeneration(System.Func{System.Boolean})'s pure outcome shape — the real EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo save-prompt dialog cannot be exercised headless, so every case here injects its own stand-in through the method's saveModifiedScenesIfUserWantsTo seam instead. The TMP-missing branch depends on whether this project has TMP Essential Resources imported, so it is asserted only up to "not declined by the save prompt", matching InitializeSerenityCreateStep's own contract of one log line per outcome rather than one shared blocking message.

DefaultSettingsAssetCreatorTestSettings

A throwaway IFoundationSettings asset type for DefaultSettingsAssetCreatorTests. A name of its own (not TestFoundationSettings) is required here: ReflectionActivationUtils.ResolveType falls back to a short-name search across every loaded type, and a second, unrelated TestFoundationSettings already exists (a private nested class in UnityDirectoryClonerTests), which would make that name resolve to nothing.

DefaultSettingsAssetCreatorTests

EditMode tests for DefaultSettingsAssetCreator. Every fixture lives under a scratch output root wiped in SetUp()/TearDown(); every test passes registerAsAddressables: false so nothing here touches the Addressables settings.

GameplayModulePlacementOnlyTests

The nine gameplay modules whose boot task only has a canonical place (after the game mode) declare it as a placement, not a requirement: a profile that runs one of them earlier still boots, so neither the project validator nor the wizard checklist may call it wrong. Wave and Game Session keep their validated orders. Pure: positions are plain numbers, no asset is involved.

GameplayModuleRequirementRulesTests

Serenity.CreateGame.Infrastructure.Editor.Systems.GameplayModuleRequirementRules reads which gameplay module another requires from the declared order.

GameplayModuleSettingsIsolationTests

A gameplay module has nothing to configure, so it must reach the boot-task paths and no settings path. With every module ticked next to every system, what the settings consumers receive and produce never names one: the Settings step's rows, the resolver behind them, and the systems the default-settings creator is asked to build an asset for.

GameplayModuleWiringTests

The gameplay modules ticked in Initialize Serenity, followed from the plan to the project's own initialization pipeline profile: Create seeds them in canonical order, Reuse inserts them once behind their anchors, and a shipped task asset or profile is referenced and never written. Everything a run makes lands under Serenity.CreateGame.Tests.Editor.GameplayModuleWiringTests.ScratchFolder, which the user-content scan is pinned to, so the real project is untouched.

InitializeSerenityCreateStepGameplayModuleTests

The Create step asks the author to confirm the statement it makes about the write. The selected systems and the gameplay modules only exist in that statement if it names them, so changing either must read as a different statement and ask for the confirmation again, instead of letting a stale confirmation sign a write the author did not read.

InitializeSerenityCreateStepTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenityCreateStep.SystemsEligibleForTaskWiring(System.Collections.Generic.IReadOnlyList{Serenity.CreateGame.Infrastructure.Editor.Systems.SerenityInstallableSystem}): a bootstrap system installs unconditionally and never gets its own Initialization Pipeline task, so the Create step's task-wiring fan-out must skip it. Pure — no AssetDatabase, no GUI.

InitializeSerenityDoneStepComposerTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.InitializeSerenityDoneStepComposer.Build(Serenity.Global.Infrastructure.Editor.SerenityWizardPrimaryActionOutcome,System.Int32,Serenity.ProjectRecipe.Infrastructure.Editor.SetupAssistant.MinimalLoopOptions,System.String,System.String,System.Action{System.String},System.Int32) — a pure model builder over the window's reload-safe Serenity.Global.Infrastructure.Editor.SerenityWizardPrimaryActionOutcome snapshot, no AssetDatabase writes. Covers the headline naming the wired profile, Created/Updated path reporting exactly what the outcome carries, and the scene-only next steps appearing exclusively when the boot scene path is actually present in the outcome.

InitializeSerenityInWindowConfirmationTests

Initialize Serenity's decisions live in its own window: an Adopt, an Adopt All and the Create step's write wait for the author's in-window confirmation, and a notice lands on the step instead of in a modal. Batch mode answers a native dialog with its first button, so every case here is shaped so that answer cannot fake it: nothing may be written before the window itself was told to proceed.

InitializeSerenitySettingsStepTests

EditMode tests for SettingsRowActionRules: the pure row → action mapping the Settings step's per-row button draws from — no GUI, no AssetDatabase. Also covers Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenitySettingsStep's own row-recompute caching (Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenitySettingsStep.EnsureRowsForTests(System.Collections.Generic.IReadOnlyList{Serenity.CreateGame.Infrastructure.Editor.Systems.SerenityInstallableSystem},System.String,System.String)).

InitializeSerenitySummaryStepTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenitySummaryStep.BuildSettingsReadinessWarnings(System.Collections.Generic.IReadOnlyList{Serenity.CreateGame.Infrastructure.Editor.Systems.SerenitySystemConfigurationRow}): the Summary step's per-row settings-readiness wording, without an IMGUI pass. Regression coverage for the Summary contradicting itself — reporting a system's boot task as "already wired" (the Boot Tasks section) while, in the very same warning list, calling its settings "not adopted" as if nothing about it were configured at all. The wording now names which is true: wired-without-settings gets its own sentence, matching SettingsRowBootTaskWiringRules.InstalledWithoutSettingsWarning's wording for the identical condition on the Settings step's own row.

InitializeSerenitySystemsStepTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenitySystemsStep's default selection.

InitializeSerenityWindowDoneStepReloadSafetyTests

Regression coverage for the Initialize Serenity Done step reading data a domain reload would otherwise silently null. InitializeSerenityCreateStep.WiringResult is a plain, non-serialized field — an unrelated script compile while the reader is still looking at the Done step (or simply reopening the window on a later session) drops it exactly the way CreateModalWindowDoneStepReloadSafetyTests already proved for Modal Builder's own cached result. The fix routes the Done step through the window's inherited, [SerializeField] Serenity.Global.Infrastructure.Editor.SerenityWizardPrimaryActionOutcome instead (Serenity.CreateGame.Infrastructure.Editor.InitializeSerenityWindow.SnapshotPrimaryActionOutcomeForTests(Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringResult) is the test seam onto the same write path RunCreate uses). Uses the same EditorJsonUtility round-trip technique the Modal suite uses to simulate the reload without an actual assembly reload.

InitializeSerenityWindowGameplayModuleTests

A gameplay module has no settings, so the only thing a tick on it changes is the wiring plan. These walk the path a reader takes: the plan is built while the Summary step's error is asked for, then the Systems step ticks something, and the plan Create acts on must reflect it, with nothing invalidating it by hand.

InitializeSerenityWindowOpenWithSystemSelectedTests

Proves OpenWithSystemSelected(string) against real window state: the Hub's registered Systems entry point (Task A, slice 2) routes a specific system id here so the reader lands directly on it instead of finding and checking it themselves in the Systems checklist.

InitializeSerenityWindowPlanFreshnessTests

The wiring plan is built the first time the Summary step's error is asked for, long before the reader reaches Create. A tick made after that must reach the plan Create acts on, with nothing invalidating it by hand.

InitializeSerenityWindowPlanInputsTests

The wiring plan is built from the Intent step's options as well as from the selection: the profile id picks the target profile and the scenes options decide the scene rows and the blocking error. An edit made after the plan was first built must reach the plan Summary and Create show, with nothing invalidating it by hand.

InitializeSerenityWindowStepErrorTests

Proves Serenity.CreateGame.Infrastructure.Editor.InitializeSerenityWindow.StepErrorForTests(System.Int32) against real window state, without an OnGUI pass — mirrors CreateModalWindowStepErrorGateTests's pattern. The Systems case is deliberately a "reports no error" assertion: an empty system selection is allowed (a reader who wants only the wired pipeline itself is not blocked) and must never gate Next/Create, unlike an empty project name or an unacceptable output root.

InstallTaskOrderCatalogTests

The contract that keeps an install task from ever being appended after the tasks that consume it: every installable system declares where its task belongs, and the canonical boot order every generated profile is seeded from honours every one of those declarations. Read-only — no asset is created, modified or deleted.

InstallableSystemDependencyOrderTests

EditMode tests for InstallableSystemDependencyOrder against synthetic graphs — no AppDomain scan involved. SerenityInstallableSystemCatalogTests covers the real catalog's end-to-end order.

PersistenceBackendDefinitionCreatorTests

EditMode tests for PersistenceBackendDefinitionCreator: the Persistence row's in-window Create action. UnityStructuredBackendDefinition subtypes are an unrelated structured-persistence concept — every asset this creator builds is a real UnityPersistenceBackendDefinition, the exact type both the row's own scan and UnitySerenityInstaller.PersistenceBackendDefinition read, so the row's own scan (ResolveSettingsContext(string, string, string)) actually finds what Create just built, in the same window, with no reopening required.

PersistenceRowActionsTests

EditMode tests for PersistenceRowActions: the Persistence row's Edit/Fix dispatch. Fix now genuinely acts (pings the row's own asset) whenever one exists to point at — a single malformed asset (a blank Id) — and stays a no-op only when the row is genuinely ambiguous (Steps.InitializeSerenitySettingsStep.ShouldDrawPersistenceAmbiguousRemedy is what stops that no-op button from ever being offered in the first place).

PipelineProfileRowActionsTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.PipelineProfileRowActions: the "Boot pipeline" row's two actions with no dialog and no drawing, so both Serenity.CreateGame.Infrastructure.Editor.Steps.PipelineProfileRowGui (IMGUI) and the Hub "Systems" view's own row report the outcome their own way. Every case here takes the early, file-system-free failure path — a real Adopt/Complete run is covered end to end by ProjectPipelineProfileFactoryTests and ProjectPipelineCompletionTests, neither of which this class duplicates.

PipelineProfileRowRulesTests

Pure EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.PipelineProfileRowRules — the Settings step's "Boot pipeline" row state-to-badge mapping, and the one line describing what completing the project's own profile would do.

PipelineProfileRowStateTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.PipelineProfileRowState: the "Boot pipeline" row's presentation-free state, resolved once and shared by Serenity.CreateGame.Infrastructure.Editor.Steps.PipelineProfileRowGui (IMGUI) and the Hub "Systems" view's own row. Covers the two branches that never touch the shipped-task preview (Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineCompletion.Preview(System.String,System.Collections.Generic.IReadOnlyCollection{System.String},System.String,System.String@)) — Create (no project-owned profile) and Ambiguous (more than one) — so no on-disk scratch profile is needed; the Reuse branch is already covered end to end by PipelineProfileRowRulesTests and the step's own recompute tests.

ProjectPipelineAdoptionExclusionTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineAdoption.IsUnselectedShippedTask(System.String,System.Collections.Generic.IReadOnlyList{System.String}) — the predicate SystemAdoptionPlanner uses to keep a deselected attributed system's shipped task out of the profile-creation adoption closure, reached through the shipped canonical profile's own Tasks[] object reference. The first four cases below drive the predicate directly with fabricated path strings — proof of the string matching alone. The two Plan_... cases exercise the real thing end to end: the actual shipped canonical profile, the actual attributed-system catalog, and the actual Plan(IReadOnlyList<string>, string, Func<string, bool>) call a real adoption run makes — one proving inclusion when selected, the other proving the predicate itself excludes what the closure walk still discovers when deselected.

ProjectPipelineCompletionRulesTests

Pure unit tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineCompletionRules.Plan(System.Collections.Generic.IReadOnlyList{System.String},System.Collections.Generic.IReadOnlyList{System.String},System.Func{System.String,System.String},System.Func{System.String,System.String},System.Collections.Generic.IReadOnlyList{System.String}) — no AssetDatabase: a synthetic profile task list, synthetic shipped/adopted path pairs and a fake twin resolver stand in for the real project scan Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineCompletion performs. The real Serenity.CreateGame.Infrastructure.Editor.BootTaskCanonicalOrder IS the template here, since the placements under test are about the actual splash tasks' real neighbours.

ProjectPipelineCompletionTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineCompletion — the Reuse-state counterpart of ProjectPipelineProfileFactoryTests. Every test builds its OWN project profile under a disposable scratch root (never InstallTaskAuthoring.FindProjectOwnedProfiles, which would find the real project's own) by seeding it through Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory.TryCreateFromShipped(System.String,System.Collections.Generic.IReadOnlyList{System.String},System.Action{System.String},System.String@,System.Collections.Generic.IReadOnlyList{System.String}@,System.Collections.Generic.IReadOnlyList{System.String}@,System.String@) with both output seams redirected, then completes it and asserts against the profile on disk. The real project's own content is never touched.

ProjectPipelineLegacyProfileReuseTests

A project whose initialization pipeline profile was created directly in the module root (where the previous version put it) keeps that profile: it is found, planned against and reused where it is, and a second profile is never adopted beside it. New profiles are created in the current folder. Adoption is redirected to the scratch root too, so a regression that adopts anyway cannot write into the real project.

ProjectPipelineProfileFactoryTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory. Creating a profile now adopts the shipped canonical one (Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineAdoption), which clones into Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineAdoption.AdoptionOutputRoot before the adopted profile itself is moved to Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory.ProjectProfileFolder — so every test here redirects BOTH seams to the same disposable scratch root via Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory.SetProjectProfileFolderOverrideForTests(System.String,System.String) and Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineAdoption.SetAdoptionOutputRootOverrideForTests(System.String) before running and restores them in TearDown() — the real project's own DefaultOutputFolder and Serenity.Global.Infrastructure.Editor.SerenityUserContentPaths.GameRoot are never touched.

ProjectPipelineTaskListWriterTests

What Initialize Serenity's pipeline writer does in a FRESH project, where the only boot profile that exists is the one the package ships. The writer itself refuses that profile — the next package update would overwrite a project's whole boot order — and the flow around it is not left with nowhere to go: Serenity.Global.Infrastructure.Editor.SerenityProjectAssetCopy produces the project-owned profile the same writer then accepts. The pair is the point: a refusal that cannot be answered would make Initialize Serenity unusable in exactly the project it exists for.

ProjectWiringPinResolutionTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringRunner.ResolveProjectOwnedSettingsPathOrNothing(System.String), the rule behind the four InheritedObjectReference wiring rows: a generated boot scene is pinned to the project's own settings asset when it has one, and to nothing at all when it does not — leaving the shipped installer prefab's own pin in place rather than writing a package path the next Serenity update overwrites.

Every candidate is a ProjectWiringPinTestSettings asset created through a ScratchAssetFixture, so the candidate set is exactly what each test says it is: under Serenity.CreateGame.Tests.Editor.ProjectWiringPinResolutionTests.PackageScratchFolder for shipped content, under Serenity.CreateGame.Tests.Editor.ProjectWiringPinResolutionTests.ProjectScratchFolder for the project's own.

ProjectWiringPinTestSettings

A throwaway settings asset type for ProjectWiringPinResolutionTests, so the fixture owns every candidate the resolver can find instead of racing the shipped assets of a real settings type. Lives in its own same-named file so Unity can bind its script when the tests create it as an asset (mirrors UnityCollectionSettingsLoaderTestSettings). Carries no Id or Guid on purpose: ProjectWiringRunner.ResolveProjectOwnedSettingsPathOrNothing finds candidates by simple type name and decides between them by asset PATH, so a foundation identity surface would be dead weight.

ProjectWiringPlanCachePlayModeTests

Building the wiring plan opens the existing boot scene, which the editor refuses while it is playing (InvalidOperationException: This cannot be used during play mode.). An Initialize Serenity window left open when the author presses Play must therefore never plan, and must say why instead.

ProjectWiringPlanCacheSelectionTests

A plan built for one selection must not be acted on once the selection changed: the gameplay modules exist nowhere but in the plan, so a stale one silently drops what the reader ticked afterwards.

ProjectWiringPlanCacheTolerantReadTests

The breadcrumb asks for the Summary and Create errors on every repaint, including while the author types in the Intent step. It may therefore answer from a plan one edit behind; the step bodies and the Create action still read through Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringPlanCache.Ensure, which never lets a stale plan through.

ProjectWiringPlanInputsSignatureTests

The signature a wiring plan is cached under covers exactly what the planner reads: a change to any of it reads as a different plan, and a change to anything else does not.

ProjectWiringPlannerTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringPlanner against real project state, with the user-content half of every scan pinned to Serenity.CreateGame.Tests.Editor.ProjectWiringPlannerTests.ScratchFolder (Serenity.Global.Infrastructure.Editor.SerenityUserContentScan.PinForTests(System.String[])): the project a test runs in may already own boot profiles of its own — every customer project does — so the "no profile yet" cases establish that premise instead of assuming it. The "one profile" case creates a disposable scratch profile outside Assets/Serenity (project-owned per FoundationAssetOwnership.IsProjectOwnedPath) and deletes it in TearDown(), without Addressables registration.

ProjectWiringRulesTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringRules — pure state resolution, no AssetDatabase access, so every case here is a plain input/output assertion.

ProjectWiringRunnerHappyPathTests

The happy path: Initialize Serenity's Create step run end to end on a fresh-project-shaped fixture. Project-owned Ui/GameMode/Menu/Modal settings are built the way the Settings step's own Adopt action builds them — cloning the shipped assets via SystemAdoptionRunner, never hand-built YAML — then Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringPlanner/Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringRunner run for real through scene generation and Health Check, mirroring ProjectWiringRunnerTests's scratch-folder pattern.

ProjectWiringRunnerTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectWiringRunner against a disposable scratch output root — the shipped project tree is never written to. Mirrors SerenityCreateGameSceneGeneratorTests's cleanup pattern: every asset a run's OWN generated content lands under Serenity.CreateGame.Tests.Editor.ProjectWiringRunnerTests.ScratchFolder, so TearDown() strips that one subtree's Addressables entries before deleting it — including the project's own initialization pipeline profile, which Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory always creates under its own pinned Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory.ProjectProfileFolder regardless of Serenity.CreateGame.Tests.Editor.ProjectWiringRunnerTests.OutputRoot, redirected here to a subfolder of Serenity.CreateGame.Tests.Editor.ProjectWiringRunnerTests.ScratchFolder via Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineProfileFactory.SetProjectProfileFolderOverrideForTests(System.String,System.String). Creating a profile now adopts the shipped canonical one, cloning into Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineAdoption.AdoptionOutputRoot first — also redirected here, to Serenity.CreateGame.Tests.Editor.ProjectWiringRunnerTests.ScratchFolder itself, via Serenity.CreateGame.Infrastructure.Editor.Wiring.ProjectPipelineAdoption.SetAdoptionOutputRootOverrideForTests(System.String) — so the real project's own pipeline folder and Assets/Game content are never touched.

SerenityBootTaskCatalogTests

EditMode tests for SerenityBootTaskCatalog's selection-aware overload — subtractive (Serenity.CreateGame.Infrastructure.Editor.BootTaskSelectionRules) plus additive (Serenity.CreateGame.Infrastructure.Editor.BootTaskSequenceRules) — exercised against the real shipped canonical profile (read-only for every system tested here — Score's task asset already ships, so no test in this file writes to the project). Score (InstallScore) stands in for "an attributed system's task"; DisableGameWrapper and InstallTimer stand in for infrastructure tasks the shipped profile also carries; the three Play*SplashScreen tasks stand in for "a task that requires a system without being one" (Serenity.CreateGame.Infrastructure.Editor.BootTaskRequirements).

SerenityBuildSettingsBinderTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.SerenityBuildSettingsBinder. UnityEditor.EditorBuildSettings.scenes is this dev project's REAL boot configuration (it ships Serenity_InitializationScene + GameScene), so every test snapshots the full array in SetUp() and restores it unconditionally in TearDown() — which then asserts the restore actually landed, so a leak into the shared project state fails loudly in the same run instead of silently corrupting it for whatever runs next.

SerenityCreateGameBootSceneTests

EditMode tests for the Create Game boot-scene engine. Every test that touches disk points at a private temp folder — the shipped Serenity.CreateGame.Infrastructure.Editor.CreateGameScenePaths.DefaultRootFolder is never written to — and cleans up both the assets and their Addressables entries in TearDown(), mirroring SerenitySampleSceneGeneratorTests.

SerenityCreateGameSceneGeneratorTests

EditMode tests for SerenityCreateGameSceneGenerator. Every test that touches disk points at a private temp folder — the shipped Serenity.CreateGame.Infrastructure.Editor.CreateGameScenePaths.DefaultRootFolder is never written to — and cleans up both the assets and their Addressables entries in TearDown(), mirroring SerenityCreateGameBootSceneTests and SerenitySampleSceneGeneratorTests.

SerenityInstallableSystemCatalogTests

EditMode tests for SerenityInstallableSystemCatalog: the reflection scan over every [SerenityInstallableSystem]-decorated Install*() method on UnitySerenityInstaller.

SerenityInstallableSystemSelectionTests

EditMode tests for SelectTier(IReadOnlyList<SerenityInstallableSystem>, SerenityInstallableSystemTier): no real installer or AssetDatabase content needed, so the catalog is a small in-memory fixture.

SerenitySystemConfigurationFreshnessWatcherTests

EditMode tests for SerenitySystemConfigurationFreshnessWatcher. Every test injects its own subscribe/unsubscribe delegates so none of them touch the real UnityEditor.EditorApplication.projectChanged event — a captured handler stands in for a raised project change.

SerenitySystemConfigurationResolverTests

EditMode tests for SerenitySystemConfigurationResolver. Every fixture is a real TestFoundationSettings asset created on disk (the identity checks read SerenityHealthCheckValidator.LoadFoundationAssets, a project-wide AssetDatabase scan, so nothing here can be faked in-memory), created in SetUp and removed in TearDown.

SettingsAdoptionConfirmationGuiTests

Pure EditMode tests for SettingsAdoptionConfirmationGui's "Ids that will change" block — built directly from hand-authored SystemAdoptionPlan instances (public constructor), so none of these touch AssetDatabase.

SettingsAdoptionShownPlanTests

The plan an Adopt confirmation shows is the plan its confirm runs. The Settings step is non-modal, so the project can change between staging and confirming; every Adopt shape — a row, a collection row, Adopt All and Adopt assets — must then refuse, name what changed and stage the refreshed plan (or say nothing is left to adopt), never quietly run a different plan than the one the author read.

SettingsReferenceRulesTests

EditMode tests for SettingsReferenceRules: pure field-type-to-system matching and message building — no UnityEditor or AssetDatabase access.

SettingsRowActionExecutorTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Steps.SettingsRowActionExecutor: the Settings row action dispatch extracted out of Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenitySettingsStep. Adopt/AdoptAllAssets are exercised only through their own zero-candidate early returns here; their in-window confirmation is covered by InitializeSerenityInWindowConfirmationTests.

SettingsRowActionRulesTests

Unit tests for SettingsRowActionRules: the pure primary/secondary action mapping, with no asset on disk needed.

SettingsRowAssetsBadgeRulesTests

Pure EditMode tests for SettingsRowAssetsBadgeRules — every combination of shipped and remaining shipped asset counts the Settings step's second row badge can render.

SettingsRowBootTaskWiringRulesTests

Pure unit tests for SettingsRowBootTaskWiringRules — no AssetDatabase.

SettingsRowDependencyRulesTests

EditMode tests for SettingsRowDependencyRules: the pure "Depends on: ..." line and dependency-not-ready warning tooltip text behind SettingsRowDependencyGui's row, and shared by the Hub "Systems" view's own row.

SettingsRowReferenceAuditorTests

EditMode tests for SettingsRowReferenceAuditor against real scratch assets: a TestReferencingFoundationSettings asset with a reference to TestFoundationSettings that was never assigned keeps the row InProject with a warning, naming the field and the system to configure first, and offers Assign; assigning the sole project-owned candidate through SettingsReferenceInspector clears the warning. A reference that WAS assigned and is now dangling (its target deleted) downgrades the row to Invalid instead. Only a project-owned row (InProject) is audited at all — a shipped (InPackage) row's unassigned reference falls back to the factory default and is never flagged.

ShippedSystemAssetCatalogTests

Read-only EditMode tests for ShippedSystemAssetCatalog against the real shipped package — every test but RemainingMemberPaths_AfterMirroringOneMember_ExcludesThatMember() reads the project as-is and creates nothing; that one test mirrors a single member into a scratch, non-Addressable output folder, deleted again in TearDown().

ShippedSystemAssetCountsTests

EditMode tests for Serenity.CreateGame.Infrastructure.Editor.Systems.ShippedSystemAssetCounts: the shipped-vs-remaining asset count lookup extracted out of Serenity.CreateGame.Infrastructure.Editor.Steps.InitializeSerenitySettingsStep.

ShippedSystemAssetMembershipRulesTests

Pure EditMode tests for ShippedSystemAssetMembershipRules — hand-written paths and a hand-written folder-rule table mirroring the relevant subset of UnityAddressablesLabeler.FolderLabelRules, so these never touch AssetDatabase and stay independent of the labeler's internal table shape.

SystemAdoptionClosureRulesTests

Pure EditMode tests for SystemAdoptionClosureRules — no AssetDatabase, no assets on disk; already-adopted detection is driven by a fake existence predicate.

SystemAdoptionFolderSummaryTests

Pure EditMode tests for SystemAdoptionFolderSummary — hand-written entries, no AssetDatabase calls.

SystemAdoptionPlanDriftTests

The pure half of "the plan shown is the plan executed": SystemAdoptionPlanDrift names every way the plan the same roots produce now differs from the plan the author read, and ReusingDestinationsCreatedEarlier(ICollection<string>, Func<string, string>) is the one adjustment a confirmed run may make to a shown plan — reusing what an earlier plan of the same run just cloned, never cloning more.

SystemAdoptionPlannerTests

EditMode tests for SystemAdoptionPlanner: real fixtures under a scratch package folder (a real shipped asset cannot stand in here, since these tests need to control the closure precisely), wiped in both SetUp() and TearDown().

SystemAdoptionRunnerTests

EditMode tests for SystemAdoptionRunner and SystemAdoptionVerifier. Every fixture lives under a scratch package folder and a scratch output root, both owned by a ScratchAssetFixture created in SetUp() and disposed in TearDown().

SystemBootTaskWiringInspectorTests

EditMode tests for SystemBootTaskWiringInspector. The profile-scanning half of the question is already covered by InstallTaskAuthoringTests.ProjectOwnedProfilePathsByInstallMethodName_* against real scratch profiles; these tests only need a method name real enough that no project profile coincidentally carries it, so a made-up name stands in without needing a scratch fixture of its own.

TestFoundationSettings

A throwaway IFoundationSettings asset type for SerenitySystemConfigurationResolverTests. Lives in its own same-named file so Unity can bind its script when the tests create it as an asset (the same reason SettingsAssetResolutionTestSettings gives).

TestReferencingFoundationSettings

A throwaway IFoundationSettings asset type for SettingsRowReferenceAuditorTests, carrying a reference to another settings asset (TestFoundationSettings) so the auditor's unassigned-reference detection has a real field to walk. Lives in its own same-named file so Unity can bind its script when the tests create it as an asset (the same reason TestFoundationSettings gives).

WiredSelectionCountPhraseTests

The count phrase the Create confirmation and the Done step share.