public void InactiveChildNotEndedAgain()
{
var parallel = new Parallel();
var childNode = new EventTrackingNode(NodeState.Inactive);
parallel.Children.Add(childNode);
parallel.End();
Assert.IsFalse(childNode.HasEnded);
}
public void ActiveChildGetsEnded()
{
var parallel = new Parallel();
var childNode = new EventTrackingNode(NodeState.Active);
parallel.Children.Add(childNode);
parallel.End();
Assert.IsTrue(childNode.HasEnded);
}
public void StartChild()
{
var overrider = new Overrider();
var childNode = new EventTrackingNode(NodeState.Inactive);
overrider.Child = childNode;
overrider.Start();
overrider.Update();
Assert.IsTrue(childNode.HasStarted);
}
public void StartChild()
{
var repeater = new RepeaterInfinite();
var childNode = new EventTrackingNode(NodeState.Inactive);
repeater.Child = childNode;
repeater.Start();
repeater.Update();
Assert.AreEqual(true, childNode.HasStarted);
}
public void ChildStartsWhenRepeaterUpdatesFirstTime()
{
var repeater = new Repeater(5);
var childNode = new EventTrackingNode(NodeState.Error);
repeater.Child = childNode;
repeater.Start();
repeater.Update();
Assert.IsTrue(childNode.HasStarted);
Assert.AreEqual(1, childNode.StartsTotal);
}
public void OneChild()
{
var parallel = new Parallel();
var childNode = new EventTrackingNode(NodeState.Active);
parallel.Children.Add(childNode);
parallel.Start();
parallel.Update();
Assert.AreEqual(NodeState.Active, parallel.Status);
}
public void EndOnSecondChildSuccess()
{
var parallel = new Parallel();
var firstChildNode = new EventTrackingNode(NodeState.Active);
var secondChildNode = new EventTrackingNode(NodeState.Successful);
parallel.Children.Add(firstChildNode);
parallel.Children.Add(secondChildNode);
parallel.Start();
parallel.Update();
Assert.AreEqual(NodeState.Successful, parallel.Status);
}
public void EndOnFirstChildFail()
{
var parallel = new Parallel();
var firstChildNode = new EventTrackingNode(NodeState.Failure);
var secondChildNode = new EventTrackingNode(NodeState.Active);
parallel.Children.Add(firstChildNode);
parallel.Children.Add(secondChildNode);
parallel.Start();
parallel.Update();
Assert.AreEqual(NodeState.Failure, parallel.Status);
}
public void InactiveChildGetsStarted()
{
var parallel = new Parallel();
var childNode = new EventTrackingNode(NodeState.Inactive);
parallel.Children.Add(childNode);
parallel.Start();
childNode.SetStatusOnNextUpdate(NodeState.Active);
parallel.Update();
Assert.IsTrue(childNode.HasStarted);
Assert.AreEqual(NodeState.Active, parallel.Status);
}
public void RepeatOneTimeTrackEvents()
{
var repeater = new Repeater(1);
var childNode = new EventTrackingNode(NodeState.Inactive);
repeater.Child = childNode;
repeater.Start();
repeater.Update();
Assert.AreEqual(1, childNode.StartsTotal);
Assert.AreEqual(1, childNode.UpdatesTotal);
Assert.AreEqual(1, childNode.EndsTotal);
}
public void ChildError()
{
var selector = new Selector();
var childNode = new EventTrackingNode(NodeState.Error);
selector.Children.Add(childNode);
selector.Start();
selector.Update();
Assert.IsTrue(childNode.HasStarted);
Assert.AreEqual(1, childNode.UpdatesTotal);
Assert.AreEqual(NodeState.Error, selector.Status);
}
public void EndBeforeUpdate()
{
var repeater = new RepeaterInfinite();
var childNode = new EventTrackingNode(NodeState.Inactive);
repeater.Child = childNode;
repeater.Start();
repeater.End();
Assert.AreEqual(false, childNode.HasStarted);
Assert.AreEqual(false, childNode.HasEnded);
Assert.AreEqual(0, childNode.UpdatesTotal);
}
public void ChildError()
{
var repeater = new RepeaterInfinite();
var childNode = new EventTrackingNode(NodeState.Inactive);
repeater.Child = childNode;
repeater.Start();
childNode.SetStatusOnNextUpdate(NodeState.Error);
repeater.Update();
Assert.AreEqual(NodeState.Error, repeater.Status);
Assert.AreEqual(true, childNode.HasEnded);
}
public void ChildEndsWhenRepeaterEnds()
{
var repeater = new Repeater(3, true);
var childNode = new EventTrackingNode(NodeState.Successful);
repeater.Child = childNode;
repeater.Start();
repeater.Update();
repeater.Update();
repeater.Update();
Assert.IsTrue(childNode.HasEnded);
}
public void OverrideChildFailure()
{
var overrider = new Overrider();
var overrideStatus = NodeState.Successful;
overrider.FailureOverride = overrideStatus;
var childNode = new EventTrackingNode(NodeState.Inactive);
overrider.Child = childNode;
overrider.Start();
childNode.SetStatusOnNextUpdate(NodeState.Failure);
overrider.Update();
Assert.AreEqual(overrideStatus, overrider.Status);
}
public void OverrideToSuccessEndsChild()
{
var overrider = new Overrider();
overrider.ActiveOverride = NodeState.Successful;
var childNode = new EventTrackingNode(NodeState.Inactive);
overrider.Child = childNode;
overrider.Start();
childNode.SetStatusOnNextUpdate(NodeState.Active);
overrider.Update();
Assert.IsTrue(childNode.HasEnded);
Assert.AreEqual(1, childNode.EndsTotal);
Assert.AreNotEqual(overrider.Status, childNode.Status);
}
public void RepeatMultipleTimesIgnoringChildTrackEvents()
{
var repeater = new Repeater(5, true);
var childNode = new EventTrackingNode(NodeState.Inactive);
repeater.Child = childNode;
repeater.Start();
repeater.Update();
repeater.Update();
repeater.Update();
repeater.Update();
Assert.AreEqual(4, childNode.StartsTotal, "child start events");
Assert.AreEqual(4, childNode.UpdatesTotal, "child update events");
Assert.AreEqual(4, childNode.EndsTotal, "child end events");
}
public void ErrorInterruptsUpdateWithAllChildren()
{
var parallel = new Parallel();
var firstChildNode = new EventTrackingNode(NodeState.Active);
var secondChildNode = new EventTrackingNode(NodeState.Active);
parallel.Children.Add(firstChildNode);
parallel.Children.Add(secondChildNode);
parallel.ShouldUpdateUntilAllChildrenComplete = true;
parallel.Start();
parallel.Update();
firstChildNode.SetStatusOnNextUpdate(NodeState.Error);
parallel.Update();
Assert.AreEqual(NodeState.Error, parallel.Status);
}
public void FirstChildSucceeds()
{
var selector = new Selector();
var firstChild = new EventTrackingNode(NodeState.Successful);
var secondChild = new EventTrackingNode(NodeState.Successful);
selector.Children.AddRange(new List <INode>()
{
firstChild, secondChild
});
selector.Start();
selector.Update();
Assert.AreEqual(1, firstChild.UpdatesTotal);
Assert.AreEqual(0, secondChild.UpdatesTotal);
Assert.AreEqual(NodeState.Successful, selector.Status);
}
public void AllChildrenFail()
{
var selector = new Selector();
var firstChild = new EventTrackingNode(NodeState.Failure);
var secondChild = new EventTrackingNode(NodeState.Failure);
selector.Children.AddRange(new List <INode>()
{
firstChild, secondChild
});
selector.Start();
selector.Update();
Assert.AreEqual(1, firstChild.UpdatesTotal);
Assert.AreEqual(1, secondChild.UpdatesTotal);
Assert.AreEqual(NodeState.Failure, selector.Status);
}
public void FirstChildTakesPrecedenceOverSecond()
{
var selector = new Selector();
var firstChild = new EventTrackingNode(NodeState.Failure);
var secondChild = new EventTrackingNode(NodeState.Active);
selector.Children.AddRange(new List <INode>()
{
firstChild, secondChild
});
selector.Start();
selector.Update();
firstChild.SetStatusOnNextUpdate(NodeState.Active);
selector.Update();
selector.Update();
Assert.AreEqual(3, firstChild.UpdatesTotal);
Assert.AreEqual(1, secondChild.UpdatesTotal);
}
public void FailureWithAllChildren()
{
var parallel = new Parallel();
var firstChildNode = new EventTrackingNode(NodeState.Active);
var secondChildNode = new EventTrackingNode(NodeState.Active);
parallel.Children.Add(firstChildNode);
parallel.Children.Add(secondChildNode);
parallel.ShouldUpdateUntilAllChildrenComplete = true;
parallel.Start();
parallel.Update();
firstChildNode.SetStatusOnNextUpdate(NodeState.Failure);
parallel.Update();
secondChildNode.SetStatusOnNextUpdate(NodeState.Failure);
parallel.Update();
Assert.AreEqual(2, firstChildNode.UpdatesTotal);
Assert.AreEqual(3, secondChildNode.UpdatesTotal);
Assert.AreEqual(NodeState.Failure, parallel.Status);
}
public void TwoChildren()
{
var parallel = new Parallel();
var firstChildNode = new EventTrackingNode(NodeState.Inactive);
var secondChildNode = new EventTrackingNode(NodeState.Inactive);
parallel.Children.Add(firstChildNode);
parallel.Children.Add(secondChildNode);
parallel.Start();
firstChildNode.SetStatusOnNextUpdate(NodeState.Active);
secondChildNode.SetStatusOnNextUpdate(NodeState.Active);
parallel.Update();
parallel.Update();
parallel.Update();
Assert.IsTrue(firstChildNode.HasStarted);
Assert.AreEqual(3, firstChildNode.UpdatesTotal);
Assert.IsTrue(secondChildNode.HasStarted);
Assert.AreEqual(3, secondChildNode.UpdatesTotal);
Assert.AreEqual(NodeState.Active, parallel.Status);
}
public void ChildrenStopUpdatingWhenComplete()
{
var parallel = new Parallel();
var firstChildNode = new EventTrackingNode(NodeState.Active);
var secondChildNode = new EventTrackingNode(NodeState.Active);
parallel.Children.Add(firstChildNode);
parallel.Children.Add(secondChildNode);
parallel.ShouldUpdateUntilAllChildrenComplete = true;
parallel.Start();
parallel.Update();
parallel.Update();
firstChildNode.SetStatusOnNextUpdate(NodeState.Successful);
parallel.Update();
parallel.Update();
secondChildNode.SetStatusOnNextUpdate(NodeState.Successful);
parallel.Update();
Assert.AreEqual(3, firstChildNode.UpdatesTotal);
Assert.AreEqual(5, secondChildNode.UpdatesTotal);
}
