private IEnumerator WaitForNestedCoroutinesDepthOne() { yield return(new WaitForSeconds(2f)); Debug.Log("EditorCoroutine Demo. Nested routine depth 1. Waiting for nested coroutines to finish now."); yield return(EditorCoroutineService.StartCoroutine(WaitForNestedCoroutinesDepthTwo())); }
public IEnumerator StopAllCoroutines_SpecificOwnerArg_StopsAllCoroutinesCorrectly() { OwnerOfRoutine ownerA = new OwnerOfRoutine(); RefBool wasCancelledA = new RefBool(); RefBool wasCancelledB = new RefBool(); // Test coroutines will be stopped. Check in 1 second for expected results. Test coroutines should finish by then, successfully or not. DateTime then = DateTime.Now; const double secondsToWait = 1; TestContext.WriteLine("Starting SimpleIteratorToBeStoppedB and ownerA.SimpleIteratorToBeStoppedA routines.\nWill automatically attempt to stop routines belonging to ownerA after a frame."); // All the following coroutines will be attempted to be cancelled after 1 frame, in the line after the following `yield return null`. EditorCoroutineService.StartCoroutine(ownerA, "SimpleIteratorToBeStoppedA", new object[] { wasCancelledA }); EditorCoroutineService.StartCoroutine(SimpleIteratorToBeStoppedB(wasCancelledB)); yield return(null); EditorCoroutineService.StopAllCoroutines(ownerA); double deltaSeconds = (DateTime.Now - then).TotalSeconds; while (deltaSeconds < secondsToWait) { yield return(null); deltaSeconds = (DateTime.Now - then).TotalSeconds; } Assert.IsTrue(wasCancelledA.Value && !wasCancelledB.Value, "EditorCoroutines belonging to a specific owner were not stopped correctly."); }
private void OnGUI() { if (GUILayout.Button("Wait for two seconds")) { _loopEveryTwoSecondsHandle = EditorCoroutineService.StartCoroutine(WaitForTwoSeconds()); } if (GUILayout.Button("Wait for 20 frames")) { EditorCoroutineService.StartCoroutine(WaitForTwentyFrames()); } if (GUILayout.Button("Wait for UnityWebRequest")) { EditorCoroutineService.StartCoroutine(WaitForUnityWebRequest()); } if (GUILayout.Button("Wait for nested coroutines")) { EditorCoroutineService.StartCoroutine(WaitForNestedCoroutines()); } if (GUILayout.Button("Stop 'Wait for two seconds' coroutine")) { if (_loopEveryTwoSecondsHandle != null) { EditorCoroutineService.StopCoroutine(_loopEveryTwoSecondsHandle); } } if (GUILayout.Button("Stop all")) { EditorCoroutineService.StopAllCoroutines(); } }
private IEnumerator WaitForNestedCoroutinesDepthOne() { yield return(new WaitForSeconds(2f)); CustomLog("嵌套一层协程"); yield return(EditorCoroutineService.StartCoroutine(WaitForNestedCoroutinesDepthTwo())); }
public IEnumerator StartCoroutine_IEnumeratorArg_StartsCorrectly() { RefBool isTestComplete = new RefBool(); EditorCoroutineService.StartCoroutine(SimpleIterator(isTestComplete)); yield return(null); Assert.IsTrue(isTestComplete.Value, "EditorCoroutine was not started correctly via IEnumerator arg."); }
private IEnumerator WaitForNestedCoroutines() { while (true) { yield return(new WaitForSeconds(2f)); CustomLog("2秒进入另一个嵌套协程."); yield return(EditorCoroutineService.StartCoroutine(WaitForNestedCoroutinesDepthOne())); } }
private IEnumerator WaitForNestedCoroutines() { while (true) { yield return(new WaitForSeconds(2f)); Debug.Log("EditorCoroutine Demo. Parent coroutine. Logging again after nested coroutines finish + 2 seconds..."); yield return(EditorCoroutineService.StartCoroutine(WaitForNestedCoroutinesDepthOne())); } }
public IEnumerator StartCoroutine_MethodNameArg_StartsCorrectly() { RefBool isTestComplete = new RefBool(); object owner = this; const string methodName = "SimpleIterator"; EditorCoroutineService.StartCoroutine(owner, methodName, new object[] { isTestComplete }); yield return(null); Assert.IsTrue(isTestComplete.Value, $"EditorCoroutine was not started correctly via method name {methodName}."); }
private IEnumerator ReturnAfterCustomYieldInstructionSucceeds(RefBool isTestComplete) { TestContext.WriteLine("In ReturnAfterCustomYieldInstructionSucceeds routine. Starting."); EditorCoroutineService.StartCoroutine(SetIndexAfterSeconds(2f)); yield return(new CustomWaitWhile(IsIndexStillZero)); TestContext.WriteLine("In ReturnAfterCustomYieldInstructionSucceeds routine. Finished."); isTestComplete.Value = true; bool IsIndexStillZero() { return(_customIndex == 0); } }
public IEnumerator StartCoroutine_CustomYieldInstruction_ReturnsCorrectly() { RefBool isTestComplete = new RefBool(); _customIndex = 0; EditorCoroutineService.StartCoroutine(ReturnAfterCustomYieldInstructionSucceeds(isTestComplete)); while (!isTestComplete.Value) { yield return(null); } Assert.AreEqual(1, _customIndex, "EditorCoroutine yielding on a CustomYieldInstruction was not returned correctly."); }
public IEnumerator StartCoroutine_IndependentCoroutinesInParallel_ReturnInCorrectOrder() { RefBool isTestComplete = new RefBool(); _parallelRoutinesTracker = new Queue <char> (); EditorCoroutineService.StartCoroutine(ReturnAfterRoutinesRunInParallel(isTestComplete)); while (!isTestComplete.Value) { yield return(null); } Assert.AreEqual(0, _parallelRoutinesTracker.Count, "EditorCoroutines started in parallel were not run in the correct order."); }
private IEnumerator ReturnAfterRoutinesRunInParallel(RefBool isTestComplete) { const float secondsToWaitInEachRoutine = 2f; const float secondRoutineStartDelay = 0.5f; TestContext.WriteLine("In ReturnAfterRoutinesRunInParallel routine. Starting."); _parallelRoutinesTracker.Enqueue('a'); EditorCoroutineService.StartCoroutine(ReturnAfterSecondsA(secondsToWaitInEachRoutine)); TestContext.WriteLine($"In ReturnAfterRoutinesRunInParallel routine. Waiting for {secondRoutineStartDelay} seconds."); yield return(new WaitForSeconds(secondRoutineStartDelay)); _parallelRoutinesTracker.Enqueue('b'); EditorCoroutineService.StartCoroutine(ReturnAfterSecondsB(secondsToWaitInEachRoutine, isTestComplete)); TestContext.WriteLine("In ReturnAfterRoutinesRunInParallel routine. Finished, though an EditorCoroutine started in parallel may still be running."); }
public IEnumerator StartCoroutine_YieldWaitForAsyncOperation_ReturnsCorrectly() { RefBool isTestComplete = new RefBool(); _webRequestData = null; const string uri = "http://httpbin.org/get"; EditorCoroutineService.StartCoroutine(ReturnAfterWebRequest(uri, isTestComplete)); while (!isTestComplete.Value) { yield return(null); } Assert.IsNotNull(_webRequestData, $"WebRequest EditorCoroutine did not return any data.\nThis may be an issue with the URI {uri} itself, but for now, this test has failed."); }
public IEnumerator StartCoroutine_YieldWaitForNestedCoroutines_ReturnsInCorrectOrder() { RefBool isTestComplete = new RefBool(); _nestedRoutinesTracker = new Stack <int> (); for (int i = 0; i < 3; i++) { _nestedRoutinesTracker.Push(i); } EditorCoroutineService.StartCoroutine(ReturnAfterNestedRoutines(isTestComplete)); while (!isTestComplete.Value) { yield return(null); } Assert.AreEqual(0, _nestedRoutinesTracker.Count, "Nested EditorCoroutines were not run in the correct order."); }
public IEnumerator StartCoroutine_YieldWaitForSeconds_SuccessAfterSeconds() { RefBool isTestComplete = new RefBool(); DateTime then = DateTime.Now; const float secondsToWait = 2f; EditorCoroutineService.StartCoroutine(ReturnAfterSeconds(secondsToWait, isTestComplete)); while (!isTestComplete.Value) { yield return(null); } double deltaSeconds = (DateTime.Now - then).TotalSeconds; Assert.AreEqual(secondsToWait, deltaSeconds, 0.024, // A little over a single frame margin of error at 60 fps, which Unity Editor _definitely_ runs at. /s $"WaitForSeconds EditorCoroutine returned in {deltaSeconds}, when expected to return in {secondsToWait} seconds."); }
private IEnumerator ReturnAfterNestedRoutinesDepthOne() { const float secondsToWait = 1f; TestContext.WriteLine("In nested routine depth one. Starting."); yield return(new WaitForSeconds(secondsToWait)); yield return(EditorCoroutineService.StartCoroutine(ReturnAfterNestedRoutinesDepthTwo())); if (_nestedRoutinesTracker.Count == 2) { _nestedRoutinesTracker.Pop(); } else { throw new Exception("Nested routine depth one is run in wrong order."); } TestContext.WriteLine("In nested routine depth one. Finished."); }
private IEnumerator ReturnAfterNestedRoutines(RefBool isTestComplete) { const float secondsToWait = 1f; TestContext.WriteLine("In parent routine. Starting."); yield return(new WaitForSeconds(secondsToWait)); yield return(EditorCoroutineService.StartCoroutine(ReturnAfterNestedRoutinesDepthOne())); if (_nestedRoutinesTracker.Count == 1) { _nestedRoutinesTracker.Pop(); } else { throw new Exception("Parent routine is run in wrong order."); } isTestComplete.Value = true; TestContext.WriteLine("In parent routine. Finished."); }
public IEnumerator StopCoroutine_MethodName_StopsCorrectly() { RefBool isTestComplete = new RefBool(); RefBool wasCancelled = new RefBool(); // Test coroutine will be stopped. Check in 1 second for expected results. Test coroutine should finish by then, successfully or not. EditorCoroutineService.StartCoroutine(ReturnAfterSecondsToBeStopped(1f, isTestComplete)); TestContext.WriteLine("Starting SimpleIteratorToBeStopped routine.\nWill automatically attempt to stop it after a frame."); // This coroutine will be attempted to be cancelled after 1 frame, in the line after the following `yield return null`. EditorCoroutineService.StartCoroutine(this, "SimpleIteratorToBeStopped", new object[] { wasCancelled }); yield return(null); EditorCoroutineService.StopCoroutine(this, "SimpleIteratorToBeStopped"); while (!isTestComplete.Value) { yield return(null); } Assert.IsTrue(wasCancelled.Value, "EditorCoroutine was not stopped correctly via Method Name arg."); }
private void Button_3() { EditorCoroutineService.StartCoroutine(WaitForNestedCoroutines()); }
private void Button_2() { EditorCoroutineService.StartCoroutine(WaitForUnityWebRequest()); }
private void Button_1() { EditorCoroutineService.StartCoroutine(WaitForTwentyFrames()); }
private void Button_0() { loopEveryTwoSecondsHandle = EditorCoroutineService.StartCoroutine(WaitForTwoSeconds()); }