Testing multithreading (#9193)

core-java-modules/core-java-concurrency-2/src/main/java/com/baeldung/concurrent/MyCounter.java

@@ -0,0 +1,22 @@
+package com.baeldung.concurrent;
+
+public class MyCounter {
+
+    private int count;
+
+    public void increment() {
+        int temp = count;
+        count = temp + 1;
+    }
+
+    public synchronized void incrementWithWait() throws InterruptedException {
+        int temp = count;
+        wait(100);
+        count = temp + 1;
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+}

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

@@ -0,0 +1,36 @@
+package com.baeldung.concurrent;
+
+import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE;
+import static org.openjdk.jcstress.annotations.Expect.ACCEPTABLE_INTERESTING;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.I_Result;
+
+@JCStressTest
+@Outcome(id = "1", expect = ACCEPTABLE_INTERESTING, desc = "One update lost.")
+@Outcome(id = "2", expect = ACCEPTABLE, desc = "Both updates.")
+@State
+public class MyCounterJCStressUnitTest {
+
+    private MyCounter counter;
+
+    @Actor
+    public void actor1() {
+        counter.increment();
+    }
+
+    @Actor
+    public void actor2() {
+        counter.increment();
+    }
+
+    @Arbiter
+    public void arbiter(I_Result r) {
+        r.r1 = counter.getCount();
+    }
+
+}

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

@@ -0,0 +1,37 @@
+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 {
+
+    private MyCounter counter;
+
+    @Override
+    public void initialize() {
+        counter = new MyCounter();
+    }
+
+    public void thread1() throws InterruptedException {
+        counter.increment();
+    }
+
+    public void thread2() throws InterruptedException {
+        counter.increment();
+    }
+
+    @SuppressWarnings("deprecation")
+    @Override
+    public void finish() {
+    	assertEquals(2, counter.getCount());
+    }
+
+    @Ignore
+    @Test
+    public void testCounter() throws Throwable {
+        TestFramework.runManyTimes(new MyCounterMultithreadedTCUnitTest(), 1000);
+    }
+}

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

@@ -0,0 +1,60 @@
+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/MyCounterTempusFugitUnitTest.java

@@ -0,0 +1,37 @@
+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/MyCounterThreadWeaverUnitTest.java

@@ -0,0 +1,44 @@
+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);
+    }
+
+}