public void Merge1()
{
var edge13 = new EquatableEdge <int>(1, 3);
var edge13Bis = new EquatableEdge <int>(1, 3);
var edge21 = new EquatableEdge <int>(2, 1);
var edge23 = new EquatableEdge <int>(2, 3);
var edge34 = new EquatableEdge <int>(3, 4);
var edge35 = new EquatableEdge <int>(3, 5);
var edge35Bis = new EquatableEdge <int>(3, 5);
var edge45 = new EquatableEdge <int>(4, 5);
Merge_Test(
new[] { 1, 2, 3, 4, 5 },
new[] { edge13, edge13Bis, edge21, edge23, edge34, edge35, edge35Bis, edge45 },
3,
9,
6,
new[]
{
edge21, edge45,
new EquatableEdge <int>(1, 4),
new EquatableEdge <int>(1, 5),
new EquatableEdge <int>(1, 5),
new EquatableEdge <int>(1, 4),
new EquatableEdge <int>(1, 5),
new EquatableEdge <int>(1, 5),
new EquatableEdge <int>(2, 4),
new EquatableEdge <int>(2, 5),
new EquatableEdge <int>(2, 5)
});
}
protected static void AddEdge_EquatableEdge_ForbiddenParallelEdges_Test(
[NotNull] BidirectionalMatrixGraph <EquatableEdge <int> > graph)
{
int edgeAdded = 0;
AssertNoEdge(graph);
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.EdgeAdded += e =>
{
Assert.IsNotNull(e);
++edgeAdded;
};
// Edge 1
var edge1 = new EquatableEdge <int>(1, 2);
Assert.IsTrue(graph.AddEdge(edge1));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 2
var edge2 = new EquatableEdge <int>(2, 1);
Assert.IsTrue(graph.AddEdge(edge2));
Assert.AreEqual(2, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge2 });
// Edge 3 self edge
var edge3 = new EquatableEdge <int>(2, 2);
Assert.IsTrue(graph.AddEdge(edge3));
Assert.AreEqual(3, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge2, edge3 });
}
protected static void AddEdge_EquatableEdge_ForbiddenParallelEdges_Test(
BidirectionalMatrixGraph <EquatableEdge <int> > graph)
{
int edgeAdded = 0;
AssertNoEdge(graph);
graph.EdgeAdded += e =>
{
Assert.IsNotNull(e);
++edgeAdded;
};
// Edge 1
var edge1 = new EquatableEdge <int>(1, 2);
Assert.IsTrue(graph.AddEdge(edge1));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 2
var edge2 = new EquatableEdge <int>(2, 1);
Assert.IsTrue(graph.AddEdge(edge2));
Assert.AreEqual(2, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge2 });
// Edge 3 self edge
var edge3 = new EquatableEdge <int>(2, 2);
Assert.IsTrue(graph.AddEdge(edge3));
Assert.AreEqual(3, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge2, edge3 });
}
public void TransitiveClosure_IsolatedVertices()
{
const string vertex1 = "/test";
const string vertex2 = "/test/123";
const string vertex3 = "/test/456";
const string vertex4 = "/test/notlinked";
var edge12 = new EquatableEdge <string>(vertex1, vertex2);
var edge23 = new EquatableEdge <string>(vertex2, vertex3);
var graph = new BidirectionalGraph <string, EquatableEdge <string> >();
graph.AddVertexRange(new[] { vertex1, vertex2, vertex3, vertex4 });
graph.AddEdgeRange(new[] { edge12, edge23 });
BidirectionalGraph <string, EquatableEdge <string> > result = graph.ComputeTransitiveClosure((u, v) => new EquatableEdge <string>(u, v));
AssertHasVertices(result, new[] { vertex1, vertex2, vertex3, vertex4 });
AssertHasEdges(
result,
new[]
{
edge12,
new EquatableEdge <string>(vertex1, vertex3),
edge23
});
}
public void ObjectToString()
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(2, 1);
Assert.AreEqual("1 -> 2", edge1.ToString());
Assert.AreEqual("2 -> 1", edge2.ToString());
}
protected static void RemoveEdge_EquatableEdge_EdgesOnly_Test(
[NotNull] EdgeListGraph <int, EquatableEdge <int> > graph)
{
int edgesRemoved = 0;
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.EdgeRemoved += e =>
{
Assert.IsNotNull(e);
// ReSharper disable once AccessToModifiedClosure
++edgesRemoved;
};
var edge12 = new EquatableEdge <int>(1, 2);
var edge13 = new EquatableEdge <int>(1, 3);
var edge14 = new EquatableEdge <int>(1, 4);
var edge24 = new EquatableEdge <int>(2, 4);
var edge31 = new EquatableEdge <int>(3, 1);
var edge33 = new EquatableEdge <int>(3, 3);
var edgeNotInGraph = new EquatableEdge <int>(3, 4);
var edgeEquatable = new EquatableEdge <int>(1, 2);
graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
Assert.IsFalse(graph.RemoveEdge(edgeNotInGraph));
CheckCounter(0);
Assert.IsTrue(graph.RemoveEdge(edgeEquatable));
CheckCounter(1);
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge13, edge14, edge24, edge31, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge13));
CheckCounter(1);
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge14, edge24, edge31, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge31));
CheckCounter(1);
AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
AssertHasEdges(graph, new[] { edge14, edge24, edge33 });
Assert.IsTrue(graph.RemoveEdge(edge14));
Assert.IsTrue(graph.RemoveEdge(edge24));
Assert.IsTrue(graph.RemoveEdge(edge33));
CheckCounter(3);
AssertEmptyGraph(graph); // Vertices removed in the same time as edges
#region Local function
void CheckCounter(int expectedRemovedEdges)
{
Assert.AreEqual(expectedRemovedEdges, edgesRemoved);
edgesRemoved = 0;
}
#endregion
}
protected static void ContainsEdge_EquatableEdge_Test(
[NotNull] IEdgeSet <int, EquatableEdge <int> > graph,
[NotNull, InstantHandle] Action <EquatableEdge <int> > addVerticesAndEdge)
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 3);
var edge3 = new EquatableEdge <int>(2, 1);
var edge4 = new EquatableEdge <int>(2, 2);
var otherEdge1 = new EquatableEdge <int>(1, 2);
Assert.IsFalse(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsFalse(graph.ContainsEdge(otherEdge1));
addVerticesAndEdge(edge1);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
addVerticesAndEdge(edge2);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
addVerticesAndEdge(edge3);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
addVerticesAndEdge(edge4);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsTrue(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
addVerticesAndEdge(otherEdge1);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsTrue(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
// Both vertices not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(0, 10)));
// Source not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(0, 1)));
// Target not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(1, 0)));
}
protected static void ContainsEdge_EquatableEdge_EdgesOnly_Test(
[NotNull] EdgeListGraph <int, EquatableEdge <int> > graph)
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 3);
var edge3 = new EquatableEdge <int>(2, 1);
var edge4 = new EquatableEdge <int>(2, 2);
var otherEdge1 = new EquatableEdge <int>(1, 2);
Assert.IsFalse(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsFalse(graph.ContainsEdge(otherEdge1));
graph.AddVerticesAndEdge(edge1);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddVerticesAndEdge(edge2);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddVerticesAndEdge(edge3);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddVerticesAndEdge(edge4);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsTrue(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddVerticesAndEdge(otherEdge1);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsTrue(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
// Both vertices not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(0, 10)));
// Source not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(0, 1)));
// Target not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(1, 0)));
}
public TestCase AddDirectedEdge(String source, String target, double weight)
{
var e = new EquatableEdge <String>(source, target);
Graph.AddEdge(e);
WeightsDict.Add(e, weight);
return(this);
}
public void Hashcode()
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 2);
var edge3 = new EquatableEdge <int>(2, 1);
Assert.AreEqual(edge1.GetHashCode(), edge2.GetHashCode());
Assert.AreNotEqual(edge1.GetHashCode(), edge3.GetHashCode());
}
private static IBuilder FindSolutionRootBuilder(ISet<EquatableEdge<IBuilder>> graph, EquatableEdge<IBuilder> edge)
{
var msbuild = (MSBuildRunner)edge.Source;
IBuilder result = FollowMergingSources(graph, msbuild);
log.DebugFormat("Found solution root builder for {0}: {1}", edge.Target, result);
return result;
}
public void RemoveEdgeTest()
{
var g = new EdgeListGraph <int, EquatableEdge <int> >(true, false);
EquatableEdge <int> e = new EquatableEdge <int>(0, 1);
g.AddEdge(e);
Assert.IsTrue(g.RemoveEdge(e));
Assert.IsFalse(g.RemoveEdge(e));
}
public TestCase AddDirectedEdge([NotNull] string source, [NotNull] string target, double weight)
{
var edge = new EquatableEdge <string>(source, target);
Graph.AddEdge(edge);
_weightsDict.Add(edge, weight);
return(this);
}
public void Merge3()
{
var edge34 = new EquatableEdge <int>(3, 4);
Merge_Test(
new[] { 1, 2, 3, 4 },
new[] { edge34 },
1,
0,
0,
new[] { edge34 });
}
public void ContainsEdge_DirectedEdge()
{
var graph = new UndirectedGraph <int, IEdge <int> >();
var e12 = new EquatableEdge <int>(1, 2);
var f12 = new EquatableEdge <int>(1, 2);
var e21 = new EquatableEdge <int>(2, 1);
var f21 = new EquatableEdge <int>(2, 1);
graph.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(graph, e12, f12, e21, f21);
}
public void ContainsEdgeTest2()
{
var u = new UndirectedGraph <int, IEdge <int> >();
var e12 = new EquatableEdge <int>(1, 2);
var f12 = new EquatableEdge <int>(1, 2);
var e21 = new EquatableEdge <int>(2, 1);
var f21 = new EquatableEdge <int>(2, 1);
u.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(u, e12, f12, e21, f21);
}
public void Equals()
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 2);
var edge3 = new EquatableEdge <int>(2, 1);
Assert.AreEqual(edge1, edge1);
Assert.AreEqual(edge1, edge2);
Assert.AreNotEqual(edge1, edge3);
Assert.AreNotEqual(edge1, null);
}
public void Equals()
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 2);
var edge3 = new EquatableEdge <int>(2, 1);
Assert.AreEqual(edge1, edge1);
Assert.AreEqual(edge1, edge2);
Assert.IsTrue(edge1.Equals((object)edge2));
Assert.AreNotEqual(edge1, edge3);
Assert.IsFalse(edge1.Equals(null));
Assert.AreNotEqual(edge1, null);
}
protected static void ContainsEdge_EquatableEdges_ForbiddenParallelEdges_ImmutableVertices_Test(
[NotNull] IMutableEdgeListGraph <int, EquatableEdge <int> > graph)
{
var edge1 = new EquatableEdge <int>(1, 2);
var edge2 = new EquatableEdge <int>(1, 3);
var edge3 = new EquatableEdge <int>(2, 1);
var edge4 = new EquatableEdge <int>(2, 2);
var otherEdge1 = new EquatableEdge <int>(1, 2);
Assert.IsFalse(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsFalse(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge1);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsFalse(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge2);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsFalse(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge3);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsFalse(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
graph.AddEdge(edge4);
Assert.IsTrue(graph.ContainsEdge(edge1));
Assert.IsTrue(graph.ContainsEdge(edge2));
Assert.IsTrue(graph.ContainsEdge(edge3));
Assert.IsTrue(graph.ContainsEdge(edge4));
Assert.IsTrue(graph.ContainsEdge(otherEdge1));
// Both vertices not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(10, 11)));
// Source not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(10, 1)));
// Target not in graph
Assert.IsFalse(graph.ContainsEdge(new EquatableEdge <int>(1, 10)));
}
public void MergeIf3()
{
var edge34 = new EquatableEdge <int>(3, 4);
MergeIf_Test(
new[] { 1, 2, 3, 4 },
new[] { edge34 },
vertex => vertex == 1 || vertex == 2,
1 + 1,
0 + 0,
0 + 0,
new[] { 3, 4 },
new[] { edge34 });
}
public void MergeIf4()
{
var edge34 = new EquatableEdge <int>(3, 4);
MergeIf_Test(
new[] { 1, 2, 3, 4 },
new[] { edge34 },
vertex => vertex == 1 || vertex == 3,
1 + 1,
0 + 0,
0 + 1,
new[] { 2, 4 },
Enumerable.Empty <EquatableEdge <int> >());
}
private bool CutRedundantSolutionBuilds(ISet <EquatableEdge <IBuilder> > graph)
{
log.Debug("### Cutting redundant solution builds");
var slnBuilders = new HashSet <SlnBuilder>(graph.Select(edge => edge.Target).OfType <SlnBuilder>());
var rootBuilderMap = graph
.Where(edge => edge.Source is MSBuildRunner && slnBuilders.Contains(edge.Target))
.ToDictionary(edge => (SlnBuilder)edge.Target, edge => FindSolutionRootBuilder(graph, edge));
if (slnBuilders.Any())
{
foreach (var slnBuilder in slnBuilders)
{
if (rootBuilderMap.ContainsKey(slnBuilder))
{
var projectSet = new HashSet <Project>(slnBuilder.Projects);
var childProjectBuilders = new HashSet <ISlnProjectBuilder>(slnBuilder
.Prerequisites
.OfType <ISlnProjectBuilder>());
foreach (var projectBuilder in childProjectBuilders)
{
foreach (var dep in projectBuilder.Prerequisites.OfType <SuiteReferenceBuilder>().ToList())
{
if (dep.Reference.Type == ReferenceType.Build &&
projectSet.Contains(dep.ReferencedProject))
{
log.DebugFormat(
"Project {0}'s reference {1} can be replaced to in-solution-reference in {2}",
projectBuilder.Project, dep, slnBuilder);
// All sln project builders belonging to `slnBuilder` must replace their reference to dep to a
// new in solution reference builder (both in the builder and in the graph)
ReplaceWithInSolutionReference(graph, childProjectBuilders, dep);
// All edges from dep must be removed and a single new edge to the MSBuild runner belonging to this `slnBuilder` added
RemoveEdgesWhereSourceIs(graph, dep);
var newEdge = new EquatableEdge <IBuilder>(dep, rootBuilderMap[slnBuilder]);
AddEdge(graph, newEdge);
}
}
}
}
}
}
return(true);
}
protected static void AddEdge_NoParallelEdges_EquatableEdge_UndirectedGraph_Test <TGraph>([NotNull] TGraph graph)
where TGraph : IMutableVertexSet <int>, IMutableEdgeListGraph <int, EquatableEdge <int> >
{
int edgeAdded = 0;
graph.AddVertex(1);
graph.AddVertex(2);
AssertNoEdge(graph);
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
graph.EdgeAdded += e =>
{
Assert.IsNotNull(e);
++edgeAdded;
};
// Edge 1
var edge1 = new EquatableEdge <int>(1, 2);
Assert.IsTrue(graph.AddEdge(edge1));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 2
var edge2 = new EquatableEdge <int>(1, 2);
Assert.IsFalse(graph.AddEdge(edge2));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 3
var edge3 = new EquatableEdge <int>(2, 1);
Assert.IsFalse(graph.AddEdge(edge3)); // Parallel to edge 1
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 1 bis
Assert.IsFalse(graph.AddEdge(edge1));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 4 self edge
var edge4 = new EquatableEdge <int>(2, 2);
Assert.IsTrue(graph.AddEdge(edge4));
Assert.AreEqual(2, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge4 });
}
public void removeIsolatedVertices()
{
var graph = new UndirectedGraph <int, IEdge <int> >();
graph.AddVertex(1);
var edge = new EquatableEdge <int>(2, 3);
graph.AddVerticesAndEdge(edge);
graph.RemoveVertexIf(graph.IsAdjacentEdgesEmpty);
Assert.IsTrue(graph.ContainsVertex(2));
Assert.IsTrue(graph.ContainsEdge(edge));
Assert.IsTrue(graph.ContainsEdge(2, 3));
Assert.IsTrue(graph.ContainsEdge(3, 2));
Assert.IsFalse(graph.ContainsVertex(1));
}
void AddNewBranch(ISet <EquatableEdge <IBuilder> > graph, IBuilder rootBuilder)
{
log.DebugFormat("Adding new node: {0}", rootBuilder);
graph.Add(new EquatableEdge <IBuilder>(rootBuilder, rootBuilder));
foreach (var prereq in rootBuilder.Prerequisites)
{
var newEdge = new EquatableEdge <IBuilder>(rootBuilder, prereq);
if (!graph.Contains(newEdge))
{
AddEdge(graph, newEdge);
AddNewBranch(graph, prereq);
}
}
}
public void removeIsolatedVertices()
{
var graph = new BidirectionalGraph <int, IEdge <int> >();
graph.AddVertex(1);
var edge = new EquatableEdge <int>(2, 3);
graph.AddVerticesAndEdge(edge);
var predicate = new IsolatedVertexPredicate <int, IEdge <int> >(graph);
graph.RemoveVertexIf(predicate.Test);
Assert.IsTrue(graph.ContainsVertex(2));
Assert.IsTrue(graph.ContainsEdge(edge));
Assert.IsFalse(graph.ContainsVertex(1));
}
public bool Split(out Task <TVertex, TEdge> taskTake, out Task <TVertex, TEdge> taskDrop)
{
if (!canSplit())
{
taskTake = null;
taskDrop = null;
return(false);
}
TEdge edgeForSplit = this.chooseEdgeForSplit();
var v1 = edgeForSplit.Source;
var v2 = edgeForSplit.Target;
var graphTake = this._graph.Clone();
var weightsTake = new Dictionary <EquatableEdge <TVertex>, double>(_weight);
var reverseEdge = new EquatableEdge <TVertex>(edgeForSplit.Target, edgeForSplit.Source);
weightsTake.Remove(reverseEdge);
graphTake.RemoveEdgeIf(edge => edge.Equals(reverseEdge));
foreach (var outEdge in graphTake.OutEdges(v1))
{
weightsTake.Remove(outEdge);
}
foreach (var inEdge in graphTake.InEdges(v2))
{
weightsTake.Remove(inEdge);
}
graphTake.ClearOutEdges(v1);
graphTake.ClearInEdges(v2);
var pathTake = new BidirectionalGraph <TVertex, TEdge>(Path);
pathTake.AddEdge(edgeForSplit);
taskTake = new Task <TVertex, TEdge>(graphTake, weightsTake, pathTake, MinCost);
taskTake.TaskName = "Take" + edgeForSplit.ToString();
var graphDrop = this._graph.Clone();
var weightsDrop = new Dictionary <EquatableEdge <TVertex>, double>(_weight);
weightsDrop.Remove(edgeForSplit);
graphDrop.RemoveEdge(edgeForSplit);
taskDrop = new Task <TVertex, TEdge>(graphDrop, weightsDrop, new BidirectionalGraph <TVertex, TEdge>(Path), MinCost);
taskDrop.TaskName = "Drop" + edgeForSplit.ToString();
return(true);
}
protected static void AddEdge_NoParallelEdges_EquatableEdge_Test <TGraph>(TGraph graph)
where TGraph : IMutableVertexSet <int>, IMutableEdgeListGraph <int, EquatableEdge <int> >
{
int edgeAdded = 0;
graph.AddVertex(1);
graph.AddVertex(2);
AssertNoEdge(graph);
graph.EdgeAdded += e =>
{
Assert.IsNotNull(e);
++edgeAdded;
};
// Edge 1
var edge1 = new EquatableEdge <int>(1, 2);
Assert.IsTrue(graph.AddEdge(edge1));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 2
var edge2 = new EquatableEdge <int>(1, 2);
Assert.IsFalse(graph.AddEdge(edge2));
Assert.AreEqual(1, edgeAdded);
AssertHasEdges(graph, new[] { edge1 });
// Edge 3
var edge3 = new EquatableEdge <int>(2, 1);
Assert.IsTrue(graph.AddEdge(edge3));
Assert.AreEqual(2, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge3 });
// Edge 1 bis
Assert.IsFalse(graph.AddEdge(edge1));
Assert.AreEqual(2, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge3 });
// Edge 4 self edge
var edge4 = new EquatableEdge <int>(2, 2);
Assert.IsTrue(graph.AddEdge(edge4));
Assert.AreEqual(3, edgeAdded);
AssertHasEdges(graph, new[] { edge1, edge3, edge4 });
}
public void toBidirectionalGraphTest()
{
var graph = new UndirectedGraph <int, IEdge <int> >();
graph.AddVertex(1);
var edge = new EquatableEdge <int>(2, 3);
graph.AddVerticesAndEdge(edge);
var bidirectionalGraph = graph.ToBidirectionalGraph();
Assert.IsTrue(bidirectionalGraph.ContainsVertex(1));
Assert.IsTrue(bidirectionalGraph.ContainsVertex(2));
Assert.IsTrue(bidirectionalGraph.ContainsVertex(3));
Assert.IsTrue(bidirectionalGraph.ContainsEdge(2, 3));
Assert.IsFalse(bidirectionalGraph.ContainsEdge(3, 2));
}
public void ContainsEdgeTest2()
{
var bd = new BidirectionalGraph<int, IEdge<int>>();
var e12 = new EquatableEdge<int>(1, 2);
var f12 = new EquatableEdge<int>(1, 2);
var e21 = new EquatableEdge<int>(2, 1);
var f21 = new EquatableEdge<int>(2, 1);
bd.AddVerticesAndEdge(e12);
ContainsEdgeAssertions(bd, e12, f12, e21, f21);
var u = new UndirectedBidirectionalGraph<int, IEdge<int>>(bd);
UndirectedGraphTest.ContainsEdgeAssertions(u, e12, f12, e21, f21);
}
public bool Split(out Task <TVertex, TEdge> taskTake, out Task <TVertex, TEdge> taskDrop)
{
if (!CanSplit())
{
taskTake = null;
taskDrop = null;
return(false);
}
TEdge edgeForSplit = ChooseEdgeForSplit();
TVertex v1 = edgeForSplit.Source;
TVertex v2 = edgeForSplit.Target;
BidirectionalGraph <TVertex, TEdge> graphTake = _graph.Clone();
var weightsTake = new Dictionary <EquatableEdge <TVertex>, double>(_weight);
var reverseEdge = new EquatableEdge <TVertex>(edgeForSplit.Target, edgeForSplit.Source);
weightsTake.Remove(reverseEdge);
graphTake.RemoveEdgeIf(edge => reverseEdge.Equals(edge));
foreach (TEdge outEdge in graphTake.OutEdges(v1))
{
weightsTake.Remove(outEdge);
}
foreach (TEdge inEdge in graphTake.InEdges(v2))
{
weightsTake.Remove(inEdge);
}
graphTake.ClearOutEdges(v1);
graphTake.ClearInEdges(v2);
var pathTake = new BidirectionalGraph <TVertex, TEdge>(Path);
pathTake.AddEdge(edgeForSplit);
taskTake = new Task <TVertex, TEdge>(graphTake, weightsTake, pathTake, MinCost, $"Take{edgeForSplit}");
BidirectionalGraph <TVertex, TEdge> graphDrop = _graph.Clone();
var weightsDrop = new Dictionary <EquatableEdge <TVertex>, double>(_weight);
weightsDrop.Remove(edgeForSplit);
graphDrop.RemoveEdge(edgeForSplit);
taskDrop = new Task <TVertex, TEdge>(graphDrop, weightsDrop, new BidirectionalGraph <TVertex, TEdge>(Path), MinCost, $"Drop{edgeForSplit}");
return(true);
}
public void Prim12240WithDelegate()
{
var vertices = new int[]{ 1,2,3,4};
var g = vertices.ToDelegateUndirectedGraph(
delegate(int v, out IEnumerable<EquatableEdge<int>> ov)
{
switch (v)
{
case 1: ov = new EquatableEdge<int>[] { new EquatableEdge<int>(1, 2), new EquatableEdge<int>(1, 4) }; break;
case 2: ov = new EquatableEdge<int>[] { new EquatableEdge<int>(1, 2), new EquatableEdge<int>(3, 2) }; break;
case 3: ov = new EquatableEdge<int>[] { new EquatableEdge<int>(3, 2), new EquatableEdge<int>(3, 4) }; break;
case 4: ov = new EquatableEdge<int>[] { new EquatableEdge<int>(1, 4), new EquatableEdge<int>(3, 4) }; break;
default: ov = null; break;
}
return ov != null;
});
var cost = CompareRoot(g);
Assert.AreEqual(9, cost);
}
private bool CutRedundantSolutionBuilds(ISet<EquatableEdge<IBuilder>> graph)
{
log.Debug("### Cutting redundant solution builds");
var slnBuilders = new HashSet<SlnBuilder>(graph.Select(edge => edge.Target).OfType<SlnBuilder>());
var rootBuilderMap = graph
.Where(edge => edge.Source is MSBuildRunner && slnBuilders.Contains(edge.Target))
.ToDictionary(edge => (SlnBuilder)edge.Target, edge => FindSolutionRootBuilder(graph, edge));
if (slnBuilders.Any())
{
foreach (var slnBuilder in slnBuilders)
{
if (rootBuilderMap.ContainsKey(slnBuilder))
{
var projectSet = new HashSet<Project>(slnBuilder.Projects);
var childProjectBuilders = new HashSet<ISlnProjectBuilder>(slnBuilder
.Prerequisites
.OfType<ISlnProjectBuilder>());
foreach (var projectBuilder in childProjectBuilders)
{
foreach (var dep in projectBuilder.Prerequisites.OfType<SuiteReferenceBuilder>().ToList())
{
if (dep.Reference.Type == ReferenceType.Build &&
projectSet.Contains(dep.ReferencedProject))
{
log.DebugFormat(
"Project {0}'s reference {1} can be replaced to in-solution-reference in {2}",
projectBuilder.Project, dep, slnBuilder);
// All sln project builders belonging to `slnBuilder` must replace their reference to dep to a
// new in solution reference builder (both in the builder and in the graph)
ReplaceWithInSolutionReference(graph, childProjectBuilders, dep);
// All edges from dep must be removed and a single new edge to the MSBuild runner belonging to this `slnBuilder` added
RemoveEdgesWhereSourceIs(graph, dep);
var newEdge = new EquatableEdge<IBuilder>(dep, rootBuilderMap[slnBuilder]);
AddEdge(graph, newEdge);
}
}
}
}
}
}
return true;
}
public TestCase AddDirectedEdge(String source, String target, double weight)
{
var e = new EquatableEdge<String>(source, target);
Graph.AddEdge(e);
WeightsDict.Add(e, weight);
return this;
}
void AddNewBranch(ISet<EquatableEdge<IBuilder>> graph, IBuilder rootBuilder)
{
log.DebugFormat("Adding new node: {0}", rootBuilder);
graph.Add(new EquatableEdge<IBuilder>(rootBuilder, rootBuilder));
foreach (var prereq in rootBuilder.Prerequisites)
{
var newEdge = new EquatableEdge<IBuilder>(rootBuilder, prereq);
if (!graph.Contains(newEdge))
{
AddEdge(graph, newEdge);
AddNewBranch(graph, prereq);
}
}
}
private static void AddEdge(ISet<EquatableEdge<IBuilder>> graph, EquatableEdge<IBuilder> newEdge)
{
log.DebugFormat("-> adding edge {0}", newEdge);
newEdge.Source.AddPrerequisite(newEdge.Target);
graph.Add(newEdge);
}
private void RerouteEdgesTargeting(ISet<EquatableEdge<IBuilder>> graph, ISet<IBuilder> originalTargets, IBuilder replacementTarget)
{
log.DebugFormat("-> Rerouting edges targeting {0} to {1}", string.Join(", ", originalTargets), replacementTarget);
var edgesToRemove = new HashSet<EquatableEdge<IBuilder>>();
var edgesToAdd = new HashSet<EquatableEdge<IBuilder>>();
foreach (var edge in graph)
{
if (originalTargets.Contains(edge.Target) && edge.Target != edge.Source && edge.Target != replacementTarget)
{
edgesToRemove.Add(edge);
var newEdge = new EquatableEdge<IBuilder>(edge.Source, replacementTarget);
edgesToAdd.Add(newEdge);
}
}
RemoveEdges(graph, edgesToRemove);
foreach (var edge in edgesToAdd)
AddEdge(graph, edge);
}
void ReplaceWithInSolutionReference(ISet<EquatableEdge<IBuilder>> graph, IEnumerable<ISlnProjectBuilder> childProjectBuilders, SuiteReferenceBuilder dep)
{
var inSolutionRef = inSolutionReferenceBuilderFactory.CreateInSolutionReferenceBuilder(dep.ReferencedProject);
inSolutionRef.Reference = dep.Reference;
foreach (var builder in childProjectBuilders)
{
builder.RemovePrerequisite(dep);
var edgesToModify = new HashSet<EquatableEdge<IBuilder>>(graph.Where(edge => edge.Source == builder && edge.Target == dep));
RemoveEdges(graph, edgesToModify);
foreach (var edge in edgesToModify)
{
var newEdge = new EquatableEdge<IBuilder>(edge.Source, inSolutionRef);
AddEdge(graph, newEdge);
}
}
}
