[JAVA-18123] Upgraded algorithms-modules to java 11 + Upgraded unit t… (#13437)

* [JAVA-18123] Upgraded algorithms-modules to java 11 + Upgraded unit tests to junit5

* [JAVA-18123] Clean up properties

---------

Co-authored-by: panagiotiskakos <panagiotis.kakos@libra-is.com>

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/DijkstraAlgorithmLongRunningUnitTest.java

@@ -1,6 +1,6 @@
 package com.baeldung.algorithms;
 
-import org.junit.Test;
+
 
 import com.baeldung.algorithms.ga.dijkstra.Dijkstra;
 import com.baeldung.algorithms.ga.dijkstra.Graph;
@@ -11,7 +11,9 @@ import java.util.List;
 
 import static org.junit.Assert.assertTrue;
 
-public class DijkstraAlgorithmLongRunningUnitTest {
+import org.junit.jupiter.api.Test;
+
+class DijkstraAlgorithmLongRunningUnitTest {
 
     @Test
     public void whenSPPSolved_thenCorrect() {

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/astar/underground/RouteFinderIntegrationTest.java

@@ -1,5 +1,6 @@
 package com.baeldung.algorithms.astar.underground;
 
+
 import static org.assertj.core.api.Assertions.assertThat;
 
 import java.util.HashMap;
@@ -10,22 +11,22 @@ import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
 import com.baeldung.algorithms.astar.Graph;
 import com.baeldung.algorithms.astar.RouteFinder;
 
 import lombok.extern.slf4j.Slf4j;
 
-import org.junit.Before;
-import org.junit.Test;
-
 @Slf4j
-public class RouteFinderIntegrationTest {
+class RouteFinderIntegrationTest {
 
     private Graph<Station> underground;
 
     private RouteFinder<Station> routeFinder;
 
-    @Before
+    @BeforeEach
     public void setUp() throws Exception {
         Set<Station> stations = new HashSet<>();
         Map<String, Set<String>> connections = new HashMap<>();
@@ -641,7 +642,7 @@ public class RouteFinderIntegrationTest {
     }
 
     @Test
-    public void findRoute() {
+    void findRoute() {
         List<Station> route = routeFinder.findRoute(underground.getNode("74"), underground.getNode("7"));
         assertThat(route).size().isPositive();
 

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/editdistance/EditDistanceDataProvider.java

@@ -1,21 +0,0 @@
-package com.baeldung.algorithms.editdistance;
-
-import org.junit.runners.Parameterized.Parameters;
-
-import java.util.Arrays;
-import java.util.Collection;
-
-public class EditDistanceDataProvider {
-
-    @Parameters
-    public static Collection<Object[]> getLists() {
-        return Arrays.asList(new Object[][] { 
-            { "", "", 0 }, 
-            { "ago", "", 3 }, 
-            { "", "do", 2 }, 
-            { "abc", "adc", 1 }, 
-            { "peek", "pesek", 1 }, 
-            { "sunday", "saturday", 3 } 
-        });
-    }
-}

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/editdistance/EditDistanceUnitTest.java

@@ -1,32 +1,39 @@
 package com.baeldung.algorithms.editdistance;
 
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-@RunWith(Parameterized.class)
-public class EditDistanceUnitTest extends EditDistanceDataProvider {
+import java.util.stream.Stream;
 
-    private String x;
-    private String y;
-    private int result;
 
-    public EditDistanceUnitTest(String a, String b, int res) {
-        super();
-        x = a;
-        y = b;
-        result = res;
-    }
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
 
-    @Test
-    public void testEditDistance_RecursiveImplementation() {
+import org.junit.jupiter.params.provider.MethodSource;
+
+class EditDistanceUnitTest {
+
+    @ParameterizedTest
+    @MethodSource("provideArguments")
+    void testEditDistance_RecursiveImplementation(String x, String y, int result) {
         assertEquals(result, EditDistanceRecursive.calculate(x, y));
     }
 
-    @Test
-    public void testEditDistance_givenDynamicProgrammingImplementation() {
+    @ParameterizedTest
+    @MethodSource("provideArguments")
+    void testEditDistance_givenDynamicProgrammingImplementation(String x, String y, int result) {
         assertEquals(result, EditDistanceDynamicProgramming.calculate(x, y));
     }
+
+
+    static Stream<? extends Arguments> provideArguments() {
+        return Stream.of(new Object[][] {
+            { "", "", 0 },
+            { "ago", "", 3 },
+            { "", "do", 2 },
+            { "abc", "adc", 1 },
+            { "peek", "pesek", 1 },
+            { "sunday", "saturday", 3 }
+        }).map(Arguments::of);
+    }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceUnitTest.java

@@ -1,23 +1,16 @@
 package com.baeldung.algorithms.linkedlist;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-@RunWith(value = Parameterized.class)
-public class CycleDetectionBruteForceUnitTest extends CycleDetectionTestBase {
-    boolean cycleExists;
-    Node<Integer> head;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
-    public CycleDetectionBruteForceUnitTest(Node<Integer> head, boolean cycleExists) {
-        super();
-        this.cycleExists = cycleExists;
-        this.head = head;
-    }
+class CycleDetectionBruteForceUnitTest extends CycleDetectionTestBase {
 
-    @Test
-    public void givenList_detectLoop() {
-        Assert.assertEquals(cycleExists, CycleDetectionBruteForce.detectCycle(head).cycleExists);
+
+    @ParameterizedTest
+    @MethodSource("getLists")
+    void givenList_detectLoop(Node<Integer> head, boolean cycleExists) {
+        assertEquals(cycleExists, CycleDetectionBruteForce.detectCycle(head).cycleExists);
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIteratorsUnitTest.java

@@ -1,23 +1,16 @@
 package com.baeldung.algorithms.linkedlist;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
 
-@RunWith(value = Parameterized.class)
-public class CycleDetectionByFastAndSlowIteratorsUnitTest extends CycleDetectionTestBase {
-    boolean cycleExists;
-    Node<Integer> head;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-    public CycleDetectionByFastAndSlowIteratorsUnitTest(Node<Integer> head, boolean cycleExists) {
-        super();
-        this.cycleExists = cycleExists;
-        this.head = head;
-    }
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
-    @Test
-    public void givenList_detectLoop() {
-        Assert.assertEquals(cycleExists, CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+class CycleDetectionByFastAndSlowIteratorsUnitTest extends CycleDetectionTestBase {
+
+    @ParameterizedTest
+    @MethodSource("getLists")
+    void givenList_detectLoop(Node<Integer> head, boolean cycleExists) {
+        assertEquals(cycleExists, CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashingUnitTest.java

@@ -1,23 +1,17 @@
 package com.baeldung.algorithms.linkedlist;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
 
-@RunWith(value = Parameterized.class)
-public class CycleDetectionByHashingUnitTest extends CycleDetectionTestBase {
-    boolean cycleExists;
-    Node<Integer> head;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-    public CycleDetectionByHashingUnitTest(Node<Integer> head, boolean cycleExists) {
-        super();
-        this.cycleExists = cycleExists;
-        this.head = head;
-    }
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
-    @Test
-    public void givenList_detectLoop() {
-        Assert.assertEquals(cycleExists, CycleDetectionByHashing.detectCycle(head).cycleExists);
+
+class CycleDetectionByHashingUnitTest extends CycleDetectionTestBase {
+
+    @ParameterizedTest
+    @MethodSource("getLists")
+    void givenList_detectLoop(Node<Integer> head, boolean cycleExists) {
+        assertEquals(cycleExists, CycleDetectionByHashing.detectCycle(head).cycleExists);
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionTestBase.java

@@ -7,7 +7,7 @@ import org.junit.runners.Parameterized.Parameters;
 
 public class CycleDetectionTestBase {
 
-    @Parameters
+
     public static Collection<Object[]> getLists() {
         return Arrays.asList(new Object[][] { 
             { createList(), false }, 

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForceUnitTest.java

@@ -1,24 +1,19 @@
 package com.baeldung.algorithms.linkedlist;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
 
-@RunWith(value = Parameterized.class)
-public class CycleRemovalBruteForceUnitTest extends CycleDetectionTestBase {
-    boolean cycleExists;
-    Node<Integer> head;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
-    public CycleRemovalBruteForceUnitTest(Node<Integer> head, boolean cycleExists) {
-        super();
-        this.cycleExists = cycleExists;
-        this.head = head;
-    }
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
-    @Test
-    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
-        Assert.assertEquals(cycleExists, CycleRemovalBruteForce.detectAndRemoveCycle(head));
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+
+class CycleRemovalBruteForceUnitTest extends CycleDetectionTestBase {
+
+    @ParameterizedTest
+    @MethodSource("getLists")
+    void givenList_ifLoopExists_thenDetectAndRemoveLoop(Node<Integer> head, boolean cycleExists) {
+        assertEquals(cycleExists, CycleRemovalBruteForce.detectAndRemoveCycle(head));
+        assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodesUnitTest.java

@@ -1,24 +1,17 @@
 package com.baeldung.algorithms.linkedlist;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
-@RunWith(value = Parameterized.class)
-public class CycleRemovalByCountingLoopNodesUnitTest extends CycleDetectionTestBase {
-    boolean cycleExists;
-    Node<Integer> head;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
-    public CycleRemovalByCountingLoopNodesUnitTest(Node<Integer> head, boolean cycleExists) {
-        super();
-        this.cycleExists = cycleExists;
-        this.head = head;
-    }
+class CycleRemovalByCountingLoopNodesUnitTest extends CycleDetectionTestBase {
 
-    @Test
-    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
-        Assert.assertEquals(cycleExists, CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(head));
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    @ParameterizedTest
+    @MethodSource("getLists")
+    void givenList_ifLoopExists_thenDetectAndRemoveLoop(Node<Integer> head, boolean cycleExists) {
+        assertEquals(cycleExists, CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(head));
+        assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodesUnitTest.java

@@ -1,24 +1,19 @@
 package com.baeldung.algorithms.linkedlist;
 
-import org.junit.Assert;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
 
-@RunWith(value = Parameterized.class)
-public class CycleRemovalWithoutCountingLoopNodesUnitTest extends CycleDetectionTestBase {
-    boolean cycleExists;
-    Node<Integer> head;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 
-    public CycleRemovalWithoutCountingLoopNodesUnitTest(Node<Integer> head, boolean cycleExists) {
-        super();
-        this.cycleExists = cycleExists;
-        this.head = head;
-    }
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
 
-    @Test
-    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
-        Assert.assertEquals(cycleExists, CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(head));
-        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+
+class CycleRemovalWithoutCountingLoopNodesUnitTest extends CycleDetectionTestBase {
+
+    @ParameterizedTest
+    @MethodSource("getLists")
+    void givenList_ifLoopExists_thenDetectAndRemoveLoop(Node<Integer> head, boolean cycleExists) {
+        assertEquals(cycleExists, CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(head));
+        assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/algorithms/moneywords/NumberWordConverterUnitTest.java

@@ -1,84 +1,84 @@
 package com.baeldung.algorithms.moneywords;
 
-import static org.junit.Assert.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import com.baeldung.algorithms.numberwordconverter.NumberWordConverter;
 
-public class NumberWordConverterUnitTest {
+class NumberWordConverterUnitTest {
 
     @Test
-    public void whenMoneyNegative_thenReturnInvalidInput() {
+    void whenMoneyNegative_thenReturnInvalidInput() {
         assertEquals(NumberWordConverter.INVALID_INPUT_GIVEN, NumberWordConverter.getMoneyIntoWords(-13));
     }
 
     @Test
-    public void whenZeroDollarsGiven_thenReturnEmptyString() {
+    void whenZeroDollarsGiven_thenReturnEmptyString() {
         assertEquals("", NumberWordConverter.getMoneyIntoWords(0));
     }
 
     @Test
-    public void whenOnlyDollarsGiven_thenReturnWords() {
+    void whenOnlyDollarsGiven_thenReturnWords() {
         assertEquals("one dollar", NumberWordConverter.getMoneyIntoWords(1));
     }
 
     @Test
-    public void whenOnlyCentsGiven_thenReturnWords() {
+    void whenOnlyCentsGiven_thenReturnWords() {
         assertEquals("sixty cents", NumberWordConverter.getMoneyIntoWords(0.6));
     }
     
     @Test
-    public void whenAlmostAMillioDollarsGiven_thenReturnWords() {
+    void whenAlmostAMillioDollarsGiven_thenReturnWords() {
         String expectedResult = "nine hundred ninety nine thousand nine hundred ninety nine dollars";
         assertEquals(expectedResult, NumberWordConverter.getMoneyIntoWords(999_999));
     }
     
     @Test
-    public void whenThirtyMillionDollarsGiven_thenReturnWords() {
+    void whenThirtyMillionDollarsGiven_thenReturnWords() {
         String expectedResult = "thirty three million three hundred forty eight thousand nine hundred seventy eight dollars";
         assertEquals(expectedResult, NumberWordConverter.getMoneyIntoWords(33_348_978));
     }
     
     @Test
-    public void whenTwoBillionDollarsGiven_thenReturnWords() {
+    void whenTwoBillionDollarsGiven_thenReturnWords() {
         String expectedResult = "two billion one hundred thirty three million two hundred forty seven thousand eight hundred ten dollars";
         assertEquals(expectedResult, NumberWordConverter.getMoneyIntoWords(2_133_247_810));
     }
 
     @Test
-    public void whenGivenDollarsAndCents_thenReturnWords() {
+    void whenGivenDollarsAndCents_thenReturnWords() {
         String expectedResult = "nine hundred twenty four dollars and sixty cents";
         assertEquals(expectedResult, NumberWordConverter.getMoneyIntoWords(924.6));
     }
 
     @Test
-    public void whenOneDollarAndNoCents_thenReturnDollarSingular() {
+    void whenOneDollarAndNoCents_thenReturnDollarSingular() {
         assertEquals("one dollar", NumberWordConverter.getMoneyIntoWords(1));
     }
 
     @Test
-    public void whenNoDollarsAndOneCent_thenReturnCentSingular() {
+    void whenNoDollarsAndOneCent_thenReturnCentSingular() {
         assertEquals("one cent", NumberWordConverter.getMoneyIntoWords(0.01));
     }
 
     @Test
-    public void whenNoDollarsAndTwoCents_thenReturnCentsPlural() {
+    void whenNoDollarsAndTwoCents_thenReturnCentsPlural() {
         assertEquals("two cents", NumberWordConverter.getMoneyIntoWords(0.02));
     }
 
     @Test
-    public void whenNoDollarsAndNinetyNineCents_thenReturnWords() {
+    void whenNoDollarsAndNinetyNineCents_thenReturnWords() {
         assertEquals("ninety nine cents", NumberWordConverter.getMoneyIntoWords(0.99));
     }
 
     @Test
-    public void whenNoDollarsAndNineFiveNineCents_thenCorrectRounding() {
+    void whenNoDollarsAndNineFiveNineCents_thenCorrectRounding() {
         assertEquals("ninety six cents", NumberWordConverter.getMoneyIntoWords(0.959));
     }
 
     @Test
-    public void whenGivenDollarsAndCents_thenReturnWordsVersionTwo() {
+    void whenGivenDollarsAndCents_thenReturnWordsVersionTwo() {
         assertEquals("three hundred ten £ 00/100", NumberWordConverter.getMoneyIntoWords("310"));
     }
 }

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/CompleteGraphUnitTest.java

@@ -1,6 +1,8 @@
 package com.baeldung.jgrapht;
 
-import static org.junit.Assert.assertEquals;
+
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
 
 import java.util.List;
 
@@ -9,15 +11,15 @@ import org.jgrapht.alg.HamiltonianCycle;
 import org.jgrapht.generate.CompleteGraphGenerator;
 import org.jgrapht.graph.DefaultEdge;
 import org.jgrapht.graph.SimpleWeightedGraph;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-public class CompleteGraphUnitTest {
+class CompleteGraphUnitTest {
 
     static SimpleWeightedGraph<String, DefaultEdge> completeGraph;
     static int size = 10;
 
-    @Before
+    @BeforeEach
     public void createCompleteGraph() {
         completeGraph = new SimpleWeightedGraph<>(DefaultEdge.class);
         CompleteGraphGenerator<String, DefaultEdge> completeGenerator = new CompleteGraphGenerator<String, DefaultEdge>(size);

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/DirectedGraphUnitTest.java

@@ -1,7 +1,9 @@
 package com.baeldung.jgrapht;
 
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
+
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -21,13 +23,13 @@ import org.jgrapht.graph.DefaultEdge;
 import org.jgrapht.graph.DirectedSubgraph;
 import org.jgrapht.traverse.BreadthFirstIterator;
 import org.jgrapht.traverse.DepthFirstIterator;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-public class DirectedGraphUnitTest {
+class DirectedGraphUnitTest {
     DirectedGraph<String, DefaultEdge> directedGraph;
 
-    @Before
+    @BeforeEach
     public void createDirectedGraph() {
         directedGraph = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
         IntStream.range(1, 10).forEach(i -> {
@@ -46,7 +48,7 @@ public class DirectedGraphUnitTest {
     }
 
     @Test
-    public void givenDirectedGraph_whenGetStronglyConnectedSubgraphs_thenPathExistsBetweenStronglyconnectedVertices() {
+    void givenDirectedGraph_whenGetStronglyConnectedSubgraphs_thenPathExistsBetweenStronglyconnectedVertices() {
         StrongConnectivityAlgorithm<String, DefaultEdge> scAlg = new KosarajuStrongConnectivityInspector<>(directedGraph);
         List<DirectedSubgraph<String, DefaultEdge>> stronglyConnectedSubgraphs = scAlg.stronglyConnectedSubgraphs();
         List<String> stronglyConnectedVertices = new ArrayList<>(stronglyConnectedSubgraphs.get(3).vertexSet());
@@ -60,7 +62,7 @@ public class DirectedGraphUnitTest {
     }
 
     @Test
-    public void givenDirectedGraphWithCycle_whenCheckCycles_thenDetectCycles() {
+    void givenDirectedGraphWithCycle_whenCheckCycles_thenDetectCycles() {
         CycleDetector<String, DefaultEdge> cycleDetector = new CycleDetector<String, DefaultEdge>(directedGraph);
         assertTrue(cycleDetector.detectCycles());
         Set<String> cycleVertices = cycleDetector.findCycles();
@@ -68,26 +70,26 @@ public class DirectedGraphUnitTest {
     }
 
     @Test
-    public void givenDirectedGraph_whenCreateInstanceDepthFirstIterator_thenGetIterator() {
+    void givenDirectedGraph_whenCreateInstanceDepthFirstIterator_thenGetIterator() {
         DepthFirstIterator depthFirstIterator = new DepthFirstIterator<>(directedGraph);
         assertNotNull(depthFirstIterator);
     }
 
     @Test
-    public void givenDirectedGraph_whenCreateInstanceBreadthFirstIterator_thenGetIterator() {
+    void givenDirectedGraph_whenCreateInstanceBreadthFirstIterator_thenGetIterator() {
         BreadthFirstIterator breadthFirstIterator = new BreadthFirstIterator<>(directedGraph);
         assertNotNull(breadthFirstIterator);
     }
 
     @Test
-    public void givenDirectedGraph_whenGetDijkstraShortestPath_thenGetNotNullPath() {
+    void givenDirectedGraph_whenGetDijkstraShortestPath_thenGetNotNullPath() {
         DijkstraShortestPath dijkstraShortestPath = new DijkstraShortestPath(directedGraph);
         List<String> shortestPath = dijkstraShortestPath.getPath("v1", "v4").getVertexList();
         assertNotNull(shortestPath);
     }
 
     @Test
-    public void givenDirectedGraph_whenGetBellmanFordShortestPath_thenGetNotNullPath() {
+    void givenDirectedGraph_whenGetBellmanFordShortestPath_thenGetNotNullPath() {
         BellmanFordShortestPath bellmanFordShortestPath = new BellmanFordShortestPath(directedGraph);
         List<String> shortestPath = bellmanFordShortestPath.getPath("v1", "v4").getVertexList();
         assertNotNull(shortestPath);

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/EulerianCircuitUnitTest.java

@@ -1,7 +1,7 @@
 package com.baeldung.jgrapht;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.stream.IntStream;
 
@@ -9,13 +9,13 @@ import org.jgrapht.GraphPath;
 import org.jgrapht.alg.cycle.HierholzerEulerianCycle;
 import org.jgrapht.graph.DefaultEdge;
 import org.jgrapht.graph.SimpleWeightedGraph;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
-public class EulerianCircuitUnitTest {
+class EulerianCircuitUnitTest {
     SimpleWeightedGraph<String, DefaultEdge> simpleGraph;
 
-    @Before
+    @BeforeEach
     public void createGraphWithEulerianCircuit() {
         simpleGraph = new SimpleWeightedGraph<>(DefaultEdge.class);
         IntStream.range(1, 6).forEach(i -> {

algorithms-modules/algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/GraphImageGenerationUnitTest.java

@@ -1,6 +1,8 @@
 package com.baeldung.jgrapht;
 
-import static org.junit.Assert.assertTrue;
+
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.awt.Color;
 import java.awt.image.BufferedImage;
@@ -12,18 +14,18 @@ import javax.imageio.ImageIO;
 import org.jgrapht.ext.JGraphXAdapter;
 import org.jgrapht.graph.DefaultDirectedGraph;
 import org.jgrapht.graph.DefaultEdge;
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
 
 import com.mxgraph.layout.mxCircleLayout;
 import com.mxgraph.layout.mxIGraphLayout;
 import com.mxgraph.util.mxCellRenderer;
 
-public class GraphImageGenerationUnitTest {
+class GraphImageGenerationUnitTest {
     static DefaultDirectedGraph<String, DefaultEdge> g;
 
-    @Before
+    @BeforeEach
     public void createGraph() throws IOException {
         File imgFile = new File("src/test/resources/graph1.png");
         imgFile.createNewFile();
@@ -39,14 +41,14 @@ public class GraphImageGenerationUnitTest {
         g.addEdge(x3, x1);
     }
 
-    @After
+    @AfterEach
     public void cleanup() {
         File imgFile = new File("src/test/resources/graph1.png");
         imgFile.deleteOnExit();
     }
 
     @Test
-    public void givenAdaptedGraph_whenWriteBufferedImage_ThenFileShouldExist() throws IOException {
+    void givenAdaptedGraph_whenWriteBufferedImage_ThenFileShouldExist() throws IOException {
         JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, DefaultEdge>(g);
         mxIGraphLayout layout = new mxCircleLayout(graphAdapter);
         layout.execute(graphAdapter.getDefaultParent());