Refactor BellmanFordTest to use Edge class

Fixed compilation errors by using BellmanFord.Edge instead of int[] arrays.
Updated all test methods to create Edge objects properly.
Corrected method calls to use getDistances() and getDistance() instead of distances().

Author: vardhan30016

src/test/java/com/thealgorithms/graph/BellmanFordTest.java

@@ -14,31 +14,31 @@ class BellmanFordTest {
 
     @Test
     void testSimpleGraph() {
-        List<int[]> edges = new ArrayList<>();
-        edges.add(new int[] {0, 1, 6});
-        edges.add(new int[] {0, 2, 7});
-        edges.add(new int[] {1, 2, 8});
-        edges.add(new int[] {1, 3, 5});
-        edges.add(new int[] {1, 4, -4});
-        edges.add(new int[] {2, 3, -3});
-        edges.add(new int[] {2, 4, 9});
-        edges.add(new int[] {3, 1, -2});
-        edges.add(new int[] {4, 0, 2});
-        edges.add(new int[] {4, 3, 7});
+        List<BellmanFord.Edge> edges = new ArrayList<>();
+        edges.add(new BellmanFord.Edge(0, 1, 6));
+        edges.add(new BellmanFord.Edge(0, 2, 7));
+        edges.add(new BellmanFord.Edge(1, 2, 8));
+        edges.add(new BellmanFord.Edge(1, 3, 5));
+        edges.add(new BellmanFord.Edge(1, 4, -4));
+        edges.add(new BellmanFord.Edge(2, 3, -3));
+        edges.add(new BellmanFord.Edge(2, 4, 9));
+        edges.add(new BellmanFord.Edge(3, 1, -2));
+        edges.add(new BellmanFord.Edge(4, 0, 2));
+        edges.add(new BellmanFord.Edge(4, 3, 7));
 
         BellmanFord.Result result = BellmanFord.findShortestPaths(5, edges, 0);
 
         assertTrue(result.hasPath());
         assertFalse(result.hasNegativeCycle());
-        assertArrayEquals(new double[] {0, 2, 7, 4, -2}, result.distances());
+        assertArrayEquals(new int[] {0, 2, 7, 4, -2}, result.getDistances());
     }
 
     @Test
     void testGraphWithNegativeCycle() {
-        List<int[]> edges = new ArrayList<>();
-        edges.add(new int[] {0, 1, 1});
-        edges.add(new int[] {1, 2, -3});
-        edges.add(new int[] {2, 0, 1});
+        List<BellmanFord.Edge> edges = new ArrayList<>();
+        edges.add(new BellmanFord.Edge(0, 1, 1));
+        edges.add(new BellmanFord.Edge(1, 2, -3));
+        edges.add(new BellmanFord.Edge(2, 0, 1));
 
         BellmanFord.Result result = BellmanFord.findShortestPaths(3, edges, 0);
 
@@ -47,36 +47,36 @@ void testGraphWithNegativeCycle() {
 
     @Test
     void testDisconnectedGraph() {
-        List<int[]> edges = new ArrayList<>();
-        edges.add(new int[] {0, 1, 5});
-        edges.add(new int[] {2, 3, 2});
+        List<BellmanFord.Edge> edges = new ArrayList<>();
+        edges.add(new BellmanFord.Edge(0, 1, 5));
+        edges.add(new BellmanFord.Edge(2, 3, 2));
 
         BellmanFord.Result result = BellmanFord.findShortestPaths(4, edges, 0);
 
         assertTrue(result.hasPath());
-        assertEquals(0, result.distances()[0]);
-        assertEquals(5, result.distances()[1]);
-        assertEquals(Double.POSITIVE_INFINITY, result.distances()[2]);
-        assertEquals(Double.POSITIVE_INFINITY, result.distances()[3]);
+        assertEquals(0, result.getDistance(0));
+        assertEquals(5, result.getDistance(1));
+        assertEquals(Integer.MAX_VALUE, result.getDistance(2));
+        assertEquals(Integer.MAX_VALUE, result.getDistance(3));
     }
 
     @Test
     void testSingleVertex() {
-        List<int[]> edges = new ArrayList<>();
+        List<BellmanFord.Edge> edges = new ArrayList<>();
         BellmanFord.Result result = BellmanFord.findShortestPaths(1, edges, 0);
 
         assertTrue(result.hasPath());
         assertFalse(result.hasNegativeCycle());
-        assertArrayEquals(new double[] {0}, result.distances());
+        assertArrayEquals(new int[] {0}, result.getDistances());
     }
 
     @Test
     void testPathReconstruction() {
-        List<int[]> edges = new ArrayList<>();
-        edges.add(new int[] {0, 1, 4});
-        edges.add(new int[] {0, 2, 2});
-        edges.add(new int[] {1, 2, 1});
-        edges.add(new int[] {2, 3, 3});
+        List<BellmanFord.Edge> edges = new ArrayList<>();
+        edges.add(new BellmanFord.Edge(0, 1, 4));
+        edges.add(new BellmanFord.Edge(0, 2, 2));
+        edges.add(new BellmanFord.Edge(1, 2, 1));
+        edges.add(new BellmanFord.Edge(2, 3, 3));
 
         BellmanFord.Result result = BellmanFord.findShortestPaths(4, edges, 0);
 
@@ -87,25 +87,25 @@ void testPathReconstruction() {
 
     @Test
     void testNegativeWeights() {
-        List<int[]> edges = new ArrayList<>();
-        edges.add(new int[] {0, 1, 5});
-        edges.add(new int[] {1, 2, -2});
-        edges.add(new int[] {2, 3, 3});
+        List<BellmanFord.Edge> edges = new ArrayList<>();
+        edges.add(new BellmanFord.Edge(0, 1, 5));
+        edges.add(new BellmanFord.Edge(1, 2, -2));
+        edges.add(new BellmanFord.Edge(2, 3, 3));
 
         BellmanFord.Result result = BellmanFord.findShortestPaths(4, edges, 0);
 
         assertTrue(result.hasPath());
         assertFalse(result.hasNegativeCycle());
-        assertEquals(0, result.distances()[0]);
-        assertEquals(5, result.distances()[1]);
-        assertEquals(3, result.distances()[2]);
-        assertEquals(6, result.distances()[3]);
+        assertEquals(0, result.getDistance(0));
+        assertEquals(5, result.getDistance(1));
+        assertEquals(3, result.getDistance(2));
+        assertEquals(6, result.getDistance(3));
     }
 
     @Test
     void testInvalidSource() {
-        List<int[]> edges = new ArrayList<>();
-        edges.add(new int[] {0, 1, 5});
+        List<BellmanFord.Edge> edges = new ArrayList<>();
+        edges.add(new BellmanFord.Edge(0, 1, 5));
 
         assertThrows(IllegalArgumentException.class, () -> {
             BellmanFord.findShortestPaths(2, edges, -1);
@@ -118,7 +118,7 @@ void testInvalidSource() {
 
     @Test
     void testInvalidVertexCount() {
-        List<int[]> edges = new ArrayList<>();
+        List<BellmanFord.Edge> edges = new ArrayList<>();
 
         assertThrows(IllegalArgumentException.class, () -> {
             BellmanFord.findShortestPaths(0, edges, 0);