public void Edge_SameHashCode()
{
Assert.IsTrue(AB.GetHashCode().Equals(BA.GetHashCode()));
Assert.IsTrue(AB.GetHashCode().Equals(new Edge(A, B).GetHashCode()));
Assert.IsTrue(AB.GetHashCode().Equals(new Edge(B, A).GetHashCode()));
Assert.IsTrue(AC.GetHashCode().Equals(CA.GetHashCode()));
Assert.IsTrue(AC.GetHashCode().Equals(new Edge(C, A).GetHashCode()));
}
public void ShouldBeEqual()
{
var e1 = new Edge(new Vertex(1, 1), new Vertex(2, 2));
var e2 = new Edge(new Vertex(1, 1), new Vertex(2, 2));
var e3 = new Edge(new Vertex(2, 2), new Vertex(1, 1));
Assert.AreEqual(e1.GetHashCode(), e2.GetHashCode());
Assert.AreEqual(true, e1.Equals(e2));
Assert.AreEqual(e1.GetHashCode(), e3.GetHashCode());
Assert.AreEqual(true, e1.Equals(e3));
}
public void TestMethod1()
{
var edge1 = new Edge<string, int> {Dist = 1, From = "aa", To = "ab"};
var edge2 = new Edge<string, int> {Dist = 1, From = "aa", To = "ab"};
var edge3 = new Edge<string, int> {Dist = 1, From = "ab", To = "ab"};
Assert.IsTrue(edge1.GetHashCode() == edge2.GetHashCode());
Assert.IsTrue(edge2.GetHashCode() != edge3.GetHashCode());
Assert.IsTrue(edge1 == edge2);
Assert.IsTrue(edge1.Equals(edge2));
Assert.IsTrue(edge1 == edge2);
Assert.IsTrue(edge1 != edge3);
}
public bool Equals(Edge e)
{
if (e.v1 == v1 && e.v2 == v2)
{
Debug.Assert(e.GetHashCode() == GetHashCode());
return(true);
}
else
{
Debug.Assert(e.GetHashCode() != GetHashCode());
return(false);
}
}
public void GetHashCode_ReturnsEqualHashCodes_ForEqualComponents()
{
var edge1 = new Edge <string>("from", "to");
var edge2 = new Edge <string>("from", "to");
Assert.AreEqual(edge1.GetHashCode(), edge2.GetHashCode());
}
public void GetHashCode_ReturnsDifferentHashCodes_ForDifferentWeight()
{
var edge1 = new Edge <string>("from", "to", 99);
var edge2 = new Edge <string>("from", "to", 991);
Assert.AreNotEqual(edge1.GetHashCode(), edge2.GetHashCode());
}
public void GetHashCode_ReturnsDifferentHashCodes_ForDifferentToVertex()
{
var edge1 = new Edge <string>("from", "to");
var edge2 = new Edge <string>("from", "to1");
Assert.AreNotEqual(edge1.GetHashCode(), edge2.GetHashCode());
}
public static void TestComparison_EDGE()
{
Edge a = (Edge)RandEdge();
Edge b = (Edge)(a + 20);
Edge c = (Edge) new Edge(a.a + 10, a.a);
Edge d = (Edge) new Edge(a.a, a.b);
Edge[] arr = ArrayUtility.Fill <Edge>(24, (i) => { return(i % 2 == 0 ? a : (Edge)RandEdge()); });
Assert.IsFalse(a == b, "a == b");
Assert.IsFalse(a == c, "a == c");
Assert.IsFalse(a.GetHashCode() == b.GetHashCode(), "a.GetHashCode() == b.GetHashCode()");
Assert.IsFalse(a.GetHashCode() == c.GetHashCode(), "a.GetHashCode() == c.GetHashCode()");
Assert.IsTrue(a.GetHashCode() == d.GetHashCode(), "a.GetHashCode() == d.GetHashCode()");
Assert.AreEqual(a, d, "Assert.AreEqual(a, d);");
Assert.IsTrue(a == d, "Assert.IsTrue(a != d);");
Assert.AreEqual(13, arr.Distinct().Count(), "Assert.AreEqual(13, arr.Distinct().Count());");
}
public void TestInitializeEdges()
{
var edge1 = new Edge <string, int> {
Dist = 1, From = "aa", To = "ab"
};
var edge2 = new Edge <string, int> {
Dist = 1, From = "aa", To = "ab"
};
var edge3 = new Edge <string, int> {
Dist = 1, From = "ab", To = "ab"
};
edge1.GetHashCode().Should().Be(edge2.GetHashCode());
edge2.GetHashCode().Should().NotBe(edge3.GetHashCode());
(edge1 == edge2).Should().BeTrue();
edge1.Equals(edge2).Should().BeTrue();
(edge1 == edge2).Should().BeTrue();
(edge1 != edge3).Should().BeTrue();
}
public void TestEdgeEquals()
{
RootGraph graph = Utils.CreateUniqueTestGraph();
Node node = graph.GetOrAddNode("node 1");
Node node2 = graph.GetOrAddNode("node 2");
Node node3 = graph.GetOrAddNode("node 3");
Edge edge = graph.GetOrAddEdge(node, node, "edge 1");
Edge edge2 = graph.GetOrAddEdge(node, node, "edge 2");
Edge edge3 = graph.GetOrAddEdge(node, node2, "edge 3");
Edge edge4 = graph.GetOrAddEdge(node2, node3, "edge 4");
Assert.AreEqual(edge, edge);
Assert.AreNotEqual(edge, edge2);
Assert.AreNotEqual(edge, edge3);
Assert.AreNotEqual(edge, edge4);
Assert.AreEqual(edge.GetHashCode(), edge.GetHashCode());
Assert.AreNotEqual(edge.GetHashCode(), edge2.GetHashCode());
Assert.AreNotEqual(edge.GetHashCode(), edge3.GetHashCode());
Assert.AreNotEqual(edge.GetHashCode(), edge4.GetHashCode());
}
static void AddEdge(int i0, int i1, Dictionary <Edge, int> edgeCounts)
{
Edge edge = new Edge()
{
I0 = i0, I1 = i1
};
System.Diagnostics.Debug.Assert(edge.I0 != edge.I1);
var hash = edge.GetHashCode();
if (edgeCounts.ContainsKey(edge))
{
edgeCounts[edge] = edgeCounts[edge] + 1;
}
else
{
edgeCounts[edge] = 1;
}
}
public void HashCodeIsDeterministic()
{
var edgeA = new Edge();
edgeA.Id = 100;
edgeA.RelationshipType = "R1";
edgeA.Source = 1;
edgeA.Destination = 2;
edgeA.AddProperty("Hello", "World");
var edgeB = new Edge();
edgeB.Id = 100;
edgeB.RelationshipType = "R1";
edgeB.Source = 1;
edgeB.Destination = 2;
edgeB.AddProperty("Hello", "World");
Assert.Equal(edgeA.GetHashCode(), edgeB.GetHashCode());
}
public static IEnumerable <TestCaseData> GetTestEdges()
{
PlanePoint p1 = new PlanePoint(new double[] { 1, 1, 1, 0 });
PlanePoint p2 = new PlanePoint(new double[] { 4, 4, 0, 0 });
PlanePoint p3 = new PlanePoint(new double[] { 1, 1, 1, 0 });
PlanePoint p4 = new PlanePoint(new double[] { 4, 4, 0, 0 });
PlanePoint p5 = new PlanePoint(new double[] { 1, 1, 1, 1 });
Edge edge1 = new Edge(p1, p2);
Edge edge2 = new Edge(p3, p4);
yield return(new TestCaseData(edge1, edge2).SetName("{m}_When same point and same order.").Returns(true));
Edge edge3 = new Edge(p4, p3);
yield return(new TestCaseData(edge1, edge3).SetName("{m}_Equals_When same point and different order.").Returns(true));
Edge edge4 = new Edge(p4, p5);
yield return(new TestCaseData(edge1, edge4).SetName("{m}_Equals_When different point.").Returns(false));
PlanePoint p11 = new PlanePoint(new double[] { 4, 4, 0, 0 });
PlanePoint p21 = new PlanePoint(new double[] { 4, 4, 1, 0 });
PlanePoint pp11 = new PlanePoint(new double[] { 1, 1, 1 }, p1);
Point pp21 = new PlanePoint(new double[] { 2, 2, 2 }, p2);
PlanePoint p31 = new PlanePoint(new double[] { 4, 4, 0, 0 });
PlanePoint p41 = new PlanePoint(new double[] { 4, 4, 1, 0 });
PlanePoint pp31 = new PlanePoint(new double[] { 1, 1, 2 }, p1);
Point pp41 = new PlanePoint(new double[] { 2, 2, 3 }, p2);
Edge edge11 = new Edge(p11, p21);
Edge edge21 = new Edge(p41, p31);
int i = edge11.GetHashCode();
int i1 = edge21.GetHashCode();
yield return(new TestCaseData(edge11, edge21).SetName("{m}_When different point and order.").Returns(true));
}
public override int GetHashCode()
{
return(edge.GetHashCode());
}
public void TestGetHashCode()
{
Assert.Equal(E.GetHashCode(), EEqual.GetHashCode());
Assert.NotEqual(E.GetHashCode(), ENotEqual.GetHashCode());
}
private void LogEdgeNotFoundError(string msg, Edge edge)
{
if (s_logEdgeNotFoundError)
{
string logFilePath = @"./SOM_Analytical.txt";
Tasks.Task task = edge as Tasks.Task;
StreamWriter sw = new StreamWriter(logFilePath);
sw.WriteLine("\r\n::::::::::::::::Message::::::::::::::::\r\n" + msg + "\r\n");
sw.WriteLine("\r\n::::::::::::::::Call Stack::::::::::::::::\r\n");
StackTrace st = new StackTrace(true);
sw.WriteLine(st.ToString());
sw.WriteLine("\r\n::::::::::::::::Requested Edge::::::::::::::::\r\n");
sw.WriteLine("Name : " + edge.Name + "\r\nGuid : " + task.Guid + "\r\nHashCode : " + task.GetHashCode());
sw.WriteLine("\r\n::::::::::::::::Known Edges::::::::::::::::\r\n");
foreach (DictionaryEntry de in Edges)
{
Edge knownEdge = (Edge)de.Key;
EdgeData knownEdgeData = (EdgeData)de.Value;
Tasks.Task knownTask = knownEdge as Tasks.Task;
if (knownTask != null)
{
sw.WriteLine("Name : " + knownTask.Name + "\r\nGuid : " + knownTask.Guid + "\r\nHashCode : " + knownTask.GetHashCode());
}
else
{
sw.WriteLine("Name : " + knownEdge.Name + "\r\nGuid : <Edge, not task, therefore no Guid>\r\nHashCode : " + knownEdge.GetHashCode());
}
}
sw.Flush();
sw.Close();
_Debug.WriteLine("Dumped log file to " + logFilePath);
}
}
public void testHashCode()
{
AreEqual(edgeX.GetHashCode(), edgeY.GetHashCode());
}
public override bool Equals(object obj)
{
Edge other = (Edge)obj;
return(other.GetHashCode() == this.GetHashCode());
}
public int GetHashCode(Edge <int> obj)
{
return(obj.GetHashCode());
}
/// <summary>
/// Serves as a hash function for a particular type.
/// </summary>
/// <returns>A hash code for this instance.</returns>
public override Int32 GetHashCode()
{
return(Edge.GetHashCode() >> 4 ^ LeftCoordinate.GetHashCode() >> 2 ^ RightCoordinate.GetHashCode());
}
/// <summary>
/// Override of GetHashCode method
/// </summary>
/// <returns></returns>
public override int GetHashCode()
{
return(Ray.GetHashCode() ^ Edge.GetHashCode());
}
public override int GetHashCode()
{
return(m_Edge != null ? m_Edge.GetHashCode() : 0);
}