public void IslandNodes_RegisterBothAsLeafAndRoot([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
test.Nodes.Add(test.TestDatabase.CreateNode());
var cache = test.GetUpdatedCache();
Assert.AreEqual(cache.Leaves.Length, 1);
Assert.AreEqual(cache.Roots.Length, 1);
var roots = new List <Node>();
for (int i = 0; i < cache.Leaves.Length; ++i)
{
roots.Add(cache.OrderedTraversal[cache.Roots[i]].Vertex);
}
var leaves = new List <Node>();
for (int i = 0; i < cache.Roots.Length; ++i)
{
leaves.Add(cache.OrderedTraversal[cache.Leaves[i]].Vertex);
}
CollectionAssert.Contains(leaves, test.Nodes[0]);
CollectionAssert.Contains(roots, test.Nodes[0]);
}
}
public void CanCongaWalkAndDependenciesAreInCorrectOrder([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
var node1 = test.TestDatabase.CreateNode();
var node2 = test.TestDatabase.CreateNode();
var node3 = test.TestDatabase.CreateNode();
test.Nodes.Add(node1);
test.Nodes.Add(node2);
test.Nodes.Add(node3);
test.TestDatabase.Connect(node1, k_OutputOne, node2, k_InputOne);
test.TestDatabase.Connect(node2, k_OutputOne, node3, k_InputOne);
var index = 0;
foreach (var node in test.GetWalker())
{
Assert.AreEqual(node.CacheIndex, index);
Assert.AreEqual(node.Vertex, test.Nodes[index]);
index++;
}
}
}
public void ComplexDAG_ProducesDeterministic_TraversalOrder([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
const int k_NumGraphs = 10;
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < k_NumGraphs; ++i)
{
test.CreateTestDAG();
}
var cache = test.GetUpdatedCache();
const string kExpectedMaximallyParallelOrder =
"0, 2, 5, 8, 13, 14, 16, 19, 22, 27, 28, 30, 33, 36, " +
"41, 42, 44, 47, 50, 55, 56, 58, 61, 64, 69, 70, 72, 75, " +
"78, 83, 84, 86, 89, 92, 97, 98, 100, 103, 106, 111, 112, 114, " +
"117, 120, 125, 126, 128, 131, 134, 139, 1, 9, 15, 23, 29, 37, " +
"43, 51, 57, 65, 71, 79, 85, 93, 99, 107, 113, 121, 127, " +
"135, 10, 24, 38, 52, 66, 80, 94, 108, 122, 136, 6, 3, 20, " +
"17, 34, 31, 48, 45, 62, 59, 76, 73, 90, 87, 104, 101, 118, " +
"115, 132, 129, 7, 11, 4, 21, 25, 18, 35, 39, 32, 49, 53, " +
"46, 63, 67, 60, 77, 81, 74, 91, 95, 88, 105, 109, 102, 119, " +
"123, 116, 133, 137, 130, 12, 26, 40, 54, 68, 82, 96, 110, 124, 138";
const string kExpectedIslandOrder =
"0, 1, 2, 8, 9, 10, 5, 6, 7, 3, 11, 12, 4, 13, " +
"14, 15, 16, 22, 23, 24, 19, 20, 21, 17, 25, 26, 18, 27, " +
"28, 29, 30, 36, 37, 38, 33, 34, 35, 31, 39, 40, 32, 41, " +
"42, 43, 44, 50, 51, 52, 47, 48, 49, 45, 53, 54, 46, 55, " +
"56, 57, 58, 64, 65, 66, 61, 62, 63, 59, 67, 68, 60, 69, " +
"70, 71, 72, 78, 79, 80, 75, 76, 77, 73, 81, 82, 74, 83, " +
"84, 85, 86, 92, 93, 94, 89, 90, 91, 87, 95, 96, 88, 97, " +
"98, 99, 100, 106, 107, 108, 103, 104, 105, 101, 109, 110, 102, 111, " +
"112, 113, 114, 120, 121, 122, 117, 118, 119, 115, 123, 124, 116, 125, " +
"126, 127, 128, 134, 135, 136, 131, 132, 133, 129, 137, 138, 130, 139";
var traversalIndices = new List <string>();
for (int i = 0; i < cache.OrderedTraversal.Length; ++i)
{
traversalIndices.Add(cache.OrderedTraversal[i].Vertex.Id.ToString());
}
var stringTraversalOrder = string.Join(", ", traversalIndices);
switch (algo)
{
case Topology.SortingAlgorithm.GlobalBreadthFirst:
Assert.AreEqual(kExpectedMaximallyParallelOrder, stringTraversalOrder);
break;
case Topology.SortingAlgorithm.LocalDepthFirst:
Assert.AreEqual(kExpectedIslandOrder, stringTraversalOrder);
break;
}
}
}
public Test(Topology.SortingAlgorithm algo, ComputeType computingType, uint traversalMask, uint alternateMask)
{
Cache = new Topology.TraversalCache(0, traversalMask, alternateMask);
Nodes = new NativeList <Node>(10, Allocator.Temp);
TestDatabase = new TopologyTestDatabase(Allocator.Temp);
m_Options = Topology.CacheAPI.ComputationOptions.Create(computeJobified: computingType == ComputeType.Jobified);
Version = Topology.CacheAPI.VersionTracker.Create();
m_Algorithm = algo;
}
public void DeepImplicitlyCyclicDataGraph_ProducesDeferredError([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType, [Values(0, 1, 10, 13, 100)] int depth)
{
using (var test = new Test(algo, computeType))
{
// create three branches
Node
a = test.TestDatabase.CreateNode(),
b = test.TestDatabase.CreateNode(),
c = test.TestDatabase.CreateNode();
// intertwine
test.TestDatabase.Connect(a, k_OutputOne, b, k_InputOne);
test.TestDatabase.Connect(b, k_OutputOne, c, k_InputOne);
test.Nodes.Add(a);
test.Nodes.Add(b);
test.Nodes.Add(c);
// fork off ->
// o-o-o-o-o-o-o-o ...
// |
// o-o-o-o-o-o-o-o ...
// |
// o-o-o-o-o-o-o-o ...
for (int i = 0; i < depth; ++i)
{
a = test.TestDatabase.CreateNode();
b = test.TestDatabase.CreateNode();
c = test.TestDatabase.CreateNode();
test.TestDatabase.Connect(test.Nodes[i * 3 + 0], k_OutputOne, a, k_InputOne);
test.TestDatabase.Connect(test.Nodes[i * 3 + 1], k_OutputOne, b, k_InputOne);
test.TestDatabase.Connect(test.Nodes[i * 3 + 2], k_OutputOne, c, k_InputOne);
test.Nodes.Add(a);
test.Nodes.Add(b);
test.Nodes.Add(c);
}
// connect very last node to start, forming a cycle
// -> o-o-o-o-o-o-o-o->
// | |
// | o-o-o-o-o-o-o-o->
// | |
// | o-o-o-o-o-o-o-o
// -----------------|
test.TestDatabase.Connect(test.Nodes[test.Nodes.Length - 1], k_OutputOne, test.Nodes[0], k_InputOne);
var cache = test.GetUpdatedCache();
Assert.AreEqual(1, cache.Errors.Length);
Assert.AreEqual(Topology.TraversalCache.Error.Cycles, cache.Errors[0]);
}
}
public void CanFindParentsAndChildren([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
var parents = new List <Node>();
foreach (var parent in node.GetParents())
{
parents.Add(parent.Vertex);
}
var children = new List <Node>();
foreach (var child in node.GetChildren())
{
children.Add(child.Vertex);
}
Assert.AreEqual(2, children.Count);
Assert.AreEqual(2, parents.Count);
Assert.IsTrue(parents.Exists(e => e == test.Nodes[0]));
Assert.IsTrue(parents.Exists(e => e == test.Nodes[1]));
Assert.IsTrue(children.Exists(e => e == test.Nodes[3]));
Assert.IsTrue(children.Exists(e => e == test.Nodes[4]));
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
public void TestInternalIndices([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
var node1 = test.TestDatabase.CreateNode();
var node2 = test.TestDatabase.CreateNode();
var node3 = test.TestDatabase.CreateNode();
test.Nodes.Add(node1);
test.Nodes.Add(node2);
test.Nodes.Add(node3);
Assert.DoesNotThrow(() => test.TestDatabase.Connect(node2, k_OutputOne, node1, k_InputOne));
Assert.DoesNotThrow(() => test.TestDatabase.Connect(node3, k_OutputOne, node1, k_InputThree));
var entryIndex = 0;
foreach (var node in test.GetWalker())
{
if (entryIndex == 0 || entryIndex == 1)
{
Assert.AreEqual(0, node.GetParents().Count);
}
else
{
Assert.AreEqual(2, node.GetParents().Count);
foreach (var parent in node.GetParents())
{
Assert.IsTrue(parent.Vertex == node2 || parent.Vertex == node3);
}
}
if (entryIndex == 0 || entryIndex == 1)
{
Assert.AreEqual(1, node.GetChildren().Count);
foreach (var child in node.GetChildren())
{
Assert.AreEqual(node1, child.Vertex);
}
}
else
{
Assert.AreEqual(0, node.GetChildren().Count);
}
entryIndex++;
}
}
}
public void PortIndices_OnCacheConnections_MatchesOriginalTopology([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
var inPorts = new[] { k_InputOne, k_InputTwo };
var outPorts = new[] { k_OutputOne, k_OutputTwo };
for (int i = 0; i < 2; ++i)
{
foreach (var parentConnection in node.GetParentConnectionsByPort(inPorts[i]))
{
Assert.AreEqual(k_OutputOne, parentConnection.OutputPort);
Assert.AreEqual(inPorts[i], parentConnection.InputPort);
}
}
for (int i = 0; i < 2; ++i)
{
foreach (var childConnection in node.GetChildConnectionsByPort(outPorts[i]))
{
Assert.AreEqual(k_InputOne, childConnection.InputPort);
Assert.AreEqual(outPorts[i], childConnection.OutputPort);
}
}
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
public void CompletelyCyclicDataGraph_ProducesAvailableError([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType)
{
using (var test = new Test(algo, computeType))
{
test.Nodes.Add(test.TestDatabase.CreateNode());
test.Nodes.Add(test.TestDatabase.CreateNode());
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[1], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[0], k_InputOne);
var cache = test.GetUpdatedCache();
Assert.AreEqual(1, cache.Errors.Length);
Assert.AreEqual(Topology.TraversalCache.Error.Cycles, cache.Errors[0]);
}
}
public void CanFindParentsAndChildren_ByPort_ThroughConnection([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
for (int i = 0; i < 2; ++i)
{
foreach (var parentConnection in node.GetParentConnectionsByPort(i == 0 ? k_InputOne : k_InputTwo))
{
Assert.AreEqual(test.Nodes[i], parentConnection.Target.Vertex);
}
}
for (int i = 0; i < 2; ++i)
{
foreach (var childConnection in node.GetChildConnectionsByPort(i == 0 ? k_OutputOne : k_OutputTwo))
{
Assert.AreEqual(test.Nodes[i + 3], childConnection.Target.Vertex);
}
}
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
public void MultipleIsolatedGraphs_CanStillBeWalked_InOneCompleteOrder([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
const int graphs = 5, nodes = 5;
using (var test = new Test(algo, jobified))
{
for (int g = 0; g < graphs; ++g)
{
for (int n = 0; n < nodes; ++n)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
for (int n = 0; n < nodes - 1; ++n)
{
test.TestDatabase.Connect(test.Nodes[0 + n + g * nodes], k_OutputOne, test.Nodes[1 + n + g * nodes], k_InputOne);
}
}
foreach (var node in test.GetWalker())
{
for (int g = 0; g < graphs; ++g)
{
if (node.Vertex == test.Nodes[g * nodes]) // root ?
{
// walk root, and ensure each next child is ordered with respect to original connection order (conga line)
var parent = node;
for (int n = 0; n < nodes - 1; ++n)
{
foreach (var child in parent.GetChildren())
{
Assert.AreEqual(child.Vertex, test.Nodes[n + 1 + g * nodes]);
parent = child;
break;
}
}
}
}
}
}
}
public void RootsAndLeaves_InternalIndices_AreRegistrered([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
var cache = test.GetUpdatedCache();
var rootWalker = new Topology.RootCacheWalker(cache);
var leafWalker = new Topology.LeafCacheWalker(cache);
var roots = new List <Node>();
var leaves = new List <Node>();
Assert.AreEqual(rootWalker.Count, 2);
Assert.AreEqual(leafWalker.Count, 2);
foreach (var nodeCache in rootWalker)
{
roots.Add(nodeCache.Vertex);
}
foreach (var nodeCache in leafWalker)
{
leaves.Add(nodeCache.Vertex);
}
CollectionAssert.Contains(leaves, test.Nodes[0]);
CollectionAssert.Contains(leaves, test.Nodes[1]);
CollectionAssert.Contains(roots, test.Nodes[3]);
CollectionAssert.Contains(roots, test.Nodes[4]);
}
}
public void RootAndLeafCacheWalker_WalksRootsAndLeaves([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
var cache = test.GetUpdatedCache();
Assert.AreEqual(cache.Leaves.Length, 2);
Assert.AreEqual(cache.Roots.Length, 2);
var roots = new List <Node>();
for (int i = 0; i < cache.Leaves.Length; ++i)
{
roots.Add(cache.OrderedTraversal[cache.Roots[i]].Vertex);
}
var leaves = new List <Node>();
for (int i = 0; i < cache.Roots.Length; ++i)
{
leaves.Add(cache.OrderedTraversal[cache.Leaves[i]].Vertex);
}
CollectionAssert.Contains(leaves, test.Nodes[0]);
CollectionAssert.Contains(leaves, test.Nodes[1]);
CollectionAssert.Contains(roots, test.Nodes[3]);
CollectionAssert.Contains(roots, test.Nodes[4]);
}
}
public void TraversalCache_DoesNotInclude_IgnoredTraversalTypes([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType, [Values] TraversalType traversalType)
{
using (var test = new Test(algo, computeType, (uint)traversalType))
{
int numParents = traversalType == TraversalType.Different ? 2 : 0;
int numChildren = traversalType == TraversalType.Normal ? 2 : 0;
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[0], k_DifferentOutput, test.Nodes[2], k_DifferentInput);
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[1], k_DifferentOutput, test.Nodes[2], k_DifferentInput);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[2], k_OutputOne, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
Assert.AreEqual(0, node.GetParentsByPort(k_InputOne).Count);
Assert.AreEqual(numParents, node.GetParentsByPort(k_DifferentInput).Count);
Assert.AreEqual(0, node.GetChildrenByPort(k_DifferentOutput).Count);
Assert.AreEqual(numChildren, node.GetChildrenByPort(k_OutputOne).Count);
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
public void CacheUpdate_IsComputed_InExpectedExecutionVehicle([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.GetUpdatedCache();
Assert.AreNotEqual(BurstConfig.ExecutionResult.Undefined, test.TestDatabase.Nodes.GetLastExecutionEngine());
if (!BurstConfig.IsBurstEnabled)
{
Assert.AreEqual(BurstConfig.ExecutionResult.InsideMono, test.TestDatabase.Nodes.GetLastExecutionEngine());
}
else
{
Assert.AreEqual(jobified == ComputeType.Jobified, test.TestDatabase.Nodes.GetLastExecutionEngine() == BurstConfig.ExecutionResult.InsideBurst);
}
}
}
public void ParentAndChildConnections_HasCorrectCounts([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
test.TestDatabase.Connect(test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect(test.Nodes[1], k_OutputOne, test.Nodes[2], k_InputTwo);
test.TestDatabase.Connect(test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect(test.Nodes[2], k_OutputTwo, test.Nodes[4], k_InputOne);
bool centerNodeWasFound = false;
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[2])
{
Assert.AreEqual(2, node.GetParentConnections().Count);
Assert.AreEqual(1, node.GetParentConnectionsByPort(k_InputOne).Count);
Assert.AreEqual(1, node.GetParentConnectionsByPort(k_InputTwo).Count);
Assert.AreEqual(2, node.GetChildConnections().Count);
Assert.AreEqual(1, node.GetChildConnectionsByPort(k_OutputOne).Count);
Assert.AreEqual(1, node.GetChildConnectionsByPort(k_OutputTwo).Count);
centerNodeWasFound = true;
break;
}
}
Assert.IsTrue(centerNodeWasFound, "Couldn't find middle of graph");
}
}
public void TraversalCache_ForUnrelatedNodes_StillContainAllNodes([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
var foundNodes = new List <Node>();
foreach (var node in test.GetWalker())
{
foundNodes.Add(node.Vertex);
}
for (int i = 0; i < test.Nodes.Length; ++i)
{
CollectionAssert.Contains(foundNodes, test.Nodes[i]);
}
Assert.AreEqual(test.Nodes.Length, foundNodes.Count);
}
}
public void AlternateDependencies_CanDiffer_FromTraversal([Values] Topology.SortingAlgorithm algo, [Values] ComputeType computeType)
{
using (var test = new Test(algo, computeType, (uint)TraversalType.Normal, (uint)TraversalType.Different))
{
for (int i = 0; i < 4; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
// Setup normal traversal dependencies
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[0], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[2], k_OutputOne, test.Nodes[3], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Normal, test.Nodes[0], k_OutputOne, test.Nodes[3], k_InputOne);
// Setup an alternate dependency hierarchy
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[3], k_OutputOne, test.Nodes[2], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[2], k_OutputOne, test.Nodes[1], k_InputOne);
test.TestDatabase.Connect((uint)TraversalType.Different, test.Nodes[1], k_OutputOne, test.Nodes[3], k_InputOne);
foreach (var node in test.GetWalker())
{
if (node.Vertex == test.Nodes[0])
{
Assert.Zero(node.GetParents().Count);
AssertAreSame(new List <Node> {
test.Nodes[2], test.Nodes[3]
}, node.GetChildren());
Assert.Zero(node.GetParents(Topology.TraversalCache.Hierarchy.Alternate).Count);
Assert.Zero(node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate).Count);
}
if (node.Vertex == test.Nodes[1])
{
Assert.Zero(node.GetParents().Count);
Assert.Zero(node.GetChildren().Count);
AssertAreSame(new List <Node> {
test.Nodes[2]
}, node.GetParents(Topology.TraversalCache.Hierarchy.Alternate));
AssertAreSame(new List <Node> {
test.Nodes[3]
}, node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate));
}
if (node.Vertex == test.Nodes[2])
{
AssertAreSame(new List <Node> {
test.Nodes[0]
}, node.GetParents());
AssertAreSame(new List <Node> {
test.Nodes[3]
}, node.GetChildren());
AssertAreSame(new List <Node> {
test.Nodes[3]
}, node.GetParents(Topology.TraversalCache.Hierarchy.Alternate));
AssertAreSame(new List <Node> {
test.Nodes[1]
}, node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate));
}
if (node.Vertex == test.Nodes[3])
{
AssertAreSame(new List <Node> {
test.Nodes[0], test.Nodes[2]
}, node.GetParents());
Assert.Zero(node.GetChildren().Count);
AssertAreSame(new List <Node> {
test.Nodes[1]
}, node.GetParents(Topology.TraversalCache.Hierarchy.Alternate));
AssertAreSame(new List <Node> {
test.Nodes[2]
}, node.GetChildren(Topology.TraversalCache.Hierarchy.Alternate));
}
}
}
}
public Test(Topology.SortingAlgorithm algo, ComputeType computingType)
: this(algo, computingType, Topology.TraversalCache.TraverseAllMask)
{
}
public Test(Topology.SortingAlgorithm algo, ComputeType computingType, uint traversalMask)
: this(algo, computingType, traversalMask, traversalMask)
{
}
public void TraversalCacheWalkers_AreProperlyCleared_AfterAllNodesAreDestroyed([Values] Topology.SortingAlgorithm algo, [Values] ComputeType jobified)
{
using (var test = new Test(algo, jobified))
{
for (int i = 0; i < 5; ++i)
{
test.Nodes.Add(test.TestDatabase.CreateNode());
}
var foundNodes = new List <Node>();
test.GetUpdatedCache();
test.TestDatabase.DestroyAllNodes();
test.Nodes.Clear();
var cache = test.GetUpdatedCache();
Assert.AreEqual(0, cache.Leaves.Length);
Assert.AreEqual(0, cache.Roots.Length);
Assert.AreEqual(0, cache.OrderedTraversal.Length);
Assert.AreEqual(0, cache.ParentTable.Length);
Assert.AreEqual(0, cache.ChildTable.Length);
Assert.AreEqual(0, new Topology.CacheWalker(cache).Count);
Assert.AreEqual(0, new Topology.RootCacheWalker(cache).Count);
Assert.AreEqual(0, new Topology.LeafCacheWalker(cache).Count);
}
}
