public void AddWithNullCondition()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
Assert.Throws <ArgumentNullException>(
() => collection.Add(null, "a", "b"));
}
public void RunWithMissingProcessors()
{
var schedule = BuildThreeVertexSchedule(new InsertVertex(3));
using (var info = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
},
ScheduleConditionStorage.CreateInstanceWithoutTimeline(),
schedule,
new ScheduleId(),
info))
{
var state = ScheduleExecutionState.None;
executor.OnFinish += (s, e) => { state = e.State; };
executor.Start();
Assert.AreEqual(ScheduleExecutionState.NoProcessorForVertex, state);
}
}
}
public void RunWithMarkHistoryVertex()
{
var marker = new TimeMarker(10);
var timeline = new Mock <ITimeline>();
{
timeline.Setup(t => t.Mark())
.Returns(marker);
}
TimeMarker storedMarker = null;
var schedule = BuildThreeVertexSchedule(new MarkHistoryVertex(3));
using (var info = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new MarkHistoryVertexProcessor(timeline.Object, m => storedMarker = m),
},
ScheduleConditionStorage.CreateInstanceWithoutTimeline(),
schedule,
new ScheduleId(),
info))
{
var state = ScheduleExecutionState.None;
executor.OnFinish += (s, e) => { state = e.State; };
executor.Start();
Assert.AreEqual(ScheduleExecutionState.Completed, state);
Assert.AreEqual(marker, storedMarker);
}
}
}
public void RunWithNonPassableEdgeSet()
{
var condition = new Mock <IScheduleCondition>();
{
condition.Setup(c => c.CanTraverse(It.IsAny <CancellationToken>()))
.Returns(false);
}
var conditionStorage = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var conditionInfo = conditionStorage.Add(condition.Object, "a", "b");
Schedule schedule;
{
var graph = new BidirectionalGraph <IScheduleVertex, ScheduleEdge>();
var start = new StartVertex(1);
graph.AddVertex(start);
var end = new EndVertex(2);
graph.AddVertex(end);
var middle1 = new InsertVertex(3);
graph.AddVertex(middle1);
var middle2 = new InsertVertex(4);
graph.AddVertex(middle2);
graph.AddEdge(new ScheduleEdge(start, middle1, conditionInfo.Id));
graph.AddEdge(new ScheduleEdge(start, middle2, conditionInfo.Id));
graph.AddEdge(new ScheduleEdge(middle1, end));
graph.AddEdge(new ScheduleEdge(middle2, end));
schedule = new Schedule(graph, start, end);
}
using (var info = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new InsertVertexProcessor(),
},
conditionStorage,
schedule,
new ScheduleId(),
info))
{
var state = ScheduleExecutionState.None;
executor.OnFinish += (s, e) => { state = e.State; };
executor.Start();
Assert.AreEqual(ScheduleExecutionState.NoTraversableEdgeFound, state);
}
}
}
public void RunWithBlockingConditionOnSecondEdge()
{
var condition = new Mock <IScheduleCondition>();
{
condition.Setup(c => c.CanTraverse(It.IsAny <CancellationToken>()))
.Returns(false);
}
var conditionStorage = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var conditionInfo = conditionStorage.Add(condition.Object, "a", "b");
Schedule schedule;
{
var graph = new BidirectionalGraph <IScheduleVertex, ScheduleEdge>();
var start = new StartVertex(1);
graph.AddVertex(start);
var end = new EndVertex(2);
graph.AddVertex(end);
var middle1 = new InsertVertex(3);
graph.AddVertex(middle1);
var middle2 = new InsertVertex(4);
graph.AddVertex(middle2);
graph.AddEdge(new ScheduleEdge(start, middle1));
graph.AddEdge(new ScheduleEdge(start, middle2, conditionInfo.Id));
graph.AddEdge(new ScheduleEdge(middle1, end));
graph.AddEdge(new ScheduleEdge(middle2, end));
schedule = new Schedule(graph, start, end);
}
using (var info = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new InsertVertexProcessor(),
},
conditionStorage,
schedule,
new ScheduleId(),
info))
{
var executionOrder = new List <int>();
executor.OnVertexProcess += (s, e) => executionOrder.Add(e.Vertex);
executor.Start();
Assert.That(executionOrder, Is.EquivalentTo(new[] { 1, 3, 2 }));
}
}
}
public void UpdateWithNullAction()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var condition = new Mock <IScheduleCondition>();
var info = collection.Add(condition.Object, "a", "b");
Assert.Throws <ArgumentNullException>(() => collection.Update(info.Id, null));
}
public void UpdateWithUnknownId()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var condition = new Mock <IScheduleCondition>();
collection.Add(condition.Object, "a", "b");
var otherCondition = new Mock <IScheduleCondition>();
Assert.Throws <UnknownScheduleConditionException>(() => collection.Update(new ScheduleElementId(), otherCondition.Object));
}
public void Add()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var condition = new Mock <IScheduleCondition>();
var info = collection.Add(condition.Object, "a", "b");
Assert.AreSame(info, collection.Information(info.Id));
Assert.AreSame(condition.Object, collection.Condition(info.Id));
}
public void Contains()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var condition = new Mock <IScheduleCondition>();
var info = collection.Add(condition.Object, "a", "b");
Assert.IsTrue(collection.Contains(info.Id));
Assert.IsFalse(collection.Contains(new ScheduleElementId()));
Assert.IsFalse(collection.Contains(null));
}
public void RunWithSubScheduleVertex()
{
var subExecutor = new Mock <IExecuteSchedules>();
{
subExecutor.Setup(s => s.IsLocal)
.Returns(false);
}
var distributor = new Mock <IDistributeScheduleExecutions>();
{
distributor.Setup(
d => d.Execute(
It.IsAny <ScheduleId>(),
It.IsAny <IEnumerable <IScheduleVariable> >(),
It.IsAny <ScheduleExecutionInfo>(),
It.IsAny <bool>()))
.Returns(subExecutor.Object);
}
var id = new ScheduleId();
var schedule = BuildThreeVertexSchedule(new SubScheduleVertex(3, id));
using (var info = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new SubScheduleVertexProcessor(distributor.Object),
},
ScheduleConditionStorage.CreateInstanceWithoutTimeline(),
schedule,
new ScheduleId(),
info))
{
var state = ScheduleExecutionState.None;
executor.OnFinish += (s, e) => { state = e.State; };
executor.Start();
Assert.AreEqual(ScheduleExecutionState.Completed, state);
}
}
}
public void Update()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var condition = new Mock <IScheduleCondition>();
var info = collection.Add(condition.Object, "a", "b");
Assert.AreSame(condition.Object, collection.Condition(info.Id));
var otherCondition = new Mock <IScheduleCondition>();
collection.Update(info.Id, otherCondition.Object);
var otherInfo = collection.Information(info.Id);
Assert.AreEqual(info.Id, otherInfo.Id);
Assert.AreEqual(info.Name, otherInfo.Name);
Assert.AreEqual(info.Description, otherInfo.Description);
Assert.AreSame(otherCondition.Object, collection.Condition(info.Id));
}
public void RunWithActionVertex()
{
var action = new Mock <IScheduleAction>();
{
action.Setup(a => a.Execute(It.IsAny <CancellationToken>()))
.Verifiable();
}
var collection = ScheduleActionStorage.CreateInstanceWithoutTimeline();
var info = collection.Add(
action.Object,
"a",
"b");
var schedule = BuildThreeVertexSchedule(new ExecutingActionVertex(3, info.Id));
using (var executionInfo = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new ActionVertexProcessor(collection),
},
ScheduleConditionStorage.CreateInstanceWithoutTimeline(),
schedule,
new ScheduleId(),
executionInfo))
{
var state = ScheduleExecutionState.None;
executor.OnFinish += (s, e) => { state = e.State; };
executor.Start();
Assert.AreEqual(ScheduleExecutionState.Completed, state);
action.Verify(a => a.Execute(It.IsAny <CancellationToken>()), Times.Once());
}
}
}
public void RunWithInnerAndOuterLoop()
{
bool outerLoopPassThrough = false;
var outerLoopCondition = new Mock <IScheduleCondition>();
{
outerLoopCondition.Setup(c => c.CanTraverse(It.IsAny <CancellationToken>()))
.Returns(() => outerLoopPassThrough);
}
bool innerLoopPassThrough = false;
var innerLoopCondition = new Mock <IScheduleCondition>();
{
innerLoopCondition.Setup(c => c.CanTraverse(It.IsAny <CancellationToken>()))
.Returns(() => innerLoopPassThrough);
}
var conditionStorage = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var outerLoopConditionInfo = conditionStorage.Add(
outerLoopCondition.Object,
"a",
"b");
var innerLoopConditionInfo = conditionStorage.Add(
innerLoopCondition.Object,
"a",
"b");
var outerLoopAction = new Mock <IScheduleAction>();
{
outerLoopAction.Setup(a => a.Execute(It.IsAny <CancellationToken>()))
.Callback(() => outerLoopPassThrough = true);
}
var innerLoopAction = new Mock <IScheduleAction>();
{
innerLoopAction.Setup(a => a.Execute(It.IsAny <CancellationToken>()))
.Callback(() => innerLoopPassThrough = true);
}
var collection = ScheduleActionStorage.CreateInstanceWithoutTimeline();
var outerLoopInfo = collection.Add(
outerLoopAction.Object,
"a",
"b");
var innerLoopInfo = collection.Add(
innerLoopAction.Object,
"a",
"b");
// Making a schedule that looks like:
// start -> node1 --> node2 -> end
// ^ |
// |-- node3 <-|
// ^ |
// node5--| |-> node4
// ^ |
// |--------------|
Schedule schedule;
{
schedule = CreateScheduleGraphWithOuterAndInnerLoop(outerLoopConditionInfo, innerLoopConditionInfo, outerLoopInfo, innerLoopInfo);
}
using (var info = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new InsertVertexProcessor(),
new ActionVertexProcessor(collection),
},
conditionStorage,
schedule,
new ScheduleId(),
info))
{
var executionOrder = new List <int>();
executor.OnVertexProcess += (s, e) => executionOrder.Add(e.Vertex);
executor.Start();
Assert.That(executionOrder, Is.EquivalentTo(new[] { 1, 3, 4, 5, 6, 7, 5, 3, 4, 2 }));
}
}
}
public void RunWithLoop()
{
bool passThrough = false;
var condition = new Mock <IScheduleCondition>();
{
condition.Setup(c => c.CanTraverse(It.IsAny <CancellationToken>()))
.Returns(() => passThrough);
}
var conditionStorage = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
var conditionInfo = conditionStorage.Add(condition.Object, "a", "b");
var action = new Mock <IScheduleAction>();
{
action.Setup(a => a.Execute(It.IsAny <CancellationToken>()))
.Callback(() => passThrough = true);
}
var collection = ScheduleActionStorage.CreateInstanceWithoutTimeline();
var info = collection.Add(
action.Object,
"a",
"b");
// Making a schedule that looks like:
// start -> node1 --> node2 -> end
// ^ |
// |-- node3 <-|
Schedule schedule;
{
var graph = new BidirectionalGraph <IScheduleVertex, ScheduleEdge>();
var start = new StartVertex(1);
graph.AddVertex(start);
var end = new EndVertex(2);
graph.AddVertex(end);
var vertex1 = new InsertVertex(3);
graph.AddVertex(vertex1);
var vertex2 = new InsertVertex(4);
graph.AddVertex(vertex2);
var vertex3 = new ExecutingActionVertex(5, info.Id);
graph.AddVertex(vertex3);
graph.AddEdge(new ScheduleEdge(start, vertex1));
graph.AddEdge(new ScheduleEdge(vertex1, vertex2));
graph.AddEdge(new ScheduleEdge(vertex2, end, conditionInfo.Id));
graph.AddEdge(new ScheduleEdge(vertex2, vertex3));
graph.AddEdge(new ScheduleEdge(vertex3, vertex1));
schedule = new Schedule(graph, start, end);
}
using (var executionInfo = new ScheduleExecutionInfo(new CurrentThreadTaskScheduler()))
{
using (var executor = new ScheduleExecutor(
new List <IProcesExecutableScheduleVertices>
{
new StartVertexProcessor(),
new EndVertexProcessor(),
new InsertVertexProcessor(),
new ActionVertexProcessor(collection),
},
conditionStorage,
schedule,
new ScheduleId(),
executionInfo))
{
var executionOrder = new List <int>();
executor.OnVertexProcess += (s, e) => executionOrder.Add(e.Vertex);
executor.Start();
Assert.That(executionOrder, Is.EquivalentTo(new[] { 1, 3, 4, 5, 3, 4, 2 }));
}
}
}
public void RemoveWithNullId()
{
var collection = ScheduleConditionStorage.CreateInstanceWithoutTimeline();
Assert.DoesNotThrow(() => collection.Remove(null));
}
