internal void Graph_OutEdgesShouldHaveSameTail(GraphDefinitionParameter p)
{
// Arrange
Graph.Builder builder = new(p.VertexCount, p.Edges.Count);
foreach (Endpoints endpoints in p.Edges)
{
builder.Add(endpoints.Tail, endpoints.Head);
}
Graph graph = builder.ToGraph();
// Act
for (int vertex = 0; vertex < graph.VertexCount; ++vertex)
{
EdgeEnumerator outEdges = graph.EnumerateOutEdges(vertex);
while (outEdges.MoveNext())
{
int edge = outEdges.Current;
bool hasTail = graph.TryGetTail(edge, out int tail);
if (!hasTail)
{
Assert.True(hasTail);
}
// Assert
Assert.Equal(vertex, tail);
}
}
}
internal void Graph_ShouldContainSameSetOfEdges(GraphDefinitionParameter p)
{
// Arrange
Graph.Builder builder = new(p.VertexCount, p.Edges.Count);
foreach (Endpoints endpoints in p.Edges)
{
builder.Add(endpoints.Tail, endpoints.Head);
}
Graph graph = builder.ToGraph();
HashSet <Endpoints> expectedEdgeSet = p.Edges.ToHashSet();
// Act
HashSet <Endpoints> actualEdgeSet = new();
for (int vertex = 0; vertex < graph.VertexCount; ++vertex)
{
EdgeEnumerator outEdges = graph.EnumerateOutEdges(vertex);
while (outEdges.MoveNext())
{
int edge = outEdges.Current;
bool hasEndpoints = TryGetEndpoints(graph, edge, out Endpoints endpoints);
if (!hasEndpoints)
{
Assert.True(hasEndpoints);
}
actualEdgeSet.Add(endpoints);
}
}
// Assert
Assert.Equal(expectedEdgeSet, actualEdgeSet, HashSetEqualityComparer);
}
private static bool TryGetEndpoints(Graph graph, int edge, out Endpoints endpoints)
{
bool hasTail = graph.TryGetTail(edge, out int tail);
bool hasHead = graph.TryGetHead(edge, out int head);
endpoints = new Endpoints(tail, head);
return(hasTail && hasHead);
}
internal void Graph_SizeShouldMatch(GraphDefinitionParameter p)
{
// Arrange
Graph.Builder builder = new(p.VertexCount, p.Edges.Count);
foreach (Endpoints endpoints in p.Edges)
{
builder.Add(endpoints.Tail, endpoints.Head);
}
// Act
Graph graph = builder.ToGraph();
// Assert
Assert.Equal(p.VertexCount, graph.VertexCount);
Assert.Equal(p.Edges.Count, graph.EdgeCount);
}
/// <inheritdoc/> public bool Equals(IndexedIncidenceGraph other) => _data == other._data;
private void EnumerateEdgesCore(Graph graph, bool multipleSource)
{
// Arrange
byte[] mapBackingStore = ArrayPool <byte> .Shared.Rent(Math.Max(graph.VertexCount, 1));
Array.Clear(mapBackingStore, 0, mapBackingStore.Length);
IndexedColorDictionary eagerColorMap = new(mapBackingStore);
byte[] setBackingStore = ArrayPool <byte> .Shared.Rent(Math.Max(graph.VertexCount, 1));
Array.Clear(setBackingStore, 0, setBackingStore.Length);
IndexedSet set = new(setBackingStore);
using Rist <int> eagerSteps = new(graph.VertexCount);
using Rist <int> enumerableSteps = new(graph.VertexCount);
DfsHandler <Graph, int, int> dfsHandler = CreateDfsHandler(eagerSteps);
// Act
if (multipleSource)
{
if (graph.VertexCount < 3)
{
return;
}
int sourceCount = graph.VertexCount / 3;
IndexEnumerator sources = new(sourceCount);
EagerDfs.Traverse(graph, sources, eagerColorMap, dfsHandler);
using IEnumerator <int> edges = EnumerableDfs.EnumerateEdges(graph, sources, set);
enumerableSteps.AddEnumerator(edges);
}
else
{
int source = graph.VertexCount >> 1;
EagerDfs.Traverse(graph, source, eagerColorMap, dfsHandler);
using IEnumerator <int> edges = EnumerableDfs.EnumerateEdges(graph, source, set);
enumerableSteps.AddEnumerator(edges);
}
// Assert
int eagerStepCount = eagerSteps.Count;
int enumerableStepCount = enumerableSteps.Count;
Assert.Equal(eagerStepCount, enumerableStepCount);
int count = eagerStepCount;
for (int i = 0; i < count; ++i)
{
int eagerStep = eagerSteps[i];
int enumerableStep = enumerableSteps[i];
if (eagerStep == enumerableStep)
{
continue;
}
Assert.Equal(eagerStep, enumerableStep);
}
// Cleanup
ArrayPool <byte> .Shared.Return(mapBackingStore);
ArrayPool <byte> .Shared.Return(setBackingStore);
}
