From 41017b5f8a6bc18eba88740daa638e2b739b4b53 Mon Sep 17 00:00:00 2001 From: Zaafar Date: Thu, 18 Mar 2021 16:35:12 -0400 Subject: [PATCH] few more test-cases --- Tests/EventBasedCoroutineTests.cs | 203 ++++++++++++++++++++++++++++++ 1 file changed, 203 insertions(+) diff --git a/Tests/EventBasedCoroutineTests.cs b/Tests/EventBasedCoroutineTests.cs index eb90b10..c8fd3c7 100644 --- a/Tests/EventBasedCoroutineTests.cs +++ b/Tests/EventBasedCoroutineTests.cs @@ -28,5 +28,208 @@ namespace Tests { Assert.AreEqual(cr.MoveNextCount, 2, "Incorrect MoveNextCount value."); } + [Test] + public void TestInfiniteCoroutineNeverFinishesUnlessCanceled() { + var myEvent = new Event(); + var myOtherEvent = new Event(); + var counter = 0; + + IEnumerator OnEventTriggeredInfinite() { + while (true) { + counter++; + yield return new Wait(myEvent); + } + } + + void SetCounterToUnreachableValue(ActiveCoroutine coroutine) { + counter = -100; + } + + var cr = CoroutineHandler.Start(OnEventTriggeredInfinite()); + cr.OnFinished += SetCounterToUnreachableValue; + for (var i = 0; i < 50; i++) + CoroutineHandler.RaiseEvent(myOtherEvent); + + for (var i = 0; i < 50; i++) + CoroutineHandler.RaiseEvent(myEvent); + + Assert.AreEqual(51, counter, "Incorrect counter value."); + Assert.AreEqual(false, cr.IsFinished, "Incorrect IsFinished value."); + Assert.AreEqual(false, cr.WasCanceled, "Incorrect IsCanceled value."); + Assert.AreEqual(51, cr.MoveNextCount, "Incorrect MoveNextCount value."); + + cr.Cancel(); + Assert.AreEqual(true, cr.WasCanceled, "Incorrect IsCanceled value after canceling."); + Assert.AreEqual(-100, counter, "OnFinished event not triggered when canceled."); + Assert.AreEqual(51, cr.MoveNextCount, "Incorrect MoveNextCount value."); + Assert.AreEqual(true, cr.IsFinished, "Incorrect IsFinished value."); + } + + [Test] + public void TestOnFinishedEventExecuted() { + var myEvent = new Event(); + var counter = 0; + + IEnumerator OnEvent() { + counter++; + yield return new Wait(myEvent); + } + + void SetCounterToUnreachableValue(ActiveCoroutine coroutine) { + counter = -100; + } + + var cr = CoroutineHandler.Start(OnEvent()); + cr.OnFinished += SetCounterToUnreachableValue; + for (int i = 0; i < 10; i++) + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(-100, counter, "Incorrect counter value."); + } + + [Test] + public void TestNestedCoroutine() { + var myEvent = new Event(); + var counterAlwaysRunning = 0; + + IEnumerator AlwaysRunning() { + while (true) { + yield return new Wait(myEvent); + counterAlwaysRunning++; + } + } + + var counterChild = 0; + + IEnumerator Child() { + yield return new Wait(myEvent); + counterChild++; + } + + var counterParent = 0; + + IEnumerator Parent() { + yield return new Wait(myEvent); + counterParent++; + // OnFinish I will start child. + } + + var counterGrandParent = 0; + + IEnumerator GrandParent() { + yield return new Wait(myEvent); + counterGrandParent++; + // Nested corotuine starting. + var p = CoroutineHandler.Start(Parent()); + // Nested corotuine starting in OnFinished. + p.OnFinished += ac => CoroutineHandler.Start(Child()); + } + + CoroutineHandler.Start(AlwaysRunning()); + CoroutineHandler.Start(GrandParent()); + Assert.AreEqual(0, counterAlwaysRunning, "Always running counter is invalid at event 0."); + Assert.AreEqual(0, counterGrandParent, "Grand Parent counter is invalid at event 0."); + Assert.AreEqual(0, counterParent, "Parent counter is invalid at event 0."); + Assert.AreEqual(0, counterChild, "Child counter is invalid at event 0."); + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(1, counterAlwaysRunning, "Always running counter is invalid at event 1."); + Assert.AreEqual(1, counterGrandParent, "Grand Parent counter is invalid at event 1."); + Assert.AreEqual(0, counterParent, "Parent counter is invalid at event 1."); + Assert.AreEqual(0, counterChild, "Child counter is invalid at event 1."); + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(2, counterAlwaysRunning, "Always running counter is invalid at event 2."); + Assert.AreEqual(1, counterGrandParent, "Grand Parent counter is invalid at event 2."); + Assert.AreEqual(1, counterParent, "Parent counter is invalid at event 2."); + Assert.AreEqual(0, counterChild, "Child counter is invalid at event 2."); + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(3, counterAlwaysRunning, "Always running counter is invalid at event 3."); + Assert.AreEqual(1, counterGrandParent, "Grand Parent counter is invalid at event 3."); + Assert.AreEqual(1, counterParent, "Parent counter is invalid at event 3."); + Assert.AreEqual(1, counterChild, "Child counter is invalid at event 3."); + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(4, counterAlwaysRunning, "Always running counter is invalid at event 4."); + Assert.AreEqual(1, counterGrandParent, "Grand Parent counter is invalid at event 4."); + Assert.AreEqual(1, counterParent, "Parent counter is invalid at event 4."); + Assert.AreEqual(1, counterChild, "Child counter is invalid at event 4."); + } + + [Test] + public void TestPriority() { + var myEvent = new Event(); + var counterShouldExecuteBefore0 = 0; + + IEnumerator ShouldExecuteBefore0() { + while (true) { + yield return new Wait(myEvent); + counterShouldExecuteBefore0++; + } + } + + var counterShouldExecuteBefore1 = 0; + + IEnumerator ShouldExecuteBefore1() { + while (true) { + yield return new Wait(myEvent); + counterShouldExecuteBefore1++; + } + } + + var counterShouldExecuteAfter = 0; + + IEnumerator ShouldExecuteAfter() { + while (true) { + yield return new Wait(myEvent); + if (counterShouldExecuteBefore0 == 1 && + counterShouldExecuteBefore1 == 1) { + counterShouldExecuteAfter++; + } + } + } + + var counterShouldExecuteFinally = 0; + + IEnumerator ShouldExecuteFinally() { + while (true) { + yield return new Wait(myEvent); + if (counterShouldExecuteAfter > 0) { + counterShouldExecuteFinally++; + } + } + } + + var highPriority = int.MaxValue; + CoroutineHandler.Start(ShouldExecuteBefore1(), priority: highPriority); + CoroutineHandler.Start(ShouldExecuteAfter()); + CoroutineHandler.Start(ShouldExecuteBefore0(), priority: highPriority); + CoroutineHandler.Start(ShouldExecuteFinally(), priority: -1); + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(1, counterShouldExecuteAfter, $"ShouldExecuteAfter counter {counterShouldExecuteAfter} is invalid."); + Assert.AreEqual(1, counterShouldExecuteFinally, $"ShouldExecuteFinally counter {counterShouldExecuteFinally} is invalid."); + } + + [Test] + public void InvokeLaterAndNameTest() { + var myEvent = new Event(); + var counter = 0; + var cr = CoroutineHandler.InvokeLater(new Wait(myEvent), () => { + counter++; + }, "Bird"); + + CoroutineHandler.InvokeLater(new Wait(myEvent), () => { + counter++; + }); + + CoroutineHandler.InvokeLater(new Wait(myEvent), () => { + counter++; + }); + + Assert.AreEqual(0, counter, "Incorrect counter value after 5 seconds."); + CoroutineHandler.RaiseEvent(myEvent); + Assert.AreEqual(3, counter, "Incorrect counter value after 10 seconds."); + Assert.AreEqual(true, cr.IsFinished, "Incorrect IsFinished value."); + Assert.AreEqual(false, cr.WasCanceled, "Incorrect IsCanceled value."); + Assert.AreEqual(cr.MoveNextCount, 2, "Incorrect MoveNextCount value."); + Assert.AreEqual(cr.Name, "Bird", "Incorrect name of the coroutine."); + } + } } \ No newline at end of file