修复 Unity Test Runner 测试签名

My project/Assets/FlowScope/Tests/EditMode/Config/JsonConfigProviderTests.cs

@@ -9,71 +9,71 @@ namespace FlowScope.Tests.EditMode.Config
     public sealed class JsonConfigProviderTests
     {
         [Test]
-        public async Task LoadAllAsync_LoadsRegisteredJsonRows()
+        public void LoadAllAsync_LoadsRegisteredJsonRows()
         {
             var provider = new JsonConfigProvider(new[]
             {
                 JsonConfigProvider.Mapping<WeaponConfig>("weapons.json", _ => Task.FromResult("[{\"id\":101,\"name\":\"Axe\"}]"))
             });
 
-            await provider.LoadAllAsync(CancellationToken.None);
+            provider.LoadAllAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(provider.Get<WeaponConfig>(101).Name, Is.EqualTo("Axe"));
         }
 
         [Test]
-        public async Task Get_MissingId_ReturnsNull()
+        public void Get_MissingId_ReturnsNull()
         {
             var provider = new JsonConfigProvider(new[]
             {
                 JsonConfigProvider.Mapping<WeaponConfig>("weapons.json", _ => Task.FromResult("[{\"id\":101,\"name\":\"Axe\"}]"))
             });
 
-            await provider.LoadAllAsync(CancellationToken.None);
+            provider.LoadAllAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(provider.Get<WeaponConfig>(999), Is.Null);
         }
 
         [Test]
-        public async Task GetAll_UnloadedType_ReturnsEmptyList()
+        public void GetAll_UnloadedType_ReturnsEmptyList()
         {
             var provider = new JsonConfigProvider(Array.Empty<JsonConfigProvider.ConfigMapping>());
 
-            await provider.LoadAllAsync(CancellationToken.None);
+            provider.LoadAllAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(provider.GetAll<WeaponConfig>(), Is.Empty);
         }
 
         [Test]
-        public async Task LoadAllAsync_DuplicateId_ThrowsWithId()
+        public void LoadAllAsync_DuplicateId_ThrowsWithId()
         {
             var provider = new JsonConfigProvider(new[]
             {
                 JsonConfigProvider.Mapping<WeaponConfig>("weapons.json", _ => Task.FromResult("[{\"id\":101,\"name\":\"Axe\"},{\"id\":101,\"name\":\"Sword\"}]"))
             });
 
-            var exception = await ThrowsAsync<InvalidOperationException>(
+            var exception = ThrowsAsync<InvalidOperationException>(
-                async () => await provider.LoadAllAsync(CancellationToken.None));
+                () => provider.LoadAllAsync(CancellationToken.None));
 
             Assert.That(exception.Message, Does.Contain("101"));
         }
 
         [Test]
-        public async Task LoadAllAsync_MalformedJson_ThrowsWithFileName()
+        public void LoadAllAsync_MalformedJson_ThrowsWithFileName()
         {
             var provider = new JsonConfigProvider(new[]
             {
                 JsonConfigProvider.Mapping<WeaponConfig>("weapons.json", _ => Task.FromResult("[{\"id\":101"))
             });
 
-            var exception = await ThrowsAsync<InvalidOperationException>(
+            var exception = ThrowsAsync<InvalidOperationException>(
-                async () => await provider.LoadAllAsync(CancellationToken.None));
+                () => provider.LoadAllAsync(CancellationToken.None));
 
             Assert.That(exception.Message, Does.Contain("weapons.json"));
         }
 
         [Test]
-        public async Task LoadAllAsync_CanceledToken_ThrowsOperationCanceledException()
+        public void LoadAllAsync_CanceledToken_ThrowsOperationCanceledException()
         {
             using var cts = new CancellationTokenSource();
             cts.Cancel();
@@ -82,16 +82,16 @@ namespace FlowScope.Tests.EditMode.Config
                 JsonConfigProvider.Mapping<WeaponConfig>("weapons.json", _ => Task.FromResult("[]"))
             });
 
-            await ThrowsAsync<OperationCanceledException>(
+            ThrowsAsync<OperationCanceledException>(
-                async () => await provider.LoadAllAsync(cts.Token));
+                () => provider.LoadAllAsync(cts.Token));
         }
 
-        private static async Task<TException> ThrowsAsync<TException>(Func<Task> action)
+        private static TException ThrowsAsync<TException>(Func<Task> action)
             where TException : Exception
         {
             try
             {
-                await action();
+                action().GetAwaiter().GetResult();
             }
             catch (TException exception)
             {

My project/Assets/FlowScope/Tests/EditMode/Flow/FeatureBaseTests.cs

@@ -12,25 +12,25 @@ namespace FlowScope.Tests.EditMode.Flow
     public sealed class FeatureBaseTests
     {
         [Test]
-        public async Task LoadAsync_StoresContext()
+        public void LoadAsync_StoresContext()
         {
             var context = CreateContext();
             var feature = new TestFeature();
 
-            await feature.LoadAsync(context);
+            feature.LoadAsync(context).GetAwaiter().GetResult();
 
             Assert.That(feature.ExposedContext, Is.SameAs(context));
         }
 
         [Test]
-        public async Task ExitAsync_ClearsContextDisposables()
+        public void ExitAsync_ClearsContextDisposables()
         {
             var context = CreateContext();
             var disposable = new SpyDisposable();
             context.Disposables.Add(disposable);
             var feature = new TestFeature();
 
-            await feature.ExitAsync(context);
+            feature.ExitAsync(context).GetAwaiter().GetResult();
 
             Assert.That(disposable.IsDisposed, Is.True);
         }

My project/Assets/FlowScope/Tests/EditMode/Flow/GameFlowTests.cs

@@ -24,14 +24,14 @@ namespace FlowScope.Tests.EditMode.Flow
         }
 
         [Test]
-        public async Task StartupAsync_LoadsConfigCreatesContextAndEntersInitialFeature()
+        public void StartupAsync_LoadsConfigCreatesContextAndEntersInitialFeature()
         {
             var services = new TestServices();
             var root = services.CreateRoot();
             using var cts = new CancellationTokenSource();
             var flow = new GameFlow();
 
-            await flow.StartupAsync<FirstFeature>(root, cts.Token);
+            flow.StartupAsync<FirstFeature>(root, cts.Token).GetAwaiter().GetResult();
 
             Assert.That(flow.State, Is.EqualTo(GameFlowState.Running));
             Assert.That(services.Config.LoadCalls, Is.EqualTo(1));
@@ -42,14 +42,14 @@ namespace FlowScope.Tests.EditMode.Flow
         }
 
         [Test]
-        public async Task SwitchToAsync_ExitsDisposesAndReleasesOldContextBeforeEnteringNextFeature()
+        public void SwitchToAsync_ExitsDisposesAndReleasesOldContextBeforeEnteringNextFeature()
         {
             var services = new TestServices();
             var root = services.CreateRoot();
             var flow = new GameFlow();
-            await flow.StartupAsync<FirstFeature>(root, CancellationToken.None);
+            flow.StartupAsync<FirstFeature>(root, CancellationToken.None).GetAwaiter().GetResult();
 
-            await flow.SwitchToAsync<SecondFeature>(CancellationToken.None);
+            flow.SwitchToAsync<SecondFeature>(CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(flow.State, Is.EqualTo(GameFlowState.Running));
             Assert.That(FirstFeature.Instance.Calls, Is.EqualTo(new[] { "Load", "Enter", "Exit", "Dispose" }));
@@ -59,14 +59,14 @@ namespace FlowScope.Tests.EditMode.Flow
         }
 
         [Test]
-        public async Task StartupAsync_WhenFeatureLoadFails_CleansCreatedFeatureAndReturnsIdle()
+        public void StartupAsync_WhenFeatureLoadFails_CleansCreatedFeatureAndReturnsIdle()
         {
             var services = new TestServices();
             var root = services.CreateRoot();
             var flow = new GameFlow();
 
-            await ThrowsAsync<InvalidOperationException>(
+            ThrowsAsync<InvalidOperationException>(
-                async () => await flow.StartupAsync<FailingLoadFeature>(root, CancellationToken.None));
+                () => flow.StartupAsync<FailingLoadFeature>(root, CancellationToken.None));
 
             Assert.That(flow.State, Is.EqualTo(GameFlowState.Idle));
             Assert.That(FailingLoadFeature.Instance.Calls, Is.EqualTo(new[] { "Load", "Dispose" }));
@@ -74,15 +74,15 @@ namespace FlowScope.Tests.EditMode.Flow
         }
 
         [Test]
-        public async Task SwitchToAsync_WhenNextEnterFails_CleansNextFeatureAndLeavesNoActiveFeature()
+        public void SwitchToAsync_WhenNextEnterFails_CleansNextFeatureAndLeavesNoActiveFeature()
         {
             var services = new TestServices();
             var root = services.CreateRoot();
             var flow = new GameFlow();
-            await flow.StartupAsync<FirstFeature>(root, CancellationToken.None);
+            flow.StartupAsync<FirstFeature>(root, CancellationToken.None).GetAwaiter().GetResult();
 
-            await ThrowsAsync<InvalidOperationException>(
+            ThrowsAsync<InvalidOperationException>(
-                async () => await flow.SwitchToAsync<FailingEnterFeature>(CancellationToken.None));
+                () => flow.SwitchToAsync<FailingEnterFeature>(CancellationToken.None));
 
             Assert.That(flow.State, Is.EqualTo(GameFlowState.NoActiveFeature));
             Assert.That(FirstFeature.Instance.Calls, Does.Contain("Dispose"));
@@ -91,55 +91,55 @@ namespace FlowScope.Tests.EditMode.Flow
         }
 
         [Test]
-        public async Task SwitchToAsync_WhenIdle_ThrowsWithOperationAndCurrentState()
+        public void SwitchToAsync_WhenIdle_ThrowsWithOperationAndCurrentState()
         {
             var flow = new GameFlow();
 
-            var exception = await ThrowsAsync<InvalidOperationException>(
+            var exception = ThrowsAsync<InvalidOperationException>(
-                async () => await flow.SwitchToAsync<FirstFeature>(CancellationToken.None));
+                () => flow.SwitchToAsync<FirstFeature>(CancellationToken.None));
 
             Assert.That(exception.Message, Does.Contain(nameof(GameFlow.SwitchToAsync)));
             Assert.That(exception.Message, Does.Contain(GameFlowState.Idle.ToString()));
         }
 
         [Test]
-        public async Task ShutdownAsync_WhenFeatureCleanupThrows_StillReachesDisposed()
+        public void ShutdownAsync_WhenFeatureCleanupThrows_StillReachesDisposed()
         {
             var services = new TestServices();
             var root = services.CreateRoot();
             var flow = new GameFlow();
-            await flow.StartupAsync<ThrowingExitAndDisposeFeature>(root, CancellationToken.None);
+            flow.StartupAsync<ThrowingExitAndDisposeFeature>(root, CancellationToken.None).GetAwaiter().GetResult();
 
-            await flow.ShutdownAsync(CancellationToken.None);
+            flow.ShutdownAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(flow.State, Is.EqualTo(GameFlowState.Disposed));
             Assert.That(services.Resource.Groups[0].IsDisposed, Is.True);
         }
 
         [Test]
-        public async Task ShutdownAsync_WhenCancellationIsAlreadyRequested_CleansUpThenThrowsCancellation()
+        public void ShutdownAsync_WhenCancellationIsAlreadyRequested_CleansUpThenThrowsCancellation()
         {
             var services = new TestServices();
             var root = services.CreateRoot();
             var flow = new GameFlow();
-            await flow.StartupAsync<FirstFeature>(root, CancellationToken.None);
+            flow.StartupAsync<FirstFeature>(root, CancellationToken.None).GetAwaiter().GetResult();
             using var cts = new CancellationTokenSource();
             cts.Cancel();
 
-            await ThrowsAsync<OperationCanceledException>(
+            ThrowsAsync<OperationCanceledException>(
-                async () => await flow.ShutdownAsync(cts.Token));
+                () => flow.ShutdownAsync(cts.Token));
 
             Assert.That(flow.State, Is.EqualTo(GameFlowState.Disposed));
             Assert.That(FirstFeature.Instance.Calls, Does.Contain("Dispose"));
             Assert.That(services.Resource.Groups[0].IsDisposed, Is.True);
         }
 
-        private static async Task<TException> ThrowsAsync<TException>(Func<Task> action)
+        private static TException ThrowsAsync<TException>(Func<Task> action)
             where TException : Exception
         {
             try
             {
-                await action();
+                action().GetAwaiter().GetResult();
             }
             catch (TException exception)
             {

My project/Assets/FlowScope/Tests/EditMode/Save/SaveServiceTests.cs

@@ -11,43 +11,43 @@ namespace FlowScope.Tests.EditMode.Save
     public sealed class SaveServiceTests
     {
         [Test]
-        public async Task SaveAsync_ThenLoadAsync_ReturnsEquivalentData()
+        public void SaveAsync_ThenLoadAsync_ReturnsEquivalentData()
         {
             var service = new SaveService(new MemorySaveStorage(), new JsonSaveSerializer());
             var data = new PlayerData();
             data.Gold.Value = 88;
 
-            await service.SaveAsync("player", data, CancellationToken.None);
+            service.SaveAsync("player", data, CancellationToken.None).GetAwaiter().GetResult();
-            var loaded = await service.LoadAsync("player", new PlayerData(), CancellationToken.None);
+            var loaded = service.LoadAsync("player", new PlayerData(), CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(loaded.Gold.Value, Is.EqualTo(88));
         }
 
         [Test]
-        public async Task LoadAsync_MissingKey_ReturnsDefaultValue()
+        public void LoadAsync_MissingKey_ReturnsDefaultValue()
         {
             var service = new SaveService(new MemorySaveStorage(), new JsonSaveSerializer());
             var fallback = new PlayerData();
             fallback.Gold.Value = 5;
 
-            var loaded = await service.LoadAsync("missing", fallback, CancellationToken.None);
+            var loaded = service.LoadAsync("missing", fallback, CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(loaded, Is.SameAs(fallback));
         }
 
         [Test]
-        public async Task Delete_RemovesExistingKey()
+        public void Delete_RemovesExistingKey()
         {
             var service = new SaveService(new MemorySaveStorage(), new JsonSaveSerializer());
 
-            await service.SaveAsync("player", new PlayerData(), CancellationToken.None);
+            service.SaveAsync("player", new PlayerData(), CancellationToken.None).GetAwaiter().GetResult();
             service.Delete("player");
 
             Assert.That(service.Exists("player"), Is.False);
         }
 
         [Test]
-        public async Task LoadAsync_DeserializeFailure_ReturnsDefaultValue()
+        public void LoadAsync_DeserializeFailure_ReturnsDefaultValue()
         {
             var storage = new MemorySaveStorage();
             storage.Seed("player", new byte[] { 123, 34, 71, 111, 108, 100 });
@@ -55,39 +55,39 @@ namespace FlowScope.Tests.EditMode.Save
             var fallback = new PlayerData();
             fallback.Gold.Value = 9;
 
-            var loaded = await service.LoadAsync("player", fallback, CancellationToken.None);
+            var loaded = service.LoadAsync("player", fallback, CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(loaded, Is.SameAs(fallback));
         }
 
         [Test]
-        public async Task SaveAsync_WriteFailure_ThrowsWithKey()
+        public void SaveAsync_WriteFailure_ThrowsWithKey()
         {
             var service = new SaveService(new FailingWriteStorage(), new JsonSaveSerializer());
 
-            var exception = await ThrowsAsync<InvalidOperationException>(
+            var exception = ThrowsAsync<InvalidOperationException>(
-                async () => await service.SaveAsync("player", new PlayerData(), CancellationToken.None));
+                () => service.SaveAsync("player", new PlayerData(), CancellationToken.None));
 
             Assert.That(exception.Message, Does.Contain("player"));
         }
 
         [Test]
-        public async Task SaveAsync_CanceledToken_ThrowsOperationCanceledException()
+        public void SaveAsync_CanceledToken_ThrowsOperationCanceledException()
         {
             using var cts = new CancellationTokenSource();
             cts.Cancel();
             var service = new SaveService(new MemorySaveStorage(), new JsonSaveSerializer());
 
-            await ThrowsAsync<OperationCanceledException>(
+            ThrowsAsync<OperationCanceledException>(
-                async () => await service.SaveAsync("player", new PlayerData(), cts.Token));
+                () => service.SaveAsync("player", new PlayerData(), cts.Token));
         }
 
-        private static async Task<TException> ThrowsAsync<TException>(Func<Task> action)
+        private static TException ThrowsAsync<TException>(Func<Task> action)
             where TException : Exception
         {
             try
             {
-                await action();
+                action().GetAwaiter().GetResult();
             }
             catch (TException exception)
             {

My project/Assets/FlowScope/Tests/PlayMode/Resources/AddressablesResourceServiceTests.cs

@@ -9,7 +9,7 @@ namespace FlowScope.Tests.PlayMode.Resources
     public sealed class AddressablesResourceServiceTests
     {
         [Test]
-        public async Task LoadAsync_WhenSameKeyLoadsConcurrently_SharesOneBackendLoad()
+        public void LoadAsync_WhenSameKeyLoadsConcurrently_SharesOneBackendLoad()
         {
             var backendLoads = 0;
             var releaseCount = 0;
@@ -26,8 +26,8 @@ namespace FlowScope.Tests.PlayMode.Resources
             var second = service.LoadAsync<TestAsset>("shared", CancellationToken.None);
 
             gate.SetResult(new TestAsset());
-            var firstHandle = await first;
+            var firstHandle = first.GetAwaiter().GetResult();
-            var secondHandle = await second;
+            var secondHandle = second.GetAwaiter().GetResult();
 
             Assert.AreEqual(1, backendLoads);
             Assert.AreSame(firstHandle.Asset, secondHandle.Asset);
@@ -39,25 +39,25 @@ namespace FlowScope.Tests.PlayMode.Resources
         }
 
         [Test]
-        public async Task LoadAsync_WhenBackendFails_IncludesKeyAndBackend()
+        public void LoadAsync_WhenBackendFails_IncludesKeyAndBackend()
         {
             var service = new AddressablesResourceService(
                 (_, _, _) => throw new InvalidOperationException("missing"),
                 (_, _) => { });
 
-            var exception = await ThrowsAsync<InvalidOperationException>(
+            var exception = ThrowsAsync<InvalidOperationException>(
                 () => service.LoadAsync<TestAsset>("missing-key", CancellationToken.None));
 
             StringAssert.Contains("missing-key", exception.Message);
             StringAssert.Contains("Addressables", exception.Message);
         }
 
-        private static async Task<TException> ThrowsAsync<TException>(Func<Task> action)
+        private static TException ThrowsAsync<TException>(Func<Task> action)
             where TException : Exception
         {
             try
             {
-                await action();
+                action().GetAwaiter().GetResult();
             }
             catch (TException exception)
             {

My project/Assets/FlowScope/Tests/PlayMode/Samples/MainMenuP0Tests.cs

@@ -21,7 +21,7 @@ namespace FlowScope.Tests.PlayMode.Samples
         }
 
         [Test]
-        public async Task Bootstrap_CanConstructAndShutdownWithoutSceneAsset()
+        public void Bootstrap_CanConstructAndShutdownWithoutSceneAsset()
         {
             var root = new GameObject("bootstrap-test");
             var panelObject = new GameObject("panel-prefab");
@@ -36,7 +36,7 @@ namespace FlowScope.Tests.PlayMode.Samples
             panel.Configure(label, button);
 
             var bootstrap = root.AddComponent<GameBootstrap>();
-            await bootstrap.ShutdownAsync(CancellationToken.None);
+            bootstrap.ShutdownAsync(CancellationToken.None).GetAwaiter().GetResult();
 
             Object.DestroyImmediate(panelObject);
             Object.DestroyImmediate(root);

My project/Assets/FlowScope/Tests/PlayMode/UI/UIManagerTests.cs

@@ -28,7 +28,7 @@ namespace FlowScope.Tests.PlayMode.UI
         }
 
         [Test]
-        public async Task OpenAsync_UsesAttributePathAndMountsPanelToRegisteredLayer()
+        public void OpenAsync_UsesAttributePathAndMountsPanelToRegisteredLayer()
         {
             var canvas = CreateCanvas("popup");
             var prefab = CreatePrefab<ExplicitPathPanel>("ExplicitPathPrefab");
@@ -38,7 +38,7 @@ namespace FlowScope.Tests.PlayMode.UI
             manager.RegisterLayer("popup", canvas, 120);
             var viewModel = new TestViewModel("first");
 
-            var panel = await manager.OpenAsync<ExplicitPathPanel, TestViewModel>(viewModel, CancellationToken.None);
+            var panel = manager.OpenAsync<ExplicitPathPanel, TestViewModel>(viewModel, CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(resources.LoadedKeys, Is.EqualTo(new[] { "Custom/Explicit" }));
             Assert.That(panel.transform.parent, Is.EqualTo(canvas.transform));
@@ -49,7 +49,7 @@ namespace FlowScope.Tests.PlayMode.UI
         }
 
         [Test]
-        public async Task OpenAsync_WhenPathIsMissing_UsesPanelNameConvention()
+        public void OpenAsync_WhenPathIsMissing_UsesPanelNameConvention()
         {
             var canvas = CreateCanvas("hud");
             var prefab = CreatePrefab<MainHudPanel>("MainHudPrefab");
@@ -58,13 +58,13 @@ namespace FlowScope.Tests.PlayMode.UI
             var manager = new UIManager(resources);
             manager.RegisterLayer("hud", canvas, 10);
 
-            await manager.OpenAsync<MainHudPanel, TestViewModel>(new TestViewModel("hud"), CancellationToken.None);
+            manager.OpenAsync<MainHudPanel, TestViewModel>(new TestViewModel("hud"), CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(resources.LoadedKeys, Is.EqualTo(new[] { "UI/MainHud/Prefab" }));
         }
 
         [Test]
-        public async Task Close_WhenPanelIsNotLayerTop_ThrowsInvalidOperationException()
+        public void Close_WhenPanelIsNotLayerTop_ThrowsInvalidOperationException()
         {
             var canvas = CreateCanvas("popup");
             var resources = new FakeResourceService();
@@ -72,8 +72,8 @@ namespace FlowScope.Tests.PlayMode.UI
             resources.Register("UI/Second/Prefab", CreatePrefab<SecondPanel>("SecondPrefab"));
             var manager = new UIManager(resources);
             manager.RegisterLayer("popup", canvas, 0);
-            await manager.OpenAsync<ExplicitPathPanel, TestViewModel>(new TestViewModel("first"), CancellationToken.None);
+            manager.OpenAsync<ExplicitPathPanel, TestViewModel>(new TestViewModel("first"), CancellationToken.None).GetAwaiter().GetResult();
-            await manager.OpenAsync<SecondPanel, TestViewModel>(new TestViewModel("second"), CancellationToken.None);
+            manager.OpenAsync<SecondPanel, TestViewModel>(new TestViewModel("second"), CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.Throws<InvalidOperationException>(() => manager.Close<ExplicitPathPanel>());
             Assert.That(manager.IsOpen<ExplicitPathPanel>(), Is.True);
@@ -81,7 +81,7 @@ namespace FlowScope.Tests.PlayMode.UI
         }
 
         [Test]
-        public async Task Close_WithDestroyStrategy_UnbindsDestroysInstanceAndDisposesHandle()
+        public void Close_WithDestroyStrategy_UnbindsDestroysInstanceAndDisposesHandle()
         {
             var canvas = CreateCanvas("popup");
             var prefab = CreatePrefab<ExplicitPathPanel>("ExplicitPathPrefab");
@@ -89,7 +89,7 @@ namespace FlowScope.Tests.PlayMode.UI
             resources.Register("Custom/Explicit", prefab);
             var manager = new UIManager(resources);
             manager.RegisterLayer("popup", canvas, 0, PanelStrategy.Destroy);
-            var panel = await manager.OpenAsync<ExplicitPathPanel, TestViewModel>(new TestViewModel("first"), CancellationToken.None);
+            var panel = manager.OpenAsync<ExplicitPathPanel, TestViewModel>(new TestViewModel("first"), CancellationToken.None).GetAwaiter().GetResult();
             var handle = resources.Handles[0];
 
             manager.Close<ExplicitPathPanel>();
@@ -101,7 +101,7 @@ namespace FlowScope.Tests.PlayMode.UI
         }
 
         [Test]
-        public async Task OpenAsync_WithCacheStrategy_ReusesHiddenInstanceAndBindsAgain()
+        public void OpenAsync_WithCacheStrategy_ReusesHiddenInstanceAndBindsAgain()
         {
             var canvas = CreateCanvas("dialog");
             var prefab = CreatePrefab<CachedPanel>("CachedPrefab");
@@ -112,9 +112,9 @@ namespace FlowScope.Tests.PlayMode.UI
             var firstViewModel = new TestViewModel("first");
             var secondViewModel = new TestViewModel("second");
 
-            var first = await manager.OpenAsync<CachedPanel, TestViewModel>(firstViewModel, CancellationToken.None);
+            var first = manager.OpenAsync<CachedPanel, TestViewModel>(firstViewModel, CancellationToken.None).GetAwaiter().GetResult();
             manager.Close<CachedPanel>();
-            var second = await manager.OpenAsync<CachedPanel, TestViewModel>(secondViewModel, CancellationToken.None);
+            var second = manager.OpenAsync<CachedPanel, TestViewModel>(secondViewModel, CancellationToken.None).GetAwaiter().GetResult();
 
             Assert.That(second, Is.SameAs(first));
             Assert.That(second.gameObject.activeSelf, Is.True);
@@ -125,7 +125,7 @@ namespace FlowScope.Tests.PlayMode.UI
         }
 
         [Test]
-        public async Task CloseLayer_OnlyClosesRequestedLayer()
+        public void CloseLayer_OnlyClosesRequestedLayer()
         {
             var popupCanvas = CreateCanvas("popup");
             var hudCanvas = CreateCanvas("hud");
@@ -135,8 +135,8 @@ namespace FlowScope.Tests.PlayMode.UI
             var manager = new UIManager(resources);
             manager.RegisterLayer("popup", popupCanvas, 0);
             manager.RegisterLayer("hud", hudCanvas, 0);
-            await manager.OpenAsync<ExplicitPathPanel, TestViewModel>(new TestViewModel("popup"), CancellationToken.None);
+            manager.OpenAsync<ExplicitPathPanel, TestViewModel>(new TestViewModel("popup"), CancellationToken.None).GetAwaiter().GetResult();
-            await manager.OpenAsync<MainHudPanel, TestViewModel>(new TestViewModel("hud"), CancellationToken.None);
+            manager.OpenAsync<MainHudPanel, TestViewModel>(new TestViewModel("hud"), CancellationToken.None).GetAwaiter().GetResult();
 
             manager.CloseLayer("popup");
 
@@ -145,7 +145,7 @@ namespace FlowScope.Tests.PlayMode.UI
         }
 
         [Test]
-        public async Task OpenAsync_WhenBindThrows_DisposesHandleAndDestroysCreatedInstance()
+        public void OpenAsync_WhenBindThrows_DisposesHandleAndDestroysCreatedInstance()
         {
             var canvas = CreateCanvas("popup");
             var prefab = CreatePrefab<ThrowingBindPanel>("ThrowingPrefab");
@@ -154,7 +154,7 @@ namespace FlowScope.Tests.PlayMode.UI
             var manager = new UIManager(resources);
             manager.RegisterLayer("popup", canvas, 0);
 
-            await ThrowsAsync<InvalidOperationException>(
+            ThrowsAsync<InvalidOperationException>(
                 () => manager.OpenAsync<ThrowingBindPanel, TestViewModel>(new TestViewModel("boom"), CancellationToken.None));
 
             Assert.That(resources.Handles[0].IsDisposed, Is.True);
@@ -169,12 +169,12 @@ namespace FlowScope.Tests.PlayMode.UI
             return gameObject.AddComponent<Canvas>();
         }
 
-        private static async Task<TException> ThrowsAsync<TException>(Func<Task> action)
+        private static TException ThrowsAsync<TException>(Func<Task> action)
             where TException : Exception
         {
             try
             {
-                await action();
+                action().GetAwaiter().GetResult();
             }
             catch (TException exception)
             {

My project/Packages/packages-lock.json

@@ -201,6 +201,13 @@
       },
       "url": "https://unitynuget-registry.openupm.com"
     },
+    "org.nuget.system.numerics.vectors": {
+      "version": "4.4.0",
+      "depth": 2,
+      "source": "registry",
+      "dependencies": {},
+      "url": "https://unitynuget-registry.openupm.com"
+    },
     "org.nuget.system.runtime.compilerservices.unsafe": {
       "version": "6.0.0",
       "depth": 1,