/// <summary>
/// Adds an undirected weighted edge to the graph
/// </summary>
/// <param name="st"></param>
/// <param name="end"></param>
/// <param name="weight">weight of the edge</param>
public void AddEdge(int st, int end, int weight)
{
if (!Edges.ContainsKey(st))
{
Edges[st] = new List <Edge>()
{
new Edge(st, end, weight)
};
}
else
{
Edges[st].Add(new Edge(st, end, weight));
}
if (!Edges.ContainsKey(end))
{
Edges[end] = new List <Edge>()
{
new Edge(end, st, weight)
};
}
else
{
Edges[end].Add(new Edge(end, st, weight));
}
TotalNumOfEdges += 2;
}
public void AddEdge(string v1Label, string v2Label)
{
// Create node map
if (!VertexLabelMap.ContainsKey(v1Label))
{
VertexLabelMap.Add(v1Label, VertexLabelMap.Count);
VertexIndexMap.Add(VertexIndexMap.Count, v1Label);
}
// Create node map
if (!VertexLabelMap.ContainsKey(v2Label))
{
VertexLabelMap.Add(v2Label, VertexLabelMap.Count);
VertexIndexMap.Add(VertexIndexMap.Count, v2Label);
}
// Add edge and vertices
if (!Edges.ContainsKey(VertexLabelMap[v1Label]))
{
Edges.Add(VertexLabelMap[v1Label], new HashSet <int>());
GraphWeight += Vertices[VertexLabelMap[v1Label]];
}
if (!Edges.ContainsKey(VertexLabelMap[v2Label]))
{
Edges.Add(VertexLabelMap[v2Label], new HashSet <int> ());
GraphWeight += Vertices[VertexLabelMap[v2Label]];
}
Edges[VertexLabelMap[v2Label]].Add(VertexLabelMap[v1Label]);
Edges[VertexLabelMap[v1Label]].Add(VertexLabelMap[v2Label]);
}
public void AddEdge(T1 from, T1 to, T2 w)
{
if (!Nodes.ContainsKey(from) || !Nodes.ContainsKey(to) || w is null)
{
throw new Exception("Node don't exist");
}
var fromNode = Nodes[from];
var toNode = Nodes[to];
if (!Edges.ContainsKey(from))
{
Edges.Add(from, new LinkedList <Edge>());
}
if (!Edges.ContainsKey(to))
{
Edges.Add(to, new LinkedList <Edge>());
}
Edges[from].AddLast(new Edge {
From = fromNode, To = toNode, Weigth = w
});
Edges[to].AddLast(new Edge {
From = toNode, To = fromNode, Weigth = w
});
}
public IEdge AddEdge(IEdge edge)
{
if (edge == null)
{
throw new ArgumentNullException(nameof(edge));
}
if (!Equals(edge.Parent) && !SubGraphs.ContainsKey(edge.Parent))
{
throw new ArgumentException(FormattableString.Invariant($"Parent of Edge {edge} not within Graph!"));
}
if ((edge.SourceNode == null) || !Nodes.ContainsKey(edge.SourceNode))
{
throw new ArgumentException(
FormattableString.Invariant($"SourceNode {edge.SourceNode} not within Graph!"));
}
if ((edge.EndNode == null) || !Nodes.ContainsKey(edge.EndNode))
{
throw new ArgumentException(FormattableString.Invariant($"EndNode {edge.EndNode} not within Graph!"));
}
if (!Edges.ContainsKey(edge))
{
Edges[edge] = edge;
}
var addedEdge = Edges[edge];
addedEdge.SetAttributes(edge.GetAttributes());
return(addedEdge);
}
public void AddEdge(IEdgeUiElement e)
{
if (!Edges.ContainsKey(e.Id))
{
Edges.Add(e.Id, e);
}
InvalidateVisual();
}
public void RemoveEdge(IEdgeUiElement e)
{
if (Edges.ContainsKey(e.Id))
{
Edges.Remove(e.Id);
}
InvalidateVisual();
}
public IEdgeUiElement FindEdge(IVertexElement v)
{
var idEdge = HashCode.GetHashCode(Id, v.Id);
if (Edges.ContainsKey(idEdge))
{
return(Edges[idEdge]);
}
return(null);
}
public bool HasEdge(INode firstNode, INode secondNode)
{
if (IsDirected)
{
return(Edges.ContainsKey(firstNode) &&
Edges[firstNode].Any(edge => edge.SecondNode == secondNode));
}
return(Edges.ContainsKey(secondNode) &&
Edges[secondNode].Any(edge => edge.SecondNode == firstNode));
}
public Dictionary <Node, Node> FindPath(Node s) // s là đỉnh gốc
{
Dictionary <Node, double> d = new Dictionary <Node, double>(V); // nhãn của nút
Dictionary <Node, double> L = new Dictionary <Node, double>(V); // nhãn của nút theo prim-dijkstra
Dictionary <Node, bool> visited = new Dictionary <Node, bool>(V);
Dictionary <Node, Node> p = new Dictionary <Node, Node>(V); // p[u] = v tức là u là con của v
for (int i = 0; i < Nodes.Count; i++)
{
d[Nodes[i]] = INF;
L[Nodes[i]] = INF;
visited[Nodes[i]] = false;
//p[Nodes[i]] = s;
}
d[s] = 0;
L[s] = 0;
int count = 1;
double lMin;
Node u = s;
while (count < V)
{
lMin = INF;
//Tìm node có nhãn min
for (int i = 0; i < V; i++)
{
if (!visited[Nodes[i]] && L[Nodes[i]] < lMin)
{
lMin = L[Nodes[i]];
u = Nodes[i];
}
}
//Xét node u
visited[u] = true;
for (int i = 0; i < V; i++)
{
Tuple <Node, Node> t = Tuple.Create(u, Nodes[i]);
if (!visited[Nodes[i]] && Edges.ContainsKey(t) && Alpha * d[u] + Edges[t] < L[Nodes[i]])
{
d[Nodes[i]] = d[u] + Edges[t];
L[Nodes[i]] = Alpha * d[u] + Edges[t];
p[Nodes[i]] = u;
}
}
count++;
}
return(p);
}
public void Add(Edge edge)
{
if (edge != null)
{
edge.SetFace(this);
var adjusted = GetAdjustedStart(edge);
if (adjusted != null && !Edges.ContainsKey(adjusted))
{
Edges.Add(GetAdjustedStart(edge), edge);
FindHole();
}
}
}
private static bool IsWired(GraphNode node1, GraphNode node2)
{
if (Edges.ContainsKey(node1))
{
foreach (GraphEdge edge in Edges[node1])
{
if (edge.NodeFirst == node2 || edge.NodeSecond == node2)
{
return(true);
}
}
}
return(false);
}
public Edge Add(Edge edge)
{
if (Edges.ContainsKey(edge))
{
Edge existingVertex;
Edges.TryGetValue(edge, out existingVertex);
return(existingVertex);
}
else
{
Edges.Add(edge, edge);
return(edge);
}
}
/// <summary>
///
/// </summary>
/// <param name="v"></param>
/// <returns></returns>
public IEdge <KEY> this[INode <KEY> v]
{
get
{
EdgeKey <KEY> key = new EdgeKey <KEY>(Key, v.Key);
if (Edges.ContainsKey(key))
{
return(Edges[key]);
}
else
{
return(null);
}
}
}
public void AddNewNeighbour(int source, int destination, int weight)
{
destination--;
if (weight > 0)
{
if (!Edges.ContainsKey(source))
{
Edges.Add(source, new List <Edge>());
}
Edges[source].Add(new Edge(source, destination, weight));
}
EdgesNo = Edges.Count;
}
public void AddEdge(string edge, int tileId, int edgeNumber, bool match)
{
if (Edges.ContainsKey(edge))
{
// exists add this tile if not there already
if (!Edges[edge].Any(t => t.Item1 == tileId && t.Item2 == edgeNumber))
{
Edges[edge].Add(Tuple.Create(tileId, edgeNumber, match));
}
}
else
{
List <Tuple <int, int, bool> > list = new List <Tuple <int, int, bool> >();
list.Add(Tuple.Create(tileId, edgeNumber, match));
Edges.Add(edge, list);
}
}
public void RemoveById(int id)
{
if (Verticies.ContainsKey(id))
{
Verticies.Remove(id);
if (VertexOfEdgesById.ContainsKey(id))
{
VertexOfEdgesById.Remove(id);
}
}
if (Edges.ContainsKey(id))
{
var e = Edges[id];
VertexOfEdgesById.Remove(e.FromId);
VertexOfEdgesById.Remove(e.ToId);
Edges.Remove(id);
}
}
public IWeightedDirectedPath <TVertex, TEdge> Path(TVertex destination)
{
if (Equals(Origin, destination))
{
return(new WeightedDirectedPath <TVertex, TEdge>(Graph, Origin));
}
if (!Edges.ContainsKey(destination) || Equals(Edges[destination].Item1, default(TEdge)))
{
return(null);
}
var edges = new LinkedList <TEdge>();
var vertices = new LinkedList <TVertex>();
var current = destination;
var weight = default(TEdge);
while (Edges.ContainsKey(current))
{
var inedge = Edges[current].Item2;
if (inedge == null)
{
break;
}
edges.AddFirst(inedge);
vertices.AddFirst(current);
bool Predicate(IWeightedEndpoint <TVertex, TEdge> endpoint)
{
return(Equals(endpoint.Edge, inedge));
}
current = Graph.PredecessorEndpoints(current).Single(Predicate).Vertex;
weight = Adder.Add(weight, inedge);
}
vertices.AddFirst(current);
return(new WeightedDirectedPath <TVertex, TEdge>(Graph, Origin, destination, vertices, edges, weight));
}
protected void AddEdgeForNode(INode node, IEdge edge)
{
if (Edges.ContainsKey(node))
{
if (Edges[node].Contains(edge))
{
throw new ArgumentException(
string.Format("The edge {0}-{1} already exists for node {2}",
edge.FirstNode.ID, edge.SecondNode.ID, node.ID));
}
Edges[node].Add(edge);
}
else
{
IList <IEdge> edges = new List <IEdge>();
edges.Add(edge);
Edges.Add(node, edges);
}
}
public static void RemoveNode(GraphNode node)
{
Canvas canvas = node.Parent as Canvas;
if (canvas != null)
{
if (Edges.ContainsKey(node))
{
foreach (GraphEdge edge in Edges[node])
{
if (node == edge.NodeFirst)
{
Edges[edge.NodeSecond].Remove(edge);
}
else
{
Edges[edge.NodeFirst].Remove(edge);
}
canvas.Children.Remove(edge.EdgeLine);
canvas.Children.Remove(edge.WeightLabel);
}
Edges.Remove(node);
}
canvas.Children.Remove(node);
Nodes.Remove(node);
Adjency.Remove(node);
if (node.Index == LastIndex)
{
LastIndex--;
}
}
}
internal Edge FindEdgeByChar(char c)
{
return(!Edges.ContainsKey(c) ? null : Edges[c]);
}
public bool HasEdgesForNode(INode node)
{
return(Edges.ContainsKey(node));
}
public void AfterRun(IPexPathComponent host, object data)
{
MessageBox.Show("AfterRun");
// Getting the executions nodes in the current path
var nodesInPath = host.PathServices.CurrentExecutionNodeProvider.ReversedNodes.Reverse().ToArray();
// Getting the sequence id of the current run
var runId = host.ExplorationServices.Driver.Runs;
// Iterating over the nodes in the path
foreach (var node in nodesInPath)
{
var vertex = new CFGNode(node.UniqueIndex, false);
// Adding the method name this early in order to color edges
string methodName = null;
int offset = 0;
if (node.CodeLocation.Method == null)
{
if (node.InCodeBranch.Method != null)
{
methodName = node.InCodeBranch.Method.FullName;
}
}
else
{
methodName = node.CodeLocation.Method.FullName;
offset = node.CodeLocation.Offset;
}
// Setting the method name
vertex.MethodName = methodName;
// Setting the offset
vertex.ILOffset = (uint)offset;
var nodeIndex = nodesInPath.ToList().IndexOf(node);
if (nodeIndex > 0)
{
var prevNode = nodesInPath [nodeIndex - 1];
// If there is no edge between the previous and the current node
if (!(Edges.ContainsKey(prevNode.UniqueIndex) && Edges [prevNode.UniqueIndex].ContainsKey(node.UniqueIndex)))
{
var prevVertex = Vertices [prevNode.UniqueIndex];
var edge = new CFGEdge(new Random().Next(), prevVertex, vertex);
Dictionary <int, CFGEdge> outEdges = null;
if (Edges.TryGetValue(prevNode.UniqueIndex, out outEdges))
{
outEdges.Add(node.UniqueIndex, edge);
}
else
{
Edges.Add(prevNode.UniqueIndex, new Dictionary <int, CFGEdge>());
Edges [prevNode.UniqueIndex].Add(node.UniqueIndex, edge);
}
// Edge coloring based on unit border detection
if (UnitNamespace != null)
{
// Checking if pointing into the unit from outside
if (!(prevVertex.MethodName.StartsWith(UnitNamespace + ".") || prevVertex.MethodName.Equals(UnitNamespace)) && (vertex.MethodName.StartsWith(UnitNamespace + ".") || vertex.MethodName.Equals(UnitNamespace)))
{
edge.Color = CFGEdge.EdgeColor.Green;
}
// Checking if pointing outside the unit from inside
if ((prevVertex.MethodName.StartsWith(UnitNamespace + ".") || prevVertex.MethodName.Equals(UnitNamespace)) && !(vertex.MethodName.StartsWith(UnitNamespace + ".") || vertex.MethodName.Equals(UnitNamespace)))
{
edge.Color = CFGEdge.EdgeColor.Red;
}
}
}
}
// If the node is new then it is added to the list and the metadata is filled
if (!Vertices.ContainsKey(node.UniqueIndex))
{
Vertices.Add(node.UniqueIndex, vertex);
// Adding source code mapping
vertex.SourceCodeMappingString = MapToSourceCodeLocationString(host, node);
// Setting the border based on mapping existence
vertex.Border = vertex.SourceCodeMappingString == null ? CFGNode.NodeBorder.Single : CFGNode.NodeBorder.Double;
// Setting the color
if (nodesInPath.LastOrDefault() == node)
{
if (!EmittedTestResult.ContainsKey(runId))
{
vertex.Color = CFGNode.NodeColor.Orange;
}
else
{
if (EmittedTestResult [runId].Item1)
{
vertex.Color = CFGNode.NodeColor.Red;
}
else
{
vertex.Color = CFGNode.NodeColor.Green;
}
vertex.GenerateTestCode = EmittedTestResult [runId].Item2;
}
}
else
{
vertex.Color = CFGNode.NodeColor.White;
}
// Setting the default shape
vertex.Shape = CFGNode.NodeShape.Rectangle;
// Adding path condition tasks and getting the required services
TermEmitter termEmitter = new TermEmitter(host.GetService <TermManager>());
SafeStringWriter safeStringWriter = new SafeStringWriter();
IMethodBodyWriter methodBodyWriter = host.GetService <IPexTestManager>().Language.CreateBodyWriter(safeStringWriter, VisibilityContext.Private, 2000);
PrettyPathConditionTasks.Add(vertex.Id, PrettyPrintPathCondition(termEmitter, methodBodyWriter, safeStringWriter, node));
// Setting the status
vertex.Status = node.ExhaustedReason.ToString();
// Collecting the parent nodes for the later incremental path condition calculation
if (nodeIndex > 0)
{
ParentNodes.Add(vertex.Id, nodesInPath [nodeIndex - 1].UniqueIndex);
}
}
// Adding the Id of the run
Vertices [node.UniqueIndex].Runs += (runId + ";");
}
}
public bool ContainsEdges(int id)
{
return(Edges.ContainsKey(id));
}
