public void LinkToWithStartAndEndEqual()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
Assert.Throws <CannotLinkAVertexToItselfException>(() => builder.LinkTo(insertVertex, insertVertex));
}
public void LinkToEndWithUnknownVertex()
{
var builder = new FixedScheduleBuilder();
var otherVertex = new InsertVertex(10);
Assert.Throws <UnknownScheduleVertexException>(() => builder.LinkToEnd(otherVertex));
}
public void AddSynchronizationStartPointWithoutVariables()
{
var builder = new FixedScheduleBuilder();
Assert.Throws <CannotCreateASynchronizationBlockWithoutVariablesException>(
() => builder.AddSynchronizationStart(new IScheduleVariable[] { }));
}
public void InsertInWithUnknownInsertVertex()
{
var builder = new FixedScheduleBuilder();
var markHistoryVertex = builder.AddHistoryMarkingPoint();
Assert.Throws <UnknownScheduleVertexException>(
() => builder.InsertIn(new InsertVertex(10), markHistoryVertex));
}
public void LinkToWithUnknownEnd()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
var otherVertex = new InsertVertex(10);
Assert.Throws <UnknownScheduleVertexException>(() => builder.LinkTo(insertVertex, otherVertex));
}
public void InsertInWithKnownVertexToInsert()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
var markHistoryVertex = builder.AddHistoryMarkingPoint();
Assert.Throws <CannotInsertExistingVertexException>(
() => builder.InsertIn(insertVertex, markHistoryVertex));
}
public void InsertInWithNoMoreRemainingInserts()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint(1);
builder.LinkFromStart(insertVertex);
builder.LinkToEnd(insertVertex);
var markHistoryVertex1 = new MarkHistoryVertex(10);
var newInserts = builder.InsertIn(insertVertex, markHistoryVertex1);
Assert.IsNull(newInserts.Item1);
Assert.IsNull(newInserts.Item2);
}
public void AddInsertPoint()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
builder.LinkFromStart(insertVertex);
builder.LinkToEnd(insertVertex);
Assert.AreEqual(2, insertVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(insertVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void AddSynchronizationEndPointWithMissingStartPoint()
{
var variable = new Mock <IScheduleVariable>();
var builder = new FixedScheduleBuilder();
Assert.Throws <UnknownScheduleVertexException>(
() => builder.AddSynchronizationEnd(
new SynchronizationStartVertex(
10,
new[]
{
variable.Object
})));
}
public void InsertInWithSubSchedule()
{
var conditionId1 = new ScheduleElementId();
var conditionId2 = new ScheduleElementId();
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
builder.LinkFromStart(insertVertex, conditionId1);
builder.LinkToEnd(insertVertex, conditionId2);
var scheduleId = new ScheduleId();
builder.InsertIn(insertVertex, scheduleId);
var schedule = builder.Build();
int index = 0;
var vertexTypes = new List <Type>
{
typeof(StartVertex),
typeof(InsertVertex),
typeof(SubScheduleVertex),
typeof(InsertVertex),
typeof(EndVertex)
};
var conditions = new List <ScheduleElementId>
{
conditionId1,
null,
null,
conditionId2
};
schedule.TraverseAllScheduleVertices(
schedule.Start,
(vertex, edges) =>
{
Assert.AreEqual(vertexTypes[index], vertex.GetType());
if (index < conditions.Count)
{
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(conditions[index], edges.First().Item1);
}
index++;
return(true);
});
}
public void AddInsertPoint()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
builder.LinkFromStart(insertVertex);
builder.LinkToEnd(insertVertex);
Assert.AreEqual(2, insertVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(insertVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void AddExecutingAction()
{
var actionId = new ScheduleElementId();
var builder = new FixedScheduleBuilder();
var actionVertex = builder.AddExecutingAction(actionId);
builder.LinkFromStart(actionVertex);
builder.LinkToEnd(actionVertex);
Assert.AreEqual(actionId, actionVertex.ActionToExecute);
Assert.AreEqual(2, actionVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(actionVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void AddSubSchedule()
{
var scheduleId = new ScheduleId();
var builder = new FixedScheduleBuilder();
var subScheduleVertex = builder.AddSubSchedule(scheduleId);
builder.LinkFromStart(subScheduleVertex);
builder.LinkToEnd(subScheduleVertex);
Assert.AreEqual(scheduleId, subScheduleVertex.ScheduleToExecute);
Assert.AreEqual(2, subScheduleVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(subScheduleVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void AddSynchronizationStartPoint()
{
var variable = new Mock <IScheduleVariable>();
var builder = new FixedScheduleBuilder();
var synchronizationVertex = builder.AddSynchronizationStart(new[] { variable.Object });
builder.LinkFromStart(synchronizationVertex);
builder.LinkToEnd(synchronizationVertex);
Assert.That(synchronizationVertex.VariablesToSynchronizeOn, Is.EquivalentTo(new[] { variable.Object }));
Assert.AreEqual(2, synchronizationVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(synchronizationVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void AddExecutingAction()
{
var actionId = new ScheduleElementId();
var builder = new FixedScheduleBuilder();
var actionVertex = builder.AddExecutingAction(actionId);
builder.LinkFromStart(actionVertex);
builder.LinkToEnd(actionVertex);
Assert.AreEqual(actionId, actionVertex.ActionToExecute);
Assert.AreEqual(2, actionVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(actionVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void InsertInWithUnknownInsertVertex()
{
var builder = new FixedScheduleBuilder();
var markHistoryVertex = builder.AddHistoryMarkingPoint();
Assert.Throws<UnknownScheduleVertexException>(
() => builder.InsertIn(new InsertVertex(10), markHistoryVertex));
}
public void InsertInWithSubSchedule()
{
var conditionId1 = new ScheduleElementId();
var conditionId2 = new ScheduleElementId();
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
builder.LinkFromStart(insertVertex, conditionId1);
builder.LinkToEnd(insertVertex, conditionId2);
var scheduleId = new ScheduleId();
builder.InsertIn(insertVertex, scheduleId);
var schedule = builder.Build();
int index = 0;
var vertexTypes = new List<Type>
{
typeof(StartVertex),
typeof(InsertVertex),
typeof(SubScheduleVertex),
typeof(InsertVertex),
typeof(EndVertex)
};
var conditions = new List<ScheduleElementId>
{
conditionId1,
null,
null,
conditionId2
};
schedule.TraverseAllScheduleVertices(
schedule.Start,
(vertex, edges) =>
{
Assert.AreEqual(vertexTypes[index], vertex.GetType());
if (index < conditions.Count)
{
Assert.AreEqual(1, edges.Count());
Assert.AreEqual(conditions[index], edges.First().Item1);
}
index++;
return true;
});
}
public void InsertInWithNoMoreRemainingInserts()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint(1);
builder.LinkFromStart(insertVertex);
builder.LinkToEnd(insertVertex);
var markHistoryVertex1 = new MarkHistoryVertex(10);
var newInserts = builder.InsertIn(insertVertex, markHistoryVertex1);
Assert.IsNull(newInserts.Item1);
Assert.IsNull(newInserts.Item2);
}
public void InsertInWithKnownVertexToInsert()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
var markHistoryVertex = builder.AddHistoryMarkingPoint();
Assert.Throws<CannotInsertExistingVertexException>(
() => builder.InsertIn(insertVertex, markHistoryVertex));
}
public void AddInsertPointWithInvalidCount()
{
var builder = new FixedScheduleBuilder();
Assert.Throws <ArgumentOutOfRangeException>(() => builder.AddInsertPoint(0));
}
public void LinkToWithUnknownStart()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
var otherVertex = new InsertVertex(10);
Assert.Throws<UnknownScheduleVertexException>(() => builder.LinkTo(otherVertex, insertVertex));
}
public void AddSynchronizationEndPointWithMissingStartPoint()
{
var variable = new Mock<IScheduleVariable>();
var builder = new FixedScheduleBuilder();
Assert.Throws<UnknownScheduleVertexException>(
() => builder.AddSynchronizationEnd(
new SynchronizationStartVertex(
10,
new[]
{
variable.Object
})));
}
public void AddSubSchedule()
{
var scheduleId = new ScheduleId();
var builder = new FixedScheduleBuilder();
var subScheduleVertex = builder.AddSubSchedule(scheduleId);
builder.LinkFromStart(subScheduleVertex);
builder.LinkToEnd(subScheduleVertex);
Assert.AreEqual(scheduleId, subScheduleVertex.ScheduleToExecute);
Assert.AreEqual(2, subScheduleVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(subScheduleVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void LinkToEndWithUnknownVertex()
{
var builder = new FixedScheduleBuilder();
var otherVertex = new InsertVertex(10);
Assert.Throws<UnknownScheduleVertexException>(() => builder.LinkToEnd(otherVertex));
}
public void LinkToWithStartAndEndEqual()
{
var builder = new FixedScheduleBuilder();
var insertVertex = builder.AddInsertPoint();
Assert.Throws<CannotLinkAVertexToItselfException>(() => builder.LinkTo(insertVertex, insertVertex));
}
public void AddSynchronizationStartPoint()
{
var variable = new Mock<IScheduleVariable>();
var builder = new FixedScheduleBuilder();
var synchronizationVertex = builder.AddSynchronizationStart(new[] { variable.Object });
builder.LinkFromStart(synchronizationVertex);
builder.LinkToEnd(synchronizationVertex);
Assert.That(synchronizationVertex.VariablesToSynchronizeOn, Is.EquivalentTo(new[] { variable.Object }));
Assert.AreEqual(2, synchronizationVertex.Index);
var schedule = builder.Build();
Assert.AreEqual(3, schedule.Vertices.Count());
Assert.IsTrue(AreVerticesEqual(schedule.Start, schedule.Vertices.ElementAt(0)));
Assert.IsTrue(AreVerticesEqual(synchronizationVertex, schedule.Vertices.ElementAt(1)));
Assert.IsTrue(AreVerticesEqual(schedule.End, schedule.Vertices.ElementAt(2)));
}
public void AddInsertPointWithInvalidCount()
{
var builder = new FixedScheduleBuilder();
Assert.Throws<ArgumentOutOfRangeException>(() => builder.AddInsertPoint(0));
}
public void AddSynchronizationStartPointWithoutVariables()
{
var builder = new FixedScheduleBuilder();
Assert.Throws<CannotCreateASynchronizationBlockWithoutVariablesException>(
() => builder.AddSynchronizationStart(new IScheduleVariable[] { }));
}
