public void ObjectEquals()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("foo");
x.Should().Be(y);
}
public void ObjectEqualsNegativeTest()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("bar");
x.Should().NotBe(y);
}
public void HashCode()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("foo");
x.GetHashCode().Should().Be(y.GetHashCode());
}
public void TwoPointersToSameInstanceHasSameRefId()
{
var p1 = NodeIdentity.Of("test");
var p2 = p1;
p2.GetRefId().Should().Be(p1.GetRefId());
}
public override bool performAction(NodeIdentity node)
{
//Check if cannot get input arguments (exit if so)
if (!node || !node.connectionsIn.ContainsKey("add"))
{
return(false);
}
double sumOutDouble = 0;
int sumOutInt = 0;
foreach (OutgoingInfo arg in node.connectionsIn["add"])
{
if (!arg.isComputed)
{
IDE_Output_Controller.instance.AddOutput("add parameter in sum node (" + node.id + ") used before it was computed!", OutputMessageType.error);
return(false);
}
double curTerm;
if (!double.TryParse(arg.outputVal, out curTerm))
{
IDE_Output_Controller.instance.AddOutput("Sum node (" + node.id + ") was given a non numerical value!", OutputMessageType.error);
return(false);
}
sumOutDouble += curTerm;
}
sumOutInt = (int)sumOutDouble;
setOutLinkValue(node, "sumFlt", sumOutDouble.ToString());
setOutLinkValue(node, "sumInt", sumOutInt.ToString());
return(true);
}
public void EquatableNegativeTest()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("bar");
x.Equals(y).Should().BeFalse();
}
public void updateComputedNodesOnDeleteNode(NodeIdentity deletedNode)
{
if (startingNodes.Contains(deletedNode.id))
{
startingNodes.Remove(deletedNode.id);
}
}
public void NotEqualsOp()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("bar");
(x != y).Should().BeTrue();
}
public BucketTxfrInfo(ArrayList bucketIds, bool isSparsed, NodeIdentity owner)
{
this.bucketIds = bucketIds;
this.isSparsed = isSparsed;
this.ownerShard = owner;
this.end = false;
}
public void TwoInstancesWithSameValuesHaveDifferentRefId()
{
var p1 = NodeIdentity.Of("test");
var p2 = NodeIdentity.Of("test");
p2.GetRefId().Should().NotBe(p1.GetRefId());
}
public BucketTxfrInfo(bool end)
{
bucketIds = null;
ownerShard = null;
isSparsed = false;
this.end = end;
}
public void TwoPathsOverSameNodesHaveSameHashcode()
{
var p1 = Path.Of(NodeIdentity.Of("A"), NodeIdentity.Of("B"));
var p2 = Path.Of(NodeIdentity.Of("A"), NodeIdentity.Of("B"));
p1.GetHashCode().Should().Be(p2.GetHashCode());
}
public void GraphCannotBeNull()
{
typeof(DepthFirst).Invoking(_ =>
DepthFirst.VisitAll(null, NodeIdentity.Of("A")).ToList())
.Should().Throw <ArgumentNullException>()
.Which.ParamName.Should().Be("graph");
}
public void NonEmptyPathIsNotEmpty()
{
var path = Path.Of(NodeIdentity.Of("foo"));
path.Should().NotBeEmpty();
Path.IsEmpty(path).Should().BeFalse();
}
public static IEnumerable <NodeIdentity> VisitAll(DirectedGraph graph, NodeIdentity start)
{
ArgumentHelpers.ThrowIfNull(() => graph);
ArgumentHelpers.ThrowIfNull(() => start);
var unvisited = new Stack <NodeIdentity>();
var spotted = new HashSet <NodeIdentity>();
void addNeighbors(IEnumerable <DirectedEdge> edges)
{
foreach (var neighbor in edges)
{
if (spotted.Add(neighbor.To))
{
unvisited.Push(neighbor.To);
}
}
}
unvisited.Push(start);
while (unvisited.Any())
{
var current = unvisited.Pop();
yield return(current);
addNeighbors(graph.EdgesFrom(current));
}
}
public void EqualsOpNegativeTest()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("bar");
(x == y).Should().BeFalse();
}
public void Equatable()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("foo");
x.Equals(y).Should().BeTrue();
}
internal DirectedEdge(NodeIdentity from, NodeIdentity to)
{
ArgumentHelpers.ThrowIfNull(() => from);
ArgumentHelpers.ThrowIfNull(() => to);
From = from;
To = to;
}
public void HashCodeNegativeTest()
{
var x = NodeIdentity.Of("foo");
var y = NodeIdentity.Of("bar");
x.GetHashCode().Should().NotBe(y.GetHashCode());
}
public static bool Visits(this IEnumerable <DirectedEdge> edges, NodeIdentity node)
{
ArgumentHelpers.ThrowIfNull(() => edges);
ArgumentHelpers.ThrowIfNull(() => node);
return(edges.First().From == node || Reaches(edges, node));
}
public void TwoPathsOverSameNodesButDifferentOrderHaveDifferentHashcode()
{
var p1 = Path.Of(NodeIdentity.Of("A"), NodeIdentity.Of("B"));
var p2 = Path.Of(NodeIdentity.Of("B"), NodeIdentity.Of("A"));
p1.GetHashCode().Should().NotBe(p2.GetHashCode());
}
public IEnumerable <DirectedEdge> EdgesFrom(NodeIdentity node)
{
if (_edges.TryGetValue(node, out var found))
{
return(found);
}
return(new List <DirectedEdge>());
}
public StateTransferIdentity(String DBName, String ColName, NodeIdentity nodeInfo, StateTransferType type, Alachisoft.NosDB.Common.Toplogies.Impl.Distribution.DistributionMethod distributionType)
{
this.DBName = DBName;
this.ColName = ColName;
this.NodeInfo = nodeInfo;
this.Type = type;
this.DistributionType = distributionType;
}
public void ReturnsEmptyPathIfNoPathIsFound()
{
var path = (object)BreadthFirst.FindPath(CreateSimpleGraph(),
NodeIdentity.Of("A"),
node => node == NodeIdentity.Of("notfound"));
path.Should().Be(Path.Empty);
}
protected void setOutLinkValue(NodeIdentity node, string parameterName, string value)
{
foreach (OutgoingInfo connection in node.connectionsOut[parameterName])
{
connection.isComputed = true;
connection.outputVal = value;
}
}
public void EqualsOpItself()
{
var x = NodeIdentity.Of("foo");
#pragma warning disable CS1718 // Comparison made to same variable
(x == x).Should().BeTrue();
#pragma warning restore CS1718 // Comparison made to same variable
}
public void InstanceHasSameRefId()
{
var p1 = NodeIdentity.Of("test");
var firstRefId = p1.GetRefId();
var secondRefId = p1.GetRefId();
secondRefId.Should().Be(firstRefId);
}
public void TwoPathsOverSameNodesButDifferentOrderAreNotEqual()
{
object p1 = Path.Of(NodeIdentity.Of("A"), NodeIdentity.Of("B"));
object p2 = Path.Of(NodeIdentity.Of("B"), NodeIdentity.Of("A"));
p1.Should().NotBe(p2);
((Path)p1 == (Path)p2).Should().BeFalse();
((Path)p1 != (Path)p2).Should().BeTrue();
}
public BucketsPack(ArrayList buckets, NodeIdentity owner)
{
if (buckets != null)
{
_bucketIds = buckets;
}
_owner = owner;
}
public void ExampleFromPaper()
{
var graph = CreateGraph();
var paths = CreatePaths();
var xform = TouringGraphTransformer
.Transform(graph, paths, NodeIdentity.Of("S"), NodeIdentity.Of("T"));
xform.EdgeCount.Should().Be(17);
}
public void ReAssignPriority(NodeIdentity leavingNode)
{
foreach (NodeIdentity node in NodeIdentities)
{
if (leavingNode.NodeName == node.NodeName)
leavingNode.NodePriority = node.NodePriority;
}
foreach (NodeIdentity oldNode in NodeIdentities)
{
if (oldNode.NodePriority > leavingNode.NodePriority)
oldNode.NodePriority = oldNode.NodePriority - 1;
}
}
