Merge branch 'master' of https://github.com/JonCook/tutorials

libraries-apache-commons/README.md

@@ -0,0 +1,15 @@
+## Apache Commons
+
+This module contains articles about Apache Commons libraries.
+
+### Relevant articles
+
+- [Array Processing with Apache Commons Lang 3](https://www.baeldung.com/array-processing-commons-lang)
+- [String Processing with Apache Commons Lang 3](https://www.baeldung.com/string-processing-commons-lang)
+- [Introduction to Apache Commons Math](https://www.baeldung.com/apache-commons-math)
+- [Introduction to Apache Commons Text](https://www.baeldung.com/java-apache-commons-text)
+- [A Guide to Apache Commons DbUtils](https://www.baeldung.com/apache-commons-dbutils)
+- [Apache Commons Chain](https://www.baeldung.com/apache-commons-chain)
+- [Apache Commons BeanUtils](https://www.baeldung.com/apache-commons-beanutils)
+- [Histograms with Apache Commons Frequency](https://www.baeldung.com/apache-commons-frequency)
+- [An Introduction to Apache Commons Lang 3](https://www.baeldung.com/java-commons-lang-3)

libraries-apache-commons/log4j.properties

@@ -0,0 +1 @@
+log4j.rootLogger=INFO, stdout

libraries-apache-commons/pom.xml

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>libraries-apache-commons</artifactId>
+    <name>libraries-apache-commons</name>
+
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-beanutils</groupId>
+            <artifactId>commons-beanutils</artifactId>
+            <version>${commons-beanutils.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-text</artifactId>
+            <version>${commons-text.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-chain</groupId>
+            <artifactId>commons-chain</artifactId>
+            <version>${commons-chain.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-dbutils</groupId>
+            <artifactId>commons-dbutils</artifactId>
+            <version>${commons.dbutils.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${common-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-net</groupId>
+            <artifactId>commons-net</artifactId>
+            <version>${commons-net.version}</version>
+        </dependency>
+		<dependency>
+            <groupId>com.h2database</groupId>
+            <artifactId>h2</artifactId>
+            <version>${h2.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.knowm.xchart</groupId>
+            <artifactId>xchart</artifactId>
+            <version>${xchart-version}</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <commons-lang3.version>3.6</commons-lang3.version>
+        <commons-text.version>1.1</commons-text.version>
+        <commons-beanutils.version>1.9.3</commons-beanutils.version>
+        <commons-chain.version>1.2</commons-chain.version>
+        <assertj.version>3.6.2</assertj.version>
+        <commons.dbutils.version>1.6</commons.dbutils.version>
+        <commons-codec-version>1.10.L001</commons-codec-version>
+        <xchart-version>3.5.2</xchart-version>
+        <commons-net.version>3.6</commons-net.version>
+        <common-math3.version>3.6.1</common-math3.version>
+    </properties>
+
+</project>

libraries-apache-commons/src/main/java/com/baeldung/commons/beanutils/Course.java

@@ -0,0 +1,35 @@
+package com.baeldung.commons.beanutils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Course {
+    private String name;
+    private List<String> codes;
+    private Map<String, Student> enrolledStudent = new HashMap<String, Student>();
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<String> getCodes() {
+        return codes;
+    }
+
+    public void setCodes(List<String> codes) {
+        this.codes = codes;
+    }
+
+    public void setEnrolledStudent(String enrolledId, Student student) {
+        enrolledStudent.put(enrolledId, student);
+    }
+
+    public Student getEnrolledStudent(String enrolledId) {
+        return enrolledStudent.get(enrolledId);
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/beanutils/CourseEntity.java

@@ -0,0 +1,35 @@
+package com.baeldung.commons.beanutils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class CourseEntity {
+    private String name;
+    private List<String> codes;
+    private Map<String, Student> students = new HashMap<String, Student>();
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public List<String> getCodes() {
+        return codes;
+    }
+
+    public void setCodes(List<String> codes) {
+        this.codes = codes;
+    }
+
+    public void setStudent(String id, Student student) {
+        students.put(id, student);
+    }
+
+    public Student getStudent(String enrolledId) {
+        return students.get(enrolledId);
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/beanutils/CourseService.java

@@ -0,0 +1,34 @@
+package com.baeldung.commons.beanutils;
+
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+import org.apache.commons.beanutils.BeanUtils;
+import org.apache.commons.beanutils.PropertyUtils;
+
+public class CourseService {
+
+    public static void setValues(Course course, String name, List<String> codes) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        // Setting the simple properties
+        PropertyUtils.setSimpleProperty(course, "name", name);
+        PropertyUtils.setSimpleProperty(course, "codes", codes);
+    }
+
+    public static void setIndexedValue(Course course, int codeIndex, String code) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        // Setting the indexed properties
+        PropertyUtils.setIndexedProperty(course, "codes[" + codeIndex + "]", code);
+    }
+
+    public static void setMappedValue(Course course, String enrollId, Student student) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        // Setting the mapped properties
+        PropertyUtils.setMappedProperty(course, "enrolledStudent(" + enrollId + ")", student);
+    }
+
+    public static String getNestedValue(Course course, String enrollId, String nestedPropertyName) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
+        return (String) PropertyUtils.getNestedProperty(course, "enrolledStudent(" + enrollId + ")." + nestedPropertyName);
+    }
+
+    public static void copyProperties(Course course, CourseEntity courseEntity) throws IllegalAccessException, InvocationTargetException {
+        BeanUtils.copyProperties(courseEntity, course);
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/beanutils/Student.java

@@ -0,0 +1,13 @@
+package com.baeldung.commons.beanutils;
+
+public class Student {
+    private String name;
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/AbstractDenominationDispenser.java

@@ -0,0 +1,23 @@
+package com.baeldung.commons.chain;
+
+import org.apache.commons.chain.Command;
+import org.apache.commons.chain.Context;
+
+import static com.baeldung.commons.chain.AtmConstants.AMOUNT_LEFT_TO_BE_WITHDRAWN;
+
+public abstract class AbstractDenominationDispenser implements Command {
+
+    @Override
+    public boolean execute(Context context) throws Exception {
+        int amountLeftToBeWithdrawn = (int) context.get(AMOUNT_LEFT_TO_BE_WITHDRAWN);
+        if (amountLeftToBeWithdrawn >= getDenominationValue()) {
+            context.put(getDenominationString(), amountLeftToBeWithdrawn / getDenominationValue());
+            context.put(AMOUNT_LEFT_TO_BE_WITHDRAWN, amountLeftToBeWithdrawn % getDenominationValue());
+        }
+        return false;
+    }
+
+    protected abstract String getDenominationString();
+
+    protected abstract int getDenominationValue();
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/AtmCatalog.java

@@ -0,0 +1,13 @@
+package com.baeldung.commons.chain;
+
+import org.apache.commons.chain.impl.CatalogBase;
+
+import static com.baeldung.commons.chain.AtmConstants.ATM_WITHDRAWAL_CHAIN;
+
+public class AtmCatalog extends CatalogBase {
+
+    public AtmCatalog() {
+        super();
+        addCommand(ATM_WITHDRAWAL_CHAIN, new AtmWithdrawalChain());
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/AtmConstants.java

@@ -0,0 +1,10 @@
+package com.baeldung.commons.chain;
+
+public class AtmConstants {
+    public static final String TOTAL_AMOUNT_TO_BE_WITHDRAWN = "totalAmountToBeWithdrawn";
+    public static final String AMOUNT_LEFT_TO_BE_WITHDRAWN = "amountLeftToBeWithdrawn";
+    public static final String NO_OF_HUNDREDS_DISPENSED = "noOfHundredsDispensed";
+    public static final String NO_OF_FIFTIES_DISPENSED = "noOfFiftiesDispensed";
+    public static final String NO_OF_TENS_DISPENSED = "noOfTensDispensed";
+    public static final String ATM_WITHDRAWAL_CHAIN = "atmWithdrawalChain";
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/AtmRequestContext.java

@@ -0,0 +1,52 @@
+package com.baeldung.commons.chain;
+
+import org.apache.commons.chain.impl.ContextBase;
+
+public class AtmRequestContext extends ContextBase {
+
+    int totalAmountToBeWithdrawn;
+    int noOfHundredsDispensed;
+    int noOfFiftiesDispensed;
+    int noOfTensDispensed;
+    int amountLeftToBeWithdrawn;
+
+    public int getTotalAmountToBeWithdrawn() {
+        return totalAmountToBeWithdrawn;
+    }
+
+    public void setTotalAmountToBeWithdrawn(int totalAmountToBeWithdrawn) {
+        this.totalAmountToBeWithdrawn = totalAmountToBeWithdrawn;
+    }
+
+    public int getNoOfHundredsDispensed() {
+        return noOfHundredsDispensed;
+    }
+
+    public void setNoOfHundredsDispensed(int noOfHundredsDispensed) {
+        this.noOfHundredsDispensed = noOfHundredsDispensed;
+    }
+
+    public int getNoOfFiftiesDispensed() {
+        return noOfFiftiesDispensed;
+    }
+
+    public void setNoOfFiftiesDispensed(int noOfFiftiesDispensed) {
+        this.noOfFiftiesDispensed = noOfFiftiesDispensed;
+    }
+
+    public int getNoOfTensDispensed() {
+        return noOfTensDispensed;
+    }
+
+    public void setNoOfTensDispensed(int noOfTensDispensed) {
+        this.noOfTensDispensed = noOfTensDispensed;
+    }
+
+    public int getAmountLeftToBeWithdrawn() {
+        return amountLeftToBeWithdrawn;
+    }
+
+    public void setAmountLeftToBeWithdrawn(int amountLeftToBeWithdrawn) {
+        this.amountLeftToBeWithdrawn = amountLeftToBeWithdrawn;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/AtmWithdrawalChain.java

@@ -0,0 +1,14 @@
+package com.baeldung.commons.chain;
+
+import org.apache.commons.chain.impl.ChainBase;
+
+public class AtmWithdrawalChain extends ChainBase {
+
+    public AtmWithdrawalChain() {
+        super();
+        addCommand(new HundredDenominationDispenser());
+        addCommand(new FiftyDenominationDispenser());
+        addCommand(new TenDenominationDispenser());
+        addCommand(new AuditFilter());
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/AuditFilter.java

@@ -0,0 +1,18 @@
+package com.baeldung.commons.chain;
+
+import org.apache.commons.chain.Context;
+import org.apache.commons.chain.Filter;
+
+public class AuditFilter implements Filter {
+
+    @Override
+    public boolean postprocess(Context context, Exception exception) {
+        // Send notification to customer & bank.
+        return false;
+    }
+
+    @Override
+    public boolean execute(Context context) throws Exception {
+        return false;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/FiftyDenominationDispenser.java

@@ -0,0 +1,15 @@
+package com.baeldung.commons.chain;
+
+import static com.baeldung.commons.chain.AtmConstants.NO_OF_FIFTIES_DISPENSED;
+
+public class FiftyDenominationDispenser extends AbstractDenominationDispenser {
+    @Override
+    protected String getDenominationString() {
+        return NO_OF_FIFTIES_DISPENSED;
+    }
+
+    @Override
+    protected int getDenominationValue() {
+        return 50;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/HundredDenominationDispenser.java

@@ -0,0 +1,15 @@
+package com.baeldung.commons.chain;
+
+import static com.baeldung.commons.chain.AtmConstants.NO_OF_HUNDREDS_DISPENSED;
+
+public class HundredDenominationDispenser extends AbstractDenominationDispenser {
+    @Override
+    protected String getDenominationString() {
+        return NO_OF_HUNDREDS_DISPENSED;
+    }
+
+    @Override
+    protected int getDenominationValue() {
+        return 100;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/chain/TenDenominationDispenser.java

@@ -0,0 +1,15 @@
+package com.baeldung.commons.chain;
+
+import static com.baeldung.commons.chain.AtmConstants.NO_OF_TENS_DISPENSED;
+
+public class TenDenominationDispenser extends AbstractDenominationDispenser {
+    @Override
+    protected String getDenominationString() {
+        return NO_OF_TENS_DISPENSED;
+    }
+
+    @Override
+    protected int getDenominationValue() {
+        return 10;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/dbutils/Email.java

@@ -0,0 +1,37 @@
+package com.baeldung.commons.dbutils;
+
+public class Email {
+    private Integer id;
+    private Integer employeeId;
+    private String address;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Integer getEmployeeId() {
+        return employeeId;
+    }
+
+    public void setEmployeeId(Integer employeeId) {
+        this.employeeId = employeeId;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    @Override
+    public String toString() {
+        return "Email{" + "id=" + id + ", address=" + address + '}';
+    }
+
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/dbutils/Employee.java

@@ -0,0 +1,67 @@
+package com.baeldung.commons.dbutils;
+
+import java.util.Date;
+import java.util.List;
+
+public class Employee {
+    private Integer id;
+    private String firstName;
+    private String lastName;
+    private Double salary;
+    private Date hiredDate;
+    private List<Email> emails;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getFirstName() {
+        return firstName;
+    }
+
+    public void setFirstName(String firstName) {
+        this.firstName = firstName;
+    }
+
+    public String getLastName() {
+        return lastName;
+    }
+
+    public void setLastName(String lastName) {
+        this.lastName = lastName;
+    }
+
+    public Double getSalary() {
+        return salary;
+    }
+
+    public void setSalary(Double salary) {
+        this.salary = salary;
+    }
+
+    public Date getHiredDate() {
+        return hiredDate;
+    }
+
+    public void setHiredDate(Date hiredDate) {
+        this.hiredDate = hiredDate;
+    }
+
+    public List<Email> getEmails() {
+        return emails;
+    }
+
+    public void setEmails(List<Email> emails) {
+        this.emails = emails;
+    }
+
+    @Override
+    public String toString() {
+        return "Employee{" + "id=" + id + ", firstName=" + firstName + ", lastName=" + lastName + ", salary=" + salary + ", hiredDate=" + hiredDate + '}';
+    }
+
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/dbutils/EmployeeHandler.java

@@ -0,0 +1,45 @@
+package com.baeldung.commons.dbutils;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import org.apache.commons.dbutils.BasicRowProcessor;
+import org.apache.commons.dbutils.BeanProcessor;
+
+import org.apache.commons.dbutils.QueryRunner;
+import org.apache.commons.dbutils.handlers.BeanListHandler;
+
+public class EmployeeHandler extends BeanListHandler<Employee> {
+
+    private Connection connection;
+
+    public EmployeeHandler(Connection con) {
+        super(Employee.class, new BasicRowProcessor(new BeanProcessor(getColumnsToFieldsMap())));
+        this.connection = con;
+    }
+
+    @Override
+    public List<Employee> handle(ResultSet rs) throws SQLException {
+        List<Employee> employees = super.handle(rs);
+
+        QueryRunner runner = new QueryRunner();
+        BeanListHandler<Email> handler = new BeanListHandler<>(Email.class);
+        String query = "SELECT * FROM email WHERE employeeid = ?";
+        for (Employee employee : employees) {
+            List<Email> emails = runner.query(connection, query, handler, employee.getId());
+            employee.setEmails(emails);
+        }
+        return employees;
+    }
+
+    public static Map<String, String> getColumnsToFieldsMap() {
+        Map<String, String> columnsToFieldsMap = new HashMap<>();
+        columnsToFieldsMap.put("FIRST_NAME", "firstName");
+        columnsToFieldsMap.put("LAST_NAME", "lastName");
+        columnsToFieldsMap.put("HIRED_DATE", "hiredDate");
+        return columnsToFieldsMap;
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/lang3/BuilderMethods.java

@@ -0,0 +1,87 @@
+package com.baeldung.commons.lang3;
+
+import org.apache.commons.lang3.builder.EqualsBuilder;
+import org.apache.commons.lang3.builder.HashCodeBuilder;
+import org.apache.commons.lang3.builder.ToStringBuilder;
+import org.apache.commons.lang3.concurrent.ConcurrentException;
+import org.apache.commons.lang3.concurrent.BackgroundInitializer;
+
+public class BuilderMethods {
+
+    private final int intValue;
+    private final String strSample;
+
+    public BuilderMethods(final int newId, final String newName) {
+        this.intValue = newId;
+        this.strSample = newName;
+    }
+
+    public int getId() {
+        return this.intValue;
+    }
+
+    public String getName() {
+        return this.strSample;
+    }
+
+    @Override
+    public int hashCode() {
+        return new HashCodeBuilder().append(this.intValue).append(this.strSample).toHashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof BuilderMethods == false) {
+            return false;
+        }
+        if (this == obj) {
+            return true;
+        }
+        final BuilderMethods otherObject = (BuilderMethods) obj;
+
+        return new EqualsBuilder().append(this.intValue, otherObject.intValue).append(this.strSample, otherObject.strSample).isEquals();
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this).append("INTVALUE", this.intValue).append("STRINGVALUE", this.strSample).toString();
+    }
+
+    public static void main(final String[] arguments) {
+        final BuilderMethods simple1 = new BuilderMethods(1, "The First One");
+        System.out.println(simple1.getName());
+        System.out.println(simple1.hashCode());
+        System.out.println(simple1.toString());
+
+        SampleLazyInitializer sampleLazyInitializer = new SampleLazyInitializer();
+
+        try {
+            sampleLazyInitializer.get();
+        } catch (ConcurrentException e1) {
+            // TODO Auto-generated catch block
+            e1.printStackTrace();
+        }
+
+        SampleBackgroundInitializer sampleBackgroundInitializer = new SampleBackgroundInitializer();
+        sampleBackgroundInitializer.start();
+
+        // Proceed with other tasks instead of waiting for the SampleBackgroundInitializer task to finish.
+
+        try {
+            Object result = sampleBackgroundInitializer.get();
+        } catch (ConcurrentException e) {
+            e.printStackTrace();
+        }
+    }
+}
+
+class SampleBackgroundInitializer extends BackgroundInitializer<String> {
+
+    @Override
+    protected String initialize() throws Exception {
+        return null;
+    }
+
+    // Any complex task that takes some time
+
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/lang3/SampleLazyInitializer.java

@@ -0,0 +1,11 @@
+package com.baeldung.commons.lang3;
+
+import org.apache.commons.lang3.concurrent.LazyInitializer;
+
+public class SampleLazyInitializer extends LazyInitializer<SampleObject> {
+
+    @Override
+    protected SampleObject initialize() {
+        return new SampleObject();
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/lang3/SampleObject.java

@@ -0,0 +1,7 @@
+package com.baeldung.commons.lang3;
+
+public class SampleObject {
+
+    // Ignored
+
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/lang3/application/Application.java

@@ -0,0 +1,8 @@
+package com.baeldung.commons.lang3.application;
+
+public class Application {
+    
+    public static void main(String[] args) {
+        
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/lang3/beans/User.java

@@ -0,0 +1,25 @@
+package com.baeldung.commons.lang3.beans;
+
+public class User {
+
+    private final String name;
+    private final String email;
+
+    public User(String name, String email) {
+        this.name = name;
+        this.email = email;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+
+    @Override
+    public String toString() {
+        return "User{" + "name=" + name + ", email=" + email + '}';
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/lang3/beans/UserInitializer.java

@@ -0,0 +1,11 @@
+package com.baeldung.commons.lang3.beans;
+
+import org.apache.commons.lang3.concurrent.LazyInitializer;
+
+public class UserInitializer extends LazyInitializer<User> {
+
+    @Override
+    protected User initialize() {
+        return new User("John", "john@domain.com");
+    }
+}

libraries-apache-commons/src/main/java/com/baeldung/commons/math3/Histogram.java

@@ -0,0 +1,97 @@
+package com.baeldung.commons.math3;
+
+import org.apache.commons.math3.stat.Frequency;
+import org.knowm.xchart.CategoryChart;
+import org.knowm.xchart.CategoryChartBuilder;
+import org.knowm.xchart.SwingWrapper;
+import org.knowm.xchart.style.Styler;
+
+import java.util.*;
+
+public class Histogram {
+
+    private Map distributionMap;
+    private int classWidth;
+
+    public Histogram() {
+
+        distributionMap = new TreeMap();
+        classWidth = 10;
+        Map distributionMap = processRawData();
+        List yData = new ArrayList();
+        yData.addAll(distributionMap.values());
+        List xData = Arrays.asList(distributionMap.keySet().toArray());
+
+        CategoryChart chart = buildChart(xData, yData);
+        new SwingWrapper<>(chart).displayChart();
+
+    }
+
+    private CategoryChart buildChart(List xData, List yData) {
+
+        // Create Chart
+        CategoryChart chart = new CategoryChartBuilder().width(800).height(600)
+                .title("Age Distribution")
+                .xAxisTitle("Age Group")
+                .yAxisTitle("Frequency")
+                .build();
+
+        chart.getStyler().setLegendPosition(Styler.LegendPosition.InsideNW);
+        chart.getStyler().setAvailableSpaceFill(0.99);
+        chart.getStyler().setOverlapped(true);
+
+        chart.addSeries("age group", xData, yData);
+
+        return chart;
+    }
+
+    private Map processRawData() {
+
+        List<Integer> datasetList = Arrays.asList(
+          36, 25, 38, 46, 55, 68, 72,
+          55, 36, 38, 67, 45, 22, 48,
+          91, 46, 52, 61, 58, 55);
+        Frequency frequency = new Frequency();
+        datasetList.forEach(d -> frequency.addValue(Double.parseDouble(d.toString())));
+
+        datasetList.stream()
+          .map(d -> Double.parseDouble(d.toString()))
+          .distinct()
+          .forEach(observation -> {
+             long observationFrequency = frequency.getCount(observation);
+             int upperBoundary = (observation > classWidth)
+               ? Math.multiplyExact( (int) Math.ceil(observation / classWidth), classWidth)
+               : classWidth;
+             int lowerBoundary = (upperBoundary > classWidth)
+               ? Math.subtractExact(upperBoundary, classWidth)
+               : 0;
+             String bin = lowerBoundary + "-" + upperBoundary;
+
+             updateDistributionMap(lowerBoundary, bin, observationFrequency);
+
+          });
+
+        return distributionMap;
+    }
+
+    private void updateDistributionMap(int lowerBoundary, String bin, long observationFrequency) {
+
+        int prevLowerBoundary = (lowerBoundary > classWidth) ? lowerBoundary - classWidth : 0;
+        String prevBin = prevLowerBoundary + "-" + lowerBoundary;
+        if(!distributionMap.containsKey(prevBin))
+            distributionMap.put(prevBin, 0);
+
+        if(!distributionMap.containsKey(bin)) {
+            distributionMap.put(bin, observationFrequency);
+        }
+        else {
+            long oldFrequency = Long.parseLong(distributionMap.get(bin).toString());
+            distributionMap.replace(bin, oldFrequency + observationFrequency);
+        }
+    }
+
+    public static void main(String[] args) {
+        new Histogram();
+    }
+
+}

libraries-apache-commons/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

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');