public IEnumerator CancelTaskRoutineShouldCancelTaskYetTest()
{
bool?cancellationExit = null;
Routine.Task(token =>
{
var timeMeter = TimeMeter.New();
while (timeMeter.ToSeconds() < 1)
{
Thread.Sleep(15);
if (token.IsCancellationRequested)
{
cancellationExit = true;
return;
}
}
cancellationExit = false;
}).Self(out var taskRoutine).InBackground();
yield return(Routine.Delay(0.1f));
taskRoutine.Cancel();
// Отклик на отмену задачи ~15 мс ( Thread.Sleep(15) ), поэтому нужно немного подождать
yield return(Routine.Delay(0.03f));
Assert.NotNull(cancellationExit);
Assert.True(cancellationExit);
}
public IEnumerator RoutineShouldBeTrueWhenRoutineIsNotProcessingTest()
{
yield return(Routine.Delay(0.025f)
.Self(out var routine));
Assert.True(routine);
}
public IEnumerator RoutineShouldBeTrueWhenRoutineIsCompleted()
{
var routine = Routine.Delay(0.025f);
yield return(routine);
Assert.True(routine); // completed
}
public void SynchronousCompleteRoutineShouldThrowExceptionByTimeoutTest()
{
var timeOut = 0.175f;
var delay = timeOut * 2 + 1;
var routine = Routine.Delay(delay);
Assert.Throws <TimeoutException>(() => routine.Complete(timeOut));
}
public void DelayRoutineShouldCompleteSynchronousTest()
{
var delay = 0.15f;
var startTime = DateTime.Now;
Routine.Delay(delay).Complete();
var deltaTime = (DateTime.Now - startTime).TotalSeconds;
Assert.Greater(deltaTime, delay);
}
public IEnumerator CancelDelayRoutineShouldBeCancelTest()
{
var timeMeter = TimeMeter.New();
var routine = Routine.Delay(1);
routine.Cancel();
yield return(routine);
var elapsed = timeMeter.ToSeconds();
Assert.Less(elapsed, 1f);
}
public IEnumerator RoutineShouldCompleteWhenHisRoutinesIsCompletedTest()
{
var routineWithDelay160Ms = Routine.Delay(TimeSpan.FromMilliseconds(160));
var routineWithDelay150Ms = Routine.Delay(TimeSpan.FromMilliseconds(150));
var startTestTime = DateTime.Now;
yield return(Routine.WhenAll(routineWithDelay160Ms, routineWithDelay150Ms));
var deltaTime = DateTime.Now - startTestTime;
Assert.Greater(TimeSpan.FromMilliseconds(160 + 150).TotalSeconds, deltaTime.TotalSeconds);
}
public void DelayRoutineShouldFulfilledSetTimeWhenUserUseForceCompleteTest()
{
var targetTime = TimeSpan.FromMilliseconds(50);
var startTime = DateTime.Now;
var scheduledReleaseTime = startTime + targetTime;
Routine.Delay(targetTime).Complete();
var delta = (DateTime.Now - scheduledReleaseTime).TotalSeconds;
Assert.Positive(delta);
Assert.GreaterOrEqual(Time.unscaledDeltaTime, delta);
}
public IEnumerator DelayRoutineShouldFulfilledSetTimeTest()
{
var targetTime = TimeSpan.FromMilliseconds(50);
var startTime = DateTime.Now;
var scheduledReleaseTime = startTime + targetTime;
yield return(Routine.Delay(targetTime));
var delta = (DateTime.Now - scheduledReleaseTime).TotalSeconds;
Assert.Positive(delta);
Assert.GreaterOrEqual(Time.unscaledDeltaTime, delta);
}
public IEnumerator DelayInBackgroundShouldCompleteTest()
{
var interval = TimeSpan.FromMilliseconds(100);
var delay = Routine.Delay(interval);
delay.InBackground();
var startTime = Time.time;
while (!delay.IsComplete && startTime + interval.TotalSeconds * 2 > Time.time)
{
yield return(null);
}
Assert.True(delay.IsComplete);
}
public void ComplexRoutineShouldCompleteSynchronousTest()
{
var complexLevel = 5;
Routine CreateRoutine(int level, float delay)
{
return(level == 0
? (Routine)Routine.Delay(delay)
: new TestRoutine(CreateRoutine(level - 1, delay)));
}
var startTime = DateTime.Now;
CreateRoutine(complexLevel, 0.15f).Complete();
var deltaTime = (DateTime.Now - startTime).TotalSeconds;
Assert.Greater(deltaTime, 0.15f);
}
public IEnumerator WaitingRoutineWhichIsProcessedFromOutsideTest()
{
var gameObject = new GameObject();
var testMonoBehaviour = gameObject.AddComponent <TestMonoBehaviour>();
var delay = TimeSpan.FromMilliseconds(75);
var delayRoutine = Routine.Delay(delay);
testMonoBehaviour.StartCoroutine(delayRoutine);
var startTime = DateTime.UtcNow;
yield return(delayRoutine);
var delta = DateTime.UtcNow - startTime;
Utilities.Object.AutoDestroy(gameObject);
Assert.GreaterOrEqual(delta, delay);
}
public void RoutineShouldBeFalseWhenRoutineIsNotStartedTest()
{
var routine = Routine.Delay(0.025f);
Assert.False(routine); // not started
}
public void DelayRoutineShouldCompleteWhenUserUseForceCompleteTest()
{
var targetTime = TimeSpan.FromMilliseconds(50);
Routine.Delay(targetTime).Complete();
}