Merge branch 'master' into master

.gitignore

@@ -42,3 +42,9 @@ spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties
 *.springBeans
 
 20171220-JMeter.csv
+
+.factorypath
+dependency-reduced-pom.xml
+*.so
+*.dylib
+*.dll

README.md

@@ -34,3 +34,9 @@ CI - Jenkins
 ================================
 This tutorials project is being built **[>> HERE](https://rest-security.ci.cloudbees.com/job/tutorials-unit/)**
 
+### Relevant Articles: 
+================================
+
+- [Apache Maven Standard Directory Layout](http://www.baeldung.com/maven-directory-structure)
+- [Apache Maven Tutorial](http://www.baeldung.com/maven)
+- [Designing a User Friendly Java Library](http://www.baeldung.com/design-a-user-friendly-java-library)

algorithms/README.md

@@ -20,4 +20,5 @@
 - [A Maze Solver in Java](http://www.baeldung.com/java-solve-maze)
 - [Create a Sudoku Solver in Java](http://www.baeldung.com/java-sudoku)
 - [Displaying Money Amounts in Words](http://www.baeldung.com/java-money-into-words)
-- [A Collaborative Filtering Recommendation System in Java](http://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [A Collaborative Filtering Recommendation System in Java](http://www.baeldung.com/java-collaborative-filtering-recommendations)
+- [Find All Pairs of Numbers in an Array That Add Up to a Given Sum](http://www.baeldung.com/java-algorithm-number-pairs-sum)

algorithms/src/main/java/com/baeldung/algorithms/mcts/tictactoe/Board.java

@@ -148,7 +148,7 @@ public class Board {
             System.out.println("Game Draw");
             break;
         case IN_PROGRESS:
-            System.out.println("Game In rogress");
+            System.out.println("Game In Progress");
             break;
         }
     }

algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/MiddleElementLookup.java

@@ -0,0 +1,88 @@
+package com.baeldung.algorithms.middleelementlookup;
+
+import java.util.LinkedList;
+import java.util.Optional;
+
+public class MiddleElementLookup {
+
+    public static Optional<String> findMiddleElementLinkedList(LinkedList<String> linkedList) {
+        if (linkedList == null || linkedList.isEmpty()) {
+            return Optional.empty();
+        }
+
+        return Optional.ofNullable(linkedList.get((linkedList.size() - 1) / 2));
+    }
+
+    public static Optional<String> findMiddleElementFromHead(Node head) {
+        if (head == null) {
+            return Optional.empty();
+        }
+
+        // calculate the size of the list
+        Node current = head;
+        int size = 1;
+        while (current.hasNext()) {
+            current = current.next();
+            size++;
+        }
+
+        // iterate till the middle element
+        current = head;
+        for (int i = 0; i < (size - 1) / 2; i++) {
+            current = current.next();
+        }
+
+        return Optional.ofNullable(current.data());
+    }
+
+    public static Optional<String> findMiddleElementFromHead1PassRecursively(Node head) {
+        if (head == null) {
+            return Optional.empty();
+        }
+
+        MiddleAuxRecursion middleAux = new MiddleAuxRecursion();
+        findMiddleRecursively(head, middleAux);
+        return Optional.ofNullable(middleAux.middle.data());
+    }
+
+    private static void findMiddleRecursively(Node node, MiddleAuxRecursion middleAux) {
+        if (node == null) {
+            // reached the end
+            middleAux.length = middleAux.length / 2;
+            return;
+        }
+        middleAux.length++;
+        findMiddleRecursively(node.next(), middleAux);
+
+        if (middleAux.length == 0) {
+            // found the middle
+            middleAux.middle = node;
+        }
+
+        middleAux.length--;
+    }
+
+    public static Optional<String> findMiddleElementFromHead1PassIteratively(Node head) {
+        if (head == null) {
+            return Optional.empty();
+        }
+
+        Node slowPointer = head;
+        Node fastPointer = head;
+
+        while (fastPointer.hasNext() && fastPointer.next()
+            .hasNext()) {
+            fastPointer = fastPointer.next()
+                .next();
+            slowPointer = slowPointer.next();
+        }
+
+        return Optional.ofNullable(slowPointer.data());
+    }
+
+    private static class MiddleAuxRecursion {
+        Node middle;
+        int length = 0;
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/middleelementlookup/Node.java

@@ -0,0 +1,34 @@
+package com.baeldung.algorithms.middleelementlookup;
+
+public class Node {
+    private Node next;
+    private String data;
+
+    public Node(String data) {
+        this.data = data;
+    }
+
+    public String data() {
+        return data;
+    }
+
+    public void setData(String data) {
+        this.data = data;
+    }
+
+    public boolean hasNext() {
+        return next != null;
+    }
+
+    public Node next() {
+        return next;
+    }
+
+    public void setNext(Node next) {
+        this.next = next;
+    }
+
+    public String toString() {
+        return this.data;
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/romannumerals/RomanArabicConverter.java

@@ -0,0 +1,52 @@
+package com.baeldung.algorithms.romannumerals;
+
+import java.util.List;
+
+class RomanArabicConverter {
+
+    public static int romanToArabic(String input) {
+        String romanNumeral = input.toUpperCase();
+        int result = 0;
+        
+        List<RomanNumeral> romanNumerals = RomanNumeral.getReverseSortedValues();
+
+        int i = 0;
+
+        while ((romanNumeral.length() > 0) && (i < romanNumerals.size())) {
+            RomanNumeral symbol = romanNumerals.get(i);
+            if (romanNumeral.startsWith(symbol.name())) {
+                result += symbol.getValue();
+                romanNumeral = romanNumeral.substring(symbol.name().length());
+            } else {
+                i++;
+            }
+        }
+        if (romanNumeral.length() > 0) {
+            throw new IllegalArgumentException(input + " cannot be converted to a Roman Numeral");
+        }
+
+        return result;
+    }
+
+    public static String arabicToRoman(int number) {
+        if ((number <= 0) || (number > 4000)) {
+            throw new IllegalArgumentException(number + " is not in range (0,4000]");
+        }
+
+        List<RomanNumeral> romanNumerals = RomanNumeral.getReverseSortedValues();
+
+        int i = 0;
+        StringBuilder sb = new StringBuilder();
+
+        while (number > 0 && i < romanNumerals.size()) {
+            RomanNumeral currentSymbol = romanNumerals.get(i);
+            if (currentSymbol.getValue() <= number) {
+                sb.append(currentSymbol.name());
+                number -= currentSymbol.getValue();
+            } else {
+                i++;
+            }
+        }
+        return sb.toString();
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/romannumerals/RomanNumeral.java

@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.romannumerals;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.stream.Collectors;
+
+enum RomanNumeral {
+    I(1), IV(4), V(5), IX(9), X(10), XL(40), L(50), XC(90), C(100), CD(400), D(500), CM(900), M(1000);
+
+    private int value;
+
+    RomanNumeral(int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+    
+    public static List<RomanNumeral> getReverseSortedValues() {
+        return Arrays.stream(values())
+          .sorted(Comparator.comparing((RomanNumeral e) -> e.value).reversed())
+          .collect(Collectors.toList());
+    }
+}

algorithms/src/test/java/algorithms/HillClimbingAlgorithmUnitTest.java

@@ -13,7 +13,7 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
 
-public class HillClimbingAlgorithmTest {
+public class HillClimbingAlgorithmUnitTest {
     private Stack<String> initStack;
     private Stack<String> goalStack;
 

algorithms/src/test/java/algorithms/MiddleElementLookupUnitTest.java

@@ -0,0 +1,118 @@
+package algorithms;
+
+import com.baeldung.algorithms.middleelementlookup.MiddleElementLookup;
+import com.baeldung.algorithms.middleelementlookup.Node;
+import org.junit.Test;
+
+import java.util.LinkedList;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+
+public class MiddleElementLookupUnitTest {
+
+    @Test
+    public void whenFindingMiddleLinkedList_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementLinkedList(createLinkedList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassRecursively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenFindingMiddleFromHead1PassIteratively_thenMiddleFound() {
+        assertEquals("3", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(5))
+          .get());
+        assertEquals("2", MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(createNodesList(4))
+          .get());
+    }
+
+    @Test
+    public void whenListEmptyOrNull_thenMiddleNotFound() {
+        // null list
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(null)
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(null)
+          .isPresent());
+
+        // empty LinkedList
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(new LinkedList<>())
+          .isPresent());
+
+        // LinkedList with nulls
+        LinkedList<String> nullsList = new LinkedList<>();
+        nullsList.add(null);
+        nullsList.add(null);
+        assertFalse(MiddleElementLookup
+          .findMiddleElementLinkedList(nullsList)
+          .isPresent());
+
+        // nodes with null values
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassIteratively(new Node(null))
+          .isPresent());
+        assertFalse(MiddleElementLookup
+          .findMiddleElementFromHead1PassRecursively(new Node(null))
+          .isPresent());
+    }
+
+    private static LinkedList<String> createLinkedList(int n) {
+        LinkedList<String> list = new LinkedList<>();
+
+        for (int i = 1; i <= n; i++) {
+            list.add(String.valueOf(i));
+        }
+
+        return list;
+    }
+
+    private static Node createNodesList(int n) {
+        Node head = new Node("1");
+        Node current = head;
+
+        for (int i = 2; i <= n; i++) {
+            Node newNode = new Node(String.valueOf(i));
+            current.setNext(newNode);
+            current = newNode;
+        }
+
+        return head;
+    }
+
+}

algorithms/src/test/java/algorithms/StringSearchAlgorithmsUnitTest.java

@@ -6,7 +6,7 @@ import org.junit.Test;
 
 import com.baeldung.algorithms.string.search.StringSearchAlgorithms;
 
-public class StringSearchAlgorithmsTest {
+public class StringSearchAlgorithmsUnitTest {
 	
 	
 	@Test

algorithms/src/test/java/algorithms/binarysearch/BinarySearchUnitTest.java

@@ -7,7 +7,7 @@ import org.junit.Assert;
 import org.junit.Test;
 import com.baeldung.algorithms.binarysearch.BinarySearch;
 
-public class BinarySearchTest {
+public class BinarySearchUnitTest {
 
     int[] sortedArray = { 0, 1, 2, 3, 4, 5, 5, 6, 7, 8, 9, 9 };
     int key = 6;

algorithms/src/test/java/algorithms/mcts/MCTSUnitTest.java

@@ -15,7 +15,7 @@ import com.baeldung.algorithms.mcts.tictactoe.Board;
 import com.baeldung.algorithms.mcts.tictactoe.Position;
 import com.baeldung.algorithms.mcts.tree.Tree;
 
-public class MCTSTest {
+public class MCTSUnitTest {
     private Tree gameTree;
     private MonteCarloTreeSearch mcts;
 

algorithms/src/test/java/algorithms/minimax/MinimaxUnitTest.java

@@ -7,7 +7,7 @@ import static org.junit.Assert.*;
 import com.baeldung.algorithms.minimax.MiniMax;
 import com.baeldung.algorithms.minimax.Tree;
 
-public class MinimaxTest {
+public class MinimaxUnitTest {
     private Tree gameTree;
     private MiniMax miniMax;
 

algorithms/src/test/java/com/baeldung/algorithms/analysis/AnalysisRunnerLiveTest.java

@@ -0,0 +1,139 @@
+package com.baeldung.algorithms.analysis;
+
+import org.junit.Test;
+
+public class AnalysisRunnerLiveTest {
+
+    int n = 10;
+    int total = 0;
+
+    @Test
+    public void whenConstantComplexity_thenConstantRuntime() {
+
+        System.out.println("**** n = " + n + " ****");
+        System.out.println();
+
+        // Constant Time
+        System.out.println("**** Constant time ****");
+
+        System.out.println("Hey - your input is: " + n);
+        System.out.println("Running time not dependent on input size!");
+        System.out.println();
+    }
+
+    @Test
+    public void whenLogarithmicComplexity_thenLogarithmicRuntime() {
+        // Logarithmic Time
+        System.out.println("**** Logarithmic Time ****");
+        for (int i = 1; i < n; i = i * 2) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenLinearComplexity_thenLinearRuntime() {
+        // Linear Time
+        System.out.println("**** Linear Time ****");
+        for (int i = 0; i < n; i++) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+
+    }
+
+    @Test
+    public void whenNLogNComplexity_thenNLogNRuntime() {
+        // N Log N Time
+        System.out.println("**** nlogn Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= n; i++) {
+            for (int j = 1; j < n; j = j * 2) {
+                // System.out.println("Hey - I'm busy looking at: " + i + " and " + j);
+                total++;
+            }
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenQuadraticComplexity_thenQuadraticRuntime() {
+        // Quadratic Time
+        System.out.println("**** Quadratic Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= n; i++) {
+            for (int j = 1; j <= n; j++) {
+                // System.out.println("Hey - I'm busy looking at: " + i + " and " + j);
+                total++;
+            }
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenCubicComplexity_thenCubicRuntime() {
+        // Cubic Time
+        System.out.println("**** Cubic Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= n; i++) {
+            for (int j = 1; j <= n; j++) {
+                for (int k = 1; k <= n; k++) {
+                    // System.out.println("Hey - I'm busy looking at: " + i + " and " + j + " and " + k);
+                    total++;
+                }
+            }
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenExponentialComplexity_thenExponentialRuntime() {
+        // Exponential Time
+        System.out.println("**** Exponential Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <= Math.pow(2, n); i++) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+        System.out.println();
+    }
+
+    @Test
+    public void whenFactorialComplexity_thenFactorialRuntime() {
+        // Factorial Time
+        System.out.println("**** Factorial Time ****");
+        total = 0;
+        for (
+
+            int i = 1; i <=
+
+            factorial(n); i++) {
+            // System.out.println("Hey - I'm busy looking at: " + i);
+            total++;
+        }
+        System.out.println("Total amount of times run: " + total);
+    }
+
+    static int factorial(int n) {
+        if (n == 0 || n == 1)
+            return 1;
+        else
+            return n * factorial(n - 1);
+    }
+}

algorithms/src/test/java/com/baeldung/algorithms/bubblesort/BubbleSortUnitTest.java

@@ -4,7 +4,7 @@ import static org.junit.Assert.*;
 
 import org.junit.Test;
 
-public class BubbleSortTest {
+public class BubbleSortUnitTest {
 
     @Test
     public void givenIntegerArray_whenSortedWithBubbleSort_thenGetSortedArray() {

algorithms/src/test/java/com/baeldung/algorithms/editdistance/EditDistanceUnitTest.java

@@ -7,13 +7,13 @@ import org.junit.runners.Parameterized;
 import static org.junit.Assert.assertEquals;
 
 @RunWith(Parameterized.class)
-public class EditDistanceTest extends EditDistanceDataProvider {
+public class EditDistanceUnitTest extends EditDistanceDataProvider {
 
     private String x;
     private String y;
     private int result;
 
-    public EditDistanceTest(String a, String b, int res) {
+    public EditDistanceUnitTest(String a, String b, int res) {
         super();
         x = a;
         y = b;

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionBruteForceUnitTest.java

@@ -6,11 +6,11 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(value = Parameterized.class)
-public class CycleDetectionBruteForceTest extends CycleDetectionTestBase {
+public class CycleDetectionBruteForceUnitTest extends CycleDetectionTestBase {
     boolean cycleExists;
     Node<Integer> head;
 
-    public CycleDetectionBruteForceTest(Node<Integer> head, boolean cycleExists) {
+    public CycleDetectionBruteForceUnitTest(Node<Integer> head, boolean cycleExists) {
         super();
         this.cycleExists = cycleExists;
         this.head = head;

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByFastAndSlowIteratorsUnitTest.java

@@ -6,11 +6,11 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(value = Parameterized.class)
-public class CycleDetectionByFastAndSlowIteratorsTest extends CycleDetectionTestBase {
+public class CycleDetectionByFastAndSlowIteratorsUnitTest extends CycleDetectionTestBase {
     boolean cycleExists;
     Node<Integer> head;
 
-    public CycleDetectionByFastAndSlowIteratorsTest(Node<Integer> head, boolean cycleExists) {
+    public CycleDetectionByFastAndSlowIteratorsUnitTest(Node<Integer> head, boolean cycleExists) {
         super();
         this.cycleExists = cycleExists;
         this.head = head;

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleDetectionByHashingUnitTest.java

@@ -6,11 +6,11 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(value = Parameterized.class)
-public class CycleDetectionByHashingTest extends CycleDetectionTestBase {
+public class CycleDetectionByHashingUnitTest extends CycleDetectionTestBase {
     boolean cycleExists;
     Node<Integer> head;
 
-    public CycleDetectionByHashingTest(Node<Integer> head, boolean cycleExists) {
+    public CycleDetectionByHashingUnitTest(Node<Integer> head, boolean cycleExists) {
         super();
         this.cycleExists = cycleExists;
         this.head = head;

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalBruteForceUnitTest.java

@@ -6,11 +6,11 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(value = Parameterized.class)
-public class CycleRemovalBruteForceTest extends CycleDetectionTestBase {
+public class CycleRemovalBruteForceUnitTest extends CycleDetectionTestBase {
     boolean cycleExists;
     Node<Integer> head;
 
-    public CycleRemovalBruteForceTest(Node<Integer> head, boolean cycleExists) {
+    public CycleRemovalBruteForceUnitTest(Node<Integer> head, boolean cycleExists) {
         super();
         this.cycleExists = cycleExists;
         this.head = head;

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalByCountingLoopNodesUnitTest.java

@@ -6,11 +6,11 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(value = Parameterized.class)
-public class CycleRemovalByCountingLoopNodesTest extends CycleDetectionTestBase {
+public class CycleRemovalByCountingLoopNodesUnitTest extends CycleDetectionTestBase {
     boolean cycleExists;
     Node<Integer> head;
 
-    public CycleRemovalByCountingLoopNodesTest(Node<Integer> head, boolean cycleExists) {
+    public CycleRemovalByCountingLoopNodesUnitTest(Node<Integer> head, boolean cycleExists) {
         super();
         this.cycleExists = cycleExists;
         this.head = head;

algorithms/src/test/java/com/baeldung/algorithms/linkedlist/CycleRemovalWithoutCountingLoopNodesUnitTest.java

@@ -6,11 +6,11 @@ import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 
 @RunWith(value = Parameterized.class)
-public class CycleRemovalWithoutCountingLoopNodesTest extends CycleDetectionTestBase {
+public class CycleRemovalWithoutCountingLoopNodesUnitTest extends CycleDetectionTestBase {
     boolean cycleExists;
     Node<Integer> head;
 
-    public CycleRemovalWithoutCountingLoopNodesTest(Node<Integer> head, boolean cycleExists) {
+    public CycleRemovalWithoutCountingLoopNodesUnitTest(Node<Integer> head, boolean cycleExists) {
         super();
         this.cycleExists = cycleExists;
         this.head = head;

algorithms/src/test/java/com/baeldung/algorithms/moneywords/NumberWordConverterUnitTest.java

@@ -6,7 +6,7 @@ import org.junit.Test;
 
 import com.baeldung.algorithms.numberwordconverter.NumberWordConverter;
 
-public class NumberWordConverterTest {
+public class NumberWordConverterUnitTest {
 
     @Test
     public void whenMoneyNegative_thenReturnInvalidInput() {

algorithms/src/test/java/com/baeldung/algorithms/prime/PrimeGeneratorUnitTest.java

@@ -7,7 +7,7 @@ import java.util.List;
 import org.junit.Test;
 import static org.junit.Assert.*;
 
-public class PrimeGeneratorTest {
+public class PrimeGeneratorUnitTest {
     @Test
     public void whenBruteForced_returnsSuccessfully() {
         final List<Integer> primeNumbers = primeNumbersBruteForce(20);

algorithms/src/test/java/com/baeldung/algorithms/romannumerals/RomanArabicConverterUnitTest.java

@@ -0,0 +1,29 @@
+package com.baeldung.algorithms.romannumerals;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.Test;
+
+public class RomanArabicConverterUnitTest {
+
+    @Test
+    public void given2018Roman_WhenConvertingToArabic_ThenReturn2018() {
+
+        String roman2018 = "MMXVIII";
+
+        int result = RomanArabicConverter.romanToArabic(roman2018);
+
+        assertThat(result).isEqualTo(2018);
+    }
+
+    @Test
+    public void given1999Arabic_WhenConvertingToRoman_ThenReturnMCMXCIX() {
+
+        int arabic1999 = 1999;
+
+        String result = RomanArabicConverter.arabicToRoman(arabic1999);
+
+        assertThat(result).isEqualTo("MCMXCIX");
+    }
+
+}

algorithms/src/test/java/com/baeldung/jgrapht/CompleteGraphUnitTest.java

@@ -12,7 +12,7 @@ import org.jgrapht.graph.SimpleWeightedGraph;
 import org.junit.Before;
 import org.junit.Test;
 
-public class CompleteGraphTest {
+public class CompleteGraphUnitTest {
 
     static SimpleWeightedGraph<String, DefaultEdge> completeGraph;
     static int size = 10;

algorithms/src/test/java/com/baeldung/jgrapht/DirectedGraphUnitTest.java

@@ -24,7 +24,7 @@ import org.jgrapht.traverse.DepthFirstIterator;
 import org.junit.Before;
 import org.junit.Test;
 
-public class DirectedGraphTests {
+public class DirectedGraphUnitTest {
     DirectedGraph<String, DefaultEdge> directedGraph;
 
     @Before

algorithms/src/test/java/com/baeldung/jgrapht/EulerianCircuitUnitTest.java

@@ -12,7 +12,7 @@ import org.jgrapht.graph.SimpleWeightedGraph;
 import org.junit.Before;
 import org.junit.Test;
 
-public class EulerianCircuitTest {
+public class EulerianCircuitUnitTest {
     SimpleWeightedGraph<String, DefaultEdge> simpleGraph;
 
     @Before

animal-sniffer-mvn-plugin/pom.xml

@@ -5,7 +5,7 @@
     <artifactId>animal-sniffer-mvn-plugin</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
-    <name>example-animal-sniffer-mvn-plugin</name>
+    <name>animal-sniffer-mvn-plugin</name>
     <url>http://maven.apache.org</url>
 
     <parent>