Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/AnnotationTestExampleUnitTest.java

@@ -0,0 +1,28 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+import java.time.Duration;
+
+@Tag("annotations")
+@Tag("junit5")
+@RunWith(JUnitPlatform.class)
+public class AnnotationTestExampleUnitTest {
+    @Test
+    public void shouldRaiseAnException() throws Exception {
+        Assertions.assertThrows(Exception.class, () -> {
+            throw new Exception("This is my expected exception");
+        });
+    }
+
+    @Test
+    @Disabled
+    public void shouldFailBecauseTimeout() throws InterruptedException {
+        Assertions.assertTimeout(Duration.ofMillis(1), () -> Thread.sleep(10));
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/AssertionUnitTest.java

@@ -0,0 +1,40 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@DisplayName("Test case for assertions")
+public class AssertionUnitTest {
+
+    @Test
+    @DisplayName("Arrays should be equals")
+    public void whenAssertingArraysEquality_thenEqual() {
+        char[] expected = {'J', 'u', 'p', 'i', 't', 'e', 'r'};
+        char[] actual = "Jupiter".toCharArray();
+
+        assertArrayEquals(expected, actual, "Arrays should be equal");
+    }
+
+    @Test
+    @DisplayName("The area of two polygons should be equal")
+    public void whenAssertingEquality_thenEqual() {
+        float square = 2 * 2;
+        float rectangle = 2 * 2;
+
+        assertEquals(square, rectangle);
+    }
+
+    @Test
+    public void givenMultipleAssertion_whenAssertingAll_thenOK() {
+        assertAll(
+                "heading",
+                () -> assertEquals(4, 2 * 2, "4 is 2 times 2"),
+                () -> assertEquals("java", "JAVA".toLowerCase()),
+                () -> assertEquals((String) null, (String) null, "null is equal to null")
+        );
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/AssumptionUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assumptions.*;
+
+public class AssumptionUnitTest {
+
+    @Test
+    public void trueAssumption() {
+        assumeTrue(5 > 1, () -> "5 is greater the 1");
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    public void falseAssumption() {
+        assumeFalse(5 < 1, () -> "5 is less then 1");
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    public void assumptionThat() {
+        String someString = "Just a string";
+        assumingThat(someString.equals("Just a string"), () -> assertEquals(2 + 2, 4));
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/ConditionalExecutionUnitTest.java

@@ -0,0 +1,69 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+public class ConditionalExecutionUnitTest {
+
+    @Test
+    @EnabledOnOs({OS.MAC})
+    void whenOperatingSystemIsMac_thenTestIsEnabled() {
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    @DisabledOnOs({OS.WINDOWS})
+    void whenOperatingSystemIsWindows_thenTestIsDisabled() {
+        assertEquals(5 + 2, 7);
+    }
+
+    @Test
+    @EnabledOnJre({JRE.JAVA_8})
+    void whenRunningTestsOnJRE8_thenTestIsEnabled() {
+        assertTrue(5 > 4, "5 is greater the 4");
+        assertTrue(null == null, "null is equal to null");
+    }
+
+    @Test
+    @DisabledOnJre({JRE.JAVA_10})
+    void whenRunningTestsOnJRE10_thenTestIsDisabled() {
+        assertTrue(5 > 4, "5 is greater the 4");
+        assertTrue(null == null, "null is equal to null");
+    }
+
+    @Test
+    @EnabledIfSystemProperty(named = "os.arch", matches = ".*64.*")
+    public void whenRunningTestsOn64BitArchitectures_thenTestIsDisabled() {
+        Integer value = 5; // result of an algorithm
+
+        assertNotEquals(0, value, "The result cannot be 0");
+    }
+
+    @Test
+    @DisabledIfSystemProperty(named = "ci-server", matches = "true")
+    public void whenRunningTestsOnCIServer_thenTestIsDisabled() {
+        Integer value = 5; // result of an algorithm
+
+        assertNotEquals(0, value, "The result cannot be 0");
+    }
+
+    @Test
+    @EnabledIfEnvironmentVariable(named = "ENV", matches = "staging-server")
+    public void whenRunningTestsStagingServer_thenTestIsEnabled() {
+        char[] expected = {'J', 'u', 'p', 'i', 't', 'e', 'r'};
+        char[] actual = "Jupiter".toCharArray();
+
+        assertArrayEquals(expected, actual, "Arrays should be equal");
+    }
+
+    @Test
+    @DisabledIfEnvironmentVariable(named = "ENV", matches = ".*development.*")
+    public void whenRunningTestsDevelopmentEnvironment_thenTestIsDisabled() {
+        char[] expected = {'J', 'u', 'p', 'i', 't', 'e', 'r'};
+        char[] actual = "Jupiter".toCharArray();
+
+        assertArrayEquals(expected, actual, "Arrays should be equal");
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/NestedUnitTest.java

@@ -0,0 +1,77 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.*;
+
+import java.util.EmptyStackException;
+import java.util.Stack;
+
+public class NestedUnitTest {
+
+    Stack<Object> stack;
+
+    @Test
+    @DisplayName("is instantiated with new Stack()")
+    void isInstantiatedWithNew() {
+        new Stack<>();
+    }
+
+    @Nested
+    @DisplayName("when new")
+    class WhenNew {
+
+        @BeforeEach
+        void init() {
+            stack = new Stack<>();
+        }
+
+        @Test
+        @DisplayName("is empty")
+        void isEmpty() {
+            Assertions.assertTrue(stack.isEmpty());
+        }
+
+        @Test
+        @DisplayName("throws EmptyStackException when popped")
+        void throwsExceptionWhenPopped() {
+            Assertions.assertThrows(EmptyStackException.class, () -> stack.pop());
+        }
+
+        @Test
+        @DisplayName("throws EmptyStackException when peeked")
+        void throwsExceptionWhenPeeked() {
+            Assertions.assertThrows(EmptyStackException.class, () -> stack.peek());
+        }
+
+        @Nested
+        @DisplayName("after pushing an element")
+        class AfterPushing {
+
+            String anElement = "an element";
+
+            @BeforeEach
+            void init() {
+                stack.push(anElement);
+            }
+
+            @Test
+            @DisplayName("it is no longer empty")
+            void isEmpty() {
+                Assertions.assertFalse(stack.isEmpty());
+            }
+
+            @Test
+            @DisplayName("returns the element when popped and is empty")
+            void returnElementWhenPopped() {
+                Assertions.assertEquals(anElement, stack.pop());
+                Assertions.assertTrue(stack.isEmpty());
+            }
+
+            @Test
+            @DisplayName("returns the element when peeked but remains not empty")
+            void returnElementWhenPeeked() {
+                Assertions.assertEquals(anElement, stack.peek());
+                Assertions.assertFalse(stack.isEmpty());
+            }
+        }
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/RuleExampleUnitTest.java

@@ -0,0 +1,17 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.platform.runner.JUnitPlatform;
+import org.junit.runner.RunWith;
+
+@RunWith(JUnitPlatform.class)
+@ExtendWith(TraceUnitExtension.class)
+public class RuleExampleUnitTest {
+
+    @Test
+    public void whenTracingTests() {
+        System.out.println("This is my test");
+        /*...*/
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/RuleMigrationSupportUnitTest.java

@@ -0,0 +1,27 @@
+package com.baeldung.junit5;
+
+import org.junit.Rule;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.migrationsupport.rules.EnableRuleMigrationSupport;
+import org.junit.rules.ExpectedException;
+
+@EnableRuleMigrationSupport
+public class RuleMigrationSupportUnitTest {
+
+    @Rule
+    public ExpectedException exceptionRule = ExpectedException.none();
+
+    @Test
+    public void whenExceptionThrown_thenExpectationSatisfied() {
+        exceptionRule.expect(NullPointerException.class);
+        String test = null;
+        test.length();
+    }
+
+    @Test
+    public void whenExceptionThrown_thenRuleIsApplied() {
+        exceptionRule.expect(NumberFormatException.class);
+        exceptionRule.expectMessage("For input string");
+        Integer.parseInt("1a");
+    }
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/TestAnnotationsUnitTest.java

@@ -0,0 +1,39 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.*;
+
+import java.util.logging.Logger;
+
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class TestAnnotationsUnitTest {
+
+    private static final Logger log = Logger.getLogger(TestAnnotationsUnitTest.class.getName());
+
+    @BeforeAll
+    static void setup() {
+        log.info("@BeforeAll - executes once before all test methods in this class");
+    }
+
+    @BeforeEach
+    void init() {
+        log.info("@BeforeEach - executes before each test method in this class");
+    }
+
+    @Test
+    @Disabled
+    void disabledTest() {
+        assertTrue(false);
+    }
+
+    @AfterEach
+    void tearDown() {
+        log.info("@AfterEach - executed after each test method.");
+    }
+
+    @AfterAll
+    static void done() {
+        log.info("@AfterAll - executed after all test methods.");
+    }
+
+}

testing-modules/junit5-migration/src/test/java/com/baeldung/junit5/TraceUnitExtension.java

@@ -0,0 +1,19 @@
+package com.baeldung.junit5;
+
+import org.junit.jupiter.api.extension.AfterEachCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
+import org.junit.jupiter.api.extension.ExtensionContext;
+
+public class TraceUnitExtension implements AfterEachCallback, BeforeEachCallback {
+
+    @Override
+    public void beforeEach(ExtensionContext context) throws Exception {
+        System.out.println("Starting test ... " + context.getDisplayName());
+    }
+
+    @Override
+    public void afterEach(ExtensionContext context) throws Exception {
+        System.out.println("... test finished. " + context.getDisplayName());
+    }
+
+}