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)); }