Add unit tests for graph algorithms (#7133)

src/test/java/com/thealgorithms/datastructures/graphs/BellmanFordTest.java

@@ -0,0 +1,158 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the BellmanFord algorithm implementation.
+ * Tests cover various graph scenarios including:
+ * - Simple weighted graphs
+ * - Graphs with negative weights
+ * - Single vertex graphs
+ * - Disconnected graphs
+ * - Linear path graphs
+ */
+class BellmanFordTest {
+
+    @Test
+    void testSimpleGraph() {
+        // Create a simple graph with 5 vertices and 8 edges
+        // Graph visualization:
+        // 1
+        // /|\
+        // 6 | 7
+        // / | \
+        // 0 5 2
+        // \ | /
+        // 8 | -2
+        // \|/
+        // 4---3
+        // 9
+        BellmanFord bellmanFord = new BellmanFord(5, 8);
+        bellmanFord.addEdge(0, 1, 6);
+        bellmanFord.addEdge(0, 4, 8);
+        bellmanFord.addEdge(1, 2, 7);
+        bellmanFord.addEdge(1, 4, 5);
+        bellmanFord.addEdge(2, 3, -2);
+        bellmanFord.addEdge(2, 4, -3);
+        bellmanFord.addEdge(3, 4, 9);
+        bellmanFord.addEdge(4, 3, 7);
+
+        // Verify edge array creation
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(8, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testGraphWithNegativeWeights() {
+        // Graph with negative edge weights (but no negative cycle)
+        BellmanFord bellmanFord = new BellmanFord(4, 5);
+        bellmanFord.addEdge(0, 1, 4);
+        bellmanFord.addEdge(0, 2, 5);
+        bellmanFord.addEdge(1, 2, -3);
+        bellmanFord.addEdge(2, 3, 4);
+        bellmanFord.addEdge(1, 3, 6);
+
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(5, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testSingleVertexGraph() {
+        // Graph with single vertex and no edges
+        BellmanFord bellmanFord = new BellmanFord(1, 0);
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(0, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testLinearGraph() {
+        // Linear graph: 0 -> 1 -> 2 -> 3
+        BellmanFord bellmanFord = new BellmanFord(4, 3);
+        bellmanFord.addEdge(0, 1, 2);
+        bellmanFord.addEdge(1, 2, 3);
+        bellmanFord.addEdge(2, 3, 4);
+
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(3, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testEdgeAddition() {
+        BellmanFord bellmanFord = new BellmanFord(3, 3);
+
+        bellmanFord.addEdge(0, 1, 5);
+        bellmanFord.addEdge(1, 2, 3);
+        bellmanFord.addEdge(0, 2, 10);
+
+        // Verify all edges were added
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(3, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testGraphWithZeroWeightEdges() {
+        // Graph with zero weight edges
+        BellmanFord bellmanFord = new BellmanFord(3, 3);
+        bellmanFord.addEdge(0, 1, 0);
+        bellmanFord.addEdge(1, 2, 0);
+        bellmanFord.addEdge(0, 2, 1);
+
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(3, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testLargerGraph() {
+        // Larger graph with 6 vertices
+        BellmanFord bellmanFord = new BellmanFord(6, 9);
+        bellmanFord.addEdge(0, 1, 5);
+        bellmanFord.addEdge(0, 2, 3);
+        bellmanFord.addEdge(1, 3, 6);
+        bellmanFord.addEdge(1, 2, 2);
+        bellmanFord.addEdge(2, 4, 4);
+        bellmanFord.addEdge(2, 5, 2);
+        bellmanFord.addEdge(2, 3, 7);
+        bellmanFord.addEdge(3, 4, -1);
+        bellmanFord.addEdge(4, 5, -2);
+
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(9, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testVertexAndEdgeCount() {
+        BellmanFord bellmanFord = new BellmanFord(10, 15);
+        assertEquals(10, bellmanFord.vertex);
+        assertEquals(15, bellmanFord.edge);
+    }
+
+    @Test
+    void testMultipleEdgesBetweenSameVertices() {
+        // Graph allowing multiple edges between same vertices
+        BellmanFord bellmanFord = new BellmanFord(2, 3);
+        bellmanFord.addEdge(0, 1, 5);
+        bellmanFord.addEdge(0, 1, 3);
+        bellmanFord.addEdge(1, 0, 2);
+
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(3, bellmanFord.getEdgeArray().length);
+    }
+
+    @Test
+    void testCompleteGraph() {
+        // Complete graph with 4 vertices (6 edges for undirected equivalent)
+        BellmanFord bellmanFord = new BellmanFord(4, 6);
+        bellmanFord.addEdge(0, 1, 1);
+        bellmanFord.addEdge(0, 2, 2);
+        bellmanFord.addEdge(0, 3, 3);
+        bellmanFord.addEdge(1, 2, 4);
+        bellmanFord.addEdge(1, 3, 5);
+        bellmanFord.addEdge(2, 3, 6);
+
+        assertNotNull(bellmanFord.getEdgeArray());
+        assertEquals(6, bellmanFord.getEdgeArray().length);
+    }
+}

src/test/java/com/thealgorithms/datastructures/graphs/ConnectedComponentTest.java

@@ -0,0 +1,204 @@
+package com.thealgorithms.datastructures.graphs;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import org.junit.jupiter.api.Test;
+
+/**
+ * Unit tests for the Graph class in ConnectedComponent.java.
+ * Tests the depth-first search implementation and connected component counting.
+ * Covers various graph topologies including:
+ * - Single connected components
+ * - Multiple disconnected components
+ * - Self-loops
+ * - Linear chains
+ * - Cyclic graphs
+ */
+class ConnectedComponentTest {
+
+    @Test
+    void testSingleConnectedComponent() {
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 4);
+        graph.addEdge(4, 1);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testTwoDisconnectedComponents() {
+        Graph<Integer> graph = new Graph<>();
+        // Component 1: 1-2-3
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        // Component 2: 4-5
+        graph.addEdge(4, 5);
+
+        assertEquals(2, graph.countGraphs());
+    }
+
+    @Test
+    void testThreeDisconnectedComponents() {
+        Graph<Character> graph = new Graph<>();
+        // Component 1: a-b-c-d-e
+        graph.addEdge('a', 'b');
+        graph.addEdge('a', 'e');
+        graph.addEdge('b', 'e');
+        graph.addEdge('b', 'c');
+        graph.addEdge('c', 'd');
+        graph.addEdge('d', 'a');
+        // Component 2: x-y-z
+        graph.addEdge('x', 'y');
+        graph.addEdge('x', 'z');
+        // Component 3: w (self-loop)
+        graph.addEdge('w', 'w');
+
+        assertEquals(3, graph.countGraphs());
+    }
+
+    @Test
+    void testSingleNodeSelfLoop() {
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(1, 1);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testLinearChain() {
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 4);
+        graph.addEdge(4, 5);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testStarTopology() {
+        // Star graph with center node 0 connected to nodes 1, 2, 3, 4
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(0, 1);
+        graph.addEdge(0, 2);
+        graph.addEdge(0, 3);
+        graph.addEdge(0, 4);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testCompleteGraph() {
+        // Complete graph K4: every node connected to every other node
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(1, 2);
+        graph.addEdge(1, 3);
+        graph.addEdge(1, 4);
+        graph.addEdge(2, 3);
+        graph.addEdge(2, 4);
+        graph.addEdge(3, 4);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testStringVertices() {
+        Graph<String> graph = new Graph<>();
+        // Component 1
+        graph.addEdge("New York", "Los Angeles");
+        graph.addEdge("Los Angeles", "Chicago");
+        // Component 2
+        graph.addEdge("London", "Paris");
+        // Component 3
+        graph.addEdge("Tokyo", "Tokyo");
+
+        assertEquals(3, graph.countGraphs());
+    }
+
+    @Test
+    void testEmptyGraph() {
+        Graph<Integer> graph = new Graph<>();
+        assertEquals(0, graph.countGraphs());
+    }
+
+    @Test
+    void testDepthFirstSearchBasic() {
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+
+        // Get the first node and perform DFS
+        assertNotNull(graph.nodeList);
+        assertEquals(3, graph.nodeList.size());
+    }
+
+    @Test
+    void testManyIsolatedComponents() {
+        Graph<Integer> graph = new Graph<>();
+        // Create 5 isolated components (each is a self-loop)
+        graph.addEdge(1, 1);
+        graph.addEdge(2, 2);
+        graph.addEdge(3, 3);
+        graph.addEdge(4, 4);
+        graph.addEdge(5, 5);
+
+        assertEquals(5, graph.countGraphs());
+    }
+
+    @Test
+    void testBidirectionalEdges() {
+        Graph<Integer> graph = new Graph<>();
+        // Note: This is a directed graph representation
+        // Adding edge 1->2 does not automatically add 2->1
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 1);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 2);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testCyclicGraph() {
+        Graph<Integer> graph = new Graph<>();
+        // Create a cycle: 1 -> 2 -> 3 -> 4 -> 1
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 4);
+        graph.addEdge(4, 1);
+
+        assertEquals(1, graph.countGraphs());
+    }
+
+    @Test
+    void testMultipleCycles() {
+        Graph<Integer> graph = new Graph<>();
+        // Cycle 1: 1 -> 2 -> 3 -> 1
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(3, 1);
+        // Cycle 2: 4 -> 5 -> 4
+        graph.addEdge(4, 5);
+        graph.addEdge(5, 4);
+
+        assertEquals(2, graph.countGraphs());
+    }
+
+    @Test
+    void testIntegerGraphFromMainExample() {
+        // Recreate the example from main method
+        Graph<Integer> graph = new Graph<>();
+        graph.addEdge(1, 2);
+        graph.addEdge(2, 3);
+        graph.addEdge(2, 4);
+        graph.addEdge(3, 5);
+        graph.addEdge(7, 8);
+        graph.addEdge(8, 10);
+        graph.addEdge(10, 8);
+
+        assertEquals(2, graph.countGraphs());
+    }
+}