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

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

testing-modules/testing-libraries/src/test/java/com/baeldung/calculator/CalculatorIntegrationTest.java

@@ -0,0 +1,14 @@
+package com.baeldung.calculator;
+
+import cucumber.api.CucumberOptions;
+import cucumber.api.junit.Cucumber;
+import org.junit.runner.RunWith;
+
+@RunWith(Cucumber.class)
+@CucumberOptions(
+  features = {"classpath:features/calculator.feature", "classpath:features/calculator-scenario-outline.feature"}
+  , plugin = {"pretty", "json:target/reports/json/calculator.json"}
+  , glue = {"com.baeldung.cucumber.calculator"}
+)
+public class CalculatorIntegrationTest {
+}

testing-modules/testing-libraries/src/test/java/com/baeldung/calculator/CalculatorRunSteps.java

@@ -0,0 +1,38 @@
+package com.baeldung.calculator;
+
+import com.baeldung.cucumber.Calculator;
+import cucumber.api.java.Before;
+import cucumber.api.java.en.Given;
+import cucumber.api.java.en.Then;
+import cucumber.api.java.en.When;
+import org.hamcrest.Matchers;
+import org.junit.Assert;
+
+public class CalculatorRunSteps {
+
+    private int total;
+
+    private Calculator calculator;
+
+    @Before
+    private void init() {
+        total = -999;
+
+    }
+
+    @Given("^I have a calculator$")
+    public void initializeCalculator() throws Throwable {
+        calculator = new Calculator();
+    }
+
+    @When("^I add (-?\\d+) and (-?\\d+)$")
+    public void testAdd(int num1, int num2) throws Throwable {
+        total = calculator.add(num1, num2);
+    }
+
+    @Then("^the result should be (-?\\d+)$")
+    public void validateResult(int result) throws Throwable {
+        Assert.assertThat(total, Matchers.equalTo(result));
+    }
+
+}

testing-modules/testing-libraries/src/test/java/com/baeldung/lambdabehave/CalculatorUnitTest.java

@@ -0,0 +1,54 @@
+package com.baeldung.lambdabehave;
+
+import com.insightfullogic.lambdabehave.JunitSuiteRunner;
+import com.insightfullogic.lambdabehave.Suite;
+import com.insightfullogic.lambdabehave.generators.Generator;
+import com.insightfullogic.lambdabehave.generators.SourceGenerator;
+import org.junit.runner.RunWith;
+
+@RunWith(JunitSuiteRunner.class)
+public class CalculatorUnitTest {
+
+    private Calculator calculator;
+
+    {
+        Suite.describe("Lambda behave example tests", it -> {
+
+            it.isSetupWith(() -> {
+                calculator = new Calculator(1, 2);
+            });
+            it.should("Add the given numbers", expect -> {
+                expect.that(calculator.add()).is(3);
+            });
+            it.should("Throw an exception if divide by 0", expect -> {
+                expect.exception(ArithmeticException.class, () -> {
+                    calculator.divide(1, 0);
+                });
+            });
+            it.uses(2, 3, 5)
+              .and(23, 10, 33)
+              .toShow("%d + %d = %d", (expect, a, b, c) -> {
+                  expect.that(calculator.add(a, b)).is(c);
+              });
+            it.requires(2)
+              .example(Generator.asciiStrings())
+              .toShow("Reversing a String twice returns the original String", (expect, str) -> {
+                  String same = new StringBuilder(str).reverse()
+                    .reverse()
+                    .toString();
+                  expect.that(same)
+                    .isEqualTo(str);
+              });
+            it.requires(2)
+              .withSource(SourceGenerator.deterministicNumbers(5626689007407L))
+              .example(Generator.asciiStrings())
+              .toShow("Reversing a String twice returns the original String", (expect, str) -> {
+                  String same = new StringBuilder(str).reverse()
+                    .reverse()
+                    .toString();
+                  expect.that(same)
+                    .isEqualTo(str);
+              });
+        });
+    }
+}

testing-modules/testing-libraries/src/test/java/com/baeldung/mutation/PalindromeUnitTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.mutation;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import com.baeldung.mutation.Palindrome;
+
+public class PalindromeUnitTest {
+    @Test
+    public void whenEmptyString_thanAccept() {
+        Palindrome palindromeTester = new Palindrome();
+        assertTrue(palindromeTester.isPalindrome("noon"));
+    }
+
+    @Test
+	public void whenPalindrom_thanAccept() {
+	    Palindrome palindromeTester = new Palindrome();
+	    assertTrue(palindromeTester.isPalindrome("noon"));
+    }
+    
+    @Test
+    public void whenNotPalindrom_thanReject(){
+    	Palindrome palindromeTester = new Palindrome();
+    	assertFalse(palindromeTester.isPalindrome("box"));
+    }
+    
+    @Test
+    public void whenNearPalindrom_thanReject(){
+    	Palindrome palindromeTester = new Palindrome();
+    	assertFalse(palindromeTester.isPalindrome("neon"));
+    }
+}

testing-modules/testing-libraries/src/test/java/com/baeldung/shopping/ShoppingIntegrationTest.java

@@ -0,0 +1,12 @@
+package com.baeldung.shopping;
+
+import org.junit.runner.RunWith;
+
+import cucumber.api.CucumberOptions;
+import cucumber.api.junit.Cucumber;
+
+@RunWith(Cucumber.class)
+@CucumberOptions(features = { "classpath:features/shopping.feature" })
+public class ShoppingIntegrationTest {
+
+}

testing-modules/testing-libraries/src/test/java/com/baeldung/shopping/ShoppingStepsDef.java

@@ -0,0 +1,22 @@
+package com.baeldung.shopping;
+
+import static org.junit.Assert.assertEquals;
+import cucumber.api.java8.En;
+
+public class ShoppingStepsDef implements En {
+
+    private int budget = 0;
+
+    public ShoppingStepsDef() {
+
+        Given("I have (\\d+) in my wallet", (Integer money) -> budget = money);
+
+        When("I buy .* with (\\d+)", (Integer price) -> budget -= price);
+
+        Then("I should have (\\d+) in my wallet", (Integer finalBudget) -> {
+            assertEquals(budget, finalBudget.intValue());
+        });
+
+    }
+
+}