Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

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

@@ -0,0 +1,86 @@
+package com.baeldung.algorithms;
+
+import org.junit.Test;
+
+import com.baeldung.algorithms.ga.dijkstra.Dijkstra;
+import com.baeldung.algorithms.ga.dijkstra.Graph;
+import com.baeldung.algorithms.ga.dijkstra.Node;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertTrue;
+
+public class DijkstraAlgorithmLongRunningUnitTest {
+
+    @Test
+    public void whenSPPSolved_thenCorrect() {
+
+        Node nodeA = new Node("A");
+        Node nodeB = new Node("B");
+        Node nodeC = new Node("C");
+        Node nodeD = new Node("D");
+        Node nodeE = new Node("E");
+        Node nodeF = new Node("F");
+
+        nodeA.addDestination(nodeB, 10);
+        nodeA.addDestination(nodeC, 15);
+
+        nodeB.addDestination(nodeD, 12);
+        nodeB.addDestination(nodeF, 15);
+
+        nodeC.addDestination(nodeE, 10);
+
+        nodeD.addDestination(nodeE, 2);
+        nodeD.addDestination(nodeF, 1);
+
+        nodeF.addDestination(nodeE, 5);
+
+        Graph graph = new Graph();
+
+        graph.addNode(nodeA);
+        graph.addNode(nodeB);
+        graph.addNode(nodeC);
+        graph.addNode(nodeD);
+        graph.addNode(nodeE);
+        graph.addNode(nodeF);
+
+        graph = Dijkstra.calculateShortestPathFromSource(graph, nodeA);
+
+        List<Node> shortestPathForNodeB = Arrays.asList(nodeA);
+        List<Node> shortestPathForNodeC = Arrays.asList(nodeA);
+        List<Node> shortestPathForNodeD = Arrays.asList(nodeA, nodeB);
+        List<Node> shortestPathForNodeE = Arrays.asList(nodeA, nodeB, nodeD);
+        List<Node> shortestPathForNodeF = Arrays.asList(nodeA, nodeB, nodeD);
+
+        for (Node node : graph.getNodes()) {
+            switch (node.getName()) {
+            case "B":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeB));
+                break;
+            case "C":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeC));
+                break;
+            case "D":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeD));
+                break;
+            case "E":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeE));
+                break;
+            case "F":
+                assertTrue(node
+                  .getShortestPath()
+                  .equals(shortestPathForNodeF));
+                break;
+            }
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+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-miscellaneous-2/src/test/java/com/baeldung/algorithms/editdistance/EditDistanceUnitTest.java

@@ -0,0 +1,32 @@
+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;
+
+@RunWith(Parameterized.class)
+public class EditDistanceUnitTest extends EditDistanceDataProvider {
+
+    private String x;
+    private String y;
+    private int result;
+
+    public EditDistanceUnitTest(String a, String b, int res) {
+        super();
+        x = a;
+        y = b;
+        result = res;
+    }
+
+    @Test
+    public void testEditDistance_RecursiveImplementation() {
+        assertEquals(result, EditDistanceRecursive.calculate(x, y));
+    }
+
+    @Test
+    public void testEditDistance_givenDynamicProgrammingImplementation() {
+        assertEquals(result, EditDistanceDynamicProgramming.calculate(x, y));
+    }
+}

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

@@ -0,0 +1,23 @@
+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 CycleDetectionBruteForceUnitTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleDetectionBruteForceUnitTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionBruteForce.detectCycle(head).cycleExists);
+    }
+}

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

@@ -0,0 +1,23 @@
+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;
+
+    public CycleDetectionByFastAndSlowIteratorsUnitTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}

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

@@ -0,0 +1,23 @@
+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;
+
+    public CycleDetectionByHashingUnitTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_detectLoop() {
+        Assert.assertEquals(cycleExists, CycleDetectionByHashing.detectCycle(head).cycleExists);
+    }
+}

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

@@ -0,0 +1,62 @@
+package com.baeldung.algorithms.linkedlist;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+import org.junit.runners.Parameterized.Parameters;
+
+public class CycleDetectionTestBase {
+
+    @Parameters
+    public static Collection<Object[]> getLists() {
+        return Arrays.asList(new Object[][] { 
+            { createList(), false }, 
+            { createListWithLoop(), true },
+            { createListWithFullCycle(), true }, 
+            { createListWithSingleNodeInCycle(), true } 
+        });
+    }
+
+    public static Node<Integer> createList() {
+        Node<Integer> root = Node.createNewNode(10, null);
+
+        for (int i = 9; i >= 1; --i) {
+            Node<Integer> current = Node.createNewNode(i, root);
+            root = current;
+        }
+
+        return root;
+    }
+
+    public static Node<Integer> createListWithLoop() {
+        Node<Integer> node = createList();
+        createLoop(node);
+        return node;
+    }
+
+    public static Node<Integer> createListWithFullCycle() {
+        Node<Integer> head = createList();
+        Node<Integer> tail = Node.getTail(head);
+        tail.next = head;
+        return head;
+    }
+
+    public static Node<Integer> createListWithSingleNodeInCycle() {
+        Node<Integer> head = createList();
+        Node<Integer> tail = Node.getTail(head);
+        tail.next = tail;
+        return head;
+    }
+
+    public static void createLoop(Node<Integer> root) {
+        Node<Integer> tail = Node.getTail(root);
+
+        Node<Integer> middle = root;
+        for (int i = 1; i <= 4; i++) {
+            middle = middle.next;
+        }
+
+        tail.next = middle;
+    }
+
+}

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

@@ -0,0 +1,24 @@
+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;
+
+    public CycleRemovalBruteForceUnitTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalBruteForce.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}

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

@@ -0,0 +1,24 @@
+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 CycleRemovalByCountingLoopNodesUnitTest extends CycleDetectionTestBase {
+    boolean cycleExists;
+    Node<Integer> head;
+
+    public CycleRemovalByCountingLoopNodesUnitTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalByCountingLoopNodes.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}

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

@@ -0,0 +1,24 @@
+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;
+
+    public CycleRemovalWithoutCountingLoopNodesUnitTest(Node<Integer> head, boolean cycleExists) {
+        super();
+        this.cycleExists = cycleExists;
+        this.head = head;
+    }
+
+    @Test
+    public void givenList_ifLoopExists_thenDetectAndRemoveLoop() {
+        Assert.assertEquals(cycleExists, CycleRemovalWithoutCountingLoopNodes.detectAndRemoveCycle(head));
+        Assert.assertFalse(CycleDetectionByFastAndSlowIterators.detectCycle(head).cycleExists);
+    }
+}

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

@@ -0,0 +1,84 @@
+package com.baeldung.algorithms.moneywords;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import com.baeldung.algorithms.numberwordconverter.NumberWordConverter;
+
+public class NumberWordConverterUnitTest {
+
+    @Test
+    public void whenMoneyNegative_thenReturnInvalidInput() {
+        assertEquals(NumberWordConverter.INVALID_INPUT_GIVEN, NumberWordConverter.getMoneyIntoWords(-13));
+    }
+
+    @Test
+    public void whenZeroDollarsGiven_thenReturnEmptyString() {
+        assertEquals("", NumberWordConverter.getMoneyIntoWords(0));
+    }
+
+    @Test
+    public void whenOnlyDollarsGiven_thenReturnWords() {
+        assertEquals("one dollar", NumberWordConverter.getMoneyIntoWords(1));
+    }
+
+    @Test
+    public void whenOnlyCentsGiven_thenReturnWords() {
+        assertEquals("sixty cents", NumberWordConverter.getMoneyIntoWords(0.6));
+    }
+    
+    @Test
+    public 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() {
+        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() {
+        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() {
+        String expectedResult = "nine hundred twenty four dollars and sixty cents";
+        assertEquals(expectedResult, NumberWordConverter.getMoneyIntoWords(924.6));
+    }
+
+    @Test
+    public void whenOneDollarAndNoCents_thenReturnDollarSingular() {
+        assertEquals("one dollar", NumberWordConverter.getMoneyIntoWords(1));
+    }
+
+    @Test
+    public void whenNoDollarsAndOneCent_thenReturnCentSingular() {
+        assertEquals("one cent", NumberWordConverter.getMoneyIntoWords(0.01));
+    }
+
+    @Test
+    public void whenNoDollarsAndTwoCents_thenReturnCentsPlural() {
+        assertEquals("two cents", NumberWordConverter.getMoneyIntoWords(0.02));
+    }
+
+    @Test
+    public void whenNoDollarsAndNinetyNineCents_thenReturnWords() {
+        assertEquals("ninety nine cents", NumberWordConverter.getMoneyIntoWords(0.99));
+    }
+
+    @Test
+    public void whenNoDollarsAndNineFiveNineCents_thenCorrectRounding() {
+        assertEquals("ninety six cents", NumberWordConverter.getMoneyIntoWords(0.959));
+    }
+
+    @Test
+    public void whenGivenDollarsAndCents_thenReturnWordsVersionTwo() {
+        assertEquals("three hundred ten £ 00/100", NumberWordConverter.getMoneyIntoWords("310"));
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.jgrapht.VertexFactory;
+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;
+
+public class CompleteGraphUnitTest {
+
+    static SimpleWeightedGraph<String, DefaultEdge> completeGraph;
+    static int size = 10;
+
+    @Before
+    public void createCompleteGraph() {
+        completeGraph = new SimpleWeightedGraph<>(DefaultEdge.class);
+        CompleteGraphGenerator<String, DefaultEdge> completeGenerator = new CompleteGraphGenerator<String, DefaultEdge>(size);
+        VertexFactory<String> vFactory = new VertexFactory<String>() {
+            private int id = 0;
+            public String createVertex() {
+                return "v" + id++;
+            }
+        };
+        completeGenerator.generateGraph(completeGraph, vFactory, null);
+    }
+
+    @Test
+    public void givenCompleteGraph_whenGetHamiltonianCyclePath_thenGetVerticeListInSequence() {
+        List<String> verticeList = HamiltonianCycle.getApproximateOptimalForCompleteGraph(completeGraph);
+        assertEquals(verticeList.size(), completeGraph.vertexSet().size());
+    }
+}

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

@@ -0,0 +1,95 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.IntStream;
+
+import org.jgrapht.DirectedGraph;
+import org.jgrapht.GraphPath;
+import org.jgrapht.alg.CycleDetector;
+import org.jgrapht.alg.KosarajuStrongConnectivityInspector;
+import org.jgrapht.alg.interfaces.StrongConnectivityAlgorithm;
+import org.jgrapht.alg.shortestpath.AllDirectedPaths;
+import org.jgrapht.alg.shortestpath.BellmanFordShortestPath;
+import org.jgrapht.alg.shortestpath.DijkstraShortestPath;
+import org.jgrapht.graph.DefaultDirectedGraph;
+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;
+
+public class DirectedGraphUnitTest {
+    DirectedGraph<String, DefaultEdge> directedGraph;
+
+    @Before
+    public void createDirectedGraph() {
+        directedGraph = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
+        IntStream.range(1, 10).forEach(i -> {
+            directedGraph.addVertex("v" + i);
+        });
+        directedGraph.addEdge("v1", "v2");
+        directedGraph.addEdge("v2", "v4");
+        directedGraph.addEdge("v4", "v3");
+        directedGraph.addEdge("v3", "v1");
+        directedGraph.addEdge("v5", "v4");
+        directedGraph.addEdge("v5", "v6");
+        directedGraph.addEdge("v6", "v7");
+        directedGraph.addEdge("v7", "v5");
+        directedGraph.addEdge("v8", "v5");
+        directedGraph.addEdge("v9", "v8");
+    }
+
+    @Test
+    public 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());
+
+        String randomVertex1 = stronglyConnectedVertices.get(0);
+        String randomVertex2 = stronglyConnectedVertices.get(3);
+        AllDirectedPaths<String, DefaultEdge> allDirectedPaths = new AllDirectedPaths<>(directedGraph);
+
+        List<GraphPath<String, DefaultEdge>> possiblePathList = allDirectedPaths.getAllPaths(randomVertex1, randomVertex2, false, stronglyConnectedVertices.size());
+        assertTrue(possiblePathList.size() > 0);
+    }
+
+    @Test
+    public void givenDirectedGraphWithCycle_whenCheckCycles_thenDetectCycles() {
+        CycleDetector<String, DefaultEdge> cycleDetector = new CycleDetector<String, DefaultEdge>(directedGraph);
+        assertTrue(cycleDetector.detectCycles());
+        Set<String> cycleVertices = cycleDetector.findCycles();
+        assertTrue(cycleVertices.size() > 0);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenCreateInstanceDepthFirstIterator_thenGetIterator() {
+        DepthFirstIterator depthFirstIterator = new DepthFirstIterator<>(directedGraph);
+        assertNotNull(depthFirstIterator);
+    }
+
+    @Test
+    public void givenDirectedGraph_whenCreateInstanceBreadthFirstIterator_thenGetIterator() {
+        BreadthFirstIterator breadthFirstIterator = new BreadthFirstIterator<>(directedGraph);
+        assertNotNull(breadthFirstIterator);
+    }
+
+    @Test
+    public 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() {
+        BellmanFordShortestPath bellmanFordShortestPath = new BellmanFordShortestPath(directedGraph);
+        List<String> shortestPath = bellmanFordShortestPath.getPath("v1", "v4").getVertexList();
+        assertNotNull(shortestPath);
+    }
+}

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

@@ -0,0 +1,42 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.util.stream.IntStream;
+
+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;
+
+public class EulerianCircuitUnitTest {
+    SimpleWeightedGraph<String, DefaultEdge> simpleGraph;
+
+    @Before
+    public void createGraphWithEulerianCircuit() {
+        simpleGraph = new SimpleWeightedGraph<>(DefaultEdge.class);
+        IntStream.range(1, 6).forEach(i -> {
+            simpleGraph.addVertex("v" + i);
+        });
+        IntStream.range(1, 6).forEach(i -> {
+            int endVertexNo = (i + 1) > 5 ? 1 : i + 1;
+            simpleGraph.addEdge("v" + i, "v" + endVertexNo);
+        });
+    }
+
+    @Test
+    public void givenGraph_whenCheckEluerianCycle_thenGetResult() {
+        HierholzerEulerianCycle eulerianCycle = new HierholzerEulerianCycle<>();
+        assertTrue(eulerianCycle.isEulerian(simpleGraph));
+    }
+
+    @Test
+    public void givenGraphWithEulerianCircuit_whenGetEulerianCycle_thenGetGraphPath() {
+        HierholzerEulerianCycle eulerianCycle = new HierholzerEulerianCycle<>();
+        GraphPath path = eulerianCycle.getEulerianCycle(simpleGraph);
+        assertTrue(path.getEdgeList().containsAll(simpleGraph.edgeSet()));
+    }
+}

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

@@ -0,0 +1,47 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertTrue;
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import org.jgrapht.ext.JGraphXAdapter;
+import org.jgrapht.graph.DefaultDirectedGraph;
+import org.jgrapht.graph.DefaultEdge;
+import org.junit.Before;
+import org.junit.Test;
+import com.mxgraph.layout.mxCircleLayout;
+import com.mxgraph.layout.mxIGraphLayout;
+import com.mxgraph.util.mxCellRenderer;
+
+public class GraphImageGenerationUnitTest {
+    static DefaultDirectedGraph<String, DefaultEdge> g;
+
+    @Before
+    public void createGraph() throws IOException {
+        File imgFile = new File("src/test/resources/graph.png");
+        imgFile.createNewFile();
+        g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
+        String x1 = "x1";
+        String x2 = "x2";
+        String x3 = "x3";
+        g.addVertex(x1);
+        g.addVertex(x2);
+        g.addVertex(x3);
+        g.addEdge(x1, x2);
+        g.addEdge(x2, x3);
+        g.addEdge(x3, x1);
+    }
+
+    @Test
+    public void givenAdaptedGraph_whenWriteBufferedImage_ThenFileShouldExist() throws IOException {
+        JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, DefaultEdge>(g);
+        mxIGraphLayout layout = new mxCircleLayout(graphAdapter);
+        layout.execute(graphAdapter.getDefaultParent());
+        File imgFile = new File("src/test/resources/graph.png");
+        BufferedImage image = mxCellRenderer.createBufferedImage(graphAdapter, null, 2, Color.WHITE, true, null);
+        ImageIO.write(image, "PNG", imgFile);
+        assertTrue(imgFile.exists());
+    }
+}