public void BasicResourceResolution()
{
DependencyGraph g = new DependencyGraph();
Resource res = new Resource(g, "resource");
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b = new OrderedProcess(g, "B");
OrderedProcess c = new OrderedProcess(g, "C");
a.Before(b);
a.Before(c);
b.Requires(res);
c.Requires(res);
IEnumerable<IEnumerable<OrderedProcess>> s = g.CalculateSort();
Assert.AreEqual(3, s.Count());
Assert.AreEqual(1, s.Skip(0).First().Count());
Assert.AreEqual(a, s.Skip(0).First().First());
Assert.AreEqual(1, s.Skip(1).First().Count());
Assert.IsTrue(s.Skip(1).First().First() == b || s.Skip(1).First().First() == c);
Assert.AreEqual(1, s.Skip(0).First().Count());
Assert.IsTrue(s.Skip(2).First().First() == b || s.Skip(2).First().First() == c);
Assert.AreNotEqual(s.Skip(1).First().First(), s.Skip(2).First().First());
}
public void BranchingResourceResolution()
{
DependencyGraph g = new DependencyGraph();
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b1 = new OrderedProcess(g, "B1");
OrderedProcess b2 = new OrderedProcess(g, "B2");
OrderedProcess c1 = new OrderedProcess(g, "C1");
OrderedProcess c2 = new OrderedProcess(g, "C2");
OrderedProcess c3 = new OrderedProcess(g, "C3");
OrderedProcess c4 = new OrderedProcess(g, "C4");
OrderedProcess d = new OrderedProcess(g, "D");
a.Before(b1, b2).Before(c1, c2, c3, c4).Before(d);
Resource resource = new Resource(g, "Resource");
resource.UsedBy(c1, c3);
IEnumerable<IEnumerable<OrderedProcess>> s = g.CalculateSort();
//check that A comes first
Assert.AreEqual(1, s.Skip(0).First().Count());
Assert.AreEqual(a, s.Skip(0).First().First());
//check that D comes last
Assert.AreEqual(1, s.Skip(4).First().Count());
Assert.AreEqual(d, s.Skip(4).First().First());
//check that no set contains both c1 and c3
Assert.AreEqual(0, s.Where(set => set.Contains(c1) && set.Contains(c3)).Count());
}
public void BasicOrderBefore()
{
DependencyGraph g = new DependencyGraph();
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b = new OrderedProcess(g, "B");
OrderedProcess c = new OrderedProcess(g, "C");
a.Before(b).Before(c);
IEnumerable<IEnumerable<OrderedProcess>> s = g.CalculateSort();
Assert.AreEqual(1, s.Skip(0).First().Count());
Assert.AreEqual(a, s.Skip(0).First().First());
Assert.AreEqual(1, s.Skip(1).First().Count());
Assert.AreEqual(b, s.Skip(1).First().First());
Assert.AreEqual(1, s.Skip(2).First().Count());
Assert.AreEqual(c, s.Skip(2).First().First());
}
public void BasicBranching()
{
DependencyGraph g = new DependencyGraph();
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b1 = new OrderedProcess(g, "B1");
OrderedProcess b2 = new OrderedProcess(g, "B2");
OrderedProcess c = new OrderedProcess(g, "C");
a.Before(b1, b2).Before(c);
IEnumerable<IEnumerable<OrderedProcess>> s = g.CalculateSort();
Assert.AreEqual(1, s.Skip(0).First().Count());
Assert.AreEqual(a, s.Skip(0).First().First());
Assert.AreEqual(2, s.Skip(1).First().Count());
Assert.IsTrue(s.Skip(1).First().Contains(b1));
Assert.IsTrue(s.Skip(1).First().Contains(b2));
Assert.AreEqual(1, s.Skip(2).First().Count());
Assert.AreEqual(c, s.Skip(2).First().First());
}
public void Unorderable()
{
DependencyGraph g = new DependencyGraph();
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b = new OrderedProcess(g, "B");
a.Before(b);
b.Before(a);
g.CalculateSort();
}
public void ComplexBranching()
{
DependencyGraph g = new DependencyGraph();
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b1 = new OrderedProcess(g, "B1");
OrderedProcess b2 = new OrderedProcess(g, "B2");
OrderedProcess c1 = new OrderedProcess(g, "C1");
OrderedProcess c2 = new OrderedProcess(g, "C2");
OrderedProcess c3 = new OrderedProcess(g, "C3");
OrderedProcess c4 = new OrderedProcess(g, "C4");
OrderedProcess d = new OrderedProcess(g, "D");
a.Before(b1, b2).Before(c1, c2, c3, c4).Before(d);
IEnumerable<IEnumerable<OrderedProcess>> s = g.CalculateSort();
Assert.AreEqual(1, s.Skip(0).First().Count());
Assert.AreEqual(a, s.Skip(0).First().First());
Assert.AreEqual(2, s.Skip(1).First().Count());
Assert.IsTrue(s.Skip(1).First().Contains(b1));
Assert.IsTrue(s.Skip(1).First().Contains(b2));
Assert.AreEqual(4, s.Skip(2).First().Count());
Assert.IsTrue(s.Skip(2).First().Contains(c1));
Assert.IsTrue(s.Skip(2).First().Contains(c2));
Assert.IsTrue(s.Skip(2).First().Contains(c3));
Assert.IsTrue(s.Skip(2).First().Contains(c4));
Assert.AreEqual(1, s.Skip(3).First().Count());
Assert.AreEqual(d, s.Skip(3).First().First());
}
public void BranchingUnorderable()
{
DependencyGraph g = new DependencyGraph();
OrderedProcess a = new OrderedProcess(g, "A");
OrderedProcess b1 = new OrderedProcess(g, "B1");
OrderedProcess b2 = new OrderedProcess(g, "B2");
OrderedProcess c1 = new OrderedProcess(g, "C1");
OrderedProcess c2 = new OrderedProcess(g, "C2");
OrderedProcess c3 = new OrderedProcess(g, "C3");
OrderedProcess c4 = new OrderedProcess(g, "C4");
OrderedProcess d = new OrderedProcess(g, "D");
a.Before(b1, b2).Before(c1, c2, c3, c4).Before(d).Before(b1);
g.CalculateSort();
}
/// <summary>
/// Indicates that all the members of the enumerable must happen after the single predecessor
/// </summary>
/// <param name="followers">The followers.</param>
/// <param name="predecessor">The predecessor.</param>
/// <returns>the predecessor</returns>
public static OrderedProcess <T> After <T>(this IEnumerable <OrderedProcess <T> > followers, OrderedProcess <T> predecessor)
{
predecessor.Before(followers);
return(predecessor);
}
/// <summary>
/// Indicates that this process should execute after another
/// </summary>
/// <param name="predecessor">The predecessor.</param>
/// <returns>returns this process</returns>
public OrderedProcess After(OrderedProcess predecessor)
{
DependencyGraph.CheckGraph(this, predecessor);
if (predecessors.Add(predecessor))
predecessor.Before(this);
return predecessor;
}
