public void Construction_Throws()
{
// ReSharper disable ObjectCreationAsStatement
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(() => new STaggedUndirectedEdge <TestVertex, TestObject>(null, new TestVertex("v1"), null));
Assert.Throws <ArgumentNullException>(() => new STaggedUndirectedEdge <TestVertex, TestObject>(new TestVertex("v1"), null, null));
Assert.Throws <ArgumentNullException>(() => new STaggedUndirectedEdge <TestVertex, TestObject>(null, null, null));
// ReSharper restore AssignNullToNotNullAttribute
Assert.Throws <ArgumentException>(() => new STaggedUndirectedEdge <int, TestObject>(2, 1, null));
// Not comparable
var v1 = new TestVertex("v1");
var v2 = new TestVertex("v2");
Assert.Throws <ArgumentException>(() => new STaggedUndirectedEdge <TestVertex, TestObject>(v1, v2, null));
var comparableV1 = new ComparableTestVertex("v1");
var comparableV2 = new ComparableTestVertex("v2");
Assert.Throws <ArgumentException>(() => new STaggedUndirectedEdge <ComparableTestVertex, TestObject>(comparableV2, comparableV1, null));
// ReSharper restore ObjectCreationAsStatement
}
public void Construction()
{
// Value type
CheckEdge(new TermEdge <int>(1, 2), 1, 2);
CheckEdge(new TermEdge <int>(2, 1), 2, 1);
CheckEdge(new TermEdge <int>(1, 1), 1, 1);
CheckTermEdge(new TermEdge <int>(1, 2, 0, 1), 1, 2, 0, 1);
CheckTermEdge(new TermEdge <int>(2, 1, 1, 0), 2, 1, 1, 0);
CheckTermEdge(new TermEdge <int>(1, 1, 0, 0), 1, 1, 0, 0);
// Reference type
var v1 = new TestVertex("v1");
var v2 = new TestVertex("v2");
CheckEdge(new TermEdge <TestVertex>(v1, v2), v1, v2);
CheckEdge(new TermEdge <TestVertex>(v2, v1), v2, v1);
CheckEdge(new TermEdge <TestVertex>(v1, v1), v1, v1);
CheckTermEdge(new TermEdge <TestVertex>(v1, v2, 0, 1), v1, v2, 0, 1);
CheckTermEdge(new TermEdge <TestVertex>(v2, v1, 1, 0), v2, v1, 1, 0);
CheckTermEdge(new TermEdge <TestVertex>(v1, v1, 0, 0), v1, v1, 0, 0);
}
public void Construction()
{
// Value type
CheckEdge(new SReversedEdge <int, Edge <int> >(new Edge <int>(1, 2)), 2, 1);
CheckEdge(new SReversedEdge <int, Edge <int> >(new Edge <int>(2, 1)), 1, 2);
CheckEdge(new SReversedEdge <int, Edge <int> >(new Edge <int>(1, 1)), 1, 1);
// Struct break the contract with their implicit default constructor
var defaultEdge = default(SReversedEdge <int, Edge <int> >);
// ReSharper disable HeuristicUnreachableCode
// Justification: Since struct has implicit default constructor it allows initialization of invalid edge
Assert.IsNull(defaultEdge.OriginalEdge);
// ReSharper disable HeuristicUnreachableCode
Assert.Throws <NullReferenceException>(() => { var _ = defaultEdge.Source; });
Assert.Throws <NullReferenceException>(() => { var _ = defaultEdge.Target; });
// ReSharper restore HeuristicUnreachableCode
// Reference type
var v1 = new TestVertex("v1");
var v2 = new TestVertex("v2");
CheckEdge(new SReversedEdge <TestVertex, Edge <TestVertex> >(new Edge <TestVertex>(v1, v2)), v2, v1);
CheckEdge(new SReversedEdge <TestVertex, Edge <TestVertex> >(new Edge <TestVertex>(v2, v1)), v1, v2);
CheckEdge(new SReversedEdge <TestVertex, Edge <TestVertex> >(new Edge <TestVertex>(v1, v1)), v1, v1);
// Struct break the contract with their implicit default constructor
var defaultEdge2 = default(SReversedEdge <TestVertex, Edge <TestVertex> >);
// ReSharper disable HeuristicUnreachableCode
// Justification: Since struct has implicit default constructor it allows initialization of invalid edge
Assert.IsNull(defaultEdge2.OriginalEdge);
// ReSharper disable HeuristicUnreachableCode
Assert.Throws <NullReferenceException>(() => { var _ = defaultEdge2.Source; });
Assert.Throws <NullReferenceException>(() => { var _ = defaultEdge2.Target; });
// ReSharper restore HeuristicUnreachableCode
}
public void GetOtherVertex()
{
var edge1 = new Edge <int>(1, 1);
var edge2 = new Edge <int>(1, 2);
var edge3 = new Edge <int>(2, 1);
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var edge4 = new Edge <TestVertex>(v1, v1);
var edge5 = new Edge <TestVertex>(v1, v2);
var edge6 = new Edge <TestVertex>(v2, v1);
Assert.AreEqual(1, edge1.GetOtherVertex(1));
Assert.AreEqual(2, edge2.GetOtherVertex(1));
Assert.AreEqual(1, edge2.GetOtherVertex(2));
Assert.AreEqual(2, edge3.GetOtherVertex(1));
Assert.AreEqual(1, edge3.GetOtherVertex(2));
Assert.AreSame(v1, edge4.GetOtherVertex(v1));
Assert.AreSame(v2, edge5.GetOtherVertex(v1));
Assert.AreSame(v1, edge5.GetOtherVertex(v2));
Assert.AreSame(v2, edge6.GetOtherVertex(v1));
Assert.AreSame(v1, edge6.GetOtherVertex(v2));
// Edges cases
var vNotInEdge = new TestVertex("1");
Assert.AreSame(v1, edge5.GetOtherVertex(vNotInEdge));
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV1Bis = new EquatableTestVertex("1");
var edge8 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
Assert.AreSame(equatableV2, edge8.GetOtherVertex(equatableV1Bis));
}
public void GetVertexInfo()
{
var vertex = new TestVertex("1");
var graph = new AdjacencyGraph <TestVertex, Edge <TestVertex> >();
var algorithm1 = new TestSimpleLayoutAlgorithm(graph);
Assert.IsNull(algorithm1.GetVertexInfo(vertex));
var algorithm2 = new TestComplexLayoutAlgorithm(graph);
Assert.IsNull(algorithm2.GetVertexInfo(vertex));
graph.AddVertex(vertex);
Assert.IsNull(algorithm2.GetVertexInfo(vertex));
const int vertexInfo = 1;
algorithm2.VerticesInfos.Add(vertex, vertexInfo);
Assert.AreEqual(vertexInfo, algorithm2.GetVertexInfo(vertex));
algorithm2.VerticesInfos.Remove(vertex);
Assert.IsNull(algorithm2.GetVertexInfo(vertex));
}
public void WriteEdge()
{
{
var g = new TestGraph()
{
Bool = true,
Double = 1.0,
Float = 2.0F,
Int = 10,
Long = 100,
String = "foo"
};
TestVertex v1 = new TestVertex("v1")
{
StringDefault = "bla",
String = "string",
Int = 10,
Long = 20,
Float = 25.0F,
Double = 30.0,
Bool = true
};
TestVertex v2 = new TestVertex("v2")
{
StringDefault = "bla",
String = "string2",
Int = 110,
Long = 120,
Float = 125.0F,
Double = 130.0,
Bool = true
};
g.AddVertex(v1);
g.AddVertex(v2);
var e = new TestEdge(
v1, v2,
"e1",
"edge",
90,
100,
25.0F,
110.0,
true
);
g.AddEdge(e);
var sg = VerifySerialization(g);
var se = Enumerable.First(sg.Edges);
Assert.AreEqual(e.ID, se.ID);
Assert.AreEqual(e.String, se.String);
Assert.AreEqual(e.Int, se.Int);
Assert.AreEqual(e.Long, se.Long);
Assert.AreEqual(e.Float, se.Float);
Assert.AreEqual(e.Double, se.Double);
Assert.AreEqual(e.Bool, se.Bool);
}
}
public void StandardFactory()
{
var vertex = new TestVertex("10");
var positions = new Dictionary <TestVertex, Point>();
var sizes = new Dictionary <TestVertex, Size>();
var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
graph.AddVertex(vertex);
var context = new ContextualLayoutContext <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(
graph,
vertex,
positions,
sizes);
var factory = new ContextualLayoutAlgorithmFactory <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >();
CollectionAssert.AreEqual(
new[] { "DoubleTree", "BalloonTree" },
factory.AlgorithmTypes);
Assert.IsNull(
factory.CreateAlgorithm(
string.Empty,
context,
new DoubleTreeLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"NotExist",
context,
new DoubleTreeLayoutParameters()));
Assert.IsNull(
factory.CreateAlgorithm(
"doubletree",
context,
new DoubleTreeLayoutParameters()));
Assert.IsInstanceOf <DoubleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"DoubleTree",
context,
new DoubleTreeLayoutParameters()));
Assert.IsInstanceOf <BalloonTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > > >(
factory.CreateAlgorithm(
"BalloonTree",
context,
new BalloonTreeLayoutParameters()));
var testParameters = new TestLayoutParameters();
var doubleTreeParameters = new DoubleTreeLayoutParameters();
ILayoutParameters createdParameters = factory.CreateParameters(string.Empty, doubleTreeParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("NotExist", doubleTreeParameters);
Assert.IsNull(createdParameters);
createdParameters = factory.CreateParameters("DoubleTree", null);
Assert.IsInstanceOf <DoubleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(doubleTreeParameters, createdParameters);
createdParameters = factory.CreateParameters("DoubleTree", testParameters);
Assert.IsInstanceOf <DoubleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("DoubleTree", doubleTreeParameters);
Assert.IsInstanceOf <DoubleTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(doubleTreeParameters, createdParameters);
var balloonTreeParameters = new BalloonTreeLayoutParameters();
createdParameters = factory.CreateParameters("BalloonTree", null);
Assert.IsInstanceOf <BalloonTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(balloonTreeParameters, createdParameters);
createdParameters = factory.CreateParameters("BalloonTree", testParameters);
Assert.IsInstanceOf <BalloonTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(testParameters, createdParameters);
createdParameters = factory.CreateParameters("BalloonTree", balloonTreeParameters);
Assert.IsInstanceOf <BalloonTreeLayoutParameters>(createdParameters);
Assert.AreNotSame(balloonTreeParameters, createdParameters);
Assert.IsFalse(factory.IsValidAlgorithm(null));
Assert.IsFalse(factory.IsValidAlgorithm(string.Empty));
Assert.IsTrue(factory.IsValidAlgorithm("DoubleTree"));
Assert.IsFalse(factory.IsValidAlgorithm("doubletree"));
Assert.IsTrue(factory.IsValidAlgorithm("BalloonTree"));
var algorithm1 = new TestLayoutAlgorithm();
Assert.IsEmpty(factory.GetAlgorithmType(algorithm1));
var algorithm2 = new DoubleTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, sizes, vertex, doubleTreeParameters);
Assert.AreEqual("DoubleTree", factory.GetAlgorithmType(algorithm2));
var algorithm3 = new BalloonTreeLayoutAlgorithm <TestVertex, Edge <TestVertex>, BidirectionalGraph <TestVertex, Edge <TestVertex> > >(graph, positions, vertex, balloonTreeParameters);
Assert.AreEqual("BalloonTree", factory.GetAlgorithmType(algorithm3));
Assert.IsFalse(factory.NeedEdgeRouting(string.Empty));
Assert.IsTrue(factory.NeedEdgeRouting("DoubleTree"));
Assert.IsTrue(factory.NeedEdgeRouting("BalloonTree"));
Assert.IsFalse(factory.NeedOverlapRemoval(string.Empty));
Assert.IsFalse(factory.NeedOverlapRemoval("DoubleTree"));
Assert.IsFalse(factory.NeedOverlapRemoval("BalloonTree"));
}
public void Constructor_Throws()
{
var vertex1 = new TestVertex("1");
var vertex2 = new TestVertex("2");
var graph = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
var graphWithVertex1 = new BidirectionalGraph <TestVertex, Edge <TestVertex> >();
graphWithVertex1.AddVertex(vertex1);
VertexFactory <TestVertex> vertexFactory = () => new TestVertex();
EdgeFactory <TestVertex, Edge <TestVertex> > edgeFactory = (source, target) => new Edge <TestVertex>(source, target);
var capacities = new Dictionary <Edge <TestVertex>, double>();
// ReSharper disable ObjectCreationAsStatement
// ReSharper disable AssignNullToNotNullAttribute
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, null, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, vertexFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, null, null));
Assert.Throws <ArgumentException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, vertexFactory, edgeFactory));
Assert.Throws <ArgumentException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graphWithVertex1, vertex1, vertex2, vertexFactory, edgeFactory));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, vertex2, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, null, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, null, edgeFactory, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, vertexFactory, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, vertexFactory, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, vertex2, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, null, edgeFactory, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, vertexFactory, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, vertex2, null, null, capacities));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, vertex1, null, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, null, null, null, null, null));
Assert.Throws <ArgumentNullException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(null, null, null, null, null, null));
Assert.Throws <ArgumentException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graph, vertex1, vertex2, vertexFactory, edgeFactory, capacities));
Assert.Throws <ArgumentException>(
() => new GraphBalancerAlgorithm <TestVertex, Edge <TestVertex> >(graphWithVertex1, vertex1, vertex2, vertexFactory, edgeFactory, capacities));
// ReSharper restore AssignNullToNotNullAttribute
// ReSharper restore ObjectCreationAsStatement
}
public void IsPathWithoutCycles()
{
Assert.IsTrue(Enumerable.Empty <Edge <int> >().IsPathWithoutCycles <int, Edge <int> >());
var edge1 = new Edge <int>(1, 1);
// 1 -> 1
Assert.IsFalse(new[] { edge1 }.IsPathWithoutCycles <int, Edge <int> >());
var edge2 = new Edge <int>(1, 2);
// 1 -> 2
Assert.IsTrue(new[] { edge2 }.IsPathWithoutCycles <int, Edge <int> >());
var edge3 = new Edge <int>(2, 1);
// 1 -> 2 -> 1
Assert.IsFalse(new[] { edge2, edge3 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 1 -> 2
Assert.IsFalse(new[] { edge3, edge2 }.IsPathWithoutCycles <int, Edge <int> >());
var edge4 = new Edge <int>(1, 4);
var edge5 = new Edge <int>(2, 3);
var edge6 = new Edge <int>(3, 4);
var edge7 = new Edge <int>(3, 1);
var edge8 = new Edge <int>(3, 3);
var edge9 = new Edge <int>(4, 3);
// 1 -> 2 -> 1 -> 4
Assert.IsFalse(new[] { edge2, edge3, edge4 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 1 -> 4 -> 3
Assert.IsTrue(new[] { edge3, edge4, edge9 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 1 -> 4 -> 3 -> 1
Assert.IsFalse(new[] { edge3, edge4, edge9, edge7 }.IsPathWithoutCycles <int, Edge <int> >());
// 2 -> 3 -> 4 -> 3 -> 3
Assert.IsFalse(new[] { edge5, edge6, edge9, edge8 }.IsPathWithoutCycles <int, Edge <int> >());
var edge10 = new Edge <int>(2, 4);
var edge11 = new Edge <int>(3, 2);
var edge12 = new Edge <int>(2, 5);
// 1 -> 4 -> 3 -> 2 -> 5
Assert.IsTrue(new[] { edge4, edge9, edge11, edge12 }.IsPathWithoutCycles <int, Edge <int> >());
// 1 -> 2 -> 4 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge2, edge10, edge9, edge11, edge12 }.IsPathWithoutCycles <int, Edge <int> >());
// 1 -> 4 -> 3 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge4, edge9, edge8, edge11, edge12 }.IsPathWithoutCycles <int, Edge <int> >());
// Not a path: 1 -> 2-4 -> 3
Assert.IsFalse(new[] { edge2, edge9 }.IsPathWithoutCycles <int, Edge <int> >());
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var v3 = new TestVertex("3");
var v4 = new TestVertex("4");
var v5 = new TestVertex("5");
var edge13 = new Edge <TestVertex>(v1, v1);
// 1 -> 1
Assert.IsFalse(new[] { edge13 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge14 = new Edge <TestVertex>(v1, v2);
// 1 -> 2
Assert.IsTrue(new[] { edge14 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge15 = new Edge <TestVertex>(v2, v1);
// 1 -> 2 -> 1
Assert.IsFalse(new[] { edge14, edge15 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 2
Assert.IsFalse(new[] { edge15, edge14 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge16 = new Edge <TestVertex>(v1, v4);
var edge17 = new Edge <TestVertex>(v2, v3);
var edge18 = new Edge <TestVertex>(v3, v4);
var edge19 = new Edge <TestVertex>(v3, v1);
var edge20 = new Edge <TestVertex>(v3, v3);
var edge21 = new Edge <TestVertex>(v4, v3);
// 1 -> 2 -> 1 -> 4
Assert.IsFalse(new[] { edge14, edge15, edge16 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 4 -> 3
Assert.IsTrue(new[] { edge15, edge16, edge21 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 4 -> 3 -> 1
Assert.IsFalse(new[] { edge15, edge16, edge21, edge19 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 2 -> 3 -> 4 -> 3 -> 3
Assert.IsFalse(new[] { edge17, edge18, edge21, edge20 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var edge22 = new Edge <TestVertex>(v2, v4);
var edge23 = new Edge <TestVertex>(v3, v2);
var edge24 = new Edge <TestVertex>(v2, v5);
// 1 -> 4 -> 3 -> 2 -> 5
Assert.IsTrue(new[] { edge16, edge21, edge23, edge24 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 1 -> 2 -> 4 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge14, edge22, edge21, edge23, edge24 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// 1 -> 4 -> 3 -> 3 -> 2 -> 5
Assert.IsFalse(new[] { edge16, edge21, edge20, edge23, edge24 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
// Edge cases
var v2Bis = new TestVertex("2");
var edge25 = new Edge <TestVertex>(v4, v2Bis);
// 1 -> 2 -> 4 -> 2Bis
Assert.IsTrue(new[] { edge14, edge22, edge25 }.IsPathWithoutCycles <TestVertex, Edge <TestVertex> >());
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV2Bis = new EquatableTestVertex("2");
var equatableV4 = new EquatableTestVertex("4");
var edge26 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
var edge27 = new Edge <EquatableTestVertex>(equatableV2, equatableV4);
var edge28 = new Edge <EquatableTestVertex>(equatableV4, equatableV2Bis);
// 1 -> 2 -> 4 -> 2Bis
Assert.IsFalse(new[] { edge26, edge27, edge28 }.IsPathWithoutCycles <EquatableTestVertex, Edge <EquatableTestVertex> >());
}
public void IsPath()
{
Assert.IsTrue(Enumerable.Empty <Edge <int> >().IsPath <int, Edge <int> >());
var edge1 = new Edge <int>(1, 1);
// 1 -> 1
Assert.IsTrue(new[] { edge1 }.IsPath <int, Edge <int> >());
var edge2 = new Edge <int>(1, 2);
// 1 -> 2
Assert.IsTrue(new[] { edge2 }.IsPath <int, Edge <int> >());
var edge3 = new Edge <int>(2, 1);
// 1 -> 2 -> 1
Assert.IsTrue(new[] { edge2, edge3 }.IsPath <int, Edge <int> >());
// 1 -> 1 -> 2 -> 1 -> 1
Assert.IsTrue(new[] { edge1, edge2, edge3, edge1 }.IsPath <int, Edge <int> >());
var edge4 = new Edge <int>(1, 4);
// 1 -> 2 -> 1 -> 4
Assert.IsTrue(new[] { edge2, edge3, edge4 }.IsPath <int, Edge <int> >());
// 1 -> 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge2, edge3, edge4, edge2 }.IsPath <int, Edge <int> >());
// 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge3, edge4, edge2 }.IsPath <int, Edge <int> >());
var v1 = new TestVertex("1");
var v2 = new TestVertex("2");
var v4 = new TestVertex("4");
var edge5 = new Edge <TestVertex>(v1, v1);
// 1 -> 1
Assert.IsTrue(new[] { edge5 }.IsPath <TestVertex, Edge <TestVertex> >());
var edge6 = new Edge <TestVertex>(v1, v2);
// 1 -> 2
Assert.IsTrue(new[] { edge6 }.IsPath <TestVertex, Edge <TestVertex> >());
var edge7 = new Edge <TestVertex>(v2, v1);
// 1 -> 2 -> 1
Assert.IsTrue(new[] { edge6, edge7 }.IsPath <TestVertex, Edge <TestVertex> >());
// 1 -> 1 -> 2 -> 1 -> 1
Assert.IsTrue(new[] { edge5, edge6, edge7, edge5 }.IsPath <TestVertex, Edge <TestVertex> >());
var edge8 = new Edge <TestVertex>(v1, v4);
// 1 -> 2 -> 1 -> 4
Assert.IsTrue(new[] { edge6, edge7, edge8 }.IsPath <TestVertex, Edge <TestVertex> >());
// 1 -> 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge6, edge7, edge8, edge6 }.IsPath <TestVertex, Edge <TestVertex> >());
// 2 -> 1 -> 4-1 -> 2
Assert.IsFalse(new[] { edge7, edge8, edge6 }.IsPath <TestVertex, Edge <TestVertex> >());
// Edge cases
var v2Bis = new TestVertex("2");
var edge9 = new Edge <TestVertex>(v2Bis, v1);
// 1 -> 1 -> 2-2Bis -> 1 -> 1 -> 1
Assert.IsFalse(new[] { edge5, edge6, edge9, edge5 }.IsPath <TestVertex, Edge <TestVertex> >());
var equatableV1 = new EquatableTestVertex("1");
var equatableV2 = new EquatableTestVertex("2");
var equatableV2Bis = new EquatableTestVertex("2");
var equatableV4 = new EquatableTestVertex("4");
var edge10 = new Edge <EquatableTestVertex>(equatableV1, equatableV1);
var edge11 = new Edge <EquatableTestVertex>(equatableV1, equatableV2);
var edge12 = new Edge <EquatableTestVertex>(equatableV2Bis, equatableV1);
var edge13 = new Edge <EquatableTestVertex>(equatableV1, equatableV4);
// 1 -> 1 -> 2-2Bis -> 1 -> 4
Assert.IsTrue(new[] { edge10, edge11, edge12, edge13 }.IsPath <EquatableTestVertex, Edge <EquatableTestVertex> >());
}
public void WriteVertex()
{
TestGraph g = new TestGraph()
{
Bool = true,
Double = 1.0,
Float = 2.0F,
Int = 10,
Long = 100,
String = "foo",
BoolArray = BoolArray,
IntArray = IntArray,
LongArray = LongArray,
FloatArray = FloatArray,
DoubleArray = DoubleArray,
StringArray = StringArray,
NullArray = null,
BoolIList = BoolIList,
IntIList = IntIList,
LongIList = LongIList,
FloatIList = FloatIList,
DoubleIList = DoubleIList,
StringIList = StringIList,
};
TestVertex v = new TestVertex("v1")
{
StringDefault = "bla",
String = "string",
Int = 10,
Long = 20,
Float = 25.0F,
Double = 30.0,
Bool = true,
IntArray = new int[] { 1, 2, 3, 4 },
IntIList = new int[] { 4, 5, 6, 7 }
};
g.AddVertex(v);
var sg = VerifySerialization(g);
Assert.AreEqual(g.Bool, sg.Bool);
Assert.AreEqual(g.Double, sg.Double);
Assert.AreEqual(g.Float, sg.Float);
Assert.AreEqual(g.Int, sg.Int);
Assert.AreEqual(g.Long, sg.Long);
Assert.AreEqual(g.String, sg.String);
Assert.IsTrue(g.BoolArray.Equals1(sg.BoolArray));
Assert.IsTrue(g.IntArray.Equals1(sg.IntArray));
Assert.IsTrue(g.LongArray.Equals1(sg.LongArray));
Assert.IsTrue(g.StringArray.Equals1(sg.StringArray));
Assert.IsTrue(g.FloatArray.Equals1(sg.FloatArray, 0.001F));
Assert.IsTrue(g.DoubleArray.Equals1(sg.DoubleArray, 0.0001));
Assert.IsTrue(g.BoolIList.Equals1(sg.BoolIList));
Assert.IsTrue(g.IntIList.Equals1(sg.IntIList));
Assert.IsTrue(g.LongIList.Equals1(sg.LongIList));
Assert.IsTrue(g.StringIList.Equals1(sg.StringIList));
Assert.IsTrue(g.FloatIList.Equals1(sg.FloatIList, 0.001F));
Assert.IsTrue(g.DoubleIList.Equals1(sg.DoubleIList, 0.0001));
var sv = Enumerable.First(sg.Vertices);
Assert.AreEqual(sv.StringDefault, "bla");
Assert.AreEqual(v.String, sv.String);
Assert.AreEqual(v.Int, sv.Int);
Assert.AreEqual(v.Long, sv.Long);
Assert.AreEqual(v.Float, sv.Float);
Assert.AreEqual(v.Double, sv.Double);
Assert.AreEqual(v.Bool, sv.Bool);
Assert.IsTrue(v.IntArray.Equals1(sv.IntArray));
Assert.IsTrue(v.IntIList.Equals1(sv.IntIList));
}
