Merge pull request #1 from eugenp/master

updating

apache-cxf-modules/README.md

@@ -4,6 +4,4 @@ This module contains articles about Apache CXF
 
 ## Relevant Articles:
 
-- [Apache CXF Support for RESTful Web Services](https://www.baeldung.com/apache-cxf-rest-api)
-- [A Guide to Apache CXF with Spring](https://www.baeldung.com/apache-cxf-with-spring)
-- [Introduction to Apache CXF](https://www.baeldung.com/introduction-to-apache-cxf)
+- [Introduction to Apache CXF Aegis Data Binding](https://www.baeldung.com/aegis-data-binding-in-apache-cxf)

apache-cxf-modules/cxf-introduction/README.md

@@ -1,2 +1,2 @@
 ### Relevant Articles:
-- [Introduction to Apache CXF](http://www.baeldung.com/introduction-to-apache-cxf)
+- [Introduction to Apache CXF](https://www.baeldung.com/introduction-to-apache-cxf)

axon/pom.xml

@@ -19,7 +19,7 @@
             <dependency>
                 <groupId>org.axonframework</groupId>
                 <artifactId>axon-bom</artifactId>
-                <version>${axon.version}</version>
+                <version>${axon-bom.version}</version>
                 <type>pom</type>
                 <scope>import</scope>
             </dependency>
@@ -57,7 +57,7 @@
     </dependencies>
 
     <properties>
-        <axon.version>4.5.0</axon.version>
+        <axon-bom.version>4.5.13</axon-bom.version>
     </properties>
 
 </project>

cas/cas-secured-app/pom.xml

@@ -10,10 +10,9 @@
     <description>Demo project for CAS</description>
 
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-boot-2</artifactId>
+        <groupId>com.baeldung.cas</groupId>
+        <artifactId>cas</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../../parent-boot-2</relativePath>
     </parent>
 
     <dependencies>

cas/cas-secured-app/src/main/java/com/baeldung/cassecuredapp/CasSecuredApplication.java

@@ -88,7 +88,6 @@ public class CasSecuredApplication {
     @Bean
     public SingleSignOutFilter singleSignOutFilter() {
         SingleSignOutFilter singleSignOutFilter = new SingleSignOutFilter();
-        singleSignOutFilter.setCasServerUrlPrefix("https://localhost:8443");
         singleSignOutFilter.setLogoutCallbackPath("/exit/cas");
         singleSignOutFilter.setIgnoreInitConfiguration(true);
         return singleSignOutFilter;

cas/pom.xml

@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    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>
+    <groupId>com.baeldung.cas</groupId>
+    <artifactId>cas</artifactId>
+    <name>cas</name>
+    <packaging>pom</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-boot-2</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../parent-boot-2</relativePath>
+    </parent>
+
+    <modules>
+        <module>cas-secured-app</module>
+    </modules>
+
+</project>

core-java-modules/core-java-11-2/README.md

@@ -13,3 +13,4 @@ This module contains articles about Java 11 core features
 - [Call Methods at Runtime Using Java Reflection](https://www.baeldung.com/java-method-reflection)
 - [Java HttpClient Basic Authentication](https://www.baeldung.com/java-httpclient-basic-auth)
 - [Java HttpClient With SSL](https://www.baeldung.com/java-httpclient-ssl)
+- [Adding Parameters to Java HttpClient Requests](https://www.baeldung.com/java-httpclient-request-parameters)

core-java-modules/core-java-11-2/src/test/java/com/baeldung/httpclient/parameters/HttpClientParametersLiveTest.java

@@ -0,0 +1,45 @@
+package com.baeldung.httpclient.parameters;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class HttpClientParametersLiveTest {
+
+    private static HttpClient client;
+
+    @BeforeAll
+    public static void setUp() {
+        client = HttpClient.newHttpClient();
+    }
+
+    @Test
+    public void givenQueryParams_whenGetRequest_thenResponseOk() throws IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+          .version(HttpClient.Version.HTTP_2)
+          .uri(URI.create("https://postman-echo.com/get?param1=value1&param2=value2"))
+          .GET()
+          .build();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertEquals(response.statusCode(), 200);
+    }
+
+    @Test
+    public void givenQueryParams_whenGetRequestWithDefaultConfiguration_thenResponseOk() throws IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+          .uri(URI.create("https://postman-echo.com/get?param1=value1&param2=value2"))
+          .build();
+        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+
+        assertEquals(response.statusCode(), 200);
+    }
+
+}

core-java-modules/core-java-11-2/src/test/java/com/baeldung/httpclient/ssl/HttpClientSSLBypassUnitTest.java

@@ -21,7 +21,7 @@ public class HttpClientSSLBypassUnitTest {
           .build();
 
         HttpRequest request = HttpRequest.newBuilder()
-          .uri(URI.create("https://www.testingmcafeesites.com/"))
+          .uri(URI.create("https://wrong.host.badssl.com/"))
           .build();
 
         HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/finalizers/CleaningDemo.java

@@ -0,0 +1,17 @@
+package com.bealdung.java9.finalizers;
+
+import java.lang.ref.Cleaner;
+
+class CleaningDemo {
+
+    public static void main(String[] args) {
+        final Cleaner cleaner = Cleaner.create();
+        try (Order order = new Order(cleaner)) {
+            for (int i = 0; i < 10; i++) {
+                order.register(new Product(i), i);
+            }
+        } catch (Exception e) {
+            System.err.println("Error: " + e);
+        }
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/finalizers/Order.java

@@ -0,0 +1,36 @@
+package com.bealdung.java9.finalizers;
+
+import java.lang.ref.Cleaner;
+
+class Order implements AutoCloseable {
+
+    private final Cleaner cleaner;
+    private Cleaner.Cleanable cleanable;
+
+    public Order(Cleaner cleaner) {
+        this.cleaner = cleaner;
+    }
+
+    public void register(Product product, int id) {
+        this.cleanable = cleaner.register(product, new CleaningAction(id));
+    }
+
+    public void close() {
+        cleanable.clean();
+        System.out.println("Cleanable closed");
+    }
+
+    static class CleaningAction implements Runnable {
+
+        private final int id;
+
+        public CleaningAction(int id) {
+            this.id = id;
+        }
+
+        @Override
+        public void run() {
+            System.out.printf("Object with id %s is garbage collected. %n", id);
+        }
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/finalizers/Product.java

@@ -0,0 +1,13 @@
+package com.bealdung.java9.finalizers;
+
+class Product {
+    private final int id;
+
+    public Product(int id) {
+        this.id = id;
+    }
+
+    public int getId() {
+        return id;
+    }
+}

core-java-modules/core-java-9/src/main/java/com/baeldung/java9/finalizers/Resource.java

@@ -0,0 +1,25 @@
+package com.bealdung.java9.finalizers;
+
+import java.io.BufferedReader;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+
+class Resource implements AutoCloseable {
+
+    final BufferedReader reader;
+
+    public Resource(String filename) throws FileNotFoundException {
+        reader = new BufferedReader(new FileReader(filename));
+    }
+
+    public long getLineNumber() {
+        return reader.lines()
+            .count();
+    }
+
+    @Override
+    public void close() throws Exception {
+        reader.close();
+        System.out.println("BufferedReader resource closed");
+    }
+}

core-java-modules/core-java-9/src/test/java/com/baeldung/java9/finalizers/FinalizeUnitTest.java

@@ -0,0 +1,30 @@
+package com.bealdung.java9.finalizers;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class FinalizeUnitTest {
+
+    @Test
+    void givenFilename_whenGetLineNumber_thenReturnCorrectNumber() throws IOException {
+        final File tmpFile = File.createTempFile("test", ".tmp");
+        final BufferedWriter writer = new BufferedWriter(new FileWriter(tmpFile));
+        writer.write("Baeldung");
+        writer.close();
+
+        long lineNumber = 0;
+        try (Resource resource = new Resource(tmpFile.getAbsolutePath())) {
+            lineNumber = resource.getLineNumber();
+        } catch (Exception e) {
+            System.err.println("Error " + e);
+        }
+
+        assertEquals(1, lineNumber);
+    }
+}

core-java-modules/core-java-collections-4/src/main/java/com/baeldung/maps/initialize/EmptyMapInitializer.java

@@ -32,7 +32,7 @@ public class EmptyMapInitializer {
     return emptyMap;
   }
 
-  public Map createGenericEmptyMapUsingMapsObject() {
+  public Map createGenericEmptyMapUsingGuavaMapsObject() {
     Map genericEmptyMap = Maps.<String, Integer>newHashMap();
     return genericEmptyMap;
   }
@@ -43,6 +43,11 @@ public class EmptyMapInitializer {
     return emptyMapUsingGuava;
   }
 
+  public static Map<String, String> createImmutableMapUsingGuava() {
+	    Map<String, String> emptyImmutableMapUsingGuava = ImmutableMap.of();
+	    return emptyImmutableMapUsingGuava;
+  }
+  
   public SortedMap<String, String> createEmptySortedMap() {
     SortedMap<String, String> sortedMap = Collections.emptySortedMap();
     return sortedMap;

core-java-modules/core-java-collections-4/src/test/java/com/baeldung/maps/initialize/EmptyMapInitializerUnitTest.java

@@ -28,4 +28,9 @@ public class EmptyMapInitializerUnitTest {
     assertFalse(emptyMapUsingGuava.isEmpty());
   }
 
+  @Test(expected=UnsupportedOperationException.class)
+  public void givenImmutableEmptyMapUsingGuava_whenAddingEntries_throwsException() {
+    Map<String, String> map = EmptyMapInitializer.createImmutableMapUsingGuava();
+    map.put("key", "value");
+  }
 }

core-java-modules/core-java-collections-list-3/README.md

@@ -13,5 +13,4 @@ This module contains articles about the Java List collection
 - [Finding the Differences Between Two Lists in Java](https://www.baeldung.com/java-lists-difference)
 - [List vs. ArrayList in Java](https://www.baeldung.com/java-list-vs-arraylist)
 - [How to Store HashMap<String, ArrayList> Inside a List](https://www.baeldung.com/java-hashmap-inside-list)
-- [Working With a List of Lists in Java](https://www.baeldung.com/java-list-of-lists)
 - [[<-- Prev]](/core-java-modules/core-java-collections-list-2)

core-java-modules/core-java-date-operations-2/pom.xml

@@ -30,11 +30,29 @@
             <artifactId>hirondelle-date4j</artifactId>
             <version>${hirondelle-date4j.version}</version>
         </dependency>
+        <dependency>
+            <groupId>net.time4j</groupId>
+            <artifactId>time4j-base</artifactId>
+            <version>${time4j-base.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>net.time4j</groupId>
+            <artifactId>time4j-sqlxml</artifactId>
+            <version>${time4j-sqlxml.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.ocpsoft.prettytime</groupId>
+            <artifactId>prettytime</artifactId>
+            <version>${prettytime.version}</version>
+        </dependency>
     </dependencies>
 
     <properties>
         <joda-time.version>2.10</joda-time.version>
         <hirondelle-date4j.version>1.5.1</hirondelle-date4j.version>
+        <prettytime.version>3.2.7.Final</prettytime.version>
+        <time4j-base.version>5.9</time4j-base.version>
+        <time4j-sqlxml.version>5.8</time4j-sqlxml.version>
     </properties>
 
 </project>

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/timeago/version7/TimeAgoCalculator.java

@@ -0,0 +1,94 @@
+package com.baeldung.timeago.version7;
+
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.joda.time.DateTime;
+import org.joda.time.DateTimeZone;
+import org.joda.time.Period;
+import org.joda.time.format.PeriodFormat;
+import org.joda.time.format.PeriodFormatter;
+import org.joda.time.format.PeriodFormatterBuilder;
+
+public class TimeAgoCalculator {
+
+    public static String calculateTimeAgoByTimeGranularity(Date pastTime, TimeGranularity granularity) {
+        Date currentTime = new Date();
+        long timeDifferenceInMillis = currentTime.getTime() - pastTime.getTime();
+        return timeDifferenceInMillis / granularity.toMillis() + " " + granularity.name()
+            .toLowerCase() + " ago";
+    }
+
+    public static String calculateHumanFriendlyTimeAgo(Date pastTime) {
+        Date currentTime = new Date();
+        long timeDifferenceInMillis = currentTime.getTime() - pastTime.getTime();
+        if (timeDifferenceInMillis / TimeGranularity.DECADES.toMillis() > 0)
+            return "several decades ago";
+        else if (timeDifferenceInMillis / TimeGranularity.YEARS.toMillis() > 0)
+            return "several years ago";
+        else if (timeDifferenceInMillis / TimeGranularity.MONTHS.toMillis() > 0)
+            return "several months ago";
+        else if (timeDifferenceInMillis / TimeGranularity.WEEKS.toMillis() > 0)
+            return "several weeks ago";
+        else if (timeDifferenceInMillis / TimeGranularity.DAYS.toMillis() > 0)
+            return "several days ago";
+        else if (timeDifferenceInMillis / TimeGranularity.HOURS.toMillis() > 0)
+            return "several hours ago";
+        else if (timeDifferenceInMillis / TimeGranularity.MINUTES.toMillis() > 0)
+            return "several minutes ago";
+        else
+            return "moments ago";
+    }
+
+    public static String calculateExactTimeAgoWithJodaTime(Date pastTime) {
+        Period period = new Period(new DateTime(pastTime.getTime()), new DateTime());
+        PeriodFormatter formatter = new PeriodFormatterBuilder().appendYears()
+            .appendSuffix(" year ", " years ")
+            .appendSeparator("and ")
+            .appendMonths()
+            .appendSuffix(" month ", " months ")
+            .appendSeparator("and ")
+            .appendWeeks()
+            .appendSuffix(" week ", " weeks ")
+            .appendSeparator("and ")
+            .appendDays()
+            .appendSuffix(" day ", " days ")
+            .appendSeparator("and ")
+            .appendHours()
+            .appendSuffix(" hour ", " hours ")
+            .appendSeparator("and ")
+            .appendMinutes()
+            .appendSuffix(" minute ", " minutes ")
+            .appendSeparator("and ")
+            .appendSeconds()
+            .appendSuffix(" second", " seconds")
+            .toFormatter();
+        return formatter.print(period);
+    }
+
+    public static String calculateHumanFriendlyTimeAgoWithJodaTime(Date pastTime) {
+        Period period = new Period(new DateTime(pastTime.getTime()), new DateTime());
+        if (period.getYears() != 0)
+            return "several years ago";
+        else if (period.getMonths() != 0)
+            return "several months ago";
+        else if (period.getWeeks() != 0)
+            return "several weeks ago";
+        else if (period.getDays() != 0)
+            return "several days ago";
+        else if (period.getHours() != 0)
+            return "several hours ago";
+        else if (period.getMinutes() != 0)
+            return "several minutes ago";
+        else
+            return "moments ago";
+    }
+
+    public static String calculateZonedTimeAgoWithJodaTime(Date pastTime, TimeZone zone) {
+        DateTimeZone dateTimeZone = DateTimeZone.forID(zone.getID());
+        Period period = new Period(new DateTime(pastTime.getTime(), dateTimeZone), new DateTime(dateTimeZone));
+        return PeriodFormat.getDefault()
+            .print(period);
+    }
+
+}

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/timeago/version7/TimeGranularity.java

@@ -0,0 +1,41 @@
+package com.baeldung.timeago.version7;
+
+import java.util.concurrent.TimeUnit;
+
+public enum TimeGranularity {
+    SECONDS {
+        public long toMillis() {
+            return TimeUnit.SECONDS.toMillis(1);
+        }
+    }, MINUTES {
+        public long toMillis() {
+            return TimeUnit.MINUTES.toMillis(1);
+        }
+    }, HOURS {
+        public long toMillis() {
+            return TimeUnit.HOURS.toMillis(1);
+        }
+    }, DAYS {
+        public long toMillis() {
+            return TimeUnit.DAYS.toMillis(1);
+        }
+    }, WEEKS {
+        public long toMillis() {
+            return TimeUnit.DAYS.toMillis(7);
+        }
+    }, MONTHS {
+        public long toMillis() {
+            return TimeUnit.DAYS.toMillis(30);
+        }
+    }, YEARS {
+        public long toMillis() {
+            return TimeUnit.DAYS.toMillis(365);
+        }
+    }, DECADES {
+        public long toMillis() {
+            return TimeUnit.DAYS.toMillis(365 * 10);
+        }
+    };
+
+    public abstract long toMillis();
+}

core-java-modules/core-java-date-operations-2/src/main/java/com/baeldung/timeago/version8/TimeAgoCalculator.java

@@ -0,0 +1,44 @@
+package com.baeldung.timeago.version8;
+
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.Period;
+import java.time.ZoneId;
+import java.util.Date;
+import java.util.Locale;
+
+import org.ocpsoft.prettytime.PrettyTime;
+
+public class TimeAgoCalculator {
+
+    public static String calculateTimeAgoWithPeriodAndDuration(LocalDateTime pastTime, ZoneId zone) {
+        Period period = Period.between(pastTime.toLocalDate(), LocalDate.now(zone));
+        Duration duration = Duration.between(pastTime, LocalDateTime.now(zone));
+        if (period.getYears() != 0)
+            return "several years ago";
+        else if (period.getMonths() != 0)
+            return "several months ago";
+        else if (period.getDays() != 0)
+            return "several days ago";
+        else if (duration.toHours() != 0)
+            return "several hours ago";
+        else if (duration.toMinutes() != 0)
+            return "several minutes ago";
+        else if (duration.getSeconds() != 0)
+            return "several seconds ago";
+        else
+            return "moments ago";
+    }
+
+    public static String calculateTimeAgoWithPrettyTime(Date pastTime) {
+        PrettyTime prettyTime = new PrettyTime();
+        return prettyTime.format(pastTime);
+    }
+
+    public static String calculateTimeAgoWithTime4J(Date pastTime, ZoneId zone, Locale locale) {
+        return net.time4j.PrettyTime.of(locale)
+            .printRelative(pastTime.toInstant(), zone);
+    }
+
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/timeago/version7/TimeAgoCalculatorUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.timeago.version7;
+
+import java.util.Date;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TimeAgoCalculatorUnitTest {
+
+    // fixing tests in BAEL-5647
+    //@Test
+    public void timeAgoByTimeGranularityTest() {
+        long DAY_IN_MILLIS = 1000 * 60 * 60 * 24;
+        Assert.assertEquals("5 seconds ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * 1000)), TimeGranularity.SECONDS));
+        Assert.assertEquals("5 minutes ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * 60 * 1000)), TimeGranularity.MINUTES));
+        Assert.assertEquals("5 hours ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * 60 * 60 * 1000)), TimeGranularity.HOURS));
+        Assert.assertEquals("5 days ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS)), TimeGranularity.DAYS));
+        Assert.assertEquals("5 months ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 30)), TimeGranularity.MONTHS));
+        Assert.assertEquals("5 weeks ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 7)), TimeGranularity.WEEKS));
+        Assert.assertEquals("5 years ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 365)), TimeGranularity.YEARS));
+        Assert.assertEquals("5 decades ago", TimeAgoCalculator.calculateTimeAgoByTimeGranularity(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 365 * 10)), TimeGranularity.DECADES));
+    }
+
+    //@Test
+    public void humanFriendlyTimeAgoTest() {
+        long DAY_IN_MILLIS = 1000 * 60 * 60 * 24;
+        Assert.assertEquals("moments ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * 1000))));
+        Assert.assertEquals("several minutes ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * 60 * 1000))));
+        Assert.assertEquals("several hours ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * 60 * 60 * 1000))));
+        Assert.assertEquals("several days ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS))));
+        Assert.assertEquals("several months ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 30))));
+        Assert.assertEquals("several weeks ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (3 * DAY_IN_MILLIS * 7))));
+        Assert.assertEquals("several years ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 365))));
+        Assert.assertEquals("several decades ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgo(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 365 * 10))));
+    }
+
+    //@Test
+    public void calculateExactTimeAgoWithJodaTimeTest() {
+        Assert.assertEquals("5 hours and 15 minutes and 3 seconds", TimeAgoCalculator.calculateExactTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * 60 * 60 * 1000 + 15 * 60 * 1000 + 3 * 1000))));
+        Assert.assertEquals("5 hours and 1 minute and 1 second", TimeAgoCalculator.calculateExactTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * 60 * 60 * 1000 + 1 * 60 * 1000 + 1 * 1000))));
+        Assert.assertEquals("2 days and 1 minute and 1 second", TimeAgoCalculator.calculateExactTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (2 * 24 * 60 * 60 * 1000 + 1 * 60 * 1000 + 1 * 1000))));
+    }
+
+    //@Test
+    public void calculateHumanFriendlyTimeAgoWithJodaTimeTest() {
+        long DAY_IN_MILLIS = 1000 * 60 * 60 * 24;
+        Assert.assertEquals("moments ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * 1000))));
+        Assert.assertEquals("several minutes ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * 60 * 1000))));
+        Assert.assertEquals("several hours ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * 60 * 60 * 1000))));
+        Assert.assertEquals("several days ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS))));
+        Assert.assertEquals("several months ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 30))));
+        Assert.assertEquals("several weeks ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (3 * DAY_IN_MILLIS * 7))));
+        Assert.assertEquals("several years ago", TimeAgoCalculator.calculateHumanFriendlyTimeAgoWithJodaTime(new Date(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 365))));
+    }
+
+}

core-java-modules/core-java-date-operations-2/src/test/java/com/baeldung/timeago/version8/TimeAgoCalculatorUnitTest.java

@@ -0,0 +1,24 @@
+package com.baeldung.timeago.version8;
+
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class TimeAgoCalculatorUnitTest {
+
+    // fixing test in BAEL-5647
+    //@Test
+    public void calculateTimeAgoWithPeriodAndDurationTest() {
+        long DAY_IN_MILLIS = 1000 * 60 * 60 * 24;
+        Assert.assertEquals("moments ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis()), ZoneId.systemDefault()), ZoneId.systemDefault()));
+        Assert.assertEquals("several seconds ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() - (5 * 1000)), ZoneId.systemDefault()), ZoneId.systemDefault()));
+        Assert.assertEquals("several minutes ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() - (5 * 60 * 1000)), ZoneId.systemDefault()), ZoneId.systemDefault()));
+        Assert.assertEquals("several hours ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() - (5 * 60 * 60 * 1000)), ZoneId.systemDefault()), ZoneId.systemDefault()));
+        Assert.assertEquals("several days ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() - (5 * DAY_IN_MILLIS)), ZoneId.systemDefault()), ZoneId.systemDefault()));
+        Assert.assertEquals("several months ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 30)), ZoneId.systemDefault()), ZoneId.systemDefault()));
+        Assert.assertEquals("several years ago", TimeAgoCalculator.calculateTimeAgoWithPeriodAndDuration(LocalDateTime.ofInstant(Instant.ofEpochMilli(System.currentTimeMillis() - (5 * DAY_IN_MILLIS * 365)), ZoneId.systemDefault()), ZoneId.systemDefault()));
+    }
+}

core-java-modules/core-java-exceptions-2/README.md

@@ -14,3 +14,5 @@ This module contains articles about core java exceptions
 - [How to Find an Exception’s Root Cause in Java](https://www.baeldung.com/java-exception-root-cause)
 - [Java IOException “Too many open files”](https://www.baeldung.com/java-too-many-open-files)
 - [When Does Java Throw the ExceptionInInitializerError?](https://www.baeldung.com/java-exceptionininitializererror)
+- More articles: [[<-- prev]](../core-java-exceptions) [[next -->]](../core-java-exceptions-3)
+

core-java-modules/core-java-exceptions-3/README.md

@@ -1,5 +1,8 @@
-### Relevant Articles:
+## Core Java Exceptions
 
+This module contains articles about core java exceptions
+
+### Relevant Articles:
 - [NoSuchMethodError in Java](https://www.baeldung.com/java-nosuchmethod-error)
 - [IllegalArgumentException or NullPointerException for a Null Parameter?](https://www.baeldung.com/java-illegalargumentexception-or-nullpointerexception)
 - [IllegalMonitorStateException in Java](https://www.baeldung.com/java-illegalmonitorstateexception)
@@ -10,3 +13,5 @@
 - [NoSuchFieldError in Java](https://www.baeldung.com/java-nosuchfielderror)
 - [IllegalAccessError in Java](https://www.baeldung.com/java-illegalaccesserror)
 - [Working with (Unknown Source) Stack Traces in Java](https://www.baeldung.com/java-unknown-source-stack-trace)
+- More articles: [[<-- prev]](../core-java-exceptions-2) [[next -->]](../core-java-exceptions-4)
+

core-java-modules/core-java-exceptions-4/README.md

@@ -1,5 +1,10 @@
-### Relevant Articles:
+## Core Java Exceptions
 
+This module contains articles about core java exceptions
+
+### Relevant articles:
 - [Java ArrayIndexOutOfBoundsException](https://www.baeldung.com/java-arrayindexoutofboundsexception)
 - [Java Missing Return Statement](https://www.baeldung.com/java-missing-return-statement)
 - [Convert long to int Type in Java](https://www.baeldung.com/java-convert-long-to-int)
+- [“Sneaky Throws” in Java](https://www.baeldung.com/java-sneaky-throws)
+- [[<-- Prev]](../core-java-exceptions-3)

core-java-modules/core-java-exceptions-4/pom.xml

@@ -22,6 +22,12 @@
             <version>${h2.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
     </dependencies>
 
     <build>

core-java-modules/core-java-exceptions-4/src/main/java/com/baeldung/exception/sneakythrows/SneakyThrowsExamples.java

@@ -0,0 +1,22 @@
+package com.baeldung.exception.sneakythrows;
+
+import lombok.SneakyThrows;
+
+import java.io.IOException;
+
+public class SneakyThrowsExamples {
+
+    public static <E extends Throwable> void sneakyThrow(Throwable e) throws E {
+        throw (E) e;
+    }
+
+    public static void throwSneakyIOException() {
+        sneakyThrow(new IOException("sneaky"));
+    }
+
+    @SneakyThrows
+    public static void throwSneakyIOExceptionUsingLombok() {
+        throw new IOException("lombok sneaky");
+    }
+
+}

core-java-modules/core-java-exceptions-4/src/test/java/com/baeldung/exception/sneakythrows/SneakyThrowsExamplesUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.exception.sneakythrows;
+
+import org.junit.Test;
+
+import java.io.IOException;
+
+import static com.baeldung.exception.sneakythrows.SneakyThrowsExamples.throwSneakyIOException;
+import static com.baeldung.exception.sneakythrows.SneakyThrowsExamples.throwSneakyIOExceptionUsingLombok;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class SneakyThrowsExamplesUnitTest {
+
+    @Test
+    public void throwSneakyIOException_IOExceptionShouldBeThrown() {
+        assertThatThrownBy(() -> throwSneakyIOException())
+            .isInstanceOf(IOException.class)
+            .hasMessage("sneaky")
+            .hasStackTraceContaining("SneakyThrowsExamples.throwSneakyIOException");
+    }
+
+    @Test
+    public void throwSneakyIOExceptionUsingLombok_IOExceptionShouldBeThrown() {
+        assertThatThrownBy(() -> throwSneakyIOExceptionUsingLombok())
+            .isInstanceOf(IOException.class)
+            .hasMessage("lombok sneaky")
+            .hasStackTraceContaining("SneakyThrowsExamples.throwSneakyIOExceptionUsingLombok");
+    }
+}

core-java-modules/core-java-exceptions/README.md

@@ -9,9 +9,9 @@ This module contains articles about core java exceptions
 - [Exception Handling in Java](https://www.baeldung.com/java-exceptions)
 - [Differences Between Final, Finally and Finalize in Java](https://www.baeldung.com/java-final-finally-finalize)
 - [Difference Between Throw and Throws in Java](https://www.baeldung.com/java-throw-throws)
-- [“Sneaky Throws” in Java](https://www.baeldung.com/java-sneaky-throws)
 - [The StackOverflowError in Java](https://www.baeldung.com/java-stack-overflow-error)
 - [Checked and Unchecked Exceptions in Java](https://www.baeldung.com/java-checked-unchecked-exceptions)
 - [Common Java Exceptions](https://www.baeldung.com/java-common-exceptions)
 - [Will an Error Be Caught by Catch Block in Java?](https://www.baeldung.com/java-error-catch)
-- [[Next -->]](/core-java-modules/core-java-exceptions-2)
+- [[Next -->]](../core-java-exceptions-2)
+- 

core-java-modules/core-java-exceptions/pom.xml

@@ -21,12 +21,6 @@
             <artifactId>mail</artifactId>
             <version>${javax.mail.version}</version>
         </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>${lombok.version}</version>
-            <scope>provided</scope>
-        </dependency>
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/sneakythrows/SneakyRunnable.java

@@ -1,23 +0,0 @@
-package com.baeldung.exceptions.sneakythrows;
-
-import lombok.SneakyThrows;
-
-public class SneakyRunnable implements Runnable {
-
-    @SneakyThrows
-    public void run() {
-        try {
-            throw new InterruptedException();
-        } catch (InterruptedException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void main(String[] args) {
-        try {
-            new SneakyRunnable().run();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/sneakythrows/SneakyThrows.java

@@ -1,25 +0,0 @@
-package com.baeldung.exceptions.sneakythrows;
-
-import java.io.IOException;
-
-public class SneakyThrows {
-
-
-    public static <E extends Throwable> void sneakyThrow(Throwable e) throws E {
-        throw (E) e;
-    }
-
-    public static void throwsSneakyIOException() {
-        sneakyThrow(new IOException("sneaky"));
-    }
-
-
-    public static void main(String[] args) {
-        try {
-            throwsSneakyIOException();
-        } catch (Exception ex) {
-            ex.printStackTrace();
-        }
-
-    }
-}

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exceptions/sneakythrows/SneakyRunnableUnitTest.java

@@ -1,17 +0,0 @@
-package com.baeldung.exceptions.sneakythrows;
-
-import org.junit.Test;
-
-import static junit.framework.TestCase.assertEquals;
-
-public class SneakyRunnableUnitTest {
-
-    @Test
-    public void whenCallSneakyRunnableMethod_thenThrowException() {
-        try {
-            new SneakyRunnable().run();
-        } catch (Exception e) {
-            assertEquals(InterruptedException.class, e.getStackTrace());
-        }
-    }
-}

core-java-modules/core-java-exceptions/src/test/java/com/baeldung/exceptions/sneakythrows/SneakyThrowsUnitTest.java

@@ -1,18 +0,0 @@
-package com.baeldung.exceptions.sneakythrows;
-
-import org.junit.Test;
-
-import static junit.framework.TestCase.assertEquals;
-
-public class SneakyThrowsUnitTest {
-
-    @Test
-    public void whenCallSneakyMethod_thenThrowSneakyException() {
-        try {
-            SneakyThrows.throwsSneakyIOException();
-        } catch (Exception ex) {
-            assertEquals("sneaky", ex.getMessage().toString());
-        }
-    }
-
-}

core-java-modules/core-java-httpclient/README.md

@@ -4,3 +4,4 @@ This module contains articles about Java HttpClient
 
 ### Relevant articles
 - [Posting with Java HttpClient](https://www.baeldung.com/java-httpclient-post)
+- [Custom HTTP Header With the Java HttpClient](https://www.baeldung.com/java-http-client-custom-header)

core-java-modules/core-java-lang-operators-2/README.md

@@ -7,3 +7,4 @@ This module contains articles about Java operators
 - [Logical vs Bitwise OR Operator](https://www.baeldung.com/java-logical-vs-bitwise-or-operator)
 - [Bitmasking in Java with Bitwise Operators](https://www.baeldung.com/java-bitmasking)
 - [Getting a Bit at a Certain Position from Integral Values](https://www.baeldung.com/java-get-bit-at-position)
+- [Check if at Least Two Out of Three Booleans Are True in Java](https://www.baeldung.com/java-check-two-of-three-booleans)

core-java-modules/core-java-lang-operators-2/src/main/java/com/baeldung/threebool/ThreeBooleans.java

@@ -0,0 +1,45 @@
+package com.baeldung.threebool;
+
+import java.util.Arrays;
+
+public class ThreeBooleans {
+    public static boolean twoOrMoreAreTrueByLoop(boolean a, boolean b, boolean c) {
+        int count = 0;
+        for (boolean i : new Boolean[] { a, b, c }) {
+            count += i ? 1 : 0;
+            if (count >= 2)
+                return true;
+        }
+        return false;
+    }
+
+    public static boolean xOrMoreAreTrueByLoop(boolean[] booleans, int x) {
+        int count = 0;
+        for (boolean i : booleans) {
+            count += i ? 1 : 0;
+            if (count >= x)
+                return true;
+        }
+        return false;
+    }
+
+    public static boolean twoOrMoreAreTrueBySum(boolean a, boolean b, boolean c) {
+        return (a ? 1 : 0) + (b ? 1 : 0) + (c ? 1 : 0) >= 2;
+    }
+
+    public static boolean xOrMoreAreTrueBySum(Boolean[] booleans, int x) {
+        return Arrays.stream(booleans).mapToInt(b -> Boolean.TRUE.equals(b) ? 1 : 0).sum() >= x;
+    }
+
+    public static boolean twoorMoreAreTrueByKarnaughMap(boolean a, boolean b, boolean c) {
+        return (c && (a || b)) || (a && b);
+    }
+
+    public static boolean twoOrMoreAreTrueByOperators(boolean a, boolean b, boolean c) {
+        return (a && b) || (a && c) || (b && c);
+    }
+
+    public static boolean twoOrMoreAreTrueByXor(boolean a, boolean b, boolean c) {
+        return a ^ b ? c : a;
+    }
+}

core-java-modules/core-java-lang-operators-2/src/test/java/com/baeldung/threebool/ThreeBooleansUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.threebool;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.google.common.collect.ImmutableMap;
+import java.util.Map;
+import org.junit.jupiter.api.Test;
+
+class ThreeBooleansUnitTest {
+    // @formatter:off
+    private static final Map<boolean[], Boolean> TEST_CASES_AND_EXPECTED = ImmutableMap.of(
+        new boolean[]{true, true, true}, true,
+        new boolean[]{true, true, false}, true,
+        new boolean[]{true, false, false}, false,
+        new boolean[]{false, false, false}, false
+        );
+    // @formatter:on
+
+    @Test
+    void given3Booleans_whenCallingTwoOrMoreAreTrueByLoop_thenGetExpectedResult() {
+        TEST_CASES_AND_EXPECTED.forEach((array, expected) -> assertThat(ThreeBooleans.twoOrMoreAreTrueByLoop(array[0], array[1], array[2])).isEqualTo(expected));
+    }
+
+    @Test
+    void given3Booleans_whenCallingTwoOrMoreAreTrueByCounting_thenGetExpectedResult() {
+        TEST_CASES_AND_EXPECTED.forEach((array, expected) -> assertThat(ThreeBooleans.twoOrMoreAreTrueBySum(array[0], array[1], array[2])).isEqualTo(expected));
+    }
+
+    @Test
+    void given3Booleans_whenCallingTwoOrMoreAreTrueByKarnaughMap_thenGetExpectedResult() {
+        TEST_CASES_AND_EXPECTED.forEach((array, expected) -> assertThat(ThreeBooleans.twoorMoreAreTrueByKarnaughMap(array[0], array[1], array[2])).isEqualTo(expected));
+    }
+
+    @Test
+    void given3Booleans_whenCallingTwoOrMoreAreTrueByOperators_thenGetExpectedResult() {
+        TEST_CASES_AND_EXPECTED.forEach((array, expected) -> assertThat(ThreeBooleans.twoOrMoreAreTrueByOperators(array[0], array[1], array[2])).isEqualTo(expected));
+    }
+
+    @Test
+    void given3Booleans_whenCallingTwoOrMoreAreTrueByXor_thenGetExpectedResult() {
+        TEST_CASES_AND_EXPECTED.forEach((array, expected) -> assertThat(ThreeBooleans.twoOrMoreAreTrueByXor(array[0], array[1], array[2])).isEqualTo(expected));
+    }
+
+}

core-java-modules/core-java-reflection-2/README.md

@@ -8,3 +8,4 @@
 - [Finding All Classes in a Java Package](https://www.baeldung.com/java-find-all-classes-in-package)
 - [Invoke a Static Method Using Java Reflection API](https://www.baeldung.com/java-invoke-static-method-reflection)
 - [What Is the JDK com.sun.proxy.$Proxy Class?](https://www.baeldung.com/jdk-com-sun-proxy)
+- [Unit Test Private Methods in Java](https://www.baeldung.com/java-unit-test-private-methods)

core-java-modules/core-java-reflection-2/pom.xml

@@ -47,6 +47,25 @@
                     <compilerArgument>-parameters</compilerArgument>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.jacoco</groupId>
+                <artifactId>jacoco-maven-plugin</artifactId>
+                <version>0.8.8</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>prepare-agent</goal>
+                        </goals>
+                    </execution>
+                    <execution>
+                        <id>report</id>
+                        <phase>prepare-package</phase>
+                        <goals>
+                            <goal>report</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
         </plugins>
     </build>
 

core-java-modules/core-java-reflection-2/src/main/java/com/baeldung/reflection/privatemethods/Utils.java

@@ -0,0 +1,19 @@
+package com.baeldung.reflection.privatemethods;
+
+public class Utils {
+
+    public static Integer validateAndDouble(Integer input) {
+        if (input == null) {
+            throw new IllegalArgumentException("input should not be null");
+        }
+        return doubleInteger(input);
+    }
+
+    private static Integer doubleInteger(Integer input) {
+        if (input == null) {
+            return null;
+        }
+        return 2 * input;
+    }
+
+}

core-java-modules/core-java-reflection-2/src/test/java/com/baeldung/reflection/privatemethods/UtilsUnitTest.java

@@ -0,0 +1,42 @@
+package com.baeldung.reflection.privatemethods;
+
+import static com.baeldung.reflection.privatemethods.Utils.validateAndDouble;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import org.junit.jupiter.api.Test;
+
+public class UtilsUnitTest {
+
+    // Let's start with the tests of the public API
+    @Test
+    void givenNull_WhenValidateAndDouble_ThenThrows() {
+        assertThrows(IllegalArgumentException.class, () -> validateAndDouble(null));
+    }
+
+    @Test
+    void givenANonNullInteger_WhenValidateAndDouble_ThenDoublesIt() {
+        assertEquals(4, validateAndDouble(2));
+    }
+
+    // Further on, let's test the private method
+    @Test
+    void givenNull_WhenDoubleInteger_ThenNull() throws InvocationTargetException, IllegalAccessException, NoSuchMethodException {
+        assertEquals(null, getDoubleIntegerMethod().invoke(null, new Integer[] { null }));
+    }
+
+    @Test
+    void givenANonNullInteger_WhenDoubleInteger_ThenDoubleIt() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
+        assertEquals(74, getDoubleIntegerMethod().invoke(null, 37));
+    }
+
+    private Method getDoubleIntegerMethod() throws NoSuchMethodException {
+        Method method = Utils.class.getDeclaredMethod("doubleInteger", Integer.class);
+        method.setAccessible(true);
+        return method;
+    }
+
+}

core-java-modules/core-java-regex-2/src/main/java/com/baeldung/regex/array/RegexMatches.java

@@ -1,4 +1,4 @@
-package regex.array;
+package com.baeldung.regex.array;
 
 import java.util.ArrayList;
 import java.util.List;

core-java-modules/core-java-regex-2/src/test/java/com/baeldung/regex/array/RegexMatchesUnitTest.java

@@ -1,10 +1,9 @@
-package regex.array;
+package com.baeldung.regex.array;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
 
-import static org.junit.jupiter.api.Assertions.*;
 import org.junit.jupiter.api.Test;
 
-import regex.array.RegexMatches;
-
 class RegexMatchesUnitTest {
 
 	@Test

core-java-modules/core-java-string-conversions-2/README.md

@@ -11,4 +11,5 @@ This module contains articles about string conversions from/to another type.
 - [Convert a String to Camel Case](https://www.baeldung.com/java-string-to-camel-case)
 - [Convert a ByteBuffer to String in Java](https://www.baeldung.com/java-bytebuffer-to-string)
 - [Convert String to Float and Back in Java](https://www.baeldung.com/java-string-to-float)
-- More articles: [[<-- prev]](/core-java-string-conversions)
+- [Difference Between parseInt() and valueOf() in Java](https://www.baeldung.com/java-integer-parseint-vs-valueof)
+- More articles: [[<-- prev]](/core-java-modules/core-java-string-conversions)

core-java-modules/core-java-string-conversions-2/src/test/java/com/baeldung/stringtointeger/StringToIntegerUnitTest.java

@@ -0,0 +1,73 @@
+package com.baeldung.stringtointeger;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class StringToIntegerUnitTest {
+
+    @Test
+    public void whenValidNumericStringIsPassed_thenShouldConvertToPrimitiveInt() {
+        assertEquals(11, Integer.parseInt("11")); 
+        assertEquals(11, Integer.parseInt("+11")); 
+        assertEquals(-11, Integer.parseInt("-11"));
+    }
+
+    @Test
+    public void whenValidNumericStringWithRadixIsPassed_thenShouldConvertToPrimitiveInt() {
+        assertEquals(17, Integer.parseInt("11", 16)); 
+        assertEquals(10, Integer.parseInt("A", 16)); 
+        assertEquals(7, Integer.parseInt("7", 8));
+    }
+
+//    public static int parseInt(CharSequence s, int beginIndex, int endIndex, int radix) throws NumberFormatException 
+//    This method is available in JDK 9 and above  
+//    @Test
+//    public void whenValidNumericStringWithRadixAndSubstringIsPassed_thenShouldConvertToPrimitiveInt() {
+//        assertEquals(5, Integer.parseInt("100101", 3, 6, 2));
+//        assertEquals(101, Integer.parseInt("100101", 3, 6, 10));
+//    }
+
+    @Test(expected = NumberFormatException.class)
+    public void whenInValidNumericStringIsPassed_thenShouldThrowNumberFormatException() {
+        int number = Integer.parseInt("abcd");
+    }
+
+    @Test
+    public void whenValidNumericStringIsPassed_thenShouldConvertToInteger() {
+        Integer expectedNumber = 11;
+        Integer expectedNegativeNumber = -11;
+        
+        assertEquals(expectedNumber, Integer.valueOf("11"));
+        assertEquals(expectedNumber, Integer.valueOf("+11"));
+        assertEquals(expectedNegativeNumber, Integer.valueOf("-11"));
+    }
+
+    @Test
+    public void whenNumberIsPassed_thenShouldConvertToInteger() {
+        Integer expectedNumber = 11;
+        Integer expectedNegativeNumber = -11;
+        Integer expectedUnicodeValue = 65;
+        
+        assertEquals(expectedNumber, Integer.valueOf(11));
+        assertEquals(expectedNumber, Integer.valueOf(+11));
+        assertEquals(expectedNegativeNumber, Integer.valueOf(-11));
+        assertEquals(expectedUnicodeValue, Integer.valueOf('A'));
+    }
+
+    @Test
+    public void whenValidNumericStringWithRadixIsPassed_thenShouldConvertToInetger() {
+        Integer expectedNumber1 = 17;
+        Integer expectedNumber2 = 10;
+        Integer expectedNumber3 = 7;
+        
+        assertEquals(expectedNumber1, Integer.valueOf("11", 16));
+        assertEquals(expectedNumber2, Integer.valueOf("A", 16));
+        assertEquals(expectedNumber3, Integer.valueOf("7", 8));
+    }
+
+    @Test(expected = NumberFormatException.class)
+    public void whenInvalidValueOfNumericStringPassed_thenShouldThrowException() {
+        Integer number = Integer.valueOf("abcd");
+    }
+}

core-java-modules/core-java-string-conversions/README.md

@@ -13,4 +13,4 @@ This module contains articles about string conversions from/to another type.
 - [Convert String to Double in Java](https://www.baeldung.com/java-string-to-double)
 - [Convert Char to String in Java](https://www.baeldung.com/java-convert-char-to-string)
 - [Convert String to int or Integer in Java](https://www.baeldung.com/java-convert-string-to-int-or-integer)
-- More articles: [[next -->]](/core-java-string-conversions-2)
+- More articles: [[next -->]](/core-java-modules/core-java-string-conversions-2)

core-java-modules/java-numbers-2/README.md

@@ -13,4 +13,4 @@ This module contains articles about numbers in Java.
 - [Binary Numbers in Java](https://www.baeldung.com/java-binary-numbers)
 - [Finding the Least Common Multiple in Java](https://www.baeldung.com/java-least-common-multiple)
 - [Binary Numbers in Java](https://www.baeldung.com/java-binary-numbers)
-- More articles: [[<-- prev]](/java-numbers) [[next -->]](/java-numbers-3)
+- More articles: [[<-- prev]](../java-numbers) [[next -->]](../java-numbers-3)

core-java-modules/java-numbers-2/pom.xml

@@ -9,10 +9,9 @@
     <packaging>jar</packaging>
 
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-java</relativePath>
     </parent>
 
     <dependencies>

core-java-modules/java-numbers-2/src/main/java/com/baeldung/binarynumbers/BinaryNumbers.java

@@ -1,140 +1,140 @@
-package com.baeldung.binarynumbers;
-
-public class BinaryNumbers {
-
-    /**
-     * This method takes a decimal number and convert it into a binary number.
-     * example:- input:10, output:1010
-     *
-     * @param decimalNumber
-     * @return binary number
-     */
-    public Integer convertDecimalToBinary(Integer decimalNumber) {
-
-        if (decimalNumber == 0) {
-            return decimalNumber;
-        }
-
-        StringBuilder binaryNumber = new StringBuilder();
-        Integer quotient = decimalNumber;
-
-        while (quotient > 0) {
-
-            int remainder = quotient % 2;
-            binaryNumber.append(remainder);
-            quotient /= 2;
-        }
-
-        binaryNumber = binaryNumber.reverse();
-        return Integer.valueOf(binaryNumber.toString());
-    }
-
-    /**
-     * This method takes a binary number and convert it into a decimal number.
-     * example:- input:101, output:5
-     *
-     * @param binary number
-     * @return decimal Number
-     */
-    public Integer convertBinaryToDecimal(Integer binaryNumber) {
-
-        Integer decimalNumber = 0;
-        Integer base = 1;
-
-        while (binaryNumber > 0) {
-
-            int lastDigit = binaryNumber % 10;
-            binaryNumber = binaryNumber / 10;
-
-            decimalNumber += lastDigit * base;
-            base = base * 2;
-        }
-        return decimalNumber;
-    }
-
-    /**
-     * This method accepts two binary numbers and returns sum of input numbers.
-     * Example:- firstNum: 101, secondNum: 100, output: 1001
-     *
-     * @param firstNum
-     * @param secondNum
-     * @return addition of input numbers
-     */
-    public Integer addBinaryNumber(Integer firstNum, Integer secondNum) {
-
-        StringBuilder output = new StringBuilder();
-
-        int carry = 0;
-        int temp;
-
-        while (firstNum != 0 || secondNum != 0) {
-
-            temp = (firstNum % 10 + secondNum % 10 + carry) % 2;
-            output.append(temp);
-
-            carry = (firstNum % 10 + secondNum % 10 + carry) / 2;
-
-            firstNum = firstNum / 10;
-            secondNum = secondNum / 10;
-        }
-
-        if (carry != 0) {
-            output.append(carry);
-        }
-
-        return Integer.valueOf(output.reverse()
-            .toString());
-    }
-
-    /**
-    * This method takes two binary number as input and subtract second number from the first number.
-    * example:- firstNum: 1000, secondNum: 11, output: 101
-    * @param firstNum
-    * @param secondNum
-    * @return Result of subtraction of secondNum from first
-    */
-    public Integer substractBinaryNumber(Integer firstNum, Integer secondNum) {
-
-        int onesComplement = Integer.valueOf(getOnesComplement(secondNum));
-        StringBuilder output = new StringBuilder();
-        int carry = 0;
-        int temp;
-
-        while (firstNum != 0 || onesComplement != 0) {
-
-            temp = (firstNum % 10 + onesComplement % 10 + carry) % 2;
-            output.append(temp);
-
-            carry = (firstNum % 10 + onesComplement % 10 + carry) / 2;
-
-            firstNum = firstNum / 10;
-            onesComplement = onesComplement / 10;
-        }
-
-        String additionOfFirstNumAndOnesComplement = output.reverse()
-            .toString();
-
-        if (carry == 1) {
-            return addBinaryNumber(Integer.valueOf(additionOfFirstNumAndOnesComplement), carry);
-        } else {
-            return getOnesComplement(Integer.valueOf(additionOfFirstNumAndOnesComplement));
-        }
-    }
-
-    public Integer getOnesComplement(Integer num) {
-
-        StringBuilder onesComplement = new StringBuilder();
-        while (num > 0) {
-            int lastDigit = num % 10;
-            if (lastDigit == 0) {
-                onesComplement.append(1);
-            } else {
-                onesComplement.append(0);
-            }
-            num = num / 10;
-        }
-        return Integer.valueOf(onesComplement.reverse()
-            .toString());
-    }
-
+package com.baeldung.binarynumbers;
+
+public class BinaryNumbers {
+
+    /**
+     * This method takes a decimal number and convert it into a binary number.
+     * example:- input:10, output:1010
+     *
+     * @param decimalNumber
+     * @return binary number
+     */
+    public Integer convertDecimalToBinary(Integer decimalNumber) {
+
+        if (decimalNumber == 0) {
+            return decimalNumber;
+        }
+
+        StringBuilder binaryNumber = new StringBuilder();
+        Integer quotient = decimalNumber;
+
+        while (quotient > 0) {
+
+            int remainder = quotient % 2;
+            binaryNumber.append(remainder);
+            quotient /= 2;
+        }
+
+        binaryNumber = binaryNumber.reverse();
+        return Integer.valueOf(binaryNumber.toString());
+    }
+
+    /**
+     * This method takes a binary number and convert it into a decimal number.
+     * example:- input:101, output:5
+     *
+     * @param binary number
+     * @return decimal Number
+     */
+    public Integer convertBinaryToDecimal(Integer binaryNumber) {
+
+        Integer decimalNumber = 0;
+        Integer base = 1;
+
+        while (binaryNumber > 0) {
+
+            int lastDigit = binaryNumber % 10;
+            binaryNumber = binaryNumber / 10;
+
+            decimalNumber += lastDigit * base;
+            base = base * 2;
+        }
+        return decimalNumber;
+    }
+
+    /**
+     * This method accepts two binary numbers and returns sum of input numbers.
+     * Example:- firstNum: 101, secondNum: 100, output: 1001
+     *
+     * @param firstNum
+     * @param secondNum
+     * @return addition of input numbers
+     */
+    public Integer addBinaryNumber(Integer firstNum, Integer secondNum) {
+
+        StringBuilder output = new StringBuilder();
+
+        int carry = 0;
+        int temp;
+
+        while (firstNum != 0 || secondNum != 0) {
+
+            temp = (firstNum % 10 + secondNum % 10 + carry) % 2;
+            output.append(temp);
+
+            carry = (firstNum % 10 + secondNum % 10 + carry) / 2;
+
+            firstNum = firstNum / 10;
+            secondNum = secondNum / 10;
+        }
+
+        if (carry != 0) {
+            output.append(carry);
+        }
+
+        return Integer.valueOf(output.reverse()
+            .toString());
+    }
+
+    /**
+    * This method takes two binary number as input and subtract second number from the first number.
+    * example:- firstNum: 1000, secondNum: 11, output: 101
+    * @param firstNum
+    * @param secondNum
+    * @return Result of subtraction of secondNum from first
+    */
+    public Integer substractBinaryNumber(Integer firstNum, Integer secondNum) {
+
+        int onesComplement = Integer.valueOf(getOnesComplement(secondNum));
+        StringBuilder output = new StringBuilder();
+        int carry = 0;
+        int temp;
+
+        while (firstNum != 0 || onesComplement != 0) {
+
+            temp = (firstNum % 10 + onesComplement % 10 + carry) % 2;
+            output.append(temp);
+
+            carry = (firstNum % 10 + onesComplement % 10 + carry) / 2;
+
+            firstNum = firstNum / 10;
+            onesComplement = onesComplement / 10;
+        }
+
+        String additionOfFirstNumAndOnesComplement = output.reverse()
+            .toString();
+
+        if (carry == 1) {
+            return addBinaryNumber(Integer.valueOf(additionOfFirstNumAndOnesComplement), carry);
+        } else {
+            return getOnesComplement(Integer.valueOf(additionOfFirstNumAndOnesComplement));
+        }
+    }
+
+    public Integer getOnesComplement(Integer num) {
+
+        StringBuilder onesComplement = new StringBuilder();
+        while (num > 0) {
+            int lastDigit = num % 10;
+            if (lastDigit == 0) {
+                onesComplement.append(1);
+            } else {
+                onesComplement.append(0);
+            }
+            num = num / 10;
+        }
+        return Integer.valueOf(onesComplement.reverse()
+            .toString());
+    }
+
 }

core-java-modules/java-numbers-2/src/test/java/com/baeldung/binarynumbers/BinaryNumbersUnitTest.java

@@ -1,73 +1,73 @@
-package com.baeldung.binarynumbers;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Test;
-
-public class BinaryNumbersUnitTest {
-
-    private BinaryNumbers binaryNumbers = new BinaryNumbers();
-
-    @Test
-    public void given_decimalNumber_then_returnBinaryNumber() {
-        assertEquals(Integer.valueOf(1000), binaryNumbers.convertDecimalToBinary(8));
-        assertEquals(Integer.valueOf(10100), binaryNumbers.convertDecimalToBinary(20));
-    }
-
-    @Test
-    public void given_decimalNumber_then_convertToBinaryNumber() {
-        assertEquals("1000", Integer.toBinaryString(8));
-        assertEquals("10100", Integer.toBinaryString(20));
-    }
-
-    @Test
-    public void given_binaryNumber_then_ConvertToDecimalNumber() {
-        assertEquals(8, Integer.parseInt("1000", 2));
-        assertEquals(20, Integer.parseInt("10100", 2));
-    }
-
-    @Test
-    public void given_binaryNumber_then_returnDecimalNumber() {
-        assertEquals(Integer.valueOf(8), binaryNumbers.convertBinaryToDecimal(1000));
-        assertEquals(Integer.valueOf(20), binaryNumbers.convertBinaryToDecimal(10100));
-    }
-
-    @Test
-    public void given_twoBinaryNumber_then_returnAddition() {
-        // adding 4 and 10
-        assertEquals(Integer.valueOf(1110), binaryNumbers.addBinaryNumber(100, 1010));
-
-        // adding 26 and 14
-        assertEquals(Integer.valueOf(101000), binaryNumbers.addBinaryNumber(11010, 1110));
-    }
-
-    @Test
-    public void given_twoBinaryNumber_then_returnSubtraction() {
-        // subtracting 16 from 25
-        assertEquals(Integer.valueOf(1001), binaryNumbers.substractBinaryNumber(11001, 10000));
-
-        // subtracting 29 from 16, the output here is negative
-        assertEquals(Integer.valueOf(1101), binaryNumbers.substractBinaryNumber(10000, 11101));
-    }
-
-    @Test
-    public void given_binaryLiteral_thenReturnDecimalValue() {
-
-        byte five = 0b101;
-        assertEquals((byte) 5, five);
-
-        short three = 0b11;
-        assertEquals((short) 3, three);
-
-        int nine = 0B1001;
-        assertEquals(9, nine);
-
-        long twentyNine = 0B11101;
-        assertEquals(29, twentyNine);
-
-        int minusThirtySeven = -0B100101;
-        assertEquals(-37, minusThirtySeven);
-
-    }
-
-}
+package com.baeldung.binarynumbers;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BinaryNumbersUnitTest {
+
+    private BinaryNumbers binaryNumbers = new BinaryNumbers();
+
+    @Test
+    public void given_decimalNumber_then_returnBinaryNumber() {
+        assertEquals(Integer.valueOf(1000), binaryNumbers.convertDecimalToBinary(8));
+        assertEquals(Integer.valueOf(10100), binaryNumbers.convertDecimalToBinary(20));
+    }
+
+    @Test
+    public void given_decimalNumber_then_convertToBinaryNumber() {
+        assertEquals("1000", Integer.toBinaryString(8));
+        assertEquals("10100", Integer.toBinaryString(20));
+    }
+
+    @Test
+    public void given_binaryNumber_then_ConvertToDecimalNumber() {
+        assertEquals(8, Integer.parseInt("1000", 2));
+        assertEquals(20, Integer.parseInt("10100", 2));
+    }
+
+    @Test
+    public void given_binaryNumber_then_returnDecimalNumber() {
+        assertEquals(Integer.valueOf(8), binaryNumbers.convertBinaryToDecimal(1000));
+        assertEquals(Integer.valueOf(20), binaryNumbers.convertBinaryToDecimal(10100));
+    }
+
+    @Test
+    public void given_twoBinaryNumber_then_returnAddition() {
+        // adding 4 and 10
+        assertEquals(Integer.valueOf(1110), binaryNumbers.addBinaryNumber(100, 1010));
+
+        // adding 26 and 14
+        assertEquals(Integer.valueOf(101000), binaryNumbers.addBinaryNumber(11010, 1110));
+    }
+
+    @Test
+    public void given_twoBinaryNumber_then_returnSubtraction() {
+        // subtracting 16 from 25
+        assertEquals(Integer.valueOf(1001), binaryNumbers.substractBinaryNumber(11001, 10000));
+
+        // subtracting 29 from 16, the output here is negative
+        assertEquals(Integer.valueOf(1101), binaryNumbers.substractBinaryNumber(10000, 11101));
+    }
+
+    @Test
+    public void given_binaryLiteral_thenReturnDecimalValue() {
+
+        byte five = 0b101;
+        assertEquals((byte) 5, five);
+
+        short three = 0b11;
+        assertEquals((short) 3, three);
+
+        int nine = 0B1001;
+        assertEquals(9, nine);
+
+        long twentyNine = 0B11101;
+        assertEquals(29, twentyNine);
+
+        int minusThirtySeven = -0B100101;
+        assertEquals(-37, minusThirtySeven);
+
+    }
+
+}

core-java-modules/java-numbers-3/README.md

@@ -14,4 +14,4 @@ This module contains articles about numbers in Java.
 - [Print an Integer in Binary Format in Java](https://www.baeldung.com/java-print-integer-binary)
 - [Number Formatting in Java](https://www.baeldung.com/java-number-formatting)
 - [Division by Zero in Java: Exception, Infinity, or Not a Number](https://www.baeldung.com/java-division-by-zero)
-- More articles: [[<-- prev]](/java-numbers-2)
+- More articles: [[<-- prev]](../java-numbers-2) [[next -->]](../java-numbers-4)

core-java-modules/java-numbers-3/pom.xml

@@ -7,10 +7,9 @@
     <packaging>jar</packaging>
 
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-java</relativePath>
     </parent>
 
     <dependencies>

core-java-modules/java-numbers-4/README.md

@@ -10,3 +10,4 @@
 - [Generate a Random Value From an Enum](https://www.baeldung.com/java-enum-random-value)
 - [Reverse a Number in Java](https://www.baeldung.com/java-reverse-number)
 - [Check if BigDecimal Value Is Zero](https://www.baeldung.com/java-bigdecimal-zero)
+- More articles: [[<-- prev]](../java-numbers-3)

core-java-modules/java-numbers-4/pom.xml

@@ -7,10 +7,9 @@
     <packaging>jar</packaging>
 
     <parent>
-        <groupId>com.baeldung</groupId>
-        <artifactId>parent-java</artifactId>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
         <version>0.0.1-SNAPSHOT</version>
-        <relativePath>../parent-java</relativePath>
     </parent>
 
     <dependencies>