Ejemplo n.º 1
0
        protected static void AddVerticesAndEdgeRange_Throws_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
        {
            int vertexAdded = 0;
            int edgeAdded   = 0;

            AssertEmptyGraph(graph);
            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
            graph.VertexAdded += v =>
            {
                Assert.IsNotNull(v);
                ++vertexAdded;
            };
            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
            graph.EdgeAdded += e =>
            {
                Assert.IsNotNull(e);
                ++edgeAdded;
            };

            // ReSharper disable once AssignNullToNotNullAttribute
            Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdgeRange(null));

            // Edge 1, 2, 3
            var edge1 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);

            Assert.Throws <ArgumentNullException>(() => graph.AddVerticesAndEdgeRange(new[] { edge1, null, edge3 }));
            Assert.AreEqual(0, vertexAdded);
            Assert.AreEqual(0, edgeAdded);
            AssertEmptyGraph(graph);
        }
Ejemplo n.º 2
0
        protected static void InEdges_ImmutableGraph_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IBidirectionalIncidenceGraph <int, Edge <int> > > createGraph)
        {
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge24 = new Edge <int>(2, 4);
            var edge32 = new Edge <int>(3, 2);
            var edge33 = new Edge <int>(3, 3);

            wrappedGraph.AddVertex(1);
            IBidirectionalIncidenceGraph <int, Edge <int> > graph = createGraph();

            AssertNoInEdge(graph, 1);
            AssertNoOutEdge(graph, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge32, edge33 });
            graph = createGraph();

            AssertHasOutEdges(graph, 1, new[] { edge12, edge13, edge14 });
            AssertHasOutEdges(graph, 2, new[] { edge24 });
            AssertHasOutEdges(graph, 3, new[] { edge32, edge33 });
            AssertNoOutEdge(graph, 4);

            AssertNoInEdge(graph, 1);
            AssertHasInEdges(graph, 2, new[] { edge12, edge32 });
            AssertHasInEdges(graph, 3, new[] { edge13, edge33 });
            AssertHasInEdges(graph, 4, new[] { edge14, edge24 });
        }
Ejemplo n.º 3
0
        protected static void TryGetOutEdges_ImmutableGraph_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IImplicitGraph <int, SEquatableEdge <int> > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(2, 2);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);
            var edge7 = new Edge <int>(4, 5);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
            IImplicitGraph <int, SEquatableEdge <int> > graph = createGraph();

            Assert.IsFalse(graph.TryGetOutEdges(0, out _));

            Assert.IsTrue(graph.TryGetOutEdges(5, out IEnumerable <SEquatableEdge <int> > gotEdges));
            CollectionAssert.IsEmpty(gotEdges);

            Assert.IsTrue(graph.TryGetOutEdges(3, out gotEdges));
            CollectionAssert.AreEqual(
                new[] { new SEquatableEdge <int>(3, 1) },
                gotEdges);

            Assert.IsTrue(graph.TryGetOutEdges(1, out gotEdges));
            CollectionAssert.AreEqual(
                new[]
            {
                new SEquatableEdge <int>(1, 2),
                new SEquatableEdge <int>(1, 2),
                new SEquatableEdge <int>(1, 3)
            },
                gotEdges);
        }
        protected static void TryGetInEdges_ImmutableGraph_Test(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IBidirectionalIncidenceGraph <int, Edge <int> > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(2, 2);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);
            var edge7 = new Edge <int>(5, 3);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
            IBidirectionalIncidenceGraph <int, Edge <int> > graph = createGraph();

            Assert.IsFalse(graph.TryGetInEdges(0, out _));

            Assert.IsTrue(graph.TryGetInEdges(5, out IEnumerable <Edge <int> > gotEdges));
            CollectionAssert.IsEmpty(gotEdges);

            Assert.IsTrue(graph.TryGetInEdges(4, out gotEdges));
            CollectionAssert.AreEqual(new[] { edge5 }, gotEdges);

            Assert.IsTrue(graph.TryGetInEdges(2, out gotEdges));
            CollectionAssert.AreEqual(new[] { edge1, edge2, edge4 }, gotEdges);
        }
Ejemplo n.º 5
0
        protected static void TryGetInEdges_ImmutableGraph_ReversedTest(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(1, 1);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);
            var edge7 = new Edge <int>(4, 5);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
            IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            Assert.IsFalse(graph.TryGetInEdges(0, out _));

            Assert.IsTrue(graph.TryGetInEdges(5, out IEnumerable <SReversedEdge <int, Edge <int> > > gotEdges));
            CollectionAssert.IsEmpty(gotEdges);

            Assert.IsTrue(graph.TryGetInEdges(4, out gotEdges));
            AssertSameReversedEdges(new[] { edge7 }, gotEdges);

            Assert.IsTrue(graph.TryGetInEdges(1, out gotEdges));
            AssertSameReversedEdges(new[] { edge1, edge2, edge3, edge4 }, gotEdges);
        }
        protected static void TryGetOutEdges_ImmutableGraph_ReversedTest(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IImplicitGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(2, 2);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);
            var edge7 = new Edge <int>(5, 4);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
            IImplicitGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            Assert.IsFalse(graph.TryGetOutEdges(0, out _));

            Assert.IsTrue(graph.TryGetOutEdges(5, out IEnumerable <SReversedEdge <int, Edge <int> > > gotEdges));
            CollectionAssert.IsEmpty(gotEdges);

            Assert.IsTrue(graph.TryGetOutEdges(3, out gotEdges));
            AssertSameReversedEdges(new[] { edge3 }, gotEdges);

            Assert.IsTrue(graph.TryGetOutEdges(2, out gotEdges));
            AssertSameReversedEdges(new[] { edge1, edge2, edge4 }, gotEdges);
        }
        protected static void TryGetEdge_ImmutableGraph_ReversedTest(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(2, 2);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6 });
            IIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            Assert.IsFalse(graph.TryGetEdge(0, 10, out _));
            Assert.IsFalse(graph.TryGetEdge(0, 1, out _));

            Assert.IsTrue(graph.TryGetEdge(4, 2, out SReversedEdge <int, Edge <int> > gotEdge));
            AssertSameReversedEdge(edge5, gotEdge);

            Assert.IsTrue(graph.TryGetEdge(2, 2, out gotEdge));
            AssertSameReversedEdge(edge4, gotEdge);

            Assert.IsTrue(graph.TryGetEdge(2, 1, out gotEdge));
            AssertSameReversedEdge(edge1, gotEdge);

            Assert.IsFalse(graph.TryGetEdge(1, 2, out _));
        }
Ejemplo n.º 8
0
        protected static void TryGetEdge_ImmutableGraph_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IIncidenceGraph <int, SEquatableEdge <int> > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(2, 2);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6 });
            IIncidenceGraph <int, SEquatableEdge <int> > graph = createGraph();

            Assert.IsFalse(graph.TryGetEdge(0, 10, out _));
            Assert.IsFalse(graph.TryGetEdge(0, 1, out _));

            Assert.IsTrue(graph.TryGetEdge(2, 4, out SEquatableEdge <int> gotEdge));
            Assert.AreEqual(new SEquatableEdge <int>(2, 4), gotEdge);

            Assert.IsTrue(graph.TryGetEdge(2, 2, out gotEdge));
            Assert.AreEqual(new SEquatableEdge <int>(2, 2), gotEdge);

            Assert.IsTrue(graph.TryGetEdge(1, 2, out gotEdge));
            Assert.AreEqual(new SEquatableEdge <int>(1, 2), gotEdge);

            Assert.IsFalse(graph.TryGetEdge(2, 1, out _));
        }
        protected static void InEdges_ImmutableGraph_ReversedTest(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge33 = new Edge <int>(3, 3);
            var edge34 = new Edge <int>(3, 4);
            var edge43 = new Edge <int>(4, 3);

            wrappedGraph.AddVertex(1);
            IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            AssertNoInEdge(graph, 1);
            AssertNoOutEdge(graph, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge33, edge34, edge43 });
            graph = createGraph();

            AssertNoOutEdge(graph, 1);
            AssertHasReversedOutEdges(graph, 2, new[] { edge12 });
            AssertHasReversedOutEdges(graph, 3, new[] { edge13, edge33, edge43 });
            AssertHasReversedOutEdges(graph, 4, new[] { edge14, edge34 });

            AssertHasReversedInEdges(graph, 1, new[] { edge12, edge13, edge14 });
            AssertNoInEdge(graph, 2);
            AssertHasReversedInEdges(graph, 3, new[] { edge33, edge34 });
            AssertHasReversedInEdges(graph, 4, new[] { edge43 });
        }
        protected static void AdjacentEdges_ImmutableGraph_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IImplicitUndirectedGraph <int, Edge <int> > > createGraph)
        {
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge24 = new Edge <int>(2, 4);
            var edge31 = new Edge <int>(3, 1);
            var edge33 = new Edge <int>(3, 3);

            wrappedGraph.AddVertex(1);
            IImplicitUndirectedGraph <int, Edge <int> > graph = createGraph();

            AssertNoAdjacentEdge(graph, 1);

            wrappedGraph.AddVertex(5);
            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
            graph = createGraph();

            AssertHasAdjacentEdges(graph, 1, new[] { edge12, edge13, edge14, edge31 });
            AssertHasAdjacentEdges(graph, 2, new[] { edge12, edge24 });
            AssertHasAdjacentEdges(graph, 3, new[] { edge13, edge31, edge33 }, 4);  // Has self edge counting twice
            AssertHasAdjacentEdges(graph, 4, new[] { edge14, edge24 });
            AssertNoAdjacentEdge(graph, 5);
        }
Ejemplo n.º 11
0
        protected static void RemoveVertexIf_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
        {
            int verticesRemoved = 0;
            int edgesRemoved    = 0;

            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
            graph.VertexRemoved += v =>
            {
                Assert.IsNotNull(v);
                // ReSharper disable once AccessToModifiedClosure
                ++verticesRemoved;
            };
            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
            graph.EdgeRemoved += e =>
            {
                Assert.IsNotNull(e);
                // ReSharper disable once AccessToModifiedClosure
                ++edgesRemoved;
            };

            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge24 = new Edge <int>(2, 4);
            var edge31 = new Edge <int>(3, 1);
            var edge33 = new Edge <int>(3, 3);

            graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });

            Assert.AreEqual(0, graph.RemoveVertexIf(vertex => vertex > 10));
            CheckCounters(0, 0);

            Assert.AreEqual(2, graph.RemoveVertexIf(vertex => vertex > 2));
            CheckCounters(2, 5);
            AssertHasVertices(graph, new[] { 1, 2 });
            AssertHasEdges(graph, new[] { edge12 });

            Assert.AreEqual(2, graph.RemoveVertexIf(_ => true));
            CheckCounters(2, 1);
            AssertEmptyGraph(graph);

            #region Local function

            void CheckCounters(int expectedRemovedVertices, int expectedRemovedEdges)
            {
                Assert.AreEqual(expectedRemovedVertices, verticesRemoved);
                Assert.AreEqual(expectedRemovedEdges, edgesRemoved);
                verticesRemoved = 0;
                edgesRemoved    = 0;
            }

            #endregion
        }
Ejemplo n.º 12
0
        protected static void AddVerticesAndEdgeRange_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
        {
            int vertexAdded = 0;
            int edgeAdded   = 0;

            AssertEmptyGraph(graph);
            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
            graph.VertexAdded += v =>
            {
                Assert.IsNotNull(v);
                ++vertexAdded;
            };
            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
            graph.EdgeAdded += e =>
            {
                Assert.IsNotNull(e);
                ++edgeAdded;
            };

            // Edge 1, 2
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 3);

            Assert.AreEqual(2, graph.AddVerticesAndEdgeRange(new[] { edge1, edge2 }));
            Assert.AreEqual(3, vertexAdded);
            Assert.AreEqual(2, edgeAdded);
            AssertHasVertices(graph, new[] { 1, 2, 3 });
            AssertHasEdges(graph, new[] { edge1, edge2 });

            // Edge 1, 3
            var edge3 = new Edge <int>(2, 3);

            Assert.AreEqual(1, graph.AddVerticesAndEdgeRange(new[] { edge1, edge3 })); // Showcase the add of only one edge
            Assert.AreEqual(3, vertexAdded);
            Assert.AreEqual(3, edgeAdded);
            AssertHasVertices(graph, new[] { 1, 2, 3 });
            AssertHasEdges(graph, new[] { edge1, edge2, edge3 });
        }
Ejemplo n.º 13
0
        protected static void AddVerticesAndEdgeRange_Test(
            IMutableVertexAndEdgeSet <int, Edge <int> > graph)
        {
            int vertexAdded = 0;
            int edgeAdded   = 0;

            AssertEmptyGraph(graph);
            graph.VertexAdded += v =>
            {
                Assert.IsNotNull(v);
                ++vertexAdded;
            };
            graph.EdgeAdded += e =>
            {
                Assert.IsNotNull(e);
                ++edgeAdded;
            };

            // Edge 1, 2
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 3);

            Assert.AreEqual(2, graph.AddVerticesAndEdgeRange(new[] { edge1, edge2 }));
            Assert.AreEqual(3, vertexAdded);
            Assert.AreEqual(2, edgeAdded);
            AssertHasVertices(graph, new[] { 1, 2, 3 });
            AssertHasEdges(graph, new[] { edge1, edge2 });

            // Edge 1, 3
            var edge3 = new Edge <int>(2, 3);

            Assert.AreEqual(1, graph.AddVerticesAndEdgeRange(new[] { edge1, edge3 })); // Showcase the add of only one edge
            Assert.AreEqual(3, vertexAdded);
            Assert.AreEqual(3, edgeAdded);
            AssertHasVertices(graph, new[] { 1, 2, 3 });
            AssertHasEdges(graph, new[] { edge1, edge2, edge3 });
        }
        protected static void InEdge_ImmutableGraph_Test(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IBidirectionalIncidenceGraph <int, Edge <int> > > createGraph)
        {
            var edge11 = new Edge <int>(1, 1);
            var edge13 = new Edge <int>(1, 3);
            var edge21 = new Edge <int>(2, 1);
            var edge41 = new Edge <int>(4, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge11, edge13, edge21, edge41 });
            IBidirectionalIncidenceGraph <int, Edge <int> > graph = createGraph();

            Assert.AreSame(edge11, graph.InEdge(1, 0));
            Assert.AreSame(edge41, graph.InEdge(1, 2));
            Assert.AreSame(edge13, graph.InEdge(3, 0));
        }
        protected static void InEdge_ImmutableGraph_ReversedTest(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge11 = new Edge <int>(1, 1);
            var edge31 = new Edge <int>(3, 1);
            var edge32 = new Edge <int>(3, 2);
            var edge34 = new Edge <int>(3, 4);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge11, edge31, edge32, edge34 });
            IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            AssertSameReversedEdge(edge11, graph.InEdge(1, 0));
            AssertSameReversedEdge(edge31, graph.InEdge(3, 0));
            AssertSameReversedEdge(edge34, graph.InEdge(3, 2));
        }
Ejemplo n.º 16
0
        protected static void OutEdges_ImmutableGraph_Test(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IImplicitGraph <int, SEquatableEdge <int> > > createGraph)
        {
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge24 = new Edge <int>(2, 4);
            var edge31 = new Edge <int>(3, 1);
            var edge33 = new Edge <int>(3, 3);

            wrappedGraph.AddVertex(1);
            IImplicitGraph <int, SEquatableEdge <int> > graph = createGraph();

            AssertNoOutEdge(graph, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });
            graph = createGraph();

            AssertHasOutEdges(
                graph,
                1,
                new[]
            {
                new SEquatableEdge <int>(1, 2),
                new SEquatableEdge <int>(1, 3),
                new SEquatableEdge <int>(1, 4)
            });
            AssertHasOutEdges(
                graph,
                2,
                new[] { new SEquatableEdge <int>(2, 4) });
            AssertHasOutEdges(
                graph,
                3,
                new[]
            {
                new SEquatableEdge <int>(3, 1),
                new SEquatableEdge <int>(3, 3)
            });
            AssertNoOutEdge(graph, 4);
        }
Ejemplo n.º 17
0
        protected static void OutEdge_ImmutableGraph_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IImplicitGraph <int, Edge <int> > > createGraph)
        {
            var edge11 = new Edge <int>(1, 1);
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge24 = new Edge <int>(2, 4);
            var edge33 = new Edge <int>(3, 3);
            var edge41 = new Edge <int>(4, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge11, edge12, edge13, edge24, edge33, edge41 });
            IImplicitGraph <int, Edge <int> > graph = createGraph();

            Assert.AreSame(edge11, graph.OutEdge(1, 0));
            Assert.AreSame(edge13, graph.OutEdge(1, 2));
            Assert.AreSame(edge24, graph.OutEdge(2, 0));
            Assert.AreSame(edge33, graph.OutEdge(3, 0));
            Assert.AreSame(edge41, graph.OutEdge(4, 0));
        }
Ejemplo n.º 18
0
        protected static void OutEdge_ImmutableGraph_Test(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IImplicitGraph <int, SEquatableEdge <int> > > createGraph)
        {
            var edge11 = new Edge <int>(1, 1);
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge24 = new Edge <int>(2, 4);
            var edge33 = new Edge <int>(3, 3);
            var edge41 = new Edge <int>(4, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge11, edge12, edge13, edge24, edge33, edge41 });
            IImplicitGraph <int, SEquatableEdge <int> > graph = createGraph();

            Assert.AreEqual(new SEquatableEdge <int>(1, 1), graph.OutEdge(1, 0));
            Assert.AreEqual(new SEquatableEdge <int>(1, 3), graph.OutEdge(1, 2));
            Assert.AreEqual(new SEquatableEdge <int>(2, 4), graph.OutEdge(2, 0));
            Assert.AreEqual(new SEquatableEdge <int>(3, 3), graph.OutEdge(3, 0));
            Assert.AreEqual(new SEquatableEdge <int>(4, 1), graph.OutEdge(4, 0));
        }
        protected static void AdjacentEdge_ImmutableGraph_Test(
            IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            Func <IImplicitUndirectedGraph <int, Edge <int> > > createGraph)
        {
            var edge11 = new Edge <int>(1, 1);
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge24 = new Edge <int>(2, 4);
            var edge33 = new Edge <int>(3, 3);
            var edge41 = new Edge <int>(4, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge11, edge12, edge13, edge24, edge33, edge41 });
            IImplicitUndirectedGraph <int, Edge <int> > graph = createGraph();

            Assert.AreSame(edge11, graph.AdjacentEdge(1, 0));
            Assert.AreSame(edge13, graph.AdjacentEdge(1, 2));
            Assert.AreSame(edge41, graph.AdjacentEdge(1, 3));
            Assert.AreSame(edge13, graph.AdjacentEdge(3, 0));
            Assert.AreSame(edge33, graph.AdjacentEdge(3, 1));
            Assert.AreSame(edge24, graph.AdjacentEdge(4, 0));
        }
Ejemplo n.º 20
0
        protected static void Degree_ImmutableGraph_ReversedTest(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 3);
            var edge3 = new Edge <int>(1, 4);
            var edge4 = new Edge <int>(2, 4);
            var edge5 = new Edge <int>(3, 2);
            var edge6 = new Edge <int>(3, 3);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6 });
            wrappedGraph.AddVertex(5);
            IBidirectionalIncidenceGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            Assert.AreEqual(3, graph.Degree(1));
            Assert.AreEqual(3, graph.Degree(2));
            Assert.AreEqual(4, graph.Degree(3)); // Self edge
            Assert.AreEqual(2, graph.Degree(4));
            Assert.AreEqual(0, graph.Degree(5));
        }
Ejemplo n.º 21
0
        protected static void TryGetEdge_ImmutableGraph_UndirectedGraph_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IImplicitUndirectedGraph <int, Edge <int> > > createGraph)
        {
            var edge1 = new Edge <int>(1, 2);
            var edge2 = new Edge <int>(1, 2);
            var edge3 = new Edge <int>(1, 3);
            var edge4 = new Edge <int>(2, 2);
            var edge5 = new Edge <int>(2, 4);
            var edge6 = new Edge <int>(3, 1);
            var edge7 = new Edge <int>(5, 2);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge1, edge2, edge3, edge4, edge5, edge6, edge7 });
            var graph = createGraph();

            Assert.IsFalse(graph.TryGetEdge(0, 10, out _));
            Assert.IsFalse(graph.TryGetEdge(0, 1, out _));

            Assert.IsTrue(graph.TryGetEdge(2, 4, out Edge <int> gotEdge));
            Assert.AreSame(edge5, gotEdge);

            Assert.IsTrue(graph.TryGetEdge(1, 2, out gotEdge));
            Assert.AreSame(edge1, gotEdge);

            Assert.IsTrue(graph.TryGetEdge(2, 2, out gotEdge));
            Assert.AreSame(edge4, gotEdge);

            // 1 -> 2 is present in this undirected graph
            Assert.IsTrue(graph.TryGetEdge(2, 1, out gotEdge));
            Assert.AreSame(edge1, gotEdge);

            Assert.IsTrue(graph.TryGetEdge(5, 2, out gotEdge));
            Assert.AreSame(edge7, gotEdge);

            // 5 -> 2 is present in this undirected graph
            Assert.IsTrue(graph.TryGetEdge(2, 5, out gotEdge));
            Assert.AreSame(edge7, gotEdge);
        }
Ejemplo n.º 22
0
        protected static void OutEdges_ImmutableGraph_ReversedTest(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > wrappedGraph,
            [NotNull, InstantHandle] Func <IImplicitGraph <int, SReversedEdge <int, Edge <int> > > > createGraph)
        {
            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge24 = new Edge <int>(2, 4);
            var edge33 = new Edge <int>(3, 3);
            var edge34 = new Edge <int>(3, 4);

            wrappedGraph.AddVertex(1);
            IImplicitGraph <int, SReversedEdge <int, Edge <int> > > graph = createGraph();

            AssertNoOutEdge(graph, 1);

            wrappedGraph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge33, edge34 });
            graph = createGraph();

            AssertNoOutEdge(graph, 1);
            AssertHasReversedOutEdges(graph, 2, new[] { edge12 });
            AssertHasReversedOutEdges(graph, 3, new[] { edge13, edge33 });
            AssertHasReversedOutEdges(graph, 4, new[] { edge14, edge24, edge34 });
        }
        protected static void RemoveVertex_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, Edge <int> > graph)
        {
            int verticesRemoved = 0;
            int edgesRemoved    = 0;

            graph.VertexRemoved += v =>
            {
                Assert.IsNotNull(v);
                // ReSharper disable once AccessToModifiedClosure
                ++verticesRemoved;
            };
            graph.EdgeRemoved += e =>
            {
                Assert.IsNotNull(e);
                // ReSharper disable once AccessToModifiedClosure
                ++edgesRemoved;
            };

            var edge12 = new Edge <int>(1, 2);
            var edge13 = new Edge <int>(1, 3);
            var edge14 = new Edge <int>(1, 4);
            var edge24 = new Edge <int>(2, 4);
            var edge31 = new Edge <int>(3, 1);
            var edge33 = new Edge <int>(3, 3);

            graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge14, edge24, edge31, edge33 });

            Assert.IsFalse(graph.RemoveVertex(5));
            CheckCounters(0, 0);

            Assert.IsTrue(graph.RemoveVertex(3));
            CheckCounters(1, 3);
            AssertHasVertices(graph, new[] { 1, 2, 4 });
            AssertHasEdges(graph, new[] { edge12, edge14, edge24 });

            Assert.IsTrue(graph.RemoveVertex(1));
            CheckCounters(1, 2);
            AssertHasVertices(graph, new[] { 2, 4 });
            AssertHasEdges(graph, new[] { edge24 });

            Assert.IsTrue(graph.RemoveVertex(2));
            CheckCounters(1, 1);
            AssertHasVertices(graph, new[] { 4 });
            AssertNoEdge(graph);

            Assert.IsTrue(graph.RemoveVertex(4));
            CheckCounters(1, 0);
            AssertEmptyGraph(graph);

            #region Local function

            void CheckCounters(int expectedRemovedVertices, int expectedRemovedEdges)
            {
                Assert.AreEqual(expectedRemovedVertices, verticesRemoved);
                Assert.AreEqual(expectedRemovedEdges, edgesRemoved);
                verticesRemoved = 0;
                edgesRemoved    = 0;
            }

            #endregion
        }
        protected static void RemoveEdge_EquatableEdge_Test(
            [NotNull] IMutableVertexAndEdgeSet <int, EquatableEdge <int> > graph)
        {
            int verticesRemoved = 0;
            int edgesRemoved    = 0;

            graph.VertexRemoved += v =>
            {
                Assert.IsNotNull(v);
                ++verticesRemoved;
            };
            graph.EdgeRemoved += e =>
            {
                Assert.IsNotNull(e);
                // ReSharper disable once AccessToModifiedClosure
                ++edgesRemoved;
            };

            var edge12                     = new EquatableEdge <int>(1, 2);
            var edge13                     = new EquatableEdge <int>(1, 3);
            var edge13Bis                  = new EquatableEdge <int>(1, 3);
            var edge14                     = new EquatableEdge <int>(1, 4);
            var edge24                     = new EquatableEdge <int>(2, 4);
            var edge31                     = new EquatableEdge <int>(3, 1);
            var edge33                     = new EquatableEdge <int>(3, 3);
            var edgeNotInGraph             = new EquatableEdge <int>(3, 4);
            var edgeWithVertexNotInGraph1  = new EquatableEdge <int>(2, 10);
            var edgeWithVertexNotInGraph2  = new EquatableEdge <int>(10, 2);
            var edgeWithVerticesNotInGraph = new EquatableEdge <int>(10, 11);
            var edgeEquatable              = new EquatableEdge <int>(1, 2);

            graph.AddVerticesAndEdgeRange(new[] { edge12, edge13, edge13Bis, edge14, edge24, edge31, edge33 });

            Assert.IsFalse(graph.RemoveEdge(edgeNotInGraph));
            CheckCounters(0);

            Assert.IsFalse(graph.RemoveEdge(edgeWithVertexNotInGraph1));
            CheckCounters(0);

            Assert.IsFalse(graph.RemoveEdge(edgeWithVertexNotInGraph2));
            CheckCounters(0);

            Assert.IsFalse(graph.RemoveEdge(edgeWithVerticesNotInGraph));
            CheckCounters(0);

            Assert.IsTrue(graph.RemoveEdge(edgeEquatable));
            CheckCounters(1);
            AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
            AssertHasEdges(graph, new[] { edge13, edge13Bis, edge14, edge24, edge31, edge33 });

            Assert.IsTrue(graph.RemoveEdge(edge13Bis));
            CheckCounters(1);
            AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
            AssertHasEdges(graph, new[] { edge13, edge14, edge24, edge31, edge33 });

            Assert.IsTrue(graph.RemoveEdge(edge31));
            CheckCounters(1);
            AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
            AssertHasEdges(graph, new[] { edge13, edge14, edge24, edge33 });

            Assert.IsTrue(graph.RemoveEdge(edge13));
            Assert.IsTrue(graph.RemoveEdge(edge14));
            Assert.IsTrue(graph.RemoveEdge(edge24));
            Assert.IsTrue(graph.RemoveEdge(edge33));
            CheckCounters(4);
            AssertHasVertices(graph, new[] { 1, 2, 3, 4 });
            AssertNoEdge(graph);

            #region Local function

            void CheckCounters(int expectedRemovedEdges)
            {
                Assert.AreEqual(0, verticesRemoved);
                Assert.AreEqual(expectedRemovedEdges, edgesRemoved);
                edgesRemoved = 0;
            }

            #endregion
        }