Merge pull request #81 from eugenp/master

update

aws-lambda/lambda/pom.xml

@@ -89,7 +89,6 @@
 
     <properties>
         <json-simple.version>1.1.1</json-simple.version>
-        <commons-io.version>2.5</commons-io.version>
         <aws-lambda-java-events.version>1.3.0</aws-lambda-java-events.version>
         <aws-lambda-java-core.version>1.2.0</aws-lambda-java-core.version>
         <gson.version>2.8.2</gson.version>

blade/pom.xml

@@ -154,7 +154,6 @@
     <properties>
         <blade-mvc.version>2.0.14.RELEASE</blade-mvc.version>
         <bootstrap.version>4.2.1</bootstrap.version>
-        <commons-lang3.version>3.8.1</commons-lang3.version>
         <lombok.version>1.18.4</lombok.version>
         <httpclient.version>4.5.6</httpclient.version>
         <httpmime.version>4.5.6</httpmime.version>

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

@@ -6,3 +6,4 @@ This module contains articles about Java 11 core features
 - [Guide to Java 8 Optional](https://www.baeldung.com/java-optional)
 - [Guide to Java Reflection](http://www.baeldung.com/java-reflection)
 - [Guide to Java 8’s Collectors](https://www.baeldung.com/java-8-collectors)
+- [New Features in Java 11](https://www.baeldung.com/java-11-new-features)

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

@@ -28,6 +28,29 @@
             <version>${assertj.version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>org.mock-server</groupId>
+            <artifactId>mockserver-junit-jupiter</artifactId>
+            <version>${mockserver.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit.jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
     <build>
@@ -48,7 +71,9 @@
         <maven.compiler.source.version>11</maven.compiler.source.version>
         <maven.compiler.target.version>11</maven.compiler.target.version>
         <guava.version>29.0-jre</guava.version>
+        <junit.jupiter.version>5.7.0</junit.jupiter.version>
         <assertj.version>3.17.2</assertj.version>
+        <mockserver.version>5.11.1</mockserver.version>
     </properties>
 
 </project>

core-java-modules/core-java-11-2/src/main/java/com/baeldung/features/MainClass.java

@@ -0,0 +1,17 @@
+package com.baeldung.features;
+
+public class MainClass {
+
+    private static boolean mainPrivateMethod() {
+        return true;
+    }
+
+    public static class NestedClass {
+
+        boolean nestedPublicMethod() {
+            return mainPrivateMethod();
+        }
+
+    }
+
+}

core-java-modules/core-java-11-2/src/test/java/com/baeldung/features/HttpClientIntegrationTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.mockserver.integration.ClientAndServer;
+import org.mockserver.model.HttpStatusCode;
+import org.mockserver.socket.PortFactory;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.time.Duration;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockserver.integration.ClientAndServer.startClientAndServer;
+
+class HttpClientIntegrationTest {
+
+    private static ClientAndServer mockServer;
+    private static int port;
+
+    @BeforeAll
+    static void startServer() {
+        port = PortFactory.findFreePort();
+        mockServer = startClientAndServer(port);
+        mockServer.when(new org.mockserver.model.HttpRequest().withMethod("GET"))
+          .respond(new org.mockserver.model.HttpResponse()
+            .withStatusCode(HttpStatusCode.OK_200.code())
+            .withBody("Hello from the server!"));
+    }
+
+    @AfterAll
+    static void stopServer() {
+        mockServer.stop();
+    }
+
+    @Test
+    void givenSampleHttpRequest_whenRequestIsSent_thenServerResponseIsReceived() throws IOException, InterruptedException {
+        HttpClient httpClient = HttpClient.newBuilder()
+          .version(HttpClient.Version.HTTP_2)
+          .connectTimeout(Duration.ofSeconds(20))
+          .build();
+        HttpRequest httpRequest = HttpRequest.newBuilder()
+          .GET()
+          .uri(URI.create("http://localhost:" + port))
+          .build();
+        HttpResponse<String> httpResponse = httpClient.send(httpRequest, HttpResponse.BodyHandlers.ofString());
+        assertThat(httpResponse.body()).isEqualTo("Hello from the server!");
+    }
+
+}

core-java-modules/core-java-11-2/src/test/java/com/baeldung/features/JavaElevenFeaturesUnitTest.java

@@ -0,0 +1,61 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import javax.annotation.Nonnull;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class JavaElevenFeaturesUnitTest {
+
+    @Test
+    void givenMultilineString_whenExtractingNonBlankStrippedLines_thenLinesAreReturned() {
+        String multilineString = "Baeldung helps \n \n developers \n explore Java.";
+        List<String> lines = multilineString.lines()
+          .filter(line -> !line.isBlank())
+          .map(String::strip)
+          .collect(Collectors.toList());
+        assertThat(lines).containsExactly("Baeldung helps", "developers", "explore Java.");
+    }
+
+    @Test
+    void givenTemporaryFile_whenReadingStringContent_thenContentIsReturned(@TempDir Path tempDir) throws IOException {
+        Path filePath = Files.writeString(Files.createTempFile(tempDir, "demo", ".txt"), "Sample text");
+        String fileContent = Files.readString(filePath);
+        assertThat(fileContent).isEqualTo("Sample text");
+    }
+
+    @Test
+    void givenSampleList_whenConvertingToArray_thenItemsRemainUnchanged() {
+        List<String> sampleList = Arrays.asList("Java", "Kotlin");
+        String[] sampleArray = sampleList.toArray(String[]::new);
+        assertThat(sampleArray).containsExactly("Java", "Kotlin");
+    }
+
+    @Test
+    void givenSampleList_whenConvertingToUppercaseString_thenUppercaseIsReturned() {
+        List<String> sampleList = Arrays.asList("Java", "Kotlin");
+        String resultString = sampleList.stream()
+          .map((@Nonnull var x) -> x.toUpperCase())
+          .collect(Collectors.joining(", "));
+        assertThat(resultString).isEqualTo("JAVA, KOTLIN");
+    }
+
+    @Test
+    void givenSampleList_whenExtractingNonBlankValues_thenOnlyNonBlanksAreReturned() {
+        List<String> sampleList = Arrays.asList("Java", "\n \n", "Kotlin", " ");
+        List<String> withoutBlanks = sampleList.stream()
+          .filter(Predicate.not(String::isBlank))
+          .collect(Collectors.toList());
+        assertThat(withoutBlanks).containsExactly("Java", "Kotlin");
+    }
+
+}

core-java-modules/core-java-11-2/src/test/java/com/baeldung/features/NestedClassesUnitTest.java

@@ -0,0 +1,37 @@
+package com.baeldung.features;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+class NestedClassesUnitTest {
+
+    @Test
+    public void giveNestedClass_whenCallingMainClassPrivateMethod_thenNoExceptionIsThrown() {
+        MainClass.NestedClass nestedInstance = new MainClass.NestedClass();
+        assertThat(nestedInstance.nestedPublicMethod()).isTrue();
+    }
+
+    @Test
+    public void giveNestedClass_whenCheckingNestmate_thenNestedClassIsReturned() {
+        assertThat(MainClass.class.isNestmateOf(MainClass.NestedClass.class)).isTrue();
+    }
+
+    @Test
+    public void giveNestedClass_whenCheckingNestHost_thenMainClassIsReturned() {
+        assertThat(MainClass.NestedClass.class.getNestHost()).isEqualTo(MainClass.class);
+    }
+
+    @Test
+    public void giveNestedClass_whenCheckingNestMembers_thenNestMembersAreReturned() {
+        Set<String> nestedMembers = Arrays.stream(MainClass.NestedClass.class.getNestMembers())
+          .map(Class::getName)
+          .collect(Collectors.toSet());
+        assertThat(nestedMembers).contains(MainClass.class.getName(), MainClass.NestedClass.class.getName());
+    }
+
+}

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

@@ -2,3 +2,4 @@
 
 
 - [String API Updates in Java 12](https://www.baeldung.com/java12-string-api)
+- [Java 12 New Features](https://www.baeldung.com/java-12-new-features)

core-java-modules/core-java-12/src/test/java/com/baeldung/newfeatures/CompactNumbersUnitTest.java

@@ -0,0 +1,21 @@
+package java.com.baeldung.newfeatures;
+
+import org.junit.Test;
+
+import java.text.NumberFormat;
+import java.util.Locale;
+
+import static org.junit.Assert.assertEquals;
+
+public class CompactNumbersUnitTest {
+
+    @Test
+    public void givenNumber_thenCompactValues() {
+        NumberFormat likesShort = NumberFormat.getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.SHORT);
+        likesShort.setMaximumFractionDigits(2);
+        assertEquals("2.59K", likesShort.format(2592));
+        NumberFormat likesLong = NumberFormat.getCompactNumberInstance(new Locale("en", "US"), NumberFormat.Style.LONG);
+        likesLong.setMaximumFractionDigits(2);
+        assertEquals("2.59 thousand", likesShort.format(2592));
+    }
+}

core-java-modules/core-java-12/src/test/java/com/baeldung/newfeatures/FileMismatchUnitTest.java

@@ -0,0 +1,32 @@
+package java.com.baeldung.newfeatures;
+
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.Assert.assertEquals;
+
+public class FileMismatchUnitTest {
+
+    @Test
+    public void givenIdenticalFiles_thenShouldNotFindMismatch() throws IOException {
+        Path filePath1 = Files.createTempFile("file1", ".txt");
+        Path filePath2 = Files.createTempFile("file2", ".txt");
+        Files.writeString(filePath1, "Java 12 Article");
+        Files.writeString(filePath2, "Java 12 Article");
+        long mismatch = Files.mismatch(filePath1, filePath2);
+        assertEquals(-1, mismatch);
+    }
+
+    @Test
+    public void givenDifferentFiles_thenShouldFindMismatch() throws IOException {
+        Path filePath3 = Files.createTempFile("file3", ".txt");
+        Path filePath4 = Files.createTempFile("file4", ".txt");
+        Files.writeString(filePath3, "Java 12 Article");
+        Files.writeString(filePath4, "Java 12 Tutorial");
+        long mismatch = Files.mismatch(filePath3, filePath4);
+        assertEquals(8, mismatch);
+    }
+}

core-java-modules/core-java-12/src/test/java/com/baeldung/newfeatures/StringUnitTest.java

@@ -0,0 +1,15 @@
+package java.com.baeldung.newfeatures;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class StringUnitTest {
+
+    @Test
+    public void givenString_thenRevertValue() {
+        String text = "Baeldung";
+        String transformed = text.transform(value -> new StringBuilder(value).reverse().toString());
+        assertEquals("gnudleaB", transformed);
+    }
+}

core-java-modules/core-java-12/src/test/java/com/baeldung/newfeatures/TeeingCollectorUnitTest.java

@@ -0,0 +1,18 @@
+package java.com.baeldung.newfeatures;
+
+import org.junit.Test;
+
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import static org.junit.Assert.assertEquals;
+
+public class TeeingCollectorUnitTest {
+
+    @Test
+    public void givenSetOfNumbers_thenCalculateAverage() {
+        double mean = Stream.of(1, 2, 3, 4, 5)
+          .collect(Collectors.teeing(Collectors.summingDouble(i -> i), Collectors.counting(), (sum, count) -> sum / count));
+        assertEquals(3.0, mean);
+    }
+}

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

@@ -20,7 +20,7 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>${apache-commons-lang3.version}</version>
+            <version>${commons-lang3.version}</version>
         </dependency>
         <dependency>
             <groupId>org.assertj</groupId>
@@ -68,7 +68,6 @@
 
     <properties>
         <maven.compiler.release>15</maven.compiler.release>
-        <apache-commons-lang3.version>3.11</apache-commons-lang3.version>
         <assertj.version>3.17.2</assertj.version>
         <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
         <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>

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

@@ -47,12 +47,12 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.11</version>
+            <version>${commons-lang3.version}</version>
         </dependency>
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>
-            <version>2.7</version>
+            <version>${commons-io.version}</version>
         </dependency>
     </dependencies>
 

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

@@ -29,8 +29,6 @@
     </dependencies>
 
     <properties>
-        <commons-lang3.version>3.9</commons-lang3.version>
-
         <assertj-core.version>3.10.0</assertj-core.version>
     </properties>
 </project>

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

@@ -68,11 +68,7 @@
 
     <properties>
         <shade.plugin.version>3.2.0</shade.plugin.version>
-
-        <commons-lang3.version>3.9</commons-lang3.version>
-
         <jmh.version>1.19</jmh.version>
-
         <assertj-core.version>3.10.0</assertj-core.version>
     </properties>
 </project>

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

@@ -76,12 +76,8 @@
 
     <properties>
         <shade.plugin.version>3.2.0</shade.plugin.version>
-
-        <commons-lang3.version>3.9</commons-lang3.version>
         <guava.version>28.2-jre</guava.version>
-
         <jmh.version>1.19</jmh.version>
-
         <assertj-core.version>3.10.0</assertj-core.version>
     </properties>
 </project>

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

@@ -3,4 +3,4 @@
 This module contains articles about Java Character Class
 
 ### Relevant Articles: 
-- Character#isAlphabetic vs Character#isLetter
+- [Character#isAlphabetic vs Character#isLetter](https://www.baeldung.com/java-character-isletter-isalphabetic)

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

@@ -35,7 +35,7 @@
         <dependency>
             <groupId>org.apache.commons</groupId>
             <artifactId>commons-lang3</artifactId>
-            <version>3.10</version>
+            <version>${commons-lang3.version}</version>
         </dependency>
     </dependencies>
 

core-java-modules/core-java-collections-list/pom.xml

@@ -36,7 +36,6 @@
 
     <properties>
         <commons-collections4.version>4.1</commons-collections4.version>
-        <commons-lang3.version>3.8.1</commons-lang3.version>
         <assertj.version>3.11.1</assertj.version>
     </properties>
 

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterJCStressManualTest.java

@@ -10,11 +10,17 @@ import org.openjdk.jcstress.annotations.Outcome;
 import org.openjdk.jcstress.annotations.State;
 import org.openjdk.jcstress.infra.results.I_Result;
 
+/**
+ * This is defined as a manual test because it tries to simulate the race conditions
+ * in a concurrent program that is poorly designed and hence may fail nondeterministically.
+ * This will help the CI jobs to ignore these tests and a developer to run them manually.
+ *
+ */
 @JCStressTest
 @Outcome(id = "1", expect = ACCEPTABLE_INTERESTING, desc = "One update lost.")
 @Outcome(id = "2", expect = ACCEPTABLE, desc = "Both updates.")
 @State
-public class MyCounterJCStressUnitTest {
+public class MyCounterJCStressManualTest {
 
     private MyCounter counter;
 

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterMultithreadedTCManualTest.java

@@ -1,12 +1,17 @@
 package com.baeldung.concurrent;
 
-import org.junit.Ignore;
 import org.junit.Test;
 
 import edu.umd.cs.mtc.MultithreadedTestCase;
 import edu.umd.cs.mtc.TestFramework;
 
-public class MyCounterMultithreadedTCUnitTest extends MultithreadedTestCase {
+/**
+ * This is defined as a manual test because it tries to simulate the race conditions
+ * in a concurrent program that is poorly designed and hence may fail nondeterministically.
+ * This will help the CI jobs to ignore these tests and a developer to run them manually.
+ *
+ */
+public class MyCounterMultithreadedTCManualTest extends MultithreadedTestCase {
 
     private MyCounter counter;
 
@@ -29,9 +34,8 @@ public class MyCounterMultithreadedTCUnitTest extends MultithreadedTestCase {
     	assertEquals(2, counter.getCount());
     }
 
-    @Ignore
     @Test
     public void testCounter() throws Throwable {
-        TestFramework.runManyTimes(new MyCounterMultithreadedTCUnitTest(), 1000);
+        TestFramework.runManyTimes(new MyCounterMultithreadedTCManualTest(), 1000);
     }
 }

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterSimpleManualTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.concurrent;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+import org.junit.Test;
+
+/**
+ * This is defined as a manual test because it tries to simulate the race conditions
+ * in a concurrent program that is poorly designed and hence may fail nondeterministically.
+ * This will help the CI jobs to ignore these tests and a developer to run them manually.
+ *
+ */
+public class MyCounterSimpleManualTest {
+
+	@Test
+	public void testCounter() {
+		MyCounter counter = new MyCounter();
+		for (int i = 0; i < 500; i++)
+			counter.increment();
+		assertEquals(500, counter.getCount());
+	}
+
+	@Test
+	public void testCounterWithConcurrency() throws InterruptedException {
+		int numberOfThreads = 100;
+		ExecutorService service = Executors.newFixedThreadPool(10);
+		CountDownLatch latch = new CountDownLatch(numberOfThreads);
+		MyCounter counter = new MyCounter();
+		for (int i = 0; i < numberOfThreads; i++) {
+			service.execute(() -> {
+				counter.increment();
+				latch.countDown();
+			});
+		}
+		latch.await();
+		assertEquals(numberOfThreads, counter.getCount());
+	}
+
+	@Test
+	public void testSummationWithConcurrencyAndWait() throws InterruptedException {
+		int numberOfThreads = 2;
+		ExecutorService service = Executors.newFixedThreadPool(10);
+		CountDownLatch latch = new CountDownLatch(numberOfThreads);
+		MyCounter counter = new MyCounter();
+		for (int i = 0; i < numberOfThreads; i++) {
+			service.submit(() -> {
+				try {
+					counter.incrementWithWait();
+				} catch (InterruptedException e) {
+					e.printStackTrace();
+				}
+				latch.countDown();
+			});
+		}
+		latch.await();
+		assertEquals(numberOfThreads, counter.getCount());
+	}
+
+}

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterSimpleUnitTest.java

@@ -1,60 +0,0 @@
-package com.baeldung.concurrent;
-
-import static org.junit.Assert.assertEquals;
-
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-public class MyCounterSimpleUnitTest {
-
-    @Test
-    public void testCounter() {
-        MyCounter counter = new MyCounter();
-        for (int i = 0; i < 500; i++)
-            counter.increment();
-        assertEquals(500, counter.getCount());
-    }
-
-    @Ignore
-    @Test
-    public void testCounterWithConcurrency() throws InterruptedException {
-        int numberOfThreads = 100;
-        ExecutorService service = Executors.newFixedThreadPool(10);
-        CountDownLatch latch = new CountDownLatch(numberOfThreads);
-        MyCounter counter = new MyCounter();
-        for (int i = 0; i < numberOfThreads; i++) {
-            service.execute(() -> {
-                counter.increment();
-                latch.countDown();
-            });
-        }
-        latch.await();
-        assertEquals(numberOfThreads, counter.getCount());
-    }
-
-    @Ignore
-    @Test
-    public void testSummationWithConcurrencyAndWait() throws InterruptedException {
-        int numberOfThreads = 2;
-        ExecutorService service = Executors.newFixedThreadPool(10);
-        CountDownLatch latch = new CountDownLatch(numberOfThreads);
-        MyCounter counter = new MyCounter();
-        for (int i = 0; i < numberOfThreads; i++) {
-            service.submit(() -> {
-                try {
-                    counter.incrementWithWait();
-                } catch (InterruptedException e) {
-                    e.printStackTrace();
-                }
-                latch.countDown();
-            });
-        }
-        latch.await();
-        assertEquals(numberOfThreads, counter.getCount());
-    }
-
-}

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterTempusFugitManualTest.java

@@ -0,0 +1,41 @@
+package com.baeldung.concurrent;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.AfterClass;
+import org.junit.Rule;
+import org.junit.Test;
+
+import com.google.code.tempusfugit.concurrency.ConcurrentRule;
+import com.google.code.tempusfugit.concurrency.RepeatingRule;
+import com.google.code.tempusfugit.concurrency.annotations.Concurrent;
+import com.google.code.tempusfugit.concurrency.annotations.Repeating;
+
+/**
+ * This is defined as a manual test because it tries to simulate the race conditions
+ * in a concurrent program that is poorly designed and hence may fail nondeterministically.
+ * This will help the CI jobs to ignore these tests and a developer to run them manually.
+ *
+ */
+public class MyCounterTempusFugitManualTest {
+
+	@Rule
+	public ConcurrentRule concurrently = new ConcurrentRule();
+	@Rule
+	public RepeatingRule rule = new RepeatingRule();
+
+	private static MyCounter counter = new MyCounter();
+
+	@Test
+	@Concurrent(count = 2)
+	@Repeating(repetition = 10)
+	public void runsMultipleTimes() {
+		counter.increment();
+	}
+
+	@AfterClass
+	public static void annotatedTestRunsMultipleTimes() throws InterruptedException {
+		assertEquals(counter.getCount(), 20);
+	}
+
+}

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterTempusFugitUnitTest.java

@@ -1,37 +0,0 @@
-package com.baeldung.concurrent;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.AfterClass;
-import org.junit.Ignore;
-import org.junit.Rule;
-import org.junit.Test;
-
-import com.google.code.tempusfugit.concurrency.ConcurrentRule;
-import com.google.code.tempusfugit.concurrency.RepeatingRule;
-import com.google.code.tempusfugit.concurrency.annotations.Concurrent;
-import com.google.code.tempusfugit.concurrency.annotations.Repeating;
-
-public class MyCounterTempusFugitUnitTest {
-
-    @Rule
-    public ConcurrentRule concurrently = new ConcurrentRule();
-    @Rule
-    public RepeatingRule rule = new RepeatingRule();
-
-    private static MyCounter counter = new MyCounter();
-
-    @Ignore
-    @Test
-    @Concurrent(count = 2)
-    @Repeating(repetition = 10)
-    public void runsMultipleTimes() {
-        counter.increment();
-    }
-
-    @AfterClass
-    public static void annotatedTestRunsMultipleTimes() throws InterruptedException {
-        assertEquals(counter.getCount(), 20);
-    }
-
-}

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterThreadWeaverManualTest.java

@@ -0,0 +1,48 @@
+package com.baeldung.concurrent;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+import com.google.testing.threadtester.AnnotatedTestRunner;
+import com.google.testing.threadtester.ThreadedAfter;
+import com.google.testing.threadtester.ThreadedBefore;
+import com.google.testing.threadtester.ThreadedMain;
+import com.google.testing.threadtester.ThreadedSecondary;
+
+/**
+ * This is defined as a manual test because it tries to simulate the race conditions
+ * in a concurrent program that is poorly designed and hence may fail nondeterministically.
+ * This will help the CI jobs to ignore these tests and a developer to run them manually.
+ *
+ */
+public class MyCounterThreadWeaverManualTest {
+
+	private MyCounter counter;
+
+	@ThreadedBefore
+	public void before() {
+		counter = new MyCounter();
+	}
+
+	@ThreadedMain
+	public void mainThread() {
+		counter.increment();
+	}
+
+	@ThreadedSecondary
+	public void secondThread() {
+		counter.increment();
+	}
+
+	@ThreadedAfter
+	public void after() {
+		assertEquals(2, counter.getCount());
+	}
+
+	@Test
+	public void testCounter() {
+		new AnnotatedTestRunner().runTests(this.getClass(), MyCounter.class);
+	}
+
+}

core-java-modules/core-java-concurrency-2/src/test/java/com/baeldung/concurrent/MyCounterThreadWeaverUnitTest.java

@@ -1,44 +0,0 @@
-package com.baeldung.concurrent;
-
-import static org.junit.Assert.assertEquals;
-
-import org.junit.Ignore;
-import org.junit.Test;
-
-import com.google.testing.threadtester.AnnotatedTestRunner;
-import com.google.testing.threadtester.ThreadedAfter;
-import com.google.testing.threadtester.ThreadedBefore;
-import com.google.testing.threadtester.ThreadedMain;
-import com.google.testing.threadtester.ThreadedSecondary;
-
-public class MyCounterThreadWeaverUnitTest {
-
-    private MyCounter counter;
-
-    @ThreadedBefore
-    public void before() {
-        counter = new MyCounter();
-    }
-
-    @ThreadedMain
-    public void mainThread() {
-        counter.increment();
-    }
-
-    @ThreadedSecondary
-    public void secondThread() {
-        counter.increment();
-    }
-
-    @ThreadedAfter
-    public void after() {
-        assertEquals(2, counter.getCount());
-    }
-
-    @Ignore
-    @Test
-    public void testCounter() {
-        new AnnotatedTestRunner().runTests(this.getClass(), MyCounter.class);
-    }
-
-}

core-java-modules/core-java-concurrency-advanced-4/README.md

@@ -0,0 +1,3 @@
+### Relevant Articles:
+
+- [Binary Semaphore vs Reentrant Lock](https://www.baeldung.com/java-binary-semaphore-vs-reentrant-lock)