Spark graphx moved to a new project due to a incompatibility of scala compiler

libraries-apache-commons/src/test/java/com/baeldung/commons/beanutils/CourseServiceUnitTest.java

@@ -0,0 +1,53 @@
+package com.baeldung.commons.beanutils;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CourseServiceUnitTest {
+
+    @Test
+    public void givenCourse_whenSetValuesUsingPropertyUtil_thenReturnSetValues() throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        Course course = new Course();
+        String name = "Computer Science";
+        List<String> codes = Arrays.asList("CS", "CS01");
+        CourseService.setValues(course, name, codes);
+
+        Assert.assertEquals(name, course.getName());
+        Assert.assertEquals(2, course.getCodes().size());
+        Assert.assertEquals("CS", course.getCodes().get(0));
+
+        CourseService.setIndexedValue(course, 1, "CS02");
+        Assert.assertEquals("CS02", course.getCodes().get(1));
+
+        Student student = new Student();
+        String studentName = "Joe";
+        student.setName(studentName);
+
+        CourseService.setMappedValue(course, "ST-1", student);
+        Assert.assertEquals(student, course.getEnrolledStudent("ST-1"));
+
+        String accessedStudentName = CourseService.getNestedValue(course, "ST-1", "name");
+        Assert.assertEquals(studentName, accessedStudentName);
+    }
+
+    @Test
+    public void givenCopyProperties_whenCopyCourseToCourseEntity_thenCopyPropertyWithSameName() throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        Course course = new Course();
+        course.setName("Computer Science");
+        course.setCodes(Arrays.asList("CS"));
+        course.setEnrolledStudent("ST-1", new Student());
+
+        CourseEntity courseEntity = new CourseEntity();
+
+        CourseService.copyProperties(course, courseEntity);
+        Assert.assertNotNull(course.getName());
+	Assert.assertNotNull(courseEntity.getName());
+        Assert.assertEquals(course.getName(), courseEntity.getName());
+        Assert.assertEquals(course.getCodes(), courseEntity.getCodes());
+        Assert.assertNull(courseEntity.getStudent("ST-1"));
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/chain/AtmChainUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.commons.chain;
+
+import org.apache.commons.chain.Catalog;
+import org.apache.commons.chain.Command;
+import org.apache.commons.chain.Context;
+import org.junit.Assert;
+import org.junit.Test;
+
+import static com.baeldung.commons.chain.AtmConstants.*;
+
+public class AtmChainUnitTest {
+
+    public static final int EXPECTED_TOTAL_AMOUNT_TO_BE_WITHDRAWN = 460;
+    public static final int EXPECTED_AMOUNT_LEFT_TO_BE_WITHDRAWN = 0;
+    public static final int EXPECTED_NO_OF_HUNDREDS_DISPENSED = 4;
+    public static final int EXPECTED_NO_OF_FIFTIES_DISPENSED = 1;
+    public static final int EXPECTED_NO_OF_TENS_DISPENSED = 1;
+
+    @Test
+    public void givenInputsToContext_whenAppliedChain_thenExpectedContext() {
+        Context context = new AtmRequestContext();
+        context.put(TOTAL_AMOUNT_TO_BE_WITHDRAWN, 460);
+        context.put(AMOUNT_LEFT_TO_BE_WITHDRAWN, 460);
+        Catalog catalog = new AtmCatalog();
+        Command atmWithdrawalChain = catalog.getCommand(ATM_WITHDRAWAL_CHAIN);
+        try {
+            atmWithdrawalChain.execute(context);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        Assert.assertEquals(EXPECTED_TOTAL_AMOUNT_TO_BE_WITHDRAWN, (int) context.get(TOTAL_AMOUNT_TO_BE_WITHDRAWN));
+        Assert.assertEquals(EXPECTED_AMOUNT_LEFT_TO_BE_WITHDRAWN, (int) context.get(AMOUNT_LEFT_TO_BE_WITHDRAWN));
+        Assert.assertEquals(EXPECTED_NO_OF_HUNDREDS_DISPENSED, (int) context.get(NO_OF_HUNDREDS_DISPENSED));
+        Assert.assertEquals(EXPECTED_NO_OF_FIFTIES_DISPENSED, (int) context.get(NO_OF_FIFTIES_DISPENSED));
+        Assert.assertEquals(EXPECTED_NO_OF_TENS_DISPENSED, (int) context.get(NO_OF_TENS_DISPENSED));
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/dbutils/DbUtilsUnitTest.java

@@ -0,0 +1,155 @@
+package com.baeldung.commons.dbutils;
+
+import org.apache.commons.dbutils.AsyncQueryRunner;
+import org.apache.commons.dbutils.DbUtils;
+import org.apache.commons.dbutils.QueryRunner;
+import org.apache.commons.dbutils.handlers.BeanListHandler;
+import org.apache.commons.dbutils.handlers.MapListHandler;
+import org.apache.commons.dbutils.handlers.ScalarHandler;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class DbUtilsUnitTest {
+
+    private Connection connection;
+
+    @Before
+    public void setupDB() throws Exception {
+        Class.forName("org.h2.Driver");
+        String db = "jdbc:h2:mem:;INIT=runscript from 'classpath:/employees.sql'";
+        connection = DriverManager.getConnection(db);
+    }
+
+    @After
+    public void closeBD() {
+        DbUtils.closeQuietly(connection);
+    }
+
+    @Test
+    public void givenResultHandler_whenExecutingQuery_thenExpectedList() throws SQLException {
+        MapListHandler beanListHandler = new MapListHandler();
+
+        QueryRunner runner = new QueryRunner();
+        List<Map<String, Object>> list = runner.query(connection, "SELECT * FROM employee", beanListHandler);
+
+        assertEquals(list.size(), 5);
+        assertEquals(list.get(0).get("firstname"), "John");
+        assertEquals(list.get(4).get("firstname"), "Christian");
+    }
+
+    @Test
+    public void givenResultHandler_whenExecutingQuery_thenEmployeeList() throws SQLException {
+        BeanListHandler<Employee> beanListHandler = new BeanListHandler<>(Employee.class);
+
+        QueryRunner runner = new QueryRunner();
+        List<Employee> employeeList = runner.query(connection, "SELECT * FROM employee", beanListHandler);
+
+        assertEquals(employeeList.size(), 5);
+        assertEquals(employeeList.get(0).getFirstName(), "John");
+        assertEquals(employeeList.get(4).getFirstName(), "Christian");
+    }
+
+    @Test
+    public void givenResultHandler_whenExecutingQuery_thenExpectedScalar() throws SQLException {
+        ScalarHandler<Long> scalarHandler = new ScalarHandler<>();
+
+        QueryRunner runner = new QueryRunner();
+        String query = "SELECT COUNT(*) FROM employee";
+        long count = runner.query(connection, query, scalarHandler);
+
+        assertEquals(count, 5);
+    }
+
+    @Test
+    public void givenResultHandler_whenExecutingQuery_thenEmailsSetted() throws SQLException {
+        EmployeeHandler employeeHandler = new EmployeeHandler(connection);
+
+        QueryRunner runner = new QueryRunner();
+        List<Employee> employees = runner.query(connection, "SELECT * FROM employee", employeeHandler);
+
+        assertEquals(employees.get(0).getEmails().size(), 2);
+        assertEquals(employees.get(2).getEmails().size(), 3);
+        assertNotNull(employees.get(0).getEmails().get(0).getEmployeeId());
+    }
+
+    @Test
+    public void givenResultHandler_whenExecutingQuery_thenAllPropertiesSetted() throws SQLException {
+        EmployeeHandler employeeHandler = new EmployeeHandler(connection);
+
+        QueryRunner runner = new QueryRunner();
+        String query = "SELECT * FROM employee_legacy";
+        List<Employee> employees = runner.query(connection, query, employeeHandler);
+
+        assertEquals((int) employees.get(0).getId(), 1);
+        assertEquals(employees.get(0).getFirstName(), "John");
+    }
+
+    @Test
+    public void whenInserting_thenInserted() throws SQLException {
+        QueryRunner runner = new QueryRunner();
+        String insertSQL = "INSERT INTO employee (firstname,lastname,salary, hireddate) VALUES (?, ?, ?, ?)";
+
+        int numRowsInserted = runner.update(connection, insertSQL, "Leia", "Kane", 60000.60, new Date());
+
+        assertEquals(numRowsInserted, 1);
+    }
+
+    @Test
+    public void givenHandler_whenInserting_thenExpectedId() throws SQLException {
+        ScalarHandler<Integer> scalarHandler = new ScalarHandler<>();
+
+        QueryRunner runner = new QueryRunner();
+        String insertSQL = "INSERT INTO employee (firstname,lastname,salary, hireddate) VALUES (?, ?, ?, ?)";
+
+        int newId = runner.insert(connection, insertSQL, scalarHandler, "Jenny", "Medici", 60000.60, new Date());
+
+        assertEquals(newId, 6);
+    }
+
+    @Test
+    public void givenSalary_whenUpdating_thenUpdated() throws SQLException {
+        double salary = 35000;
+
+        QueryRunner runner = new QueryRunner();
+        String updateSQL = "UPDATE employee SET salary = salary * 1.1 WHERE salary <= ?";
+        int numRowsUpdated = runner.update(connection, updateSQL, salary);
+
+        assertEquals(numRowsUpdated, 3);
+    }
+
+    @Test
+    public void whenDeletingRecord_thenDeleted() throws SQLException {
+        QueryRunner runner = new QueryRunner();
+        String deleteSQL = "DELETE FROM employee WHERE id = ?";
+        int numRowsDeleted = runner.update(connection, deleteSQL, 3);
+
+        assertEquals(numRowsDeleted, 1);
+    }
+
+    @Test
+    public void givenAsyncRunner_whenExecutingQuery_thenExpectedList() throws Exception {
+        AsyncQueryRunner runner = new AsyncQueryRunner(Executors.newCachedThreadPool());
+
+        EmployeeHandler employeeHandler = new EmployeeHandler(connection);
+        String query = "SELECT * FROM employee";
+        Future<List<Employee>> future = runner.query(connection, query, employeeHandler);
+        List<Employee> employeeList = future.get(10, TimeUnit.SECONDS);
+
+        assertEquals(employeeList.size(), 5);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/ArrayUtilsUnitTest.java

@@ -0,0 +1,138 @@
+package com.baeldung.commons.lang3;
+
+import org.apache.commons.lang3.ArrayUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class ArrayUtilsUnitTest {
+    @Test
+    public void givenArray_whenAddingElementAtSpecifiedPosition_thenCorrect() {
+        int[] oldArray = { 2, 3, 4, 5 };
+        int[] newArray = ArrayUtils.add(oldArray, 0, 1);
+        int[] expectedArray = { 1, 2, 3, 4, 5 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenAddingElementAtTheEnd_thenCorrect() {
+        int[] oldArray = { 2, 3, 4, 5 };
+        int[] newArray = ArrayUtils.add(oldArray, 1);
+        int[] expectedArray = { 2, 3, 4, 5, 1 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenAddingAllElementsAtTheEnd_thenCorrect() {
+        int[] oldArray = { 0, 1, 2 };
+        int[] newArray = ArrayUtils.addAll(oldArray, 3, 4, 5);
+        int[] expectedArray = { 0, 1, 2, 3, 4, 5 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenRemovingElementAtSpecifiedPosition_thenCorrect() {
+        int[] oldArray = { 1, 2, 3, 4, 5 };
+        int[] newArray = ArrayUtils.remove(oldArray, 1);
+        int[] expectedArray = { 1, 3, 4, 5 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenRemovingAllElementsAtSpecifiedPositions_thenCorrect() {
+        int[] oldArray = { 1, 2, 3, 4, 5 };
+        int[] newArray = ArrayUtils.removeAll(oldArray, 1, 3);
+        int[] expectedArray = { 1, 3, 5 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenRemovingAnElement_thenCorrect() {
+        int[] oldArray = { 1, 2, 3, 3, 4 };
+        int[] newArray = ArrayUtils.removeElement(oldArray, 3);
+        int[] expectedArray = { 1, 2, 3, 4 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenRemovingElements_thenCorrect() {
+        int[] oldArray = { 1, 2, 3, 3, 4 };
+        int[] newArray = ArrayUtils.removeElements(oldArray, 2, 3, 5);
+        int[] expectedArray = { 1, 3, 4 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenRemovingAllElementOccurences_thenCorrect() {
+        int[] oldArray = { 1, 2, 2, 2, 3 };
+        int[] newArray = ArrayUtils.removeAllOccurences(oldArray, 2);
+        int[] expectedArray = { 1, 3 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenCheckingExistingElement_thenCorrect() {
+        int[] array = { 1, 3, 5, 7, 9 };
+        boolean evenContained = ArrayUtils.contains(array, 2);
+        boolean oddContained = ArrayUtils.contains(array, 7);
+        assertEquals(false, evenContained);
+        assertEquals(true, oddContained);
+    }
+
+    @Test
+    public void givenArray_whenReversingElementsWithinARange_thenCorrect() {
+        int[] originalArray = { 1, 2, 3, 4, 5 };
+        ArrayUtils.reverse(originalArray, 1, 4);
+        int[] expectedArray = { 1, 4, 3, 2, 5 };
+        assertArrayEquals(expectedArray, originalArray);
+    }
+
+    @Test
+    public void givenArray_whenReversingAllElements_thenCorrect() {
+        int[] originalArray = { 1, 2, 3, 4, 5 };
+        ArrayUtils.reverse(originalArray);
+        int[] expectedArray = { 5, 4, 3, 2, 1 };
+        assertArrayEquals(expectedArray, originalArray);
+    }
+
+    @Test
+    public void givenArray_whenShiftingElementsWithinARange_thenCorrect() {
+        int[] originalArray = { 1, 2, 3, 4, 5 };
+        ArrayUtils.shift(originalArray, 1, 4, 1);
+        int[] expectedArray = { 1, 4, 2, 3, 5 };
+        assertArrayEquals(expectedArray, originalArray);
+    }
+
+    @Test
+    public void givenArray_whenShiftingAllElements_thenCorrect() {
+        int[] originalArray = { 1, 2, 3, 4, 5 };
+        ArrayUtils.shift(originalArray, 1);
+        int[] expectedArray = { 5, 1, 2, 3, 4 };
+        assertArrayEquals(expectedArray, originalArray);
+    }
+
+    @Test
+    public void givenArray_whenExtractingElements_thenCorrect() {
+        int[] oldArray = { 1, 2, 3, 4, 5 };
+        int[] newArray = ArrayUtils.subarray(oldArray, 2, 7);
+        int[] expectedArray = { 3, 4, 5 };
+        assertArrayEquals(expectedArray, newArray);
+    }
+
+    @Test
+    public void givenArray_whenSwapingElementsWithinARange_thenCorrect() {
+        int[] originalArray = { 1, 2, 3, 4, 5 };
+        ArrayUtils.swap(originalArray, 0, 3, 2);
+        int[] expectedArray = { 4, 5, 3, 1, 2 };
+        assertArrayEquals(expectedArray, originalArray);
+    }
+
+    @Test
+    public void givenArray_whenSwapingElementsAtSpecifiedPositions_thenCorrect() {
+        int[] originalArray = { 1, 2, 3, 4, 5 };
+        ArrayUtils.swap(originalArray, 0, 3);
+        int[] expectedArray = { 4, 2, 3, 1, 5 };
+        assertArrayEquals(expectedArray, originalArray);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/Lang3UtilsUnitTest.java

@@ -0,0 +1,149 @@
+package com.baeldung.commons.lang3;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+import java.beans.PropertyChangeEvent;
+import java.beans.PropertyChangeListener;
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.Locale;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+
+import org.apache.commons.lang3.ArchUtils;
+import org.apache.commons.lang3.BooleanUtils;
+import org.apache.commons.lang3.SystemUtils;
+import org.apache.commons.lang3.arch.Processor;
+import org.apache.commons.lang3.concurrent.BasicThreadFactory;
+import org.apache.commons.lang3.concurrent.ConcurrentException;
+import org.apache.commons.lang3.concurrent.ConcurrentRuntimeException;
+import org.apache.commons.lang3.concurrent.ConcurrentUtils;
+import org.apache.commons.lang3.event.EventUtils;
+import org.apache.commons.lang3.reflect.FieldUtils;
+import org.apache.commons.lang3.time.FastDateFormat;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class Lang3UtilsUnitTest {
+
+    @Test
+    public void test_to_Boolean_fromString() {
+        assertFalse(BooleanUtils.toBoolean("off"));
+        assertTrue(BooleanUtils.toBoolean("true"));
+        assertTrue(BooleanUtils.toBoolean("tRue"));
+        assertFalse(BooleanUtils.toBoolean("no"));
+        assertFalse(BooleanUtils.isTrue(Boolean.FALSE));
+        assertFalse(BooleanUtils.isTrue(null));
+    }
+
+    @Test
+    public void testGetUserHome() {
+        final File dir = SystemUtils.getUserHome();
+        Assert.assertNotNull(dir);
+        Assert.assertTrue(dir.exists());
+    }
+
+    @Test
+    public void testGetJavaHome() {
+        final File dir = SystemUtils.getJavaHome();
+        Assert.assertNotNull(dir);
+        Assert.assertTrue(dir.exists());
+    }
+
+    @Test
+    public void testProcessorArchType() {
+        Processor processor = ArchUtils.getProcessor("x86");
+        assertTrue(processor.is32Bit());
+        assertFalse(processor.is64Bit());
+    }
+
+    @Test
+    public void testProcessorArchType64Bit() {
+        Processor processor = ArchUtils.getProcessor("x86_64");
+        assertFalse(processor.is32Bit());
+        assertTrue(processor.is64Bit());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testConcurrentRuntimeExceptionCauseError() {
+        new ConcurrentRuntimeException("An error", new Error());
+    }
+
+    @Test
+    public void testConstantFuture_Integer() throws Exception {
+        Future<Integer> test = ConcurrentUtils.constantFuture(5);
+        assertTrue(test.isDone());
+        assertSame(5, test.get());
+        assertFalse(test.isCancelled());
+    }
+
+    @Test
+    public void testFieldUtilsGetAllFields() {
+        final Field[] fieldsNumber = Number.class.getDeclaredFields();
+        assertArrayEquals(fieldsNumber, FieldUtils.getAllFields(Number.class));
+    }
+
+    @Test
+    public void test_getInstance_String_Locale() {
+        final FastDateFormat format1 = FastDateFormat.getInstance("MM/DD/yyyy", Locale.US);
+        final FastDateFormat format3 = FastDateFormat.getInstance("MM/DD/yyyy", Locale.GERMANY);
+
+        assertNotSame(format1, format3);
+    }
+
+    @Test
+    public void testAddEventListenerThrowsException() {
+        final ExceptionEventSource src = new ExceptionEventSource();
+        try {
+            EventUtils.addEventListener(src, PropertyChangeListener.class, (PropertyChangeEvent e) -> {
+                /* Change event*/});
+            fail("Add method should have thrown an exception, so method should fail.");
+        } catch (final RuntimeException e) {
+
+        }
+    }
+
+    @Test
+    public void ConcurrentExceptionSample() throws ConcurrentException {
+        final Error err = new AssertionError("Test");
+        try {
+            ConcurrentUtils.handleCause(new ExecutionException(err));
+            fail("Error not thrown!");
+        } catch (final Error e) {
+            assertEquals("Wrong error", err, e);
+        }
+    }
+
+    public static class ExceptionEventSource {
+        public void addPropertyChangeListener(final PropertyChangeListener listener) {
+            throw new RuntimeException();
+        }
+    }
+
+    @Test
+    public void testLazyInitializer() throws Exception {
+        SampleLazyInitializer sampleLazyInitializer = new SampleLazyInitializer();
+        SampleObject sampleObjectOne = sampleLazyInitializer.get();
+        SampleObject sampleObjectTwo = sampleLazyInitializer.get();
+        assertEquals(sampleObjectOne, sampleObjectTwo);
+    }
+
+    @Test
+    public void testBuildDefaults() {
+        BasicThreadFactory.Builder builder = new BasicThreadFactory.Builder();
+        BasicThreadFactory factory = builder.build();
+        assertNull("No naming pattern set Yet", factory.getNamingPattern());
+        BasicThreadFactory factory2 = builder.namingPattern("sampleNamingPattern").daemon(true).priority(Thread.MIN_PRIORITY).build();
+        assertNotNull("Got a naming pattern", factory2.getNamingPattern());
+        assertEquals("sampleNamingPattern", factory2.getNamingPattern());
+
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/StringUtilsUnitTest.java

@@ -0,0 +1,100 @@
+package com.baeldung.commons.lang3;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class StringUtilsUnitTest {
+    @Test
+    public void givenString_whenCheckingContainsAny_thenCorrect() {
+        String string = "baeldung.com";
+        boolean contained1 = StringUtils.containsAny(string, 'a', 'b', 'c');
+        boolean contained2 = StringUtils.containsAny(string, 'x', 'y', 'z');
+        boolean contained3 = StringUtils.containsAny(string, "abc");
+        boolean contained4 = StringUtils.containsAny(string, "xyz");
+        assertTrue(contained1);
+        assertFalse(contained2);
+        assertTrue(contained3);
+        assertFalse(contained4);
+    }
+
+    @Test
+    public void givenString_whenCheckingContainsIgnoreCase_thenCorrect() {
+        String string = "baeldung.com";
+        boolean contained = StringUtils.containsIgnoreCase(string, "BAELDUNG");
+        assertTrue(contained);
+    }
+
+    @Test
+    public void givenString_whenCountingMatches_thenCorrect() {
+        String string = "welcome to www.baeldung.com";
+        int charNum = StringUtils.countMatches(string, 'w');
+        int stringNum = StringUtils.countMatches(string, "com");
+        assertEquals(4, charNum);
+        assertEquals(2, stringNum);
+    }
+
+    @Test
+    public void givenString_whenAppendingAndPrependingIfMissing_thenCorrect() {
+        String string = "baeldung.com";
+        String stringWithSuffix = StringUtils.appendIfMissing(string, ".com");
+        String stringWithPrefix = StringUtils.prependIfMissing(string, "www.");
+        assertEquals("baeldung.com", stringWithSuffix);
+        assertEquals("www.baeldung.com", stringWithPrefix);
+    }
+
+    @Test
+    public void givenString_whenSwappingCase_thenCorrect() {
+        String originalString = "baeldung.COM";
+        String swappedString = StringUtils.swapCase(originalString);
+        assertEquals("BAELDUNG.com", swappedString);
+    }
+
+    @Test
+    public void givenString_whenCapitalizing_thenCorrect() {
+        String originalString = "baeldung";
+        String capitalizedString = StringUtils.capitalize(originalString);
+        assertEquals("Baeldung", capitalizedString);
+    }
+
+    @Test
+    public void givenString_whenUncapitalizing_thenCorrect() {
+        String originalString = "Baeldung";
+        String uncapitalizedString = StringUtils.uncapitalize(originalString);
+        assertEquals("baeldung", uncapitalizedString);
+    }
+
+    @Test
+    public void givenString_whenReversingCharacters_thenCorrect() {
+        String originalString = "baeldung";
+        String reversedString = StringUtils.reverse(originalString);
+        assertEquals("gnudleab", reversedString);
+    }
+
+    @Test
+    public void givenString_whenReversingWithDelimiter_thenCorrect() {
+        String originalString = "www.baeldung.com";
+        String reversedString = StringUtils.reverseDelimited(originalString, '.');
+        assertEquals("com.baeldung.www", reversedString);
+    }
+
+    @Test
+    public void givenString_whenRotatingTwoPositions_thenCorrect() {
+        String originalString = "baeldung";
+        String rotatedString = StringUtils.rotate(originalString, 4);
+        assertEquals("dungbael", rotatedString);
+    }
+
+    @Test
+    public void givenTwoStrings_whenComparing_thenCorrect() {
+        String tutorials = "Baeldung Tutorials";
+        String courses = "Baeldung Courses";
+        String diff1 = StringUtils.difference(tutorials, courses);
+        String diff2 = StringUtils.difference(courses, tutorials);
+        assertEquals("Courses", diff1);
+        assertEquals("Tutorials", diff2);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/ArrayUtilsUnitTest.java

@@ -0,0 +1,84 @@
+package com.baeldung.commons.lang3.test;
+
+import java.util.HashMap;
+import java.util.Map;
+import org.apache.commons.lang3.ArrayUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class ArrayUtilsUnitTest {
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledtoString_thenCorrect() {
+        String[] array = {"a", "b", "c"};
+        assertThat(ArrayUtils.toString(array)).isEqualTo("{a,b,c}");
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledtoStringIfArrayisNull_thenCorrect() {
+        String[] array = null;
+        assertThat(ArrayUtils.toString(array, "Array is null")).isEqualTo("Array is null");
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledhashCode_thenCorrect() {
+        String[] array = {"a", "b", "c"};
+        assertThat(ArrayUtils.hashCode(array)).isEqualTo(997619);
+    }
+    
+    @Test
+    public void givenArrayUtilsClass_whenCalledtoMap_thenCorrect() {
+        String[][] array = {{"1", "one", }, {"2", "two", }, {"3", "three"}};
+        Map map = new HashMap();
+        map.put("1", "one");
+        map.put("2", "two");
+        map.put("3", "three");
+        assertThat(ArrayUtils.toMap(array)).isEqualTo(map);
+    }
+    
+    @Test
+    public void givenArrayUtilsClass_whenCallednullToEmptyStringArray_thenCorrect() {
+        String[] array = null;
+        assertThat(ArrayUtils.nullToEmpty(array)).isEmpty();
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCallednullToEmptyObjectArray_thenCorrect() {
+        Object[] array = null;
+        assertThat(ArrayUtils.nullToEmpty(array)).isEmpty();
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledsubarray_thenCorrect() {
+        int[] array = {1, 2, 3};
+        int[] expected = {1};
+        assertThat(ArrayUtils.subarray(array, 0, 1)).isEqualTo(expected);
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledisSameLength_thenCorrect() {
+        int[] array1 = {1, 2, 3};
+        int[] array2 = {1, 2, 3};
+        assertThat(ArrayUtils.isSameLength(array1, array2)).isTrue();
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledreverse_thenCorrect() {
+        int[] array1 = {1, 2, 3};
+        int[] array2 = {3, 2, 1};
+        ArrayUtils.reverse(array1);
+        assertThat(array1).isEqualTo(array2);
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledIndexOf_thenCorrect() {
+        int[] array = {1, 2, 3};
+        assertThat(ArrayUtils.indexOf(array, 1, 0)).isEqualTo(0);
+    }
+
+    @Test
+    public void givenArrayUtilsClass_whenCalledcontains_thenCorrect() {
+        int[] array = {1, 2, 3};
+        assertThat(ArrayUtils.contains(array, 1)).isTrue();
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/BasicThreadFactoryUnitTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.concurrent.BasicThreadFactory;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class BasicThreadFactoryUnitTest {
+
+    @Test
+    public void givenBasicThreadFactoryInstance_whenCalledBuilder_thenCorrect() {
+        BasicThreadFactory factory = new BasicThreadFactory.Builder()
+            .namingPattern("workerthread-%d")
+            .daemon(true)
+            .priority(Thread.MAX_PRIORITY)
+            .build();
+        assertThat(factory).isInstanceOf(BasicThreadFactory.class);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/ConstructorUtilsUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.commons.lang3.test;
+
+import com.baeldung.commons.lang3.beans.User;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import org.apache.commons.lang3.reflect.ConstructorUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class ConstructorUtilsUnitTest {
+
+    @Test
+    public void givenConstructorUtilsClass_whenCalledgetAccessibleConstructor_thenCorrect() {
+        assertThat(ConstructorUtils.getAccessibleConstructor(User.class, String.class, String.class)).isInstanceOf(Constructor.class);
+    }
+    
+    @Test
+    public void givenConstructorUtilsClass_whenCalledinvokeConstructor_thenCorrect() throws Exception {
+        assertThat(ConstructorUtils.invokeConstructor(User.class, "name", "email")).isInstanceOf(User.class);
+    }
+    
+    @Test
+    public void givenConstructorUtilsClass_whenCalledinvokeExactConstructor_thenCorrect() throws Exception {
+        String[] args = {"name", "email"};
+        Class[] parameterTypes= {String.class, String.class};
+        assertThat(ConstructorUtils.invokeExactConstructor(User.class, args, parameterTypes)).isInstanceOf(User.class);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/FieldUtilsUnitTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.commons.lang3.test;
+
+import com.baeldung.commons.lang3.beans.User;
+import org.apache.commons.lang3.reflect.FieldUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class FieldUtilsUnitTest {
+    
+    private static User user;
+    
+    @BeforeClass
+    public static void setUpUserInstance() {
+        user  = new User("Julie", "julie@domain.com");
+    }
+
+    @Test
+    public void givenFieldUtilsClass_whenCalledgetField_thenCorrect() {
+        assertThat(FieldUtils.getField(User.class, "name", true).getName()).isEqualTo("name");
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledgetFieldForceAccess_thenCorrect() {
+        assertThat(FieldUtils.getField(User.class, "name", true).getName()).isEqualTo("name");
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledgetDeclaredFieldForceAccess_thenCorrect() {
+        assertThat(FieldUtils.getDeclaredField(User.class, "name", true).getName()).isEqualTo("name");
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledgetAllField_thenCorrect() {
+        assertThat(FieldUtils.getAllFields(User.class).length).isEqualTo(2);  
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledreadField_thenCorrect() throws IllegalAccessException {
+        assertThat(FieldUtils.readField(user, "name", true)).isEqualTo("Julie");  
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledreadDeclaredField_thenCorrect() throws IllegalAccessException {
+        assertThat(FieldUtils.readDeclaredField(user, "name", true)).isEqualTo("Julie");  
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledwriteField_thenCorrect() throws IllegalAccessException {
+        FieldUtils.writeField(user, "name", "Julie", true);
+        assertThat(FieldUtils.readField(user, "name", true)).isEqualTo("Julie");
+        
+    }
+    
+    @Test
+    public void givenFieldUtilsClass_whenCalledwriteDeclaredField_thenCorrect() throws IllegalAccessException {
+        FieldUtils.writeDeclaredField(user, "name", "Julie", true);
+        assertThat(FieldUtils.readField(user, "name", true)).isEqualTo("Julie");    
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/FractionUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.math.Fraction;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class FractionUnitTest {
+    
+    @Test
+    public void givenFractionClass_whenCalledgetFraction_thenCorrect() {
+        assertThat(Fraction.getFraction(5, 6)).isInstanceOf(Fraction.class);
+    }
+    
+    @Test
+    public void givenTwoFractionInstances_whenCalledadd_thenCorrect() {
+        Fraction fraction1 = Fraction.getFraction(1, 4);
+        Fraction fraction2 = Fraction.getFraction(3, 4);
+        assertThat(fraction1.add(fraction2).toString()).isEqualTo("1/1");
+    }
+    
+    @Test
+    public void givenTwoFractionInstances_whenCalledsubstract_thenCorrect() {
+        Fraction fraction1 = Fraction.getFraction(3, 4);
+        Fraction fraction2 = Fraction.getFraction(1, 4);
+        assertThat(fraction1.subtract(fraction2).toString()).isEqualTo("1/2");
+    }
+    
+    @Test
+    public void givenTwoFractionInstances_whenCalledmultiply_thenCorrect() {
+        Fraction fraction1 = Fraction.getFraction(3, 4);
+        Fraction fraction2 = Fraction.getFraction(1, 4);
+        assertThat(fraction1.multiplyBy(fraction2).toString()).isEqualTo("3/16");
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/HashCodeBuilderUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class HashCodeBuilderUnitTest {
+
+    @Test
+    public void givenHashCodeBuilderInstance_whenCalledtoHashCode_thenCorrect() {
+        int hashcode = new HashCodeBuilder(17, 37)
+            .append("John")
+            .append("john@domain.com")
+            .toHashCode();
+        assertThat(hashcode).isEqualTo(1269178828);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/ImmutablePairUnitTest.java

@@ -0,0 +1,36 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class ImmutablePairUnitTest {
+    
+    private static ImmutablePair<String, String> immutablePair; 
+    
+    @BeforeClass
+    public static void setUpImmutablePairInstance() {
+        immutablePair = new ImmutablePair<>("leftElement", "rightElement");
+    }
+    
+    @Test
+    public void givenImmutablePairInstance_whenCalledgetLeft_thenCorrect() {
+        assertThat(immutablePair.getLeft()).isEqualTo("leftElement");
+    }
+    
+    @Test
+    public void givenImmutablePairInstance_whenCalledgetRight_thenCorrect() {
+        assertThat(immutablePair.getRight()).isEqualTo("rightElement");
+    }
+    
+    @Test
+    public void givenImmutablePairInstance_whenCalledof_thenCorrect() {
+        assertThat(ImmutablePair.of("leftElement", "rightElement")).isInstanceOf(ImmutablePair.class);
+    }
+    
+    @Test(expected = UnsupportedOperationException.class)
+    public void givenImmutablePairInstance_whenCalledSetValue_thenThrowUnsupportedOperationException() {
+        immutablePair.setValue("newValue");
+    } 
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/ImmutableTripleUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.tuple.ImmutableTriple;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class ImmutableTripleUnitTest {
+ 
+    private static ImmutableTriple<String, String, String> immutableTriple;
+    
+    @BeforeClass
+    public static void setUpImmutableTripleInstance() {
+        immutableTriple = new ImmutableTriple<>("leftElement", "middleElement", "rightElement");
+    }
+    
+    @Test
+    public void givenImmutableTripleInstance_whenCalledgetLeft_thenCorrect() {
+        assertThat(immutableTriple.getLeft()).isEqualTo("leftElement");
+    }
+    
+    @Test
+    public void givenImmutableTripleInstance_whenCalledgetMiddle_thenCorrect() {
+        assertThat(immutableTriple.getMiddle()).isEqualTo("middleElement");
+    }
+    
+    @Test
+    public void givenImmutableInstance_whenCalledgetRight_thenCorrect() {
+        assertThat(immutableTriple.getRight()).isEqualTo("rightElement");
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/LazyInitializerUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.commons.lang3.test;
+
+import com.baeldung.commons.lang3.beans.User;
+import com.baeldung.commons.lang3.beans.UserInitializer;
+import org.apache.commons.lang3.concurrent.ConcurrentException;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class LazyInitializerUnitTest {
+    
+    @Test
+    public void givenLazyInitializerInstance_whenCalledget_thenCorrect() throws ConcurrentException {
+        UserInitializer userInitializer = new UserInitializer();
+        assertThat(userInitializer.get()).isInstanceOf(User.class);
+    } 
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/MethodUtilsUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.commons.lang3.test;
+
+import com.baeldung.commons.lang3.beans.User;
+import java.lang.reflect.Method;
+import org.apache.commons.lang3.reflect.MethodUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class MethodUtilsUnitTest {
+
+    @Test
+    public void givenMethodUtilsClass_whenCalledgetAccessibleMethod_thenCorrect() {
+        assertThat(MethodUtils.getAccessibleMethod(User.class, "getName")).isInstanceOf(Method.class);
+    }   
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/MutableObjectUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.mutable.MutableObject;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class MutableObjectUnitTest {
+    
+    private static MutableObject mutableObject;
+    
+    @BeforeClass
+    public static void setUpMutableObject() {
+        mutableObject = new MutableObject("Initial value");
+    }
+    
+    @Test
+    public void givenMutableObject_whenCalledgetValue_thenCorrect() {
+        assertThat(mutableObject.getValue()).isInstanceOf(String.class);
+    }
+    
+    @Test
+    public void givenMutableObject_whenCalledsetValue_thenCorrect() {
+        mutableObject.setValue("Another value");
+        assertThat(mutableObject.getValue()).isEqualTo("Another value");
+    }
+    
+    @Test
+    public void givenMutableObject_whenCalledtoString_thenCorrect() {
+        assertThat(mutableObject.toString()).isEqualTo("Another value");    
+    }        
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/MutablePairUnitTest.java

@@ -0,0 +1,32 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.tuple.MutablePair;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class MutablePairUnitTest {
+    
+    private static MutablePair<String, String> mutablePair;
+    
+    @BeforeClass
+    public static void setUpMutablePairInstance() {
+        mutablePair = new MutablePair<>("leftElement", "rightElement");
+    }
+    
+    @Test
+    public void givenMutablePairInstance_whenCalledgetLeft_thenCorrect() {
+        assertThat(mutablePair.getLeft()).isEqualTo("leftElement");
+    }
+    
+    @Test
+    public void givenMutablePairInstance_whenCalledgetRight_thenCorrect() {
+        assertThat(mutablePair.getRight()).isEqualTo("rightElement");
+    }
+    
+    @Test
+    public void givenMutablePairInstance_whenCalledsetLeft_thenCorrect() {
+        mutablePair.setLeft("newLeftElement");
+        assertThat(mutablePair.getLeft()).isEqualTo("newLeftElement");
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/NumberUtilsUnitTest.java

@@ -0,0 +1,46 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.math.NumberUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class NumberUtilsUnitTest {
+    
+    @Test
+    public void givenNumberUtilsClass_whenCalledcompareWithIntegers_thenCorrect() {
+        assertThat(NumberUtils.compare(1, 1)).isEqualTo(0);
+    }
+    
+    @Test
+    public void givenNumberUtilsClass_whenCalledcompareWithLongs_thenCorrect() {
+        assertThat(NumberUtils.compare(1L, 1L)).isEqualTo(0);
+    }
+    
+    @Test
+    public void givenNumberUtilsClass_whenCalledcreateNumber_thenCorrect() {
+        assertThat(NumberUtils.createNumber("123456")).isEqualTo(123456);
+    }
+    
+    @Test
+    public void givenNumberUtilsClass_whenCalledisDigits_thenCorrect() {
+        assertThat(NumberUtils.isDigits("123456")).isTrue();
+    }
+    
+    @Test
+    public void givenNumberUtilsClass_whenCallemaxwithIntegerArray_thenCorrect() {
+        int[] array = {1, 2, 3, 4, 5, 6};
+        assertThat(NumberUtils.max(array)).isEqualTo(6);
+    }
+    
+    @Test
+    public void givenNumberUtilsClass_whenCalleminwithIntegerArray_thenCorrect() {
+        int[] array = {1, 2, 3, 4, 5, 6};
+        assertThat(NumberUtils.min(array)).isEqualTo(1);
+    }
+    
+    @Test
+    public void givenNumberUtilsClass_whenCalleminwithByteArray_thenCorrect() {
+        byte[] array = {1, 2, 3, 4, 5, 6};
+        assertThat(NumberUtils.min(array)).isEqualTo((byte) 1);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/StringUtilsUnitTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.StringUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class StringUtilsUnitTest {
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisBlank_thenCorrect() {
+        assertThat(StringUtils.isBlank(" ")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisEmpty_thenCorrect() {
+        assertThat(StringUtils.isEmpty("")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisAllLowerCase_thenCorrect() {
+        assertThat(StringUtils.isAllLowerCase("abd")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisAllUpperCase_thenCorrect() {
+        assertThat(StringUtils.isAllUpperCase("ABC")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisMixedCase_thenCorrect() {
+        assertThat(StringUtils.isMixedCase("abC")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisAlpha_thenCorrect() {
+        assertThat(StringUtils.isAlpha("abc")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledisAlphanumeric_thenCorrect() {
+        assertThat(StringUtils.isAlphanumeric("abc123")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledcontains_thenCorrect() {
+        assertThat(StringUtils.contains("abc", "ab")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledcontainsAny_thenCorrect() {
+        assertThat(StringUtils.containsAny("abc", 'a', 'b', 'c')).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledcontainsIgnoreCase_thenCorrect() {
+        assertThat(StringUtils.containsIgnoreCase("abc", "ABC")).isTrue();
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledswapCase_thenCorrect() {
+        assertThat(StringUtils.swapCase("abc")).isEqualTo("ABC");
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalledreverse_thenCorrect() {
+        assertThat(StringUtils.reverse("abc")).isEqualTo("cba");
+    }
+    
+    @Test
+    public void givenStringUtilsClass_whenCalleddifference_thenCorrect() {
+        assertThat(StringUtils.difference("abc", "abd")).isEqualTo("d");
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/SystemsUtilsManualTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.commons.lang3.test;
+
+import java.io.File;
+import org.apache.commons.lang3.JavaVersion;
+import org.apache.commons.lang3.SystemUtils;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.Test;
+
+public class SystemsUtilsManualTest {
+
+	// the paths depend on the OS and installed version of Java
+	
+    @Test
+    public void givenSystemUtilsClass_whenCalledgetJavaHome_thenCorrect() {
+        assertThat(SystemUtils.getJavaHome()).isEqualTo(new File("/usr/lib/jvm/java-8-oracle/jre"));
+    }
+
+    @Test
+    public void givenSystemUtilsClass_whenCalledgetUserHome_thenCorrect() {
+        assertThat(SystemUtils.getUserHome()).isEqualTo(new File("/home/travis"));
+    }
+
+    @Test
+    public void givenSystemUtilsClass_whenCalledisJavaVersionAtLeast_thenCorrect() {
+        assertThat(SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_RECENT)).isTrue();
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/lang3/test/TripleUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.commons.lang3.test;
+
+import org.apache.commons.lang3.tuple.Triple;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TripleUnitTest {
+    
+    private static Triple<String, String, String> triple;
+    
+    @BeforeClass
+    public static void setUpTripleInstance() {
+        triple = Triple.of("leftElement", "middleElement", "rightElement");
+    }
+    
+    @Test
+    public void givenTripleInstance_whenCalledgetLeft_thenCorrect() {
+        assertThat(triple.getLeft()).isEqualTo("leftElement");
+    }
+    
+    @Test
+    public void givenTripleInstance_whenCalledgetMiddle_thenCorrect() {
+        assertThat(triple.getMiddle()).isEqualTo("middleElement");
+    }
+    
+    @Test
+    public void givenTripleInstance_whenCalledgetRight_thenCorrect() {
+        assertThat(triple.getRight()).isEqualTo("rightElement");
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/ComplexUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.complex.Complex;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class ComplexUnitTest {
+
+    @Test
+    public void whenComplexPow_thenCorrect() {
+        Complex first = new Complex(1.0, 3.0);
+        Complex second = new Complex(2.0, 5.0);
+
+        Complex power = first.pow(second);
+
+        Assert.assertEquals(-0.007563724861696302, power.getReal(), 1e-7);
+        Assert.assertEquals(0.01786136835085382, power.getImaginary(), 1e-7);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/FractionUnitTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.fraction.Fraction;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class FractionUnitTest {
+
+    @Test
+    public void whenFractionAdd_thenCorrect() {
+        Fraction lhs = new Fraction(1, 3);
+        Fraction rhs = new Fraction(2, 5);
+        Fraction sum = lhs.add(rhs);
+
+        Assert.assertEquals(11, sum.getNumerator());
+        Assert.assertEquals(15, sum.getDenominator());
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/GeometryUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.geometry.euclidean.twod.Line;
+import org.apache.commons.math3.geometry.euclidean.twod.Vector2D;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class GeometryUnitTest {
+
+    @Test
+    public void whenLineIntersection_thenCorrect() {
+        Line l1 = new Line(new Vector2D(0, 0), new Vector2D(1, 1), 0);
+        Line l2 = new Line(new Vector2D(0, 1), new Vector2D(1, 1.5), 0);
+
+        Vector2D intersection = l1.intersection(l2);
+
+        Assert.assertEquals(2, intersection.getX(), 1e-7);
+        Assert.assertEquals(2, intersection.getY(), 1e-7);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/LinearAlgebraUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.linear.*;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LinearAlgebraUnitTest {
+
+    @Test
+    public void whenDecompositionSolverSolve_thenCorrect() {
+        RealMatrix a = new Array2DRowRealMatrix(new double[][] { { 2, 3, -2 }, { -1, 7, 6 }, { 4, -3, -5 } }, false);
+        RealVector b = new ArrayRealVector(new double[] { 1, -2, 1 }, false);
+
+        DecompositionSolver solver = new LUDecomposition(a).getSolver();
+
+        RealVector solution = solver.solve(b);
+
+        Assert.assertEquals(-0.3698630137, solution.getEntry(0), 1e-7);
+        Assert.assertEquals(0.1780821918, solution.getEntry(1), 1e-7);
+        Assert.assertEquals(-0.602739726, solution.getEntry(2), 1e-7);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/ProbabilitiesUnitTest.java

@@ -0,0 +1,15 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.distribution.NormalDistribution;
+import org.junit.Test;
+
+public class ProbabilitiesUnitTest {
+
+    @Test
+    public void whenNormalDistributionSample_thenSuccess() {
+        final NormalDistribution normalDistribution = new NormalDistribution(10, 3);
+
+        System.out.println(normalDistribution.sample());
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/RootFindingUnitTest.java

@@ -0,0 +1,20 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.analysis.UnivariateFunction;
+import org.apache.commons.math3.analysis.solvers.BracketingNthOrderBrentSolver;
+import org.apache.commons.math3.analysis.solvers.UnivariateSolver;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class RootFindingUnitTest {
+
+    @Test
+    public void whenUnivariateSolverSolver_thenCorrect() {
+        final UnivariateFunction function = v -> Math.pow(v, 2) - 2;
+        UnivariateSolver solver = new BracketingNthOrderBrentSolver(1.0e-12, 1.0e-8, 5);
+        double c = solver.solve(100, function, -10.0, 10.0, 0);
+
+        Assert.assertEquals(-Math.sqrt(2), c, 1e-7);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/SimpsonIntegratorUnitTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.analysis.UnivariateFunction;
+import org.apache.commons.math3.analysis.integration.SimpsonIntegrator;
+import org.apache.commons.math3.analysis.integration.UnivariateIntegrator;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SimpsonIntegratorUnitTest {
+
+    @Test
+    public void whenUnivariateIntegratorIntegrate_thenCorrect() {
+        final UnivariateFunction function = v -> v;
+        final UnivariateIntegrator integrator = new SimpsonIntegrator(1.0e-12, 1.0e-8, 1, 32);
+
+        final double i = integrator.integrate(100, function, 0, 10);
+
+        Assert.assertEquals(16 + 2d / 3d, i, 1e-7);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/commons/math/StatisticsUnitTest.java

@@ -0,0 +1,38 @@
+package com.baeldung.commons.math;
+
+import org.apache.commons.math3.stat.descriptive.DescriptiveStatistics;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class StatisticsUnitTest {
+
+    private double[] values;
+    private DescriptiveStatistics descriptiveStatistics;
+
+    @Before
+    public void setUp() {
+        values = new double[] { 65, 51, 16, 11, 6519, 191, 0, 98, 19854, 1, 32 };
+
+        descriptiveStatistics = new DescriptiveStatistics();
+        for (double v : values) {
+            descriptiveStatistics.addValue(v);
+        }
+    }
+
+    @Test
+    public void whenDescriptiveStatisticsGetMean_thenCorrect() {
+        Assert.assertEquals(2439.8181818181815, descriptiveStatistics.getMean(), 1e-7);
+    }
+
+    @Test
+    public void whenDescriptiveStatisticsGetMedian_thenCorrect() {
+        Assert.assertEquals(51, descriptiveStatistics.getPercentile(50), 1e-7);
+    }
+
+    @Test
+    public void whenDescriptiveStatisticsGetStandardDeviation_thenCorrect() {
+        Assert.assertEquals(6093.054649651221, descriptiveStatistics.getStandardDeviation(), 1e-7);
+    }
+
+}

libraries-apache-commons/src/test/java/com/baeldung/text/DiffUnitTest.java

@@ -0,0 +1,18 @@
+package com.baeldung.text;
+
+import org.apache.commons.text.diff.EditScript;
+import org.apache.commons.text.diff.StringsComparator;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class DiffUnitTest {
+
+    @Test
+    public void whenEditScript_thenCorrect() {
+        StringsComparator cmp = new StringsComparator("ABCFGH", "BCDEFG");
+        EditScript<Character> script = cmp.getScript();
+        int mod = script.getModifications();
+
+        Assert.assertEquals(4, mod);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/text/LongestCommonSubsequenceUnitTest.java

@@ -0,0 +1,25 @@
+package com.baeldung.text;
+
+import org.apache.commons.text.similarity.LongestCommonSubsequence;
+import org.apache.commons.text.similarity.LongestCommonSubsequenceDistance;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class LongestCommonSubsequenceUnitTest {
+
+    @Test
+    public void whenCompare_thenCorrect() {
+        LongestCommonSubsequence lcs = new LongestCommonSubsequence();
+        int countLcs = lcs.apply("New York", "New Hampshire");
+
+        Assert.assertEquals(5, countLcs);
+    }
+
+    @Test
+    public void whenCalculateDistance_thenCorrect() {
+        LongestCommonSubsequenceDistance lcsd = new LongestCommonSubsequenceDistance();
+        int countLcsd = lcsd.apply("New York", "New Hampshire");
+
+        Assert.assertEquals(11, countLcsd);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/text/StrBuilderUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.text;
+
+import org.apache.commons.text.StrBuilder;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class StrBuilderUnitTest {
+
+    @Test
+    public void whenReplaced_thenCorrect() {
+        StrBuilder strBuilder = new StrBuilder("example StrBuilder!");
+        strBuilder.replaceAll("example", "new");
+
+        Assert.assertEquals(new StrBuilder("new StrBuilder!"), strBuilder);
+    }
+
+    @Test
+    public void whenCleared_thenEmpty() {
+        StrBuilder strBuilder = new StrBuilder("example StrBuilder!");
+        strBuilder.clear();
+
+        Assert.assertEquals(new StrBuilder(""), strBuilder);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/text/StrSubstitutorUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.text;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.text.StrSubstitutor;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class StrSubstitutorUnitTest {
+
+    @Test
+    public void whenSubstituted_thenCorrect() {
+        Map<String, String> substitutes = new HashMap<>();
+        substitutes.put("name", "John");
+        substitutes.put("college", "University of Stanford");
+        String templateString = "My name is ${name} and I am a student at the ${college}.";
+        StrSubstitutor sub = new StrSubstitutor(substitutes);
+        String result = sub.replace(templateString);
+
+        Assert.assertEquals("My name is John and I am a student at the University of Stanford.", result);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/text/UnicodeEscaperUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.text;
+
+import org.apache.commons.text.translate.UnicodeEscaper;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class UnicodeEscaperUnitTest {
+
+    @Test
+    public void whenTranslate_thenCorrect() {
+        UnicodeEscaper ue = UnicodeEscaper.above(0);
+        String result = ue.translate("ABCD");
+
+        Assert.assertEquals("\\u0041\\u0042\\u0043\\u0044", result);
+    }
+}

libraries-apache-commons/src/test/java/com/baeldung/text/WordUtilsUnitTest.java

@@ -0,0 +1,23 @@
+package com.baeldung.text;
+
+import org.apache.commons.text.WordUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class WordUtilsUnitTest {
+
+    @Test
+    public void whenCapitalized_thenCorrect() {
+        String toBeCapitalized = "to be capitalized!";
+        String result = WordUtils.capitalize(toBeCapitalized);
+
+        Assert.assertEquals("To Be Capitalized!", result);
+    }
+
+    @Test
+    public void whenContainsWords_thenCorrect() {
+        boolean containsWords = WordUtils.containsAllWords("String to search", "to", "search");
+
+        Assert.assertTrue(containsWords);
+    }
+}

libraries-apache-commons/src/test/resources/employees.sql

@@ -0,0 +1,43 @@
+CREATE TABLE employee(
+    id int NOT NULL PRIMARY KEY auto_increment,
+    firstname varchar(255),
+    lastname varchar(255),
+    salary double,
+    hireddate date
+);
+
+CREATE TABLE email(
+    id int NOT NULL PRIMARY KEY auto_increment,
+    employeeid int,
+    address varchar(255)
+);
+
+CREATE TABLE employee_legacy(
+    id int NOT NULL PRIMARY KEY auto_increment,
+    first_name varchar(255),
+    last_name varchar(255),
+    salary double,
+    hired_date date
+);
+
+
+INSERT INTO employee (firstname,lastname,salary,hireddate) VALUES ('John', 'Doe', 10000.10, to_date('01-01-2001','dd-mm-yyyy'));
+INSERT INTO employee (firstname,lastname,salary,hireddate) VALUES ('Kevin', 'Smith', 20000.20, to_date('02-02-2002','dd-mm-yyyy'));
+INSERT INTO employee (firstname,lastname,salary,hireddate) VALUES ('Kim', 'Smith', 30000.30, to_date('03-03-2003','dd-mm-yyyy'));
+INSERT INTO employee (firstname,lastname,salary,hireddate) VALUES ('Stephen', 'Torvalds', 40000.40, to_date('04-04-2004','dd-mm-yyyy'));
+INSERT INTO employee (firstname,lastname,salary,hireddate) VALUES ('Christian', 'Reynolds', 50000.50, to_date('05-05-2005','dd-mm-yyyy'));
+
+INSERT INTO employee_legacy (first_name,last_name,salary,hired_date) VALUES ('John', 'Doe', 10000.10, to_date('01-01-2001','dd-mm-yyyy'));
+INSERT INTO employee_legacy (first_name,last_name,salary,hired_date) VALUES ('Kevin', 'Smith', 20000.20, to_date('02-02-2002','dd-mm-yyyy'));
+INSERT INTO employee_legacy (first_name,last_name,salary,hired_date) VALUES ('Kim', 'Smith', 30000.30, to_date('03-03-2003','dd-mm-yyyy'));
+INSERT INTO employee_legacy (first_name,last_name,salary,hired_date) VALUES ('Stephen', 'Torvalds', 40000.40, to_date('04-04-2004','dd-mm-yyyy'));
+INSERT INTO employee_legacy (first_name,last_name,salary,hired_date) VALUES ('Christian', 'Reynolds', 50000.50, to_date('05-05-2005','dd-mm-yyyy'));
+
+INSERT INTO email (employeeid,address) VALUES (1, 'john@baeldung.com');
+INSERT INTO email (employeeid,address) VALUES (1, 'john@gmail.com');
+INSERT INTO email (employeeid,address) VALUES (2, 'kevin@baeldung.com');
+INSERT INTO email (employeeid,address) VALUES (3, 'kim@baeldung.com');
+INSERT INTO email (employeeid,address) VALUES (3, 'kim@gmail.com');
+INSERT INTO email (employeeid,address) VALUES (3, 'kim@outlook.com');
+INSERT INTO email (employeeid,address) VALUES (4, 'stephen@baeldung.com');
+INSERT INTO email (employeeid,address) VALUES (5, 'christian@gmail.com');