public void Edge_Equals()
{
Assert.IsTrue(AB.Equals(BA));
Assert.IsTrue(AC.Equals(CA));
Assert.IsFalse(AB.Equals(AD));
Assert.IsFalse(GH.Equals(FH));
}
public void EdgeEquals_Object_Test()
{
var edge = new Edge <int>(1, 2);
var obj = new object();
Assert.IsFalse(edge.Equals(obj));
Assert.IsFalse(edge.Equals(obj as Edge <int>));
}
public bool ContainsEdge(Edge edge)
{
if (edge.Equals(E1) || edge.Equals(E2) || edge.Equals(E3))
{
return(true);
}
return(false);
}
public void EdgeEquals_DifferentEdge_Test()
{
var edge = new Edge <int>(1, 2);
var other = new Edge <int>(5, 3);
Assert.IsFalse(edge == other);
Assert.IsTrue(edge != other);
Assert.IsFalse(edge.Equals(other));
Assert.IsFalse(edge.Equals(other as object));
}
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 Equals_ReturnsFalse_ForDifferentWeight()
{
var edge1 = new Edge <string>("from", "to", 99);
var edge2 = new Edge <string>("from", "to", 991);
Assert.IsFalse(edge1.Equals(edge2));
}
protected Vertex NextVertexInCriticalPath(Vertex vertex, ref double mean, ref double variance)
{
Edge targetEdge = null;
foreach (Edge edge in vertex.SuccessorEdges)
{
targetEdge = edge;
if (targetEdge is Ligature)
{
targetEdge = edge.PostVertex.PrincipalEdge;
}
EdgeData ed = (EdgeData)Edges[targetEdge];
if (ed == null)
{
continue;
}
if (IsCriticalPath(targetEdge))
{
m_criticalPath.Add(targetEdge);
mean += ed.MeanDuration;
variance += ed.Variance2;
return(targetEdge.PostVertex);
}
}
if (targetEdge != null && targetEdge.Equals(Finish.PrincipalEdge))
{
return(Finish);
}
throw new ApplicationException("The vertex " + vertex.Name + " is not on the critical path.");
}
public void SimpleEqualTest()
{
Edge first = new Edge(5, 6, 7);
Edge second = new Edge(5, 6, 7);
bool result = first.Equals(second);
}
public void Equals_ReturnsTrue_ForEqualComponents()
{
var edge1 = new Edge <string>("from", "to");
var edge2 = new Edge <string>("from", "to");
Assert.IsTrue(edge1.Equals(edge2));
}
private static void TestTest()
{
HouseOfSantaClausIterative sc1 = new HouseOfSantaClausIterative();
HouseOfSantaClausRecursive sc2 = new HouseOfSantaClausRecursive();
sc1.Solve();
Console.WriteLine("{0:Path}", sc1);
sc2.Solve();
Console.WriteLine("{0:Path}", sc2);
List <List <Edge> > s1 = sc1.Solutions;
List <List <Edge> > s2 = sc2.Solutions;
for (int i = 0; i < s1.Count; i++)
{
List <Edge> l1 = s1[i];
List <Edge> l2 = s2[i];
for (int j = 0; j < l1.Count; j++)
{
Edge e1 = l1[j];
Edge e2 = l2[j];
if (!(e1.Equals(e2)))
{
Console.WriteLine("WRONG");
}
}
}
}
public void Equals_ReturnsFalse_ForDifferentToVertex()
{
var edge1 = new Edge <string>("from", "to");
var edge2 = new Edge <string>("from", "to1");
Assert.IsFalse(edge1.Equals(edge2));
}
public void TestMethod2()
{
string way = "CBEFIM";
AdjacentGraph G = new AdjacentGraph();
G += new Edge("AB");
G += new Edge("AE");
G += new Edge("BE");
G += new Edge("CB");
G += new Edge("EF");
G += new Edge("EM");
G += new Edge("FI");
G += new Edge("IM");
Program P = new Program();
P.Cut(G, way);
AdjacentGraph Answer = new AdjacentGraph();
Answer += new Edge("AB");
Answer += new Edge("AE");
Answer += new Edge("EM");
bool b = Answer.Equals(G);
Assert.AreEqual <bool>(true, b);
}
public void EdgeEquals_Null_Test()
{
var edge = new Edge <int>(1, 2);
Assert.IsFalse(edge == null);
Assert.IsTrue(edge != null);
Assert.IsFalse(edge.Equals(null));
}
public void Edge_Test_Equals_()
{
MyNode <int> n1 = new MyNode <int>(1);
MyNode <int> n2 = new MyNode <int>(2);
Edge <int, int> e1 = new Edge <int, int>(7, n1, n2);
MyNode <int> n3 = new MyNode <int>(3);
MyNode <int> n4 = new MyNode <int>(4);
Edge <int, int> e2 = new Edge <int, int>(8, n1, n2);
Edge <int, int> e3 = new Edge <int, int>(8, n3, n4);
Edge <int, int> e4 = new Edge <int, int>(8, n1, n2);
Edge <int, int> e5 = new Edge <int, int>(8, n2, n1);
Assert.IsTrue(e2.Equals(e4));
Assert.IsFalse(e1.Equals(e2));
Assert.IsFalse(e1.Equals(e3));
Assert.IsFalse(e3.Equals(e4));
Assert.IsFalse(e4.Equals(e5));
}
public void Two_Edges_Should_Be_Equal_With_Null_References()
{
var a = new Edge <string, string>(new Node <string, string>(0, "node1"), 1, null);
var b = new Edge <string, string>(new Node <string, string>(0, "node2"), 1, null);
bool act = a.Equals(b);
Assert.True(act);
}
public void Two_Edges_Should_Be_Equal()
{
var a = new Edge <string, int>(new Node <string, int>(0, "node1"), 1, 1);
var b = new Edge <string, int>(new Node <string, int>(0, "node2"), 1, 1);
bool act = a.Equals(b);
Assert.True(act);
}
public void Equals_Should_Return_False_When_Two_Edges_Are_Different()
{
var parent = new Mock <INode>().Object;
var child = new Mock <INode>().Object;
Edge edge1 = new Edge(child, parent);
Edge edge2 = new Edge(new Mock <INode>().Object, parent);
edge1.Equals(edge2).Should().BeFalse();
}
public void Equals_Should_Return_True_When_Two_Edges_Are_The_Same()
{
var parent = new Mock <INode>().Object;
var child = new Mock <INode>().Object;
Edge edge1 = new Edge(child, parent);
Edge edge2 = new Edge(child, parent);
edge1.Equals(edge2).Should().BeTrue();
}
public void Can_be_compared()
{
Node a = new Node();
Node b = new Node();
Node c = new Node();
Edge ab = new Edge(a, b);
Edge bc = new Edge(b, c);
Edge ac = new Edge(a, c);
Assert.Equal(ab, ab);
Assert.NotEqual(ab, bc);
Assert.Equal(ab, new Edge(a, b));
Assert.NotEqual(ab, new Edge(a, b, 2));
Assert.True(ab.Equals(ab));
Assert.False(ab.Equals(bc));
Assert.False(ab.Equals(ac));
Assert.False(ab.Equals(null));
Assert.True(Equals(ab, ab));
Assert.False(Equals(ab, bc));
Assert.False(Equals(ab, ac));
Assert.False(Equals(null, ab));
Assert.False(Equals(ab, null));
Assert.True(Equals(null, null));
#pragma warning disable CS1718 // Comparison made to same variable
Assert.True(ab == ab);
Assert.False(ab != ab);
#pragma warning restore CS1718 // Comparison made to same variable
Assert.False(ab == bc);
Assert.True(ab != bc);
Assert.True(ab != ac);
Assert.True(ab != null);
Assert.True(null != ab);
var values = new List <Edge> {
ab, bc, ac
};
values.Sort();
Assert.Contains(bc, values);
values = new List <Edge> {
ab, bc, null
};
Assert.Throws <InvalidOperationException>(() => values.Sort());
}
public void Equals_OneObject_True()
{
//Arrange
var sut = new Edge <string>(TestVertex1, TestVertex2, 0);
//Act
var result = sut.Equals(sut);
//Assert
Assert.True(result);
}
/// <summary>
/// Override of Equals method
/// </summary>
/// <param name="obj"></param>
/// <returns></returns>
public override bool Equals(object obj)
{
if (obj == null || GetType() != obj.GetType())
{
return(false);
}
EdgeKey k = (EdgeKey)obj;
return(Edge.Equals(k.Edge));
}
public void Two_Edges_Should_Be_Diffrent_With_Diffrent_Nodes()
{
var a = new Edge <string, string>(new Node <string, string>(0, "node1"), 1, "a");
var b = new Edge <string, string>(new Node <string, string>(1, "node2"), 1, "a");
bool act = a.Equals(b);
bool act2 = b.Equals(a);
Assert.False(act);
Assert.False(act2);
}
public void Edge_Equals()
{
var edgeA = new Edge <int, int>(1, 2, 3);
var edgeB = new Edge <int, int>(1, 2, 3);
var edgeC = new Edge <int, int>(1, 2, 4);
Assert.IsTrue(edgeA.Equals(edgeA));
Assert.IsTrue(edgeA.Equals(edgeB));
Assert.IsFalse(edgeA.Equals(edgeC));
Assert.IsFalse(edgeA.Equals(null));
Assert.IsTrue(edgeA.Equals((object)edgeA));
Assert.IsTrue(edgeA.Equals((object)edgeB));
Assert.IsFalse(edgeA.Equals((object)edgeC));
Assert.IsFalse(edgeA.Equals(default(object)));
Assert.IsFalse(edgeA.Equals("A"));
}
public Edge[] ExcludeEdge(Edge e)
{
if (e0.Equals(e))
{
return(new Edge[] { e1, e2 });
}
if (e1.Equals(e))
{
return(new Edge[] { e0, e2 });
}
return(new Edge[] { e0, e1 });
}
public void Two_Edges_Should_Be_Equal()
{
var g = new Graph <string, int>() + "node1";
var n = g >> 1;
var a = new Edge <string, int>(n, 1, 1);
var b = new Edge <string, int>(n, 1, 1);
bool act = a.Equals(b);
Assert.True(act);
}
public void Two_Edges_Should_Be_Equal_With_Null_References()
{
var g = new Graph <string, string>() + "node1";
var n = g >> 1;
var a = new Edge <string, string>(n, 1, null);
var b = new Edge <string, string>(n, 1, null);
bool act = a.Equals(b);
Assert.True(act);
}
public void Equals()
{
var edge1 = new Edge <int>(1, 2);
var edge2 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(2, 1);
Assert.AreEqual(edge1, edge1);
Assert.AreNotEqual(edge1, edge2);
Assert.AreNotEqual(edge2, edge1);
Assert.IsFalse(edge1.Equals(edge2));
Assert.IsFalse(edge2.Equals(edge1));
Assert.AreNotEqual(edge1, edge3);
Assert.AreNotEqual(edge3, edge1);
Assert.IsFalse(edge1.Equals(edge2));
Assert.IsFalse(edge2.Equals(edge1));
Assert.AreNotEqual(edge1, null);
Assert.IsFalse(edge1.Equals(null));
}
/// <summary>
/// Indicates whether this instance and a specified sweepline segment are equal.
/// </summary>
/// <param name="another">The sweepline segment to compare with this instance.</param>
/// <returns><c>true</c> if <paramref name="another" /> and this instance represent the same value; otherwise, <c>false</c>.</returns>
public Boolean Equals(SweepLineSegment other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(Edge.Equals(other.Edge) && LeftCoordinate.Equals(other.LeftCoordinate) && RightCoordinate.Equals(other.RightCoordinate));
}
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 void Equals_TwoDifferentObjects_False()
{
//Arrange
var sut1 = new Edge <string>(TestVertex1, TestVertex2, 2);
var sut2 = new Edge <string>(TestVertex2, new Vertex <string>("TestValue3"), 5);
//Act
var result1 = sut1.Equals(sut2);
var result2 = sut2.Equals(sut1);
//Assert
Assert.False(result1);
Assert.False(result2);
}
/// <summary>
/// Implementation of IComparable interaface
/// </summary>
/// <param name="other"></param>
/// <returns></returns>
public int CompareTo(EdgeKey other)
{
if (other == null)
{
return(1);
}
if (Edge.Equals(other.Edge))
{
return(1);
}
if (!VisibilityGraph.EdgeIntersect(RayEdge, other.Edge))
{
return(-1);
}
double selfDist = DistanceToIntersection(Centre, Vertex, Edge);
double otherDist = DistanceToIntersection(Centre, Vertex, other.Edge);
if (selfDist > otherDist)
{
return(1);
}
else if (selfDist < otherDist)
{
return(-1);
}
else
{
gVertex sameVertex = null;
if (other.Edge.Contains(Edge.StartVertex))
{
sameVertex = Edge.StartVertex;
}
else if (other.Edge.Contains(Edge.EndVertex))
{
sameVertex = Edge.EndVertex;
}
double aslf = gVertex.ArcRadAngle(Vertex, Centre, Edge.GetVertexPair(sameVertex));
double aot = gVertex.ArcRadAngle(Vertex, Centre, other.Edge.GetVertexPair(sameVertex));
if (aslf < aot)
{
return(-1);
}
else
{
return(1);
}
}
}
public void Equals_WithDifferentWeight_IsFalse_Test()
{
// Assign
var vertexA = new Vertex("a");
var vertexB = new Vertex("b");
var edgeA = new Edge(vertexA, vertexB, 10);
var edgeB = new Edge(vertexA, vertexB, 20);
// Act
bool actual = edgeA.Equals(edgeB);
// Assert
bool expected = false;
Assert.AreEqual(expected, actual);
}
public void Equals_WithSameVerticesAndWeight_IsTrue_Test()
{
// Assign
var vertexA = new Vertex("a");
var vertexB = new Vertex("b");
var edgeA = new Edge(vertexA, vertexB, 0);
var edgeB = new Edge(vertexA, vertexB, 0);
// Act
bool actual = edgeA.Equals(edgeB);
// Assert
bool expected = true;
Assert.AreEqual(expected, actual);
}
