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

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

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/AssertJConditionUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.assertj;
+
+import static org.assertj.core.api.Assertions.allOf;
+import static org.assertj.core.api.Assertions.anyOf;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.not;
+import static org.junit.Assert.fail;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.assertj.core.api.Condition;
+import org.junit.Test;
+
+public class AssertJConditionUnitTest {
+    private Condition<Member> senior = new Condition<>(m -> m.getAge() >= 60, "senior");
+    private Condition<Member> nameJohn = new Condition<>(m -> m.getName().equalsIgnoreCase("John"), "name John");
+
+    @Test
+    public void whenUsingMemberAgeCondition_thenCorrect() {
+        Member member = new Member("John", 65);
+        assertThat(member).is(senior);
+
+        try {
+            assertThat(member).isNot(senior);
+            fail();
+        } catch (AssertionError e) {
+            assertThat(e).hasMessageContaining("not to be <senior>");
+        }
+    }
+
+    @Test
+    public void whenUsingMemberNameCondition_thenCorrect() {
+        Member member = new Member("Jane", 60);
+        assertThat(member).doesNotHave(nameJohn);
+
+        try {
+            assertThat(member).has(nameJohn);
+            fail();
+        } catch (AssertionError e) {
+            assertThat(e).hasMessageContaining("<name John>");
+        }
+    }
+
+    @Test
+    public void whenCollectionConditionsAreSatisfied_thenCorrect() {
+        List<Member> members = new ArrayList<>();
+        members.add(new Member("Alice", 50));
+        members.add(new Member("Bob", 60));
+
+        assertThat(members).haveExactly(1, senior);
+        assertThat(members).doNotHave(nameJohn);
+    }
+
+    @Test
+    public void whenCombiningAllOfConditions_thenCorrect() {
+        Member john = new Member("John", 60);
+        Member jane = new Member("Jane", 50);
+
+        assertThat(john).is(allOf(senior, nameJohn));
+        assertThat(jane).is(allOf(not(nameJohn), not(senior)));
+    }
+
+    @Test
+    public void whenCombiningAnyOfConditions_thenCorrect() {
+        Member john = new Member("John", 50);
+        Member jane = new Member("Jane", 60);
+
+        assertThat(john).is(anyOf(senior, nameJohn));
+        assertThat(jane).is(anyOf(nameJohn, senior));
+    }
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/AssertJCoreUnitTest.java

@@ -0,0 +1,117 @@
+package com.baeldung.assertj;
+
+import org.assertj.core.util.Maps;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.io.InputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+import static org.assertj.core.api.Assertions.*;
+
+public class AssertJCoreUnitTest {
+
+    @Test
+    public void whenComparingReferences_thenNotEqual() throws Exception {
+        Dog fido = new Dog("Fido", 5.15f);
+        Dog fidosClone = new Dog("Fido", 5.15f);
+
+        assertThat(fido).isNotEqualTo(fidosClone);
+    }
+
+    @Test
+    public void whenComparingFields_thenEqual() throws Exception {
+        Dog fido = new Dog("Fido", 5.15f);
+        Dog fidosClone = new Dog("Fido", 5.15f);
+
+        assertThat(fido).isEqualToComparingFieldByFieldRecursively(fidosClone);
+    }
+
+    @Test
+    public void whenCheckingForElement_thenContains() throws Exception {
+        List<String> list = Arrays.asList("1", "2", "3");
+
+        assertThat(list).contains("1");
+    }
+
+    @Test
+    public void whenCheckingForElement_thenMultipleAssertions() throws Exception {
+        List<String> list = Arrays.asList("1", "2", "3");
+
+        assertThat(list).isNotEmpty();
+        assertThat(list).startsWith("1");
+        assertThat(list).doesNotContainNull();
+
+        assertThat(list).isNotEmpty().contains("1").startsWith("1").doesNotContainNull().containsSequence("2", "3");
+    }
+
+    @Test
+    public void whenCheckingRunnable_thenIsInterface() throws Exception {
+        assertThat(Runnable.class).isInterface();
+    }
+
+    @Test
+    public void whenCheckingCharacter_thenIsUnicode() throws Exception {
+        char someCharacter = 'c';
+
+        assertThat(someCharacter).isNotEqualTo('a').inUnicode().isGreaterThanOrEqualTo('b').isLowerCase();
+    }
+
+    @Test
+    public void whenAssigningNSEExToException_thenIsAssignable() throws Exception {
+        assertThat(Exception.class).isAssignableFrom(NoSuchElementException.class);
+    }
+
+    @Test
+    public void whenComparingWithOffset_thenEquals() throws Exception {
+        assertThat(5.1).isEqualTo(5, withPrecision(1d));
+    }
+
+    @Test
+    public void whenCheckingString_then() throws Exception {
+        assertThat("".isEmpty()).isTrue();
+    }
+
+    @Test
+    public void whenCheckingFile_then() throws Exception {
+        final File someFile = File.createTempFile("aaa", "bbb");
+        someFile.deleteOnExit();
+
+        assertThat(someFile).exists().isFile().canRead().canWrite();
+    }
+
+    @Test
+    public void whenCheckingIS_then() throws Exception {
+        InputStream given = new ByteArrayInputStream("foo".getBytes());
+        InputStream expected = new ByteArrayInputStream("foo".getBytes());
+
+        assertThat(given).hasSameContentAs(expected);
+    }
+
+    @Test
+    public void whenGivenMap_then() throws Exception {
+        Map<Integer, String> map = Maps.newHashMap(2, "a");
+
+        assertThat(map).isNotEmpty().containsKey(2).doesNotContainKeys(10).contains(entry(2, "a"));
+    }
+
+    @Test
+    public void whenGivenException_then() throws Exception {
+        Exception ex = new Exception("abc");
+
+        assertThat(ex).hasNoCause().hasMessageEndingWith("c");
+    }
+
+    @Ignore // IN ORDER TO TEST, REMOVE THIS LINE
+    @Test
+    public void whenRunningAssertion_thenDescribed() throws Exception {
+        Person person = new Person("Alex", 34);
+
+        assertThat(person.getAge()).as("%s's age should be equal to 100").isEqualTo(100);
+    }
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/AssertJGuavaUnitTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.assertj;
+
+import com.google.common.base.Optional;
+import com.google.common.collect.ArrayListMultimap;
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Multimap;
+import com.google.common.collect.Multimaps;
+import com.google.common.collect.Range;
+import com.google.common.collect.Table;
+import com.google.common.collect.TreeRangeMap;
+import com.google.common.io.Files;
+import org.assertj.guava.data.MapEntry;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import static org.assertj.guava.api.Assertions.assertThat;
+import static org.assertj.guava.api.Assertions.entry;
+
+public class AssertJGuavaUnitTest {
+
+    @Test
+    public void givenTwoEmptyFiles_whenComparingContent_thenEqual() throws Exception {
+        final File temp1 = File.createTempFile("bael", "dung1");
+        final File temp2 = File.createTempFile("bael", "dung2");
+
+        assertThat(Files.asByteSource(temp1)).hasSize(0).hasSameContentAs(Files.asByteSource(temp2));
+    }
+
+    @Test
+    public void givenMultimap_whenVerifying_thenCorrect() throws Exception {
+        final Multimap<Integer, String> mmap = ArrayListMultimap.create();
+        mmap.put(1, "one");
+        mmap.put(1, "1");
+
+        assertThat(mmap).hasSize(2).containsKeys(1).contains(entry(1, "one")).contains(entry(1, "1"));
+    }
+
+    @Test
+    public void givenMultimaps_whenVerifyingContent_thenCorrect() throws Exception {
+        final Multimap<Integer, String> mmap1 = ArrayListMultimap.create();
+        mmap1.put(1, "one");
+        mmap1.put(1, "1");
+        mmap1.put(2, "two");
+        mmap1.put(2, "2");
+
+        final Multimap<Integer, String> mmap1_clone = Multimaps.newSetMultimap(new HashMap<>(), HashSet::new);
+        mmap1_clone.put(1, "one");
+        mmap1_clone.put(1, "1");
+        mmap1_clone.put(2, "two");
+        mmap1_clone.put(2, "2");
+
+        final Multimap<Integer, String> mmap2 = Multimaps.newSetMultimap(new HashMap<>(), HashSet::new);
+        mmap2.put(1, "one");
+        mmap2.put(1, "1");
+
+        assertThat(mmap1).containsAllEntriesOf(mmap2).containsAllEntriesOf(mmap1_clone).hasSameEntriesAs(mmap1_clone);
+    }
+
+    @Test
+    public void givenOptional_whenVerifyingContent_thenShouldBeEqual() throws Exception {
+        final Optional<String> something = Optional.of("something");
+
+        assertThat(something).isPresent().extractingValue().isEqualTo("something");
+    }
+
+    @Test
+    public void givenRange_whenVerifying_thenShouldBeCorrect() throws Exception {
+        final Range<String> range = Range.openClosed("a", "g");
+
+        assertThat(range).hasOpenedLowerBound().isNotEmpty().hasClosedUpperBound().contains("b");
+    }
+
+    @Test
+    public void givenRangeMap_whenVerifying_thenShouldBeCorrect() throws Exception {
+        final TreeRangeMap<Integer, String> map = TreeRangeMap.create();
+
+        map.put(Range.closed(0, 60), "F");
+        map.put(Range.closed(61, 70), "D");
+
+        assertThat(map).isNotEmpty().containsKeys(0).contains(MapEntry.entry(34, "F"));
+    }
+
+    @Test
+    public void givenTable_whenVerifying_thenShouldBeCorrect() throws Exception {
+        final Table<Integer, String, String> table = HashBasedTable.create(2, 2);
+
+        table.put(1, "A", "PRESENT");
+        table.put(1, "B", "ABSENT");
+
+        assertThat(table).hasRowCount(1).containsValues("ABSENT").containsCell(1, "B", "ABSENT");
+    }
+
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/AssertJJava8UnitTest.java

@@ -0,0 +1,108 @@
+package com.baeldung.assertj;
+
+import org.junit.Test;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Predicate;
+
+import static java.time.LocalDate.ofYearDay;
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class AssertJJava8UnitTest {
+
+    @Test
+    public void givenOptional_shouldAssert() throws Exception {
+        final Optional<String> givenOptional = Optional.of("something");
+
+        assertThat(givenOptional).isPresent().hasValue("something");
+    }
+
+    @Test
+    public void givenPredicate_shouldAssert() throws Exception {
+        final Predicate<String> predicate = s -> s.length() > 4;
+
+        assertThat(predicate).accepts("aaaaa", "bbbbb").rejects("a", "b").acceptsAll(asList("aaaaa", "bbbbb")).rejectsAll(asList("a", "b"));
+    }
+
+    @Test
+    public void givenLocalDate_shouldAssert() throws Exception {
+        final LocalDate givenLocalDate = LocalDate.of(2016, 7, 8);
+        final LocalDate todayDate = LocalDate.now();
+
+        assertThat(givenLocalDate).isBefore(LocalDate.of(2020, 7, 8)).isAfterOrEqualTo(LocalDate.of(1989, 7, 8));
+
+        assertThat(todayDate).isAfter(LocalDate.of(1989, 7, 8)).isToday();
+    }
+
+    @Test
+    public void givenLocalDateTime_shouldAssert() throws Exception {
+        final LocalDateTime givenLocalDate = LocalDateTime.of(2016, 7, 8, 12, 0);
+
+        assertThat(givenLocalDate).isBefore(LocalDateTime.of(2020, 7, 8, 11, 2));
+    }
+
+    @Test
+    public void givenLocalTime_shouldAssert() throws Exception {
+        final LocalTime givenLocalTime = LocalTime.of(12, 15);
+
+        assertThat(givenLocalTime).isAfter(LocalTime.of(1, 0)).hasSameHourAs(LocalTime.of(12, 0));
+    }
+
+    @Test
+    public void givenList_shouldAssertFlatExtracting() throws Exception {
+        final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
+
+        assertThat(givenList).flatExtracting(LocalDate::getYear).contains(2015);
+    }
+
+    @Test
+    public void givenList_shouldAssertFlatExtractingLeapYear() throws Exception {
+        final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
+
+        assertThat(givenList).flatExtracting(LocalDate::isLeapYear).contains(true);
+    }
+
+    @Test
+    public void givenList_shouldAssertFlatExtractingClass() throws Exception {
+        final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
+
+        assertThat(givenList).flatExtracting(Object::getClass).contains(LocalDate.class);
+    }
+
+    @Test
+    public void givenList_shouldAssertMultipleFlatExtracting() throws Exception {
+        final List<LocalDate> givenList = asList(ofYearDay(2016, 5), ofYearDay(2015, 6));
+
+        assertThat(givenList).flatExtracting(LocalDate::getYear, LocalDate::getDayOfMonth).contains(2015, 6);
+    }
+
+    @Test
+    public void givenString_shouldSatisfy() throws Exception {
+        final String givenString = "someString";
+
+        assertThat(givenString).satisfies(s -> {
+            assertThat(s).isNotEmpty();
+            assertThat(s).hasSize(10);
+        });
+    }
+
+    @Test
+    public void givenString_shouldMatch() throws Exception {
+        final String emptyString = "";
+
+        assertThat(emptyString).matches(String::isEmpty);
+    }
+
+    @Test
+    public void givenList_shouldHasOnlyOneElementSatisfying() throws Exception {
+        final List<String> givenList = Arrays.asList("");
+
+        assertThat(givenList).hasOnlyOneElementSatisfying(s -> assertThat(s).isEmpty());
+    }
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/custom/AssertJCustomAssertionsUnitTest.java

@@ -0,0 +1,44 @@
+package com.baeldung.assertj.custom;
+
+import static com.baeldung.assertj.custom.Assertions.assertThat;
+import static org.junit.Assert.fail;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class AssertJCustomAssertionsUnitTest {
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Test
+    public void whenPersonNameMatches_thenCorrect() {
+        Person person = new Person("John Doe", 20);
+        assertThat(person).hasFullName("John Doe");
+    }
+
+    @Test
+    public void whenPersonAgeLessThanEighteen_thenNotAdult() {
+        Person person = new Person("Jane Roe", 16);
+
+        try {
+            assertThat(person).isAdult();
+            fail();
+        } catch (AssertionError e) {
+            org.assertj.core.api.Assertions.assertThat(e).hasMessage("Expected person to be adult");
+        }
+    }
+
+    @Test
+    public void whenPersonDoesNotHaveAMatchingNickname_thenIncorrect() {
+        Person person = new Person("John Doe", 20);
+        person.addNickname("Nick");
+
+        try {
+            assertThat(person).hasNickname("John");
+            fail();
+        } catch (AssertionError e) {
+            org.assertj.core.api.Assertions.assertThat(e).hasMessage("Expected person to have nickname John");
+        }
+    }
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/custom/Assertions.java

@@ -0,0 +1,9 @@
+package com.baeldung.assertj.custom;
+
+public class Assertions {
+    public static PersonAssert assertThat(Person actual) {
+        return new PersonAssert(actual);
+    }
+
+    // static factory methods of other assertion classes
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/custom/PersonAssert.java

@@ -0,0 +1,38 @@
+package com.baeldung.assertj.custom;
+
+import org.assertj.core.api.AbstractAssert;
+
+public class PersonAssert extends AbstractAssert<PersonAssert, Person> {
+
+    public PersonAssert(Person actual) {
+        super(actual, PersonAssert.class);
+    }
+
+    public static PersonAssert assertThat(Person actual) {
+        return new PersonAssert(actual);
+    }
+
+    public PersonAssert hasFullName(String fullName) {
+        isNotNull();
+        if (!actual.getFullName().equals(fullName)) {
+            failWithMessage("Expected person to have full name %s but was %s", fullName, actual.getFullName());
+        }
+        return this;
+    }
+
+    public PersonAssert isAdult() {
+        isNotNull();
+        if (actual.getAge() < 18) {
+            failWithMessage("Expected person to be adult");
+        }
+        return this;
+    }
+
+    public PersonAssert hasNickname(String nickName) {
+        isNotNull();
+        if (!actual.getNicknames().contains(nickName)) {
+            failWithMessage("Expected person to have nickname %s", nickName);
+        }
+        return this;
+    }
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/exceptions/Java7StyleAssertions.java

@@ -0,0 +1,24 @@
+package com.baeldung.assertj.exceptions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
+
+import org.junit.Test;
+
+public class Java7StyleAssertions {
+
+    @Test
+    public void whenDividingByZero_thenArithmeticException() {
+        try {
+            int numerator = 10;
+            int denominator = 0;
+            int quotient = numerator / denominator;
+            fail("ArithmeticException expected because dividing by zero yields an ArithmeticException.");
+            failBecauseExceptionWasNotThrown(ArithmeticException.class);
+        } catch (Exception e) {
+            assertThat(e).hasMessage("/ by zero");
+            assertThat(e).isInstanceOf(ArithmeticException.class);
+        }
+    }
+}

testing-modules/assertion-libraries/src/test/java/com/baeldung/assertj/exceptions/Java8StyleAssertions.java

@@ -0,0 +1,66 @@
+package com.baeldung.assertj.exceptions;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
+import static org.assertj.core.api.Assertions.catchThrowable;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.junit.Test;
+
+public class Java8StyleAssertions {
+
+    @Test
+    public void whenGettingOutOfBoundsItem_thenIndexOutOfBoundsException() {
+        assertThatThrownBy(() -> {
+            ArrayList<String> myStringList = new ArrayList<String>(Arrays.asList("Strine one", "String two"));
+            myStringList.get(2);
+        }).isInstanceOf(IndexOutOfBoundsException.class)
+            .hasMessageStartingWith("Index: 2")
+            .hasMessageContaining("2")
+            .hasMessageEndingWith("Size: 2")
+            .hasMessageContaining("Index: 2, Size: 2")
+            .hasMessage("Index: %s, Size: %s", 2, 2)
+            .hasMessageMatching("Index: \\d+, Size: \\d+")
+            .hasNoCause();
+    }
+
+    @Test
+    public void whenWrappingException_thenCauseInstanceOfWrappedExceptionType() {
+        assertThatThrownBy(() -> {
+            try {
+                throw new IOException();
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }).isInstanceOf(RuntimeException.class)
+            .hasCauseInstanceOf(IOException.class)
+            .hasStackTraceContaining("IOException");
+    }
+
+    @Test
+    public void whenDividingByZero_thenArithmeticException() {
+        assertThatExceptionOfType(ArithmeticException.class).isThrownBy(() -> {
+            int numerator = 10;
+            int denominator = 0;
+            int quotient = numerator / denominator;
+        })
+            .withMessageContaining("/ by zero");
+
+        // Alternatively:
+
+        // when
+        Throwable thrown = catchThrowable(() -> {
+            int numerator = 10;
+            int denominator = 0;
+            int quotient = numerator / denominator;
+        });
+
+        // then
+        assertThat(thrown).isInstanceOf(ArithmeticException.class)
+            .hasMessageContaining("/ by zero");
+
+    }
+}