public void CreateCachedQuery_OverflowWithCacheSize4_ResizesByAtLeastHalf() { var cache = new EntityQueryCache(4); SimpleWrapCreateCachedQuery(cache, 0, k_DummyGroup); SimpleWrapCreateCachedQuery(cache, 1, k_DummyGroup); SimpleWrapCreateCachedQuery(cache, 2, k_DummyGroup); SimpleWrapCreateCachedQuery(cache, 3, k_DummyGroup); #if UNITY_DOTSRUNTIME LogAssert.ExpectReset(); #endif LogAssert.Expect(LogType.Error, k_ResizeError); SimpleWrapCreateCachedQuery(cache, 4, k_DummyGroup); LogAssert.NoUnexpectedReceived(); // this should not error SimpleWrapCreateCachedQuery(cache, 5, k_DummyGroup); LogAssert.NoUnexpectedReceived(); }
public IEnumerator Test_EnemyCanOnlyAttackIfPartOfCurrentBattle() { Player player = CreatePlayer(); Enemy enemyRight = CreateEnemy(); Enemy enemyWrong = CreateEnemy(); GameController gameCtr = CreateGameController(player); enemyRight.GameCtr = gameCtr; enemyWrong.GameCtr = gameCtr; player.GameCtr = gameCtr; yield return(new WaitForEndOfFrame()); gameCtr.StartBattle(enemyRight); enemyWrong.stats.AttackOpponent(player.stats, false, true); LogAssert.Expect(LogType.Error, "Enemy that is not part of the current battle tried to attack the player!"); }
public override IEnumerator LoadScenes([ValueSource(nameof(UnityPhysicsSamplesTest.GetScenes))] string scenePath) { // Don't create log messages about the number of trial days remaining PlayerPrefs.SetInt("Havok.Auth.SuppressDialogs", 1); // Log scene name in case Unity crashes and test results aren't written out. Debug.Log("Loading " + scenePath); LogAssert.Expect(LogType.Log, "Loading " + scenePath); SceneManager.sceneLoaded += (Scene scene, LoadSceneMode mode) => SetSimulationType(SimulationType.HavokPhysics, scene, mode); SceneManager.LoadScene(scenePath); yield return(new WaitForSeconds(1)); UnityPhysicsSamplesTest.EntitiesCleanup(); yield return(new WaitForFixedUpdate()); LogAssert.NoUnexpectedReceived(); PlayerPrefs.DeleteKey("Havok.Auth.SuppressDialogs"); }
public void CreateForwardRendererAssetWithoutErrors() { // Test without any render pipeline assigned to GraphicsSettings. var renderPipelineAsset = GraphicsSettings.renderPipelineAsset; GraphicsSettings.renderPipelineAsset = null; try { var asset = ScriptableObject.CreateInstance <ForwardRendererData>(); ResourceReloader.ReloadAllNullIn(asset, LightweightRenderPipelineAsset.packagePath); LogAssert.NoUnexpectedReceived(); ScriptableObject.DestroyImmediate(asset); } // Makes sure the render pipeline is restored in case of a NullReference exception. finally { GraphicsSettings.renderPipelineAsset = renderPipelineAsset; } }
public IEnumerator RunCodeErrorsAsExpected() { // Arrange const int timeoutMilliseconds = 10_000; PMWrapper.mainCode = "IckeDefinieradFunktion()"; PMWrapper.speedMultiplier = 1; // Act var coroutine = PlaygroundTestHelper.RunCompilerWithTimeout(timeoutMilliseconds); while (coroutine.MoveNext()) { yield return(coroutine.Current); } // Assert LogAssert.Expect(LogType.Exception, new Regex(".*RuntimeVariableNotDefinedException.*")); LogAssert.Expect(LogType.Exception, new Regex(".*PMRuntimeException.*")); }
public void FindOrSpawnObject_ErrorWhenPrefabInNullInDictionary() { const uint netId = 1002; SpawnMessage msg = new SpawnMessage { netId = netId, assetId = validPrefabGuid }; // could happen if the prefab is destroyed or unloaded prefabs.Add(validPrefabGuid, null); LogAssert.Expect(LogType.Error, $"Failed to spawn server object, did you forget to add it to the NetworkManager? assetId={msg.assetId} netId={msg.netId}"); LogAssert.Expect(LogType.Error, $"Could not spawn assetId={msg.assetId} scene={msg.sceneId:X} netId={msg.netId}"); bool success = ClientScene.FindOrSpawnObject(msg, out NetworkIdentity networkIdentity); Assert.IsFalse(success); Assert.IsNull(networkIdentity); }
public IEnumerator RosIntegration_Publisher_Success() { #if INTEGRATION_TEST m_Cube.AddComponent <RosPublisherExample>().cube = m_Cube; yield return(new EnterPlayMode()); while (Time.time < k_SimulationTime) { yield return(null); } yield return(new ExitPlayMode()); LogAssert.NoUnexpectedReceived(); Object.DestroyImmediate(Object.FindObjectOfType <RosPublisherExample>().gameObject); #else ThrowNotImplementedException(); yield return(null); #endif }
[Test] // runtime string formatting public void ComponentSystemSorter_OrderLastUpdateBeforeOrderFirst_WarnAndIgnoreConstraint() { var parent = World.CreateSystem <TestGroup>(); var systems = new List <EmptySystem> { World.CreateSystem <DummyFirstSystem>(), World.CreateSystem <LastBeforeFirstSystem>(), }; // Insert in reverse order for (int i = systems.Count - 1; i >= 0; --i) { parent.AddSystemToUpdateList(systems[i]); } LogAssert.Expect(LogType.Warning, "Ignoring invalid [UpdateBefore(Unity.Entities.Tests.ComponentSystemGroupTests+DummyFirstSystem)] attribute on Unity.Entities.Tests.ComponentSystemGroupTests+LastBeforeFirstSystem because OrderFirst/OrderLast has higher precedence."); parent.SortSystems(); LogAssert.NoUnexpectedReceived(); CollectionAssert.AreEqual(systems, parent.Systems); }
public static IEnumerator TestAutoCancellation() { CoroutineRegularUpdater cru = new GameObject().AddComponent <CoroutineRegularUpdater>(); var cts = new Cancellable(); cru.RunRIEnumerator(NestLoC(cts)); cts.Cancel(); cru.gameObject.SetActive(false); Assert.AreEqual(cru.NumRunningCoroutines, 0); cru.gameObject.SetActive(true); cru.RunDroppableRIEnumerator(NestLoC(Cancellable.Null)); cru.gameObject.SetActive(false); Assert.AreEqual(cru.NumRunningCoroutines, 0); cru.gameObject.SetActive(true); cru.RunRIEnumerator(NestLoC(Cancellable.Null)); LogAssert.Expect(LogType.Error, new Regex(".*1 leftover coroutine.*")); cru.gameObject.SetActive(false); Assert.AreEqual(cru.NumRunningCoroutines, 1); yield return(null); }
public IEnumerator RosIntegration_ServiceClient_Success() { #if INTEGRATION_TEST m_Cube.AddComponent <RosServiceCallExample>().cube = m_Cube; yield return(new EnterPlayMode()); while (Time.time < k_SimulationTime) { yield return(null); } LogAssert.Expect(LogType.Log, "Destination reached."); LogAssert.Expect(LogType.Log, new Regex(@"^New Destination: .*$")); yield return(new ExitPlayMode()); Object.DestroyImmediate(Object.FindObjectOfType <RosServiceCallExample>().gameObject); #else ThrowNotImplementedException(); yield return(null); #endif }
public void SetAssetId_GivesErrorForEmptyGuid() { CreateNetworked(out GameObject _, out NetworkIdentity identity); if (identity.assetId == Guid.Empty) { identity.assetId = Guid.NewGuid(); } Guid guid1 = identity.assetId; // assign a guid Guid guid2 = new Guid(); LogAssert.Expect(LogType.Error, $"Can not set AssetId to empty guid on NetworkIdentity '{identity.name}', old assetId '{guid1.ToString("N")}'"); identity.assetId = guid2; // guid was NOT changed Assert.That(identity.assetId, Is.EqualTo(guid1)); }
public void SetAssetId_GivesErrorIfOneExists() { CreateNetworked(out GameObject _, out NetworkIdentity identity); if (identity.assetId == Guid.Empty) { identity.assetId = Guid.NewGuid(); } Guid guid1 = identity.assetId; // assign a guid Guid guid2 = Guid.NewGuid(); LogAssert.Expect(LogType.Error, $"Can not Set AssetId on NetworkIdentity '{identity.name}' because it already had an assetId, current assetId '{guid1.ToString("N")}', attempted new assetId '{guid2.ToString("N")}'"); identity.assetId = guid2; // guid was changed Assert.That(identity.assetId, Is.EqualTo(guid1)); }
public void FirstProgressReportsTheMaximumProgress3() { var deferred1 = Promise.NewDeferred <int>(); float progress = float.NaN; Promise.First(deferred1.Promise, Promise.Resolved(1)) .Progress(p => progress = p); Promise.Manager.HandleCompletesAndProgress(); Assert.AreEqual(1f, progress, 0f); deferred1.Resolve(1); Promise.Manager.HandleCompletesAndProgress(); // Clean up. GC.Collect(); Promise.Manager.HandleCompletesAndProgress(); LogAssert.NoUnexpectedReceived(); }
public void TestGetComponent() { SetupTestGraphDefinitionMultipleFrames((b, _) => { var componentTypeRef = new TypeReference { TypeHash = TypeHash.CalculateStableTypeHash(typeof(TestComponent)) }; var onUpdate = b.AddNode(new OnUpdate()); var enabled = b.AddNode(new ConstantBool { Value = true }); var getComponent = b.AddNode(new GetComponent { Type = componentTypeRef, ComponentData = new OutputDataMultiPort { DataCount = 2 } }); var log = b.AddNode(new Log() { Messages = new InputDataMultiPort { DataCount = 1 } }); b.CreateEdge(enabled.ValuePort, onUpdate.Enabled); b.CreateEdge(onUpdate.Output, log.Input); b.CreateEdge(getComponent.ComponentData.SelectPort(0), log.Messages.SelectPort(0)); b.AddReferencedComponent(componentTypeRef); }, (manager, entity, index) => { // don't add the component yet, next frame we can test that "get component" returns the default value }, (manager, entity, index) => { LogAssert.Expect(LogType.Log, "0"); // no component on entity should give default value manager.AddComponentData(entity, new TestComponent { Int = 42, Float = 12.7f }); }, (manager, entity, index) => { LogAssert.Expect(LogType.Log, "42"); }); }
public void Test_05_04_UnregisterMixedRealityExtensionServicesByType() { TestUtilities.InitializeMixedRealityToolkitScene(); var activeSystemCount = MixedRealityToolkit.ActiveSystems.Count; var activeServiceCount = MixedRealityToolkit.RegisteredMixedRealityServices.Count; // Add test ExtensionService MixedRealityToolkit.RegisterService <ITestExtensionService1>(new TestExtensionService1("Test ExtensionService 1")); MixedRealityToolkit.RegisterService <ITestExtensionService2>(new TestExtensionService2("Test ExtensionService 2")); // Retrieve all registered IMixedRealityExtensionServices var extensionServices = MixedRealityToolkit.GetActiveServices <IMixedRealityExtensionService>(); // Tests Assert.IsNotNull(MixedRealityToolkit.Instance.ActiveProfile); Assert.AreEqual(activeSystemCount, MixedRealityToolkit.ActiveSystems.Count); Assert.AreEqual(activeServiceCount + extensionServices.Count, MixedRealityToolkit.RegisteredMixedRealityServices.Count); // Retrieve services var extensionService1 = MixedRealityToolkit.GetService <ITestExtensionService1>(); var extensionService2 = MixedRealityToolkit.GetService <ITestExtensionService2>(); // Validate Assert.IsNotNull(extensionService1); Assert.IsNotNull(extensionService2); var success = MixedRealityToolkit.UnregisterServicesOfType <IMixedRealityExtensionService>(); // Validate non-existent service var isService1Registered = MixedRealityToolkit.IsServiceRegistered <ITestExtensionService1>(); var isService2Registered = MixedRealityToolkit.IsServiceRegistered <ITestExtensionService2>(); // Tests Assert.IsTrue(success); Assert.IsFalse(isService1Registered); Assert.IsFalse(isService2Registered); Assert.AreEqual(activeSystemCount, MixedRealityToolkit.ActiveSystems.Count); Assert.AreEqual(activeServiceCount, MixedRealityToolkit.RegisteredMixedRealityServices.Count); LogAssert.Expect(LogType.Error, $"Unable to find {typeof(ITestExtensionService1).Name} service."); LogAssert.Expect(LogType.Error, $"Unable to find {typeof(ITestExtensionService2).Name} service."); }
private static void Main(string[] args) { var dir = Path.GetFullPath(args[0]); if (!Directory.Exists(dir)) { Directory.CreateDirectory(dir); } Console.WriteLine("Writing logs in {0}", dir); var config = string.Format( @" <loggers> <etwlogging enabled='true' /> <log name='demo' rotationInterval='60' type='etl' directory='{0}' timestampLocal='true'> <source name='Demo' minimumSeverity='informational' /> </log> </loggers> ", dir); LogManager.Start(); LogAssert.Assert(LogManager.SetConfiguration(config)); LogManager.ConsoleLogger.SubscribeToEvents(DemoEvents.Write, EventLevel.Verbose); LogManager.ConsoleLogger.SubscribeToEvents(InternalLogger.Write, EventLevel.Verbose); var t = new Timer(_ => DemoEvents.Write.Log(DateTime.Now.ToString()), null, TimeSpan.Zero, new TimeSpan(0, 0, 1)); Console.CancelKeyPress += (sender, eventArgs) => { Console.WriteLine("Shutting down..."); LogManager.Shutdown(); Environment.Exit(0); }; while (true) { Thread.Sleep(100); } }
/// <summary> /// Tests the map. /// </summary> /// <param name="map">The map to execute.</param> /// <param name="xsltExtensionObjectOverrides">The overrides for the XSLT arguments - allowing you to mock external assembly methods.</param> /// <param name="validateInput">if set to <c>true</c> then the input flat file contents and converted XML is validated.</param> /// <param name="validateOutput">if set to <c>true</c> then the output is validated.</param> public void TestMap(TransformBase map, IEnumerable <XsltExtensionObjectDescriptor> xsltExtensionObjectOverrides, bool validateInput, bool validateOutput) { if (map == null) { throw new ArgumentNullException(nameof(map)); } XNode inputXml = BizTalkXmlFlatFileAdapter.ConvertInputFlatFileContentsToInputXml(map, this.InputFlatFileContents); if (validateInput) { BizTalkXmlMapTestValidator.ValidateInputXml(map, inputXml, this.Logger); } Logger.Log("Executing the BizTalk map (flat file to flat file) " + map.GetType().Name); string outputXmlString = BizTalkXmlMapExecutor.PerformTransform(map, xsltExtensionObjectOverrides, inputXml); LogAssert.IsTrue("XML output from the BizTalk map exists", !string.IsNullOrWhiteSpace(outputXmlString)); var actualOutputXml = XElement.Parse(outputXmlString); if (validateOutput) { BizTalkXmlMapTestValidator.ValidateOutputXml(map, actualOutputXml, this.Logger); } var schemaTree = BizTalkMapSchemaUtility.CreateSchemaTreeAndLoadSchema(map, map.TargetSchemas[0]); if (schemaTree.IsStandardXML) { throw new InvalidOperationException("The map does not have a schema for converting to a flat file."); } else { Logger.Log("Converting the XML output of the BizTalk map to a flat file"); this.ActualOutputFlatFileContents = BizTalkXmlFlatFileAdapter.ConvertOutputXmlToOutputFlatFileContents(map, actualOutputXml, validateOutput); } Logger.Log(); Logger.Log("BizTalk map (flat file to flat file) execution completed"); }
public void TestSetRotationEulerAngles() { GraphBuilder.VariableHandle handle = default; var setValue = new float3(-30f, 0f, 0f); SetupTestGraphDefinitionMultipleFrames((b, _) => { handle = b.BindVariableToDataIndex("TestEntity"); var onUpdate = b.AddNode(new OnUpdate()); var enabled = b.AddNode(new ConstantBool { Value = true }); var setRotation = b.AddNode(new SetRotation { }); var quatFromEuler = b.AddNode(new RotationEuler()); var constantRotationValue = b.AddNode(new ConstantFloat3() { Value = setValue }); b.BindVariableToInput(handle, setRotation.GameObject); b.CreateEdge(enabled.ValuePort, onUpdate.Enabled); b.CreateEdge(onUpdate.Output, setRotation.Input); b.CreateEdge(constantRotationValue.ValuePort, quatFromEuler.Euler); b.CreateEdge(quatFromEuler.Value, setRotation.Value); } , (manager, entity, index) => { GraphInstance instance = GetGraphInstance(entity); instance.WriteValueToDataSlot(handle.DataIndex, entity); Assert.That(!manager.HasComponent <Rotation>(entity)); }, (manager, entity, index) => { Rotation rotation = manager.GetComponentData <Rotation>(entity); var q = rotation.Value; Assert.That(q, Is.EqualTo(quaternion.Euler(math.radians(setValue)))); LogAssert.NoUnexpectedReceived(); }); }
public void FindOrSpawnObject_ErrorWhenSpawnHanlderReturnsNull() { const uint netId = 1003; SpawnMessage msg = new SpawnMessage { netId = netId, assetId = validPrefabGuid }; spawnHandlers.Add(validPrefabGuid, (x) => { return(null); }); LogAssert.Expect(LogType.Error, $"Spawn Handler returned null, Handler assetId '{msg.assetId}'"); LogAssert.Expect(LogType.Error, $"Could not spawn assetId={msg.assetId} scene={msg.sceneId} netId={msg.netId}"); bool success = ClientScene.FindOrSpawnObject(msg, out NetworkIdentity networkIdentity); Assert.IsFalse(success); Assert.IsNull(networkIdentity); }
public void WhenAssetHasANullRepresentation_LogsWarning() { // Create an asset string assetPath = Path.Combine(kTestAssetFolder, "myPrefab.prefab"); GUID guid = CreateGameObject(assetPath); CalculateAssetDependencyData.TaskInput input = CreateDefaultInput(); input.Assets = new List <GUID>() { guid }; input.EngineHooks = new NullLoadRepresentationFake(); LogAssert.Expect(LogType.Warning, new Regex(".+It will not be included in the build")); CalculateAssetDependencyData.RunInternal(input, out CalculateAssetDependencyData.TaskOutput output); Assert.AreEqual(guid, output.AssetResults[0].asset); Assert.AreEqual(2, output.AssetResults[0].assetInfo.includedObjects.Count); // GameObject and Transform Assert.AreEqual(0, output.AssetResults[0].assetInfo.referencedObjects.Count); }
public void CreatePipelineAssetWithoutErrors() { // Test without any render pipeline assigned to GraphicsSettings. var renderPipelineAsset = GraphicsSettings.renderPipelineAsset; GraphicsSettings.renderPipelineAsset = null; try { UniversalRendererData data = ScriptableObject.CreateInstance <UniversalRendererData>(); UniversalRenderPipelineAsset asset = UniversalRenderPipelineAsset.Create(data); LogAssert.NoUnexpectedReceived(); ScriptableObject.DestroyImmediate(asset); ScriptableObject.DestroyImmediate(data); } // Makes sure the render pipeline is restored in case of a NullReference exception. finally { GraphicsSettings.renderPipelineAsset = renderPipelineAsset; } }
public void SendCalledWhileNotActive_ShouldGiveWarning(string functionName) { LogAssert.Expect(LogType.Warning, $"Can not send using NetworkServer.{functionName}<T>(T msg) because NetworkServer is not active"); switch (functionName) { case nameof(NetworkServer.SendToAll): NetworkServer.SendToAll(new NetworkPingMessage { }); break; case nameof(NetworkServer.SendToReady): NetworkServer.SendToReady(new NetworkPingMessage { }); break; default: Debug.LogError("Could not find function name"); break; } }
public IEnumerator FailGracefullyWhenIdsCannotBeResolved() { avatarModel.wearables = new List <string>() { "Scioli_right_arm", "Peron_hands" }; avatarModel.bodyShape = "Invalid_id"; avatarRenderer.SetVisibility(true); bool success = false; avatarRenderer.ApplyModel(avatarModel, () => success = true, null); yield return(new DCL.WaitUntil(() => success, 4)); LogAssert.Expect(LogType.Error, "Bodyshape Invalid_id not found in catalog"); LogAssert.Expect(LogType.Error, "Wearable Scioli_right_arm not found in catalog"); LogAssert.Expect(LogType.Error, "Wearable Peron_hands not found in catalog"); UnityEngine.Assertions.Assert.IsTrue(success); }
public IEnumerator SetupThrows_ShouldDisable() { ResetScene(); yield return(new EnterPlayMode()); var mockLabeler = new Mock <CameraLabeler>(); mockLabeler.Protected().Setup("Setup").Throws <InvalidOperationException>(); var labeler = mockLabeler.Object; var camera = SetupCamera(null); camera.GetComponent <PerceptionCamera>().AddLabeler(labeler); LogAssert.Expect(LogType.Exception, "InvalidOperationException: Operation is not valid due to the current state of the object."); yield return(null); mockLabeler.Protected().Verify("Setup", Times.Once()); mockLabeler.Protected().Verify("OnUpdate", Times.Never()); mockLabeler.Protected().Verify("OnBeginRendering", Times.Never()); Assert.IsFalse(labeler.enabled); yield return(new ExitPlayMode()); }
public void NativeBitArray_CreateAndUseAfterFreeInBurstJob_UsesCustomOwnerTypeName() { // Make sure this isn't the first container of this type ever created, so that valid static safety data exists var numBits = 256; var test = new NativeBitArray(numBits, Allocator.Persistent, NativeArrayOptions.ClearMemory); test.Dispose(); var job = new NativeBitArrayCreateAndUseAfterFreeBurst { }; // Two things: // 1. This exception is logged, not thrown; thus, we use LogAssert to detect it. // 2. Calling write operation after container.Dispose() emits an unintuitive error message. For now, all this test cares about is whether it contains the // expected type name. job.Run(); LogAssert.Expect(LogType.Exception, new Regex($"InvalidOperationException: The {Regex.Escape(test.GetType().ToString())} has been declared as \\[ReadOnly\\] in the job, but you are writing to it")); }
public void LogResult_SupportFormattingCharacters() { var pipeline = BuildPipeline.CreateInstance(); var config = BuildConfiguration.CreateInstance(); var resultSuccess = BuildPipelineResult.Success(pipeline, config); Assert.DoesNotThrow(() => { LogAssert.Expect(LogType.Log, new Regex(@"Build succeeded after .+\.")); resultSuccess.LogResult(); }); var resultFailure = BuildPipelineResult.Failure(pipeline, config, @"{}{{}}{0}{s}%s%%\s±@£¢¤¬¦²³¼½¾"); Assert.DoesNotThrow(() => { LogAssert.Expect(LogType.Error, new Regex(@"Build failed after .+\.\n.+")); resultFailure.LogResult(); }); }
public static void ExtrudeAllFaces_IndividualFaces() { using (var shapes = new TestUtility.BuiltInPrimitives()) { foreach (var pb in (IEnumerable <ProBuilderMesh>)shapes) { int vertexCountBeforeExtrude = pb.vertexCount; pb.Extrude(pb.facesInternal, ExtrudeMethod.IndividualFaces, .5f); pb.ToMesh(); pb.Refresh(); LogAssert.NoUnexpectedReceived(); Assert.AreNotEqual(vertexCountBeforeExtrude, pb.vertexCount); TestUtility.AssertMeshAttributesValid(pb.mesh); #if PB_CREATE_TEST_MESH_TEMPLATES TestUtility.SaveAssetTemplate(pb.mesh, pb.name); #endif Mesh template = TestUtility.GetAssetTemplate <Mesh>(pb.name); TestUtility.AssertAreEqual(template, pb.mesh, message: pb.name); } } }
public void Branch_InsertTree_ReturnsFalse() { const int branchUserID = 10; const int treeUserID = 11; var tree = CSGTree.Create(treeUserID); var branch = CSGTreeBranch.Create(branchUserID); CompactHierarchyManager.ClearDirty(tree); CompactHierarchyManager.ClearDirty(branch); var result = branch.Insert(0, tree); LogAssert.Expect(LogType.Error, new Regex("Cannot add a tree as a child")); Assert.IsFalse(result); TestUtility.ExpectValidBranchWithUserID(ref branch, branchUserID); TestUtility.ExpectValidTreeWithUserID(ref tree, treeUserID); Assert.IsFalse(tree.Dirty); Assert.IsFalse(branch.Dirty); Assert.AreEqual(0, branch.Count); }
public IEnumerator UnloadingScene_Synchronously_LogsWarning() { var loadOp = m_Addressables.LoadSceneAsync(m_SceneKey, LoadSceneMode.Additive); loadOp.WaitForCompletion(); yield return(loadOp); var unloadOp = m_Addressables.UnloadSceneAsync(loadOp, UnloadSceneOptions.None, false); LogAssert.Expect(LogType.Warning, "Cannot unload a Scene with WaitForCompletion. Scenes must be unloaded asynchronously."); unloadOp.WaitForCompletion(); yield return(unloadOp); Assert.AreEqual(AsyncOperationStatus.Succeeded, unloadOp.Status); Assert.IsTrue(unloadOp.IsValid()); Assert.IsTrue(unloadOp.IsDone); //Cleanup ReleaseOp(unloadOp); ReleaseOp(loadOp); }
public void WhenPipelineFails_StepsAndCleanupRan([Values] bool shouldThrow) { var context = CreateTestContext(); var pipeline = ScriptableObject.CreateInstance <BuildPipeline>(); pipeline.AddSteps(new TestStep1(), new FailStep { Throw = shouldThrow }, new TestStep2()); LogAssert.Expect(LogType.Error, s_BuildFailureRegex); pipeline.RunSteps(context); var runResults = context.Get <StepRunResults>(); Assert.That(runResults.stepsRan, Is.EqualTo(new[] { "step1", "fail" })); var cleanResults = context.Get <StepCleanupResults>(); Assert.That(cleanResults.stepsCleaned, Is.EqualTo(new[] { "fail", "step1" })); }