public IEnumerator ActivationEventsAreEmitted()
{
// Setup Condition
TimeoutCondition condition = new TimeoutCondition(0.1f);
bool isActivationStarted = false;
bool isActivated = false;
condition.LifeCycle.StageChanged += (sender, args) =>
{
if (args.Stage == Stage.Activating)
{
isActivationStarted = true;
}
if (args.Stage == Stage.Active)
{
isActivated = true;
}
};
// Activate condition and wait
condition.LifeCycle.Activate();
while (condition.LifeCycle.Stage != Stage.Active)
{
yield return(null);
condition.Update();
}
// Check events got called
Assert.IsTrue(isActivationStarted, "TimeoutCondition was not activated");
Assert.IsTrue(isActivated, "TimeoutCondition did not call activated");
}
public IEnumerator ConditionIsCompleted()
{
// Given a TimeoutCondition which is completed after 200ms.
float targetDuration = 0.2f;
TimeoutCondition condition = new TimeoutCondition(targetDuration);
// When the condition is activated.
condition.LifeCycle.Activate();
// Activation frame
yield return(null);
condition.Update();
float startTime = Time.time;
while (condition.IsCompleted == false)
{
yield return(null);
condition.Update();
}
float duration = Time.time - startTime;
// Then the condition is completed after the specified time.
Assert.AreEqual(targetDuration, duration, Time.deltaTime);
Assert.IsTrue(condition.IsCompleted, "TimeoutCondition is not completed but should be!");
}
public IEnumerator ConditionCompletedAfterTimingBehaviorInStep()
{
float targetDuration = 0.5f;
Step step = new Step("Step1");
ICondition condition = new TimeoutCondition(targetDuration, "Timeout1");
Transition transition = new Transition();
IBehavior behavior = new TimeoutBehaviorMock(targetDuration, targetDuration);
transition.Data.Conditions.Add(condition);
step.Data.Transitions.Data.Transitions.Add(transition);
step.Data.Behaviors.Data.Behaviors.Add(behavior);
step.Configure(RuntimeConfigurator.Configuration.Modes.CurrentMode);
step.LifeCycle.Activate();
// Activation frame
yield return(null);
step.Update();
float startTime = Time.time;
while (behavior.LifeCycle.Stage != Stage.Active)
{
yield return(null);
step.Update();
}
float behaviorDuration = Time.time - startTime;
Assert.AreEqual(targetDuration, behaviorDuration, Time.deltaTime);
Assert.IsFalse(condition.IsCompleted);
// Process frames
yield return(null);
step.Update();
yield return(null);
step.Update();
yield return(null);
step.Update();
startTime = Time.time;
while (condition.IsCompleted == false)
{
yield return(null);
step.Update();
}
float conditionDuration = Time.time - startTime;
Assert.AreEqual(targetDuration, conditionDuration, 2 * Time.deltaTime);
Assert.IsTrue(condition.IsCompleted);
}
public IEnumerator ConditionIsNotCompleted()
{
// Create TimeoutCondition which is completed after 100ms
TimeoutCondition condition = new TimeoutCondition(0.1f);
// Start counter
condition.LifeCycle.Activate();
yield return(null);
condition.Update();
// Condition should be active now
Assert.AreEqual(condition.LifeCycle.Stage, Stage.Active, "TimeoutCondition is not active");
// Check if condition is still not completed
Assert.IsFalse(condition.IsCompleted, "TimeoutCondition is already completed!");
}
public IEnumerator ConditionIsActivated()
{
// Setup Condition
TimeoutCondition condition = new TimeoutCondition(0.2f);
// Activate condition and wait
condition.LifeCycle.Activate();
float startTime = Time.time;
while (Time.time < startTime + 0.1f)
{
yield return(null);
condition.Update();
}
// Check state is correct
Assert.AreEqual(condition.LifeCycle.Stage, Stage.Active, "TimeoutCondition should be active");
}
public IEnumerator FastForwardDoesNotCompleteCondition()
{
// Given a timeout condition
TimeoutCondition condition = new TimeoutCondition(0.1f);
condition.LifeCycle.Activate();
while (condition.LifeCycle.Stage != Stage.Active)
{
yield return(null);
condition.Update();
}
// When you fast-forward it
condition.LifeCycle.MarkToFastForward();
// Then nothing happens.
Assert.AreEqual(Stage.Active, condition.LifeCycle.Stage);
Assert.IsFalse(condition.IsCompleted);
}
public IEnumerator AutoCompleteActive()
{
// Given a timeout condition
TimeoutCondition condition = new TimeoutCondition(0.1f);
// When you activate and autocomplete it,
condition.LifeCycle.Activate();
while (condition.LifeCycle.Stage != Stage.Active)
{
yield return(null);
condition.Update();
}
condition.Autocomplete();
// Then it is completed.
Assert.AreEqual(Stage.Active, condition.LifeCycle.Stage);
Assert.IsTrue(condition.IsCompleted);
}
public IEnumerator TimeoutCondition()
{
// Given a training with a timeout condition
ICourse training1 = new LinearTrainingBuilder("Training")
.AddChapter(new LinearChapterBuilder("Chapter")
.AddStep(new BasicStepBuilder("Step")
.AddCondition(new TimeoutCondition(2.5f))))
.Build();
// When we serialize and deserialize it
ICourse training2 = Serializer.CourseFromByteArray((Serializer.CourseToByteArray(training1)));
// Then that condition's timeout value should stay unchanged.
TimeoutCondition condition1 = training1.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First() as TimeoutCondition;
TimeoutCondition condition2 = training2.Data.FirstChapter.Data.FirstStep.Data.Transitions.Data.Transitions.First().Data.Conditions.First() as TimeoutCondition;
Assert.IsNotNull(condition1);
Assert.IsNotNull(condition2);
Assert.AreEqual(condition1.Data.Timeout, condition2.Data.Timeout);
return(null);
}
