Merge remote-tracking branch 'upstream/master'

akka-http/src/test/java/com/baeldung/akkahttp/UserServerUnitTest.java

@@ -7,6 +7,8 @@ import akka.http.javadsl.model.HttpEntities;
 import akka.http.javadsl.model.HttpRequest;
 import akka.http.javadsl.testkit.JUnitRouteTest;
 import akka.http.javadsl.testkit.TestRoute;
+
+import org.junit.Ignore;
 import org.junit.Test;
 
 public class UserServerUnitTest extends JUnitRouteTest {
@@ -17,6 +19,7 @@ public class UserServerUnitTest extends JUnitRouteTest {
 
   TestRoute appRoute = testRoute(new UserServer(userActorRef).routes());
 
+  @Ignore
   @Test
   public void whenRequest_thenActorResponds() {
 
@@ -28,10 +31,10 @@ public class UserServerUnitTest extends JUnitRouteTest {
             .assertStatusCode(404);
 
     appRoute.run(HttpRequest.DELETE("/users/1"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);
 
     appRoute.run(HttpRequest.DELETE("/users/42"))
-            .assertStatusCode(200);
+            .assertStatusCode(405);
 
     appRoute.run(HttpRequest.POST("/users")
             .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))

algorithms-miscellaneous-2/src/main/java/com/baeldung/algorithms/slope_one/SlopeOne.java

@@ -98,7 +98,7 @@ public class SlopeOne {
             for (Item j : InputData.items) {
                 if (e.getValue().containsKey(j)) {
                     clean.put(j, e.getValue().get(j));
-                } else {
+                } else if (!clean.containsKey(j)) {
                     clean.put(j, -1.0);
                 }
             }

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingDeque.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import java.util.Deque;
+import java.util.LinkedList;
+
+public class BalancedBracketsUsingDeque {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        Deque<Character> deque = new LinkedList<>();
+        for (char ch : str.toCharArray()) {
+            if (ch == '{' || ch == '[' || ch == '(') {
+                deque.addFirst(ch);
+            } else {
+                if (!deque.isEmpty() && ((deque.peekFirst() == '{' && ch == '}') || (deque.peekFirst() == '[' && ch == ']') || (deque.peekFirst() == '(' && ch == ')'))) {
+                    deque.removeFirst();
+                } else {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+}

algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingString.java

@@ -0,0 +1,27 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+public class BalancedBracketsUsingString {
+
+    public boolean isBalanced(String str) {
+        if (null == str || ((str.length() % 2) != 0)) {
+            return false;
+        } else {
+            char[] ch = str.toCharArray();
+            for (char c : ch) {
+                if (!(c == '{' || c == '[' || c == '(' || c == '}' || c == ']' || c == ')')) {
+                    return false;
+                }
+
+            }
+        }
+
+        while (str.contains("()") || str.contains("[]") || str.contains("{}")) {
+            str = str.replaceAll("\\(\\)", "")
+                .replaceAll("\\[\\]", "")
+                .replaceAll("\\{\\}", "");
+        }
+        return (str.length() == 0);
+
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingDequeUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingDequeUnitTest {
+    private BalancedBracketsUsingDeque balancedBracketsUsingDeque;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingDeque = new BalancedBracketsUsingDeque();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingDeque.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}

algorithms-miscellaneous-5/src/test/java/com/baeldung/algorithms/balancedbrackets/BalancedBracketsUsingStringUnitTest.java

@@ -0,0 +1,76 @@
+package com.baeldung.algorithms.balancedbrackets;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class BalancedBracketsUsingStringUnitTest {
+    private BalancedBracketsUsingString balancedBracketsUsingString;
+
+    @Before
+    public void setup() {
+        balancedBracketsUsingString = new BalancedBracketsUsingString();
+    }
+
+    @Test
+    public void givenNullInput_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced(null);
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEmptyString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenInvalidCharacterString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("abc[](){}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenOddLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[]()}}}}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthUnbalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[(])}");
+        assertThat(result).isFalse();
+    }
+
+    @Test
+    public void givenEvenLengthBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{[()]}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{[[(())]]}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenAnotherBalancedString_whenCheckingForBalance_shouldReturnTrue() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{([])}}");
+        assertThat(result).isTrue();
+    }
+
+    @Test
+    public void givenUnBalancedString_whenCheckingForBalance_shouldReturnFalse() {
+        boolean result = balancedBracketsUsingString.isBalanced("{{)[](}}");
+        assertThat(result).isFalse();
+    }
+
+}

cloud-foundry-uaa/pom.xml

@@ -0,0 +1,21 @@
+<?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>cloud-foundry-uaa</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>cloud-foundry-uaa</name>
+    <packaging>pom</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <modules>
+        <module>cf-uaa-oauth2-client</module>
+        <module>cf-uaa-oauth2-resource-server</module>
+    </modules>
+
+</project>

core-groovy-2/src/test/groovy/com/baeldung/category/CategoryUnitTest.groovy

@@ -28,16 +28,17 @@ class CategoryUnitTest extends GroovyTestCase {
         }
     }
 
-    void test_whenUsingTimeCategory_thenOperationOnNumber() {
-        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
-        use (TimeCategory) {
-            assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
-
-            sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
-            assert sdf.format(10.minutes.from.now) == sdf.format(new Date() + 10.minutes)
-            assert sdf.format(2.hours.ago) == sdf.format(new Date() - 2.hours)
-        }
-    }
+//	http://team.baeldung.com/browse/BAEL-20687
+//    void test_whenUsingTimeCategory_thenOperationOnNumber() {
+//        SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy")
+//        use (TimeCategory) {
+//            assert sdf.format(5.days.from.now) == sdf.format(new Date() + 5.days)
+//
+//            sdf = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss")
+//            assert sdf.format(10.minutes.from.now) == sdf.format(new Date() + 10.minutes)
+//            assert sdf.format(2.hours.ago) == sdf.format(new Date() - 2.hours)
+//        }
+//    }
 
     void test_whenUsingDOMCategory_thenOperationOnXML() {
 

core-groovy-2/src/test/groovy/com/baeldung/webservice/WebserviceUnitTest.groovy

@@ -9,7 +9,7 @@ import wslite.soap.SOAPMessageBuilder
 import wslite.http.auth.HTTPBasicAuthorization
 import org.junit.Test
 
-class WebserviceUnitTest extends GroovyTestCase {
+class WebserviceManualTest extends GroovyTestCase {
 
     JsonSlurper jsonSlurper = new JsonSlurper()
 

core-groovy/src/test/groovy/com/baeldung/file/ReadFileUnitTest.groovy

@@ -1,6 +1,7 @@
 package com.baeldung.file
 
 import spock.lang.Specification
+import spock.lang.Ignore
 
 class ReadFileUnitTest extends Specification {
 
@@ -32,6 +33,7 @@ class ReadFileUnitTest extends Specification {
             assert lines.size(), 3
     }
     
+    @Ignore
     def 'Should return file content in string using ReadFile.readFileString given filePath' () {
         given:
             def filePath = "src/main/resources/fileContent.txt"

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

@@ -61,7 +61,7 @@
                         </goals>
                         <configuration>
                             <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </configuration>
                     </execution>
                 </executions>

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

@@ -75,7 +75,7 @@
                         <manifest>
                             <addClasspath>true</addClasspath>
                             <classpathPrefix>libs/</classpathPrefix>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </manifest>
                     </archive>
                 </configuration>
@@ -94,7 +94,7 @@
                             <archiveBaseDirectory>${project.basedir}</archiveBaseDirectory>
                             <archive>
                                 <manifest>
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                    <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                                 </manifest>
                             </archive>
                             <descriptorRefs>
@@ -118,7 +118,7 @@
                             <shadedArtifactAttached>true</shadedArtifactAttached>
                             <transformers>
                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
-                                    <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                                    <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                                 </transformer>
                             </transformers>
                         </configuration>
@@ -133,7 +133,7 @@
                 <executions>
                     <execution>
                         <configuration>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                             <attachToBuild>true</attachToBuild>
                             <filename>${project.build.finalName}-onejar.${project.packaging}</filename>
                         </configuration>
@@ -155,7 +155,7 @@
                         </goals>
                         <configuration>
                             <classifier>spring-boot</classifier>
-                            <mainClass>org.baeldung.executable.ExecutableMavenJar</mainClass>
+                            <mainClass>com.baeldung.executable.ExecutableMavenJar</mainClass>
                         </configuration>
                     </execution>
                 </executions>

core-java-modules/core-java-collections-array-list/src/test/java/com/baeldung/collections/ArrayListUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import com.google.common.collect.Sets;
 import org.junit.Before;

core-java-modules/core-java-collections-array-list/src/test/java/com/baeldung/collections/CoreJavaCollectionsUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import com.google.common.collect.ImmutableList;
 import org.apache.commons.collections4.ListUtils;

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

@@ -3,13 +3,13 @@
 This module contains articles about the Java List collection
 
 ### Relevant Articles: 
-- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
+- [Check If Two Lists are Equal in Java](https://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)
 - [Java 8 Streams: Find Items From One List Based On Values From Another List](https://www.baeldung.com/java-streams-find-list-items)
-- [A Guide to the Java LinkedList](http://www.baeldung.com/java-linkedlist)
-- [Java List UnsupportedOperationException](http://www.baeldung.com/java-list-unsupported-operation-exception)
+- [A Guide to the Java LinkedList](https://www.baeldung.com/java-linkedlist)
+- [Java List UnsupportedOperationException](https://www.baeldung.com/java-list-unsupported-operation-exception)
 - [Java List Initialization in One Line](https://www.baeldung.com/java-init-list-one-line)
 - [Ways to Iterate Over a List in Java](https://www.baeldung.com/java-iterate-list)
-- [Flattening Nested Collections in Java](http://www.baeldung.com/java-flatten-nested-collections)
+- [Flattening Nested Collections in Java](https://www.baeldung.com/java-flatten-nested-collections)
 - [Intersection of Two Lists in Java](https://www.baeldung.com/java-lists-intersection)
 - [Searching for a String in an ArrayList](https://www.baeldung.com/java-search-string-arraylist)
 - [[<-- Prev]](/core-java-modules/core-java-collections-list)[[Next -->]](/core-java-modules/core-java-collections-list-3)

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListAssertJUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Test;
 

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListJUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Assert;
 import org.junit.Test;

core-java-modules/core-java-collections-list-2/src/test/java/com/baeldung/java/list/ListTestNgUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.lists;
+package com.baeldung.java.list;
 
 import org.junit.Test;
 

core-java-modules/core-java-collections-list-2/src/test/java/org/baeldung/java/lists/README.md

@@ -1,2 +0,0 @@
-### Relevant Articles:
-- [Check If Two Lists are Equal in Java](http://www.baeldung.com/java-test-a-list-for-ordinality-and-equality)

core-java-modules/core-java-collections-list/src/test/java/com/baeldung/collections/JavaCollectionCleanupUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.collections;
+package com.baeldung.collections;
 
 import static org.hamcrest.Matchers.hasSize;
 import static org.junit.Assert.assertThat;

core-java-modules/core-java-collections-list/src/test/java/com/baeldung/list/random/RandomListElementUnitTest.java

@@ -1,4 +1,4 @@
-package org.baeldung;
+package com.baeldung.list.random;
 
 import com.google.common.collect.Lists;
 import org.junit.Test;

core-java-modules/core-java-concurrency-advanced-3/src/main/java/com/baeldung/workstealing/PrimeNumbers.java

@@ -0,0 +1,85 @@
+package com.baeldung.workstealing;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.ForkJoinTask;
+import java.util.concurrent.RecursiveAction;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class PrimeNumbers extends RecursiveAction {
+
+    private int lowerBound;
+    private int upperBound;
+    private int granularity;
+    static final List<Integer> GRANULARITIES
+      = Arrays.asList(1, 10, 100, 1000, 10000);
+    private AtomicInteger noOfPrimeNumbers;
+
+    PrimeNumbers(int lowerBound, int upperBound, int granularity, AtomicInteger noOfPrimeNumbers) {
+        this.lowerBound = lowerBound;
+        this.upperBound = upperBound;
+        this.granularity = granularity;
+        this.noOfPrimeNumbers = noOfPrimeNumbers;
+    }
+
+    PrimeNumbers(int upperBound) {
+        this(1, upperBound, 100, new AtomicInteger(0));
+    }
+
+    private PrimeNumbers(int lowerBound, int upperBound, AtomicInteger noOfPrimeNumbers) {
+        this(lowerBound, upperBound, 100, noOfPrimeNumbers);
+    }
+
+    private List<PrimeNumbers> subTasks() {
+        List<PrimeNumbers> subTasks = new ArrayList<>();
+
+        for (int i = 1; i <= this.upperBound / granularity; i++) {
+            int upper = i * granularity;
+            int lower = (upper - granularity) + 1;
+            subTasks.add(new PrimeNumbers(lower, upper, noOfPrimeNumbers));
+        }
+        return subTasks;
+    }
+
+    @Override
+    protected void compute() {
+        if (((upperBound + 1) - lowerBound) > granularity) {
+            ForkJoinTask.invokeAll(subTasks());
+        } else {
+            findPrimeNumbers();
+        }
+    }
+
+    void findPrimeNumbers() {
+        for (int num = lowerBound; num <= upperBound; num++) {
+            if (isPrime(num)) {
+                noOfPrimeNumbers.getAndIncrement();
+            }
+        }
+    }
+
+    private boolean isPrime(int number) {
+        if (number == 2) {
+            return true;
+        }
+
+        if (number == 1 || number % 2 == 0) {
+            return false;
+        }
+
+        int noOfNaturalNumbers = 0;
+
+        for (int i = 1; i <= number; i++) {
+            if (number % i == 0) {
+                noOfNaturalNumbers++;
+            }
+        }
+
+        return noOfNaturalNumbers == 2;
+    }
+
+    public int noOfPrimeNumbers() {
+        return noOfPrimeNumbers.intValue();
+    }
+}

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/rejection/SaturationPolicyUnitTest.java

@@ -1,6 +1,7 @@
 package com.baeldung.rejection;
 
 import org.junit.After;
+import org.junit.Ignore;
 import org.junit.Test;
 
 import java.util.ArrayList;
@@ -28,24 +29,26 @@ public class SaturationPolicyUnitTest {
         }
     }
 
+    @Ignore
     @Test
     public void givenAbortPolicy_WhenSaturated_ThenShouldThrowRejectedExecutionException() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new AbortPolicy());
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(250));
 
         assertThatThrownBy(() -> executor.execute(() -> System.out.println("Will be rejected"))).isInstanceOf(RejectedExecutionException.class);
     }
 
+    @Ignore
     @Test
     public void givenCallerRunsPolicy_WhenSaturated_ThenTheCallerThreadRunsTheTask() {
         executor = new ThreadPoolExecutor(1, 1, 0, MILLISECONDS, new SynchronousQueue<>(), new CallerRunsPolicy());
-        executor.execute(() -> waitFor(100));
+        executor.execute(() -> waitFor(250));
 
-        long startTime = System.nanoTime();
-        executor.execute(() -> waitFor(100));
-        double blockedDuration = (System.nanoTime() - startTime) / 1_000_000.0;
+        long startTime = System.currentTimeMillis();
+        executor.execute(() -> waitFor(500));
+        long blockedDuration = System.currentTimeMillis() - startTime;
 
-        assertThat(blockedDuration).isGreaterThanOrEqualTo(100);
+        assertThat(blockedDuration).isGreaterThanOrEqualTo(500);
     }
 
     @Test

core-java-modules/core-java-concurrency-advanced-3/src/test/java/com/baeldung/workstealing/PrimeNumbersUnitTest.java

@@ -0,0 +1,101 @@
+package com.baeldung.workstealing;
+
+import org.junit.Test;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ForkJoinPool;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.fail;
+
+public class PrimeNumbersUnitTest {
+
+    private static Logger logger = Logger.getAnonymousLogger();
+
+    @Test
+    public void givenPrimesCalculated_whenUsingPoolsAndOneThread_thenOneThreadSlowest() {
+        Options opt = new OptionsBuilder()
+          .include(Benchmarker.class.getSimpleName())
+          .forks(1)
+          .build();
+
+        try {
+            new Runner(opt).run();
+        } catch (RunnerException e) {
+            fail();
+        }
+    }
+
+    @Test
+    public void givenNewWorkStealingPool_whenGettingPrimes_thenStealCountChanges() {
+        StringBuilder info = new StringBuilder();
+
+        for (int granularity : PrimeNumbers.GRANULARITIES) {
+            int parallelism = ForkJoinPool.getCommonPoolParallelism();
+            ForkJoinPool pool =
+              (ForkJoinPool) Executors.newWorkStealingPool(parallelism);
+
+            stealCountInfo(info, granularity, pool);
+        }
+        logger.info("\nExecutors.newWorkStealingPool ->" + info.toString());
+    }
+
+    @Test
+    public void givenCommonPool_whenGettingPrimes_thenStealCountChangesSlowly() {
+        StringBuilder info = new StringBuilder();
+
+        for (int granularity : PrimeNumbers.GRANULARITIES) {
+            ForkJoinPool pool = ForkJoinPool.commonPool();
+            stealCountInfo(info, granularity, pool);
+        }
+        logger.info("\nForkJoinPool.commonPool ->" + info.toString());
+    }
+
+    private void stealCountInfo(StringBuilder info, int granularity, ForkJoinPool forkJoinPool) {
+        PrimeNumbers primes = new PrimeNumbers(1, 10000, granularity, new AtomicInteger(0));
+        forkJoinPool.invoke(primes);
+        forkJoinPool.shutdown();
+
+        long steals = forkJoinPool.getStealCount();
+        String output = "\nGranularity: [" + granularity + "], Steals: [" + steals + "]";
+        info.append(output);
+    }
+
+
+    @BenchmarkMode(Mode.AverageTime)
+    @OutputTimeUnit(TimeUnit.MILLISECONDS)
+    @State(Scope.Benchmark)
+    @Fork(value = 2, warmups = 1, jvmArgs = {"-Xms2G", "-Xmx2G"})
+    public static class Benchmarker {
+
+        @Benchmark
+        public void singleThread() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            primes.findPrimeNumbers(); // get prime numbers using a single thread
+        }
+
+        @Benchmark
+        public void commonPoolBenchmark() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            ForkJoinPool pool = ForkJoinPool.commonPool();
+            pool.invoke(primes);
+            pool.shutdown();
+        }
+
+        @Benchmark
+        public void newWorkStealingPoolBenchmark() {
+            PrimeNumbers primes = new PrimeNumbers(10000);
+            int parallelism = ForkJoinPool.getCommonPoolParallelism();
+            ForkJoinPool stealer = (ForkJoinPool) Executors.newWorkStealingPool(parallelism);
+            stealer.invoke(primes);
+            stealer.shutdown();
+        }
+    }
+}

core-java-modules/core-java-concurrency-collections/src/test/java/com/baeldung/java/stream/ThreadPoolInParallelStreamIntegrationTest.java

@@ -1,4 +1,4 @@
-package org.baeldung.java.streams;
+package com.baeldung.java.stream;
 
 import org.junit.Test;
 

core-java-modules/core-java-datetime-java8-2/pom.xml

@@ -0,0 +1,72 @@
+<?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>core-java-datetime-java8</artifactId>
+    <version>${project.parent.version}</version>
+    <name>core-java-datetime-java8</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>joda-time</groupId>
+            <artifactId>joda-time</artifactId>
+            <version>${joda-time.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>log4j</groupId>
+            <artifactId>log4j</artifactId>
+            <version>${log4j.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <finalName>core-java-datetime-java8</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
+
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <source>${maven.compiler.source}</source>
+                    <target>${maven.compiler.target}</target>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.source>1.9</maven.compiler.source>
+        <maven.compiler.target>1.9</maven.compiler.target>
+        <joda-time.version>2.10</joda-time.version>
+        <!-- testing -->
+        <assertj.version>3.6.1</assertj.version>
+    </properties>
+
+</project>

core-java-modules/core-java-datetime-java8-2/src/main/java/com/baeldung/localdate/LocalDateExample.java

@@ -0,0 +1,31 @@
+package com.baeldung.localdate;
+
+import java.time.LocalDate;
+import java.time.Month;
+import java.time.format.DateTimeFormatter;
+
+public class LocalDateExample {
+    public LocalDate getCustomDateOne(int year, int month, int dayOfMonth) {
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+
+    public LocalDate getCustomDateTwo(int year, Month month, int dayOfMonth) {
+        return LocalDate.of(year, month, dayOfMonth);
+    }
+
+    public LocalDate getDateFromEpochDay(long epochDay) {
+        return LocalDate.ofEpochDay(epochDay);
+    }
+
+    public LocalDate getDateFromYearAndDayOfYear(int year, int dayOfYear) {
+        return LocalDate.ofYearDay(year, dayOfYear);
+    }
+
+    public LocalDate getDateFromString(String date) {
+        return LocalDate.parse(date);
+    }
+
+    public LocalDate getDateFromStringAndFormatter(String date, String pattern) {
+        return LocalDate.parse(date, DateTimeFormatter.ofPattern(pattern));
+    }
+}

core-java-modules/core-java-datetime-java8-2/src/test/java/com/baeldung/localdate/LocalDateExampleUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.datebasics;
+package com.baeldung.localdate;
 
 import static org.junit.Assert.assertEquals;
 
@@ -6,49 +6,34 @@ import java.time.Month;
 
 import org.junit.Test;
 
-public class CreateDateUnitTest {
-    private CreateDate date = new CreateDate();
-    
-    @Test
-    public void whenUsingNowMethod_thenLocalDate() {
-        assertEquals("2020-01-08", date.getTodaysDate());
-    }
-    
-    @Test
-    public void whenUsingClock_thenLocalDate() {
-        assertEquals("2020-01-08", date.getTodaysDateFromClock());
-    }
-    
-    @Test
-    public void givenValues_whenUsingZone_thenLocalDate() {
-        assertEquals("2020-01-08", date.getTodaysDateFromZone("Asia/Kolkata"));
-    }
-    
+public class LocalDateExampleUnitTest {
+    private LocalDateExample date = new LocalDateExample();
+
     @Test
     public void givenValues_whenUsingOfMethod_thenLocalDate() {
         assertEquals("2020-01-08", date.getCustomDateOne(2020, 1, 8));
     }
-    
+
     @Test
     public void givenValuesWithMonthEnum_whenUsingOfMethod_thenLocalDate() {
         assertEquals("2020-01-08", date.getCustomDateTwo(2020, Month.JANUARY, 8));
     }
-    
+
     @Test
     public void givenValues_whenUsingEpochDay_thenLocalDate() {
         assertEquals("2020-01-08", date.getDateFromEpochDay(18269));
     }
-    
+
     @Test
     public void givenValues_whenUsingYearDay_thenLocalDate() {
         assertEquals("2020-01-08", date.getDateFromYearAndDayOfYear(2020, 8));
     }
-    
+
     @Test
     public void givenValues_whenUsingParse_thenLocalDate() {
         assertEquals("2020-01-08", date.getDateFromString("2020-01-08"));
     }
-    
+
     @Test
     public void givenValuesWithFormatter_whenUsingParse_thenLocalDate() {
         assertEquals("2020-01-08", date.getDateFromStringAndFormatter("8-Jan-2020", "d-MMM-yyyy"));

core-java-modules/core-java-datetime-java8/src/main/java/com/baeldung/datebasics/CreateDate.java

@@ -1,45 +0,0 @@
-package com.baeldung.datebasics;
-
-import java.time.Clock;
-import java.time.LocalDate;
-import java.time.Month;
-import java.time.ZoneId;
-import java.time.format.DateTimeFormatter;
-
-public class CreateDate {
-	public LocalDate getTodaysDate() {
-		return LocalDate.now();
-	}
-
-	public LocalDate getTodaysDateFromClock() {
-		return LocalDate.now(Clock.systemDefaultZone());
-	}
-
-	public LocalDate getTodaysDateFromZone(String zone) {
-		return LocalDate.now(ZoneId.of(zone));
-	}
-
-	public LocalDate getCustomDateOne(int year, int month, int dayOfMonth) {
-		return LocalDate.of(year, month, dayOfMonth);
-	}
-
-	public LocalDate getCustomDateTwo(int year, Month month, int dayOfMonth) {
-		return LocalDate.of(year, month, dayOfMonth);
-	}
-
-	public LocalDate getDateFromEpochDay(long epochDay) {
-		return LocalDate.ofEpochDay(epochDay);
-	}
-
-	public LocalDate getDateFromYearAndDayOfYear(int year, int dayOfYear) {
-		return LocalDate.ofYearDay(year, dayOfYear);
-	}
-
-	public LocalDate getDateFromString(String date) {
-		return LocalDate.parse(date);
-	}
-
-	public LocalDate getDateFromStringAndFormatter(String date, String pattern) {
-		return LocalDate.parse(date, DateTimeFormatter.ofPattern(pattern));
-	}
-}

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

@@ -13,12 +13,24 @@
 		<version>0.0.1-SNAPSHOT</version>
 		<relativePath>../../parent-java</relativePath>
 	</parent>
+	
+	<dependencies>
+		<!-- test scoped -->
+		<dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+	</dependencies>
 
 	<description> </description>
 	<url>http://maven.apache.org</url>
 
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<!-- testing -->
+		<assertj-core.version>3.10.0</assertj-core.version>
 	</properties>
 
 </project>