From 4cb0c18dcab5ef768aefd936628a92d736534fe1 Mon Sep 17 00:00:00 2001 From: Andrei Punko Date: Sat, 12 Apr 2025 21:35:13 +0300 Subject: [PATCH] Replace Hamcrest matchers with AssertJ matchers. Fix #24 --- build.gradle | 1 - .../java/by/andd3dfx/numeric/Fibonacci.java | 6 +- .../cache/LFUCacheUsingLinkedHashSetTest.java | 66 ++++--- .../andd3dfx/cache/LFUCacheUsingTimeTest.java | 66 ++++--- .../java/by/andd3dfx/cache/LRUCacheTest.java | 18 +- .../collections/ReverseLinkedListTest.java | 22 ++- .../custom/CustomArrayListTest.java | 135 +++++++------- .../collections/custom/CustomHashMapTest.java | 134 +++++++------- .../collections/custom/CustomHashSetTest.java | 39 ++-- .../custom/CustomLinkedHashSetTest.java | 41 +++-- .../custom/CustomLinkedListTest.java | 168 +++++++++--------- .../by/andd3dfx/common/ArrayRangesTest.java | 13 +- .../java/by/andd3dfx/common/CandiesTest.java | 13 +- .../andd3dfx/common/CountStreamersTest.java | 9 +- .../by/andd3dfx/common/CustomEnumTest.java | 21 ++- .../andd3dfx/common/FileSystemPathTest.java | 21 ++- .../andd3dfx/common/InsuranceNumberTest.java | 97 +++++----- .../java/by/andd3dfx/common/NeedleTest.java | 16 +- .../common/PasswordBruteforceTest.java | 13 +- .../common/PropertiesExtractorTest.java | 11 +- .../common/SkipItemsByConditionTest.java | 23 ++- .../andd3dfx/common/TrainCompositionTest.java | 11 +- .../by/andd3dfx/common/UrlShortenerTest.java | 45 ++--- .../by/andd3dfx/common/UserInputTest.java | 37 ++-- .../common/birdsfarm/BirdsFarmTest.java | 5 +- .../core/GenericClassCreationTest.java | 14 +- .../java/by/andd3dfx/dynamic/StoriesTest.java | 25 ++- .../andd3dfx/iterators/EvenIteratorTest.java | 49 +++-- .../multithreading/AddMultithreadingTest.java | 3 +- .../multithreading/CustomAtomicTest.java | 27 ++- .../multithreading/TwoLegsRobotTest.java | 8 +- .../forkjoin/CommonRecursiveTaskTest.java | 17 +- .../forkjoin/CustomRecursiveTaskTest.java | 11 +- .../future/FactorialSquareCalculatorTest.java | 5 +- .../future/SquareCalculatorTest.java | 7 +- .../queue/AbstractBlockingQueueTest.java | 5 +- .../stack/CustomConcurrentStackTest.java | 25 ++- .../numeric/BestAverageScoreTest.java | 11 +- .../java/by/andd3dfx/numeric/BitsRowTest.java | 19 +- .../by/andd3dfx/numeric/FibonacciTest.java | 103 +++++------ .../FindNumberWhichAppearsOnceTest.java | 2 +- .../numeric/GreatestCommonDivisorTest.java | 21 +-- .../by/andd3dfx/numeric/IntDividerTest.java | 27 ++- .../by/andd3dfx/numeric/LargestPitTest.java | 22 +-- .../MaxMultiplicationOf3InArrayTest.java | 19 +- .../by/andd3dfx/numeric/RaiseToPowerTest.java | 51 ++++-- .../numeric/SecondLargestElementTest.java | 13 +- .../andd3dfx/numeric/SumOfTwoInArrayTest.java | 47 +++-- .../factorial/AbstractFactorialTest.java | 17 +- .../parser/xml/FolderNamesXmlParserTest.java | 8 +- .../parser/xml/LogsXmlParserTest.java | 8 +- .../proxy/ProxyCreationByInterfacesTest.java | 11 +- .../andd3dfx/recursion/BrickPyramidTest.java | 28 +-- .../andd3dfx/recursion/EightQueensTest.java | 25 ++- .../andd3dfx/recursion/HanoiTowersTest.java | 11 +- .../by/andd3dfx/regexp/RegExpCheckerTest.java | 86 ++++----- .../FindAmountOfElementsLessThanTest.java | 63 ++++--- ...rrayWhichNotPresentInAnotherArrayTest.java | 15 +- .../search/InterpolationSearchTest.java | 21 ++- .../string/MakeStringCompactTest.java | 21 ++- .../by/andd3dfx/string/PalindromeTest.java | 49 ++--- .../by/andd3dfx/string/ReverseStringTest.java | 9 +- ...hiftCharactersAndCapitalizeVowelsTest.java | 7 +- .../andd3dfx/tree/BinaryTreeWalkingTest.java | 52 +++--- .../tree/NextNodeForBinarySearchTreeTest.java | 15 +- .../equivalent/EquivalentNodesOfTreeTest.java | 31 ++-- 66 files changed, 1034 insertions(+), 1005 deletions(-) diff --git a/build.gradle b/build.gradle index 95972fff..baea7e6b 100644 --- a/build.gradle +++ b/build.gradle @@ -23,7 +23,6 @@ dependencies { testImplementation 'junit:junit:4.13.2' testImplementation 'net.bytebuddy:byte-buddy:1.14.12' testImplementation 'org.assertj:assertj-core:3.27.3' - testImplementation 'org.hamcrest:hamcrest:3.0' testImplementation 'org.mockito:mockito-core:5.17.0' testImplementation 'org.awaitility:awaitility:4.3.0' testImplementation 'nl.jqno.equalsverifier:equalsverifier:3.19.3' diff --git a/src/main/java/by/andd3dfx/numeric/Fibonacci.java b/src/main/java/by/andd3dfx/numeric/Fibonacci.java index 5fefd288..fae52095 100644 --- a/src/main/java/by/andd3dfx/numeric/Fibonacci.java +++ b/src/main/java/by/andd3dfx/numeric/Fibonacci.java @@ -19,11 +19,11 @@ public class Fibonacci { /** * Top-down approach (recursive, better) */ - public static int calculate(int n) { + public static int calculateTopDown(int n) { if (n < 0) throw new IllegalArgumentException("Number should be not less than 0!"); if (!map.containsKey(n)) { - map.put(n, calculate(n - 1) + calculate(n - 2)); + map.put(n, calculateTopDown(n - 1) + calculateTopDown(n - 2)); } return map.get(n); @@ -32,7 +32,7 @@ public static int calculate(int n) { /** * Down-top approach (loop, just as example) */ - public static int calculate2(int n) { + public static int calculateDownTop(int n) { if (n < 0) throw new IllegalArgumentException("Number should be not less than 0!"); for (int i = 2; i <= n; i++) { diff --git a/src/test/java/by/andd3dfx/cache/LFUCacheUsingLinkedHashSetTest.java b/src/test/java/by/andd3dfx/cache/LFUCacheUsingLinkedHashSetTest.java index 741ba614..e2b2bcbf 100644 --- a/src/test/java/by/andd3dfx/cache/LFUCacheUsingLinkedHashSetTest.java +++ b/src/test/java/by/andd3dfx/cache/LFUCacheUsingLinkedHashSetTest.java @@ -2,9 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class LFUCacheUsingLinkedHashSetTest { @@ -12,9 +10,9 @@ public class LFUCacheUsingLinkedHashSetTest { public void testCacheWithZeroCapacity() { LFUCacheUsingLinkedHashSet cache = new LFUCacheUsingLinkedHashSet<>(0); - assertThat(cache.get(2), nullValue()); + assertThat(cache.get(2)).isNull(); cache.put(2, 67); - assertThat(cache.get(2), nullValue()); + assertThat(cache.get(2)).isNull(); } @Test @@ -22,18 +20,18 @@ public void testCache() { LFUCacheUsingLinkedHashSet cache = new LFUCacheUsingLinkedHashSet<>(2); cache.put(1, 10); cache.put(2, 20); - assertThat(cache.get(1), is(10)); + assertThat(cache.get(1)).isEqualTo(10); cache.put(3, 30); //evicts key 2 - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(3), is(30)); + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(3)).isEqualTo(30); cache.put(4, 40); //evicts key 1 - assertThat(cache.get(1), nullValue()); - assertThat(cache.get(3), is(30)); - assertThat(cache.get(4), is(40)); + assertThat(cache.get(1)).isNull(); + assertThat(cache.get(3)).isEqualTo(30); + assertThat(cache.get(4)).isEqualTo(40); } @Test @@ -42,29 +40,29 @@ public void testCacheComplex() { cache.put(1, 10); cache.put(2, 20); cache.put(3, 30); - assertThat(cache.get(1), is(10)); - assertThat(cache.get(3), is(30)); - assertThat(cache.get(1), is(10)); - assertThat(cache.get(1), is(10)); // 1 -> 3 times used - assertThat(cache.get(3), is(30)); // 3 -> 2 times used - assertThat(cache.get(2), is(20)); // 2 -> 1 times used + assertThat(cache.get(1)).isEqualTo(10); + assertThat(cache.get(3)).isEqualTo(30); + assertThat(cache.get(1)).isEqualTo(10); + assertThat(cache.get(1)).isEqualTo(10); // 1 -> 3 times used + assertThat(cache.get(3)).isEqualTo(30); // 3 -> 2 times used + assertThat(cache.get(2)).isEqualTo(20); // 2 -> 1 times used cache.put(4, 40); // evicts key 2 (less used) - assertThat(cache.get(1), is(10)); // 1 -> 4 times used - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(4), is(40)); - assertThat(cache.get(4), is(40)); - assertThat(cache.get(4), is(40)); // 4 -> 3 times used - assertThat(cache.get(3), is(30)); // 3 -> 3 times used + assertThat(cache.get(1)).isEqualTo(10); // 1 -> 4 times used + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(4)).isEqualTo(40); + assertThat(cache.get(4)).isEqualTo(40); + assertThat(cache.get(4)).isEqualTo(40); // 4 -> 3 times used + assertThat(cache.get(3)).isEqualTo(30); // 3 -> 3 times used cache.put(5, 50); // evicts key 4 (same used as 3, but 3 is last used) - assertThat(cache.get(1), is(10)); - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(3), is(30)); - assertThat(cache.get(4), nullValue()); - assertThat(cache.get(5), is(50)); + assertThat(cache.get(1)).isEqualTo(10); + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(3)).isEqualTo(30); + assertThat(cache.get(4)).isNull(); + assertThat(cache.get(5)).isEqualTo(50); } @Test @@ -74,7 +72,7 @@ public void testCacheLeetCode_updateValue() { cache.put(2, 1); cache.put(2, 2); // overwrites value for key 2 cache.put(4, 4); // evicts key 3 - assertThat(cache.get(2), is(2)); + assertThat(cache.get(2)).isEqualTo(2); } @Test @@ -82,15 +80,15 @@ public void determineKeyToDelete() { var cache = new LFUCacheUsingLinkedHashSet(2); cache.put(2, 100); cache.put(3, 200); - assertThat(cache.determineKeyToDelete(), is(2)); + assertThat(cache.determineKeyToDelete()).isEqualTo(2); cache.get(2); - assertThat(cache.determineKeyToDelete(), is(3)); + assertThat(cache.determineKeyToDelete()).isEqualTo(3); cache.get(3); - assertThat(cache.determineKeyToDelete(), is(2)); + assertThat(cache.determineKeyToDelete()).isEqualTo(2); cache.put(4, 500); - assertThat(cache.determineKeyToDelete(), is(4)); + assertThat(cache.determineKeyToDelete()).isEqualTo(4); cache.get(4); - assertThat(cache.determineKeyToDelete(), is(3)); + assertThat(cache.determineKeyToDelete()).isEqualTo(3); } } diff --git a/src/test/java/by/andd3dfx/cache/LFUCacheUsingTimeTest.java b/src/test/java/by/andd3dfx/cache/LFUCacheUsingTimeTest.java index be4cc975..79770e4a 100644 --- a/src/test/java/by/andd3dfx/cache/LFUCacheUsingTimeTest.java +++ b/src/test/java/by/andd3dfx/cache/LFUCacheUsingTimeTest.java @@ -2,9 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class LFUCacheUsingTimeTest { @@ -12,9 +10,9 @@ public class LFUCacheUsingTimeTest { public void testCacheWithZeroCapacity() { LFUCacheUsingTime cache = new LFUCacheUsingTime<>(0); - assertThat(cache.get(2), nullValue()); + assertThat(cache.get(2)).isNull(); cache.put(2, 67); - assertThat(cache.get(2), nullValue()); + assertThat(cache.get(2)).isNull(); } @Test @@ -22,18 +20,18 @@ public void testCache() { LFUCacheUsingTime cache = new LFUCacheUsingTime<>(2); cache.put(1, 10); cache.put(2, 20); - assertThat(cache.get(1), is(10)); + assertThat(cache.get(1)).isEqualTo(10); cache.put(3, 30); //evicts key 2 - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(3), is(30)); + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(3)).isEqualTo(30); cache.put(4, 40); //evicts key 1 - assertThat(cache.get(1), nullValue()); - assertThat(cache.get(3), is(30)); - assertThat(cache.get(4), is(40)); + assertThat(cache.get(1)).isNull(); + assertThat(cache.get(3)).isEqualTo(30); + assertThat(cache.get(4)).isEqualTo(40); } @Test @@ -42,29 +40,29 @@ public void testCacheComplex() { cache.put(1, 10); cache.put(2, 20); cache.put(3, 30); - assertThat(cache.get(1), is(10)); - assertThat(cache.get(3), is(30)); - assertThat(cache.get(1), is(10)); - assertThat(cache.get(1), is(10)); // 1 -> 3 times used - assertThat(cache.get(3), is(30)); // 3 -> 2 times used - assertThat(cache.get(2), is(20)); // 2 -> 1 times used + assertThat(cache.get(1)).isEqualTo(10); + assertThat(cache.get(3)).isEqualTo(30); + assertThat(cache.get(1)).isEqualTo(10); + assertThat(cache.get(1)).isEqualTo(10); // 1 -> 3 times used + assertThat(cache.get(3)).isEqualTo(30); // 3 -> 2 times used + assertThat(cache.get(2)).isEqualTo(20); // 2 -> 1 times used cache.put(4, 40); // evicts key 2 (less used) - assertThat(cache.get(1), is(10)); // 1 -> 4 times used - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(4), is(40)); - assertThat(cache.get(4), is(40)); - assertThat(cache.get(4), is(40)); // 4 -> 3 times used - assertThat(cache.get(3), is(30)); // 3 -> 3 times used + assertThat(cache.get(1)).isEqualTo(10); // 1 -> 4 times used + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(4)).isEqualTo(40); + assertThat(cache.get(4)).isEqualTo(40); + assertThat(cache.get(4)).isEqualTo(40); // 4 -> 3 times used + assertThat(cache.get(3)).isEqualTo(30); // 3 -> 3 times used cache.put(5, 50); // evicts key 4 (same used as 3, but 3 is last used) - assertThat(cache.get(1), is(10)); - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(3), is(30)); - assertThat(cache.get(4), nullValue()); - assertThat(cache.get(5), is(50)); + assertThat(cache.get(1)).isEqualTo(10); + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(3)).isEqualTo(30); + assertThat(cache.get(4)).isNull(); + assertThat(cache.get(5)).isEqualTo(50); } @Test @@ -74,7 +72,7 @@ public void testCacheLeetcode_updateValue() { cache.put(2, 1); cache.put(2, 2); // overwrites value for key 2 cache.put(4, 4); // evicts key 3 - assertThat(cache.get(2), is(2)); + assertThat(cache.get(2)).isEqualTo(2); } @Test @@ -82,15 +80,15 @@ public void determineKeyToDelete() { var cache = new LFUCacheUsingTime(2); cache.put(2, 100); cache.put(3, 200); - assertThat(cache.determineKeyToDelete(), is(2)); + assertThat(cache.determineKeyToDelete()).isEqualTo(2); cache.get(2); - assertThat(cache.determineKeyToDelete(), is(3)); + assertThat(cache.determineKeyToDelete()).isEqualTo(3); cache.get(3); - assertThat(cache.determineKeyToDelete(), is(2)); + assertThat(cache.determineKeyToDelete()).isEqualTo(2); cache.put(4, 500); - assertThat(cache.determineKeyToDelete(), is(4)); + assertThat(cache.determineKeyToDelete()).isEqualTo(4); cache.get(4); - assertThat(cache.determineKeyToDelete(), is(3)); + assertThat(cache.determineKeyToDelete()).isEqualTo(3); } } diff --git a/src/test/java/by/andd3dfx/cache/LRUCacheTest.java b/src/test/java/by/andd3dfx/cache/LRUCacheTest.java index fafeb6e0..de490c4a 100644 --- a/src/test/java/by/andd3dfx/cache/LRUCacheTest.java +++ b/src/test/java/by/andd3dfx/cache/LRUCacheTest.java @@ -2,9 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class LRUCacheTest { @@ -13,20 +11,20 @@ public void testCache() { LRUCache cache = new LRUCache<>(2); cache.put(1, 1); cache.put(2, 4); - assertThat(cache.get(1), is(1)); + assertThat(cache.get(1)).isEqualTo(1); cache.put(3, 9); // evicts key 2 - assertThat(cache.get(2), nullValue()); + assertThat(cache.get(2)).isNull(); cache.put(4, 16); // evicts key 1 - assertThat(cache.get(1), nullValue()); - assertThat(cache.get(3), is(9)); - assertThat(cache.get(4), is(16)); + assertThat(cache.get(1)).isNull(); + assertThat(cache.get(3)).isEqualTo(9); + assertThat(cache.get(4)).isEqualTo(16); } @Test public void testCacheForZeroCapacity() { LRUCache cache = new LRUCache<>(0); cache.put(2, 4); - assertThat(cache.get(2), nullValue()); - assertThat(cache.get(1), nullValue()); + assertThat(cache.get(2)).isNull(); + assertThat(cache.get(1)).isNull(); } } diff --git a/src/test/java/by/andd3dfx/collections/ReverseLinkedListTest.java b/src/test/java/by/andd3dfx/collections/ReverseLinkedListTest.java index 256f9f41..e91194a6 100644 --- a/src/test/java/by/andd3dfx/collections/ReverseLinkedListTest.java +++ b/src/test/java/by/andd3dfx/collections/ReverseLinkedListTest.java @@ -6,8 +6,7 @@ import static by.andd3dfx.collections.ReverseLinkedList.reverseUsingLoop; import static by.andd3dfx.collections.ReverseLinkedList.reverseUsingRecursion; import static by.andd3dfx.collections.ReverseLinkedList.reverseUsingStack; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertNull; public class ReverseLinkedListTest { @@ -51,15 +50,20 @@ public void testReverseUsingRecursionForNull() { assertNull(reverseUsingRecursion(null)); } - private Node buildLinkedList() { - return new Node(3, new Node(7, new Node(12, new Node(10, null)))); + private Node buildLinkedList() { + return new Node<>(3, new Node<>(7, new Node<>(12, new Node<>(10, null)))); } private void checkReversedList(Node head) { - assertThat("Wrong 0 item of reversed list", head.getValue(), is(10)); - assertThat("Wrong 1 item of reversed list", head.getNext().getValue(), is(12)); - assertThat("Wrong 2 item of reversed list", head.getNext().getNext().getValue(), is(7)); - assertThat("Wrong 3 item of reversed list", head.getNext().getNext().getNext().getValue(), is(3)); - assertNull("Wrong next of 3 item of reversed list", head.getNext().getNext().getNext().getNext()); + assertThat(head.getValue()) + .as("Wrong 0 item of reversed list").isEqualTo(10); + assertThat(head.getNext().getValue()) + .as("Wrong 1 item of reversed list").isEqualTo(12); + assertThat(head.getNext().getNext().getValue()) + .as("Wrong 2 item of reversed list").isEqualTo(7); + assertThat(head.getNext().getNext().getNext().getValue()) + .as("Wrong 3 item of reversed list").isEqualTo(3); + assertThat(head.getNext().getNext().getNext().getNext()) + .as("Wrong next of 3 item of reversed list").isNull(); } } \ No newline at end of file diff --git a/src/test/java/by/andd3dfx/collections/custom/CustomArrayListTest.java b/src/test/java/by/andd3dfx/collections/custom/CustomArrayListTest.java index 179f12f7..d1a48bd1 100644 --- a/src/test/java/by/andd3dfx/collections/custom/CustomArrayListTest.java +++ b/src/test/java/by/andd3dfx/collections/custom/CustomArrayListTest.java @@ -7,10 +7,7 @@ import java.util.ArrayList; import java.util.List; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThanOrEqualTo; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; @@ -20,17 +17,17 @@ public class CustomArrayListTest { @Test public void addNGet() { CustomArrayList list = new CustomArrayList<>(); - assertThat(list.size(), is(0)); + assertThat(list.size()).isEqualTo(0); assertTrue(list.isEmpty()); list.add(4); list.add(5); list.add(12); - assertThat(list.size(), is(3)); + assertThat(list.size()).isEqualTo(3); assertFalse(list.isEmpty()); - assertThat(list.get(0), is(4)); - assertThat(list.get(1), is(5)); - assertThat(list.get(2), is(12)); + assertThat(list.get(0)).isEqualTo(4); + assertThat(list.get(1)).isEqualTo(5); + assertThat(list.get(2)).isEqualTo(12); } @Test @@ -43,35 +40,35 @@ public void addByIndexNGet() { list.add(1, 34); // 3 34 7 67 12 list.add(5, 102); // 3 34 7 67 12 102 - addition of a new element at the right should pass - assertThat(list.size(), is(6)); - assertThat(list.get(0), is(3)); - assertThat(list.get(1), is(34)); - assertThat(list.get(2), is(7)); - assertThat(list.get(3), is(67)); - assertThat(list.get(4), is(12)); - assertThat(list.get(5), is(102)); + assertThat(list.size()).isEqualTo(6); + assertThat(list.get(0)).isEqualTo(3); + assertThat(list.get(1)).isEqualTo(34); + assertThat(list.get(2)).isEqualTo(7); + assertThat(list.get(3)).isEqualTo(67); + assertThat(list.get(4)).isEqualTo(12); + assertThat(list.get(5)).isEqualTo(102); } @Test public void addNGetWhenArrayUpResizeExpected() { CustomArrayList list = new CustomArrayList<>(); - assertThat(determineInnerArrayLength(list), is(10)); + assertThat(determineInnerArrayLength(list)).isEqualTo(10); for (int i = 0; i < 20; i++) { list.add(i * i); } - assertThat(list.size(), is(20)); + assertThat(list.size()).isEqualTo(20); assertFalse(list.isEmpty()); - assertThat(determineInnerArrayLength(list), greaterThanOrEqualTo(20)); + assertThat(determineInnerArrayLength(list)).isGreaterThanOrEqualTo(20); for (int i = 0; i < 20; i++) { - assertThat(list.get(i), is(i * i)); + assertThat(list.get(i)).isEqualTo(i * i); } } @Test public void addIntoMiddleOfListNGetWhenArrayUpResizeExpected() { CustomArrayList list = new CustomArrayList<>(); - assertThat(determineInnerArrayLength(list), is(10)); + assertThat(determineInnerArrayLength(list)).isEqualTo(10); for (int i = 0; i < 10; i++) { list.add(i * i); } @@ -79,24 +76,24 @@ public void addIntoMiddleOfListNGetWhenArrayUpResizeExpected() { list.add(i + 5, i * i); } - assertThat(list.size(), is(20)); + assertThat(list.size()).isEqualTo(20); assertFalse(list.isEmpty()); - assertThat(determineInnerArrayLength(list), greaterThanOrEqualTo(20)); + assertThat(determineInnerArrayLength(list)).isGreaterThanOrEqualTo(20); for (int i = 0; i < 5; i++) { - assertThat(list.get(i), is(i * i)); + assertThat(list.get(i)).isEqualTo(i * i); } for (int i = 0; i < 10; i++) { - assertThat(list.get(i + 5), is(i * i)); + assertThat(list.get(i + 5)).isEqualTo(i * i); } for (int i = 5; i < 10; i++) { - assertThat(list.get(i + 10), is(i * i)); + assertThat(list.get(i + 10)).isEqualTo(i * i); } } @Test public void addNSetNGet() { CustomArrayList list = new CustomArrayList<>(); - assertThat(list.size(), is(0)); + assertThat(list.size()).isEqualTo(0); assertTrue(list.isEmpty()); list.add(4); list.add(5); @@ -104,11 +101,11 @@ public void addNSetNGet() { list.add(12); list.set(0, 31); - assertThat(list.size(), is(3)); + assertThat(list.size()).isEqualTo(3); assertFalse(list.isEmpty()); - assertThat(list.get(0), is(31)); - assertThat(list.get(1), is(56)); - assertThat(list.get(2), is(12)); + assertThat(list.get(0)).isEqualTo(31); + assertThat(list.get(1)).isEqualTo(56); + assertThat(list.get(2)).isEqualTo(12); } @Test @@ -155,35 +152,35 @@ public void removeByIndex() { var removed = list.remove(2); - assertThat(removed, is(12)); - assertThat(list.size(), is(3)); - assertThat(list.get(0), is(11)); - assertThat(list.get(1), is(7)); - assertThat(list.get(2), is(34)); + assertThat(removed).isEqualTo(12); + assertThat(list.size()).isEqualTo(3); + assertThat(list.get(0)).isEqualTo(11); + assertThat(list.get(1)).isEqualTo(7); + assertThat(list.get(2)).isEqualTo(34); var removed2 = list.remove(2); - assertThat(removed2, is(34)); - assertThat(list.size(), is(2)); - assertThat(list.get(0), is(11)); - assertThat(list.get(1), is(7)); + assertThat(removed2).isEqualTo(34); + assertThat(list.size()).isEqualTo(2); + assertThat(list.get(0)).isEqualTo(11); + assertThat(list.get(1)).isEqualTo(7); } @Test public void removeByIndexWhenArrayDecResizedExpected() { CustomArrayList list = new CustomArrayList<>(); - assertThat(determineInnerArrayLength(list), is(10)); + assertThat(determineInnerArrayLength(list)).isEqualTo(10); for (int i = 0; i < 20; i++) { list.add(i * i); } - assertThat(determineInnerArrayLength(list), greaterThanOrEqualTo(20)); + assertThat(determineInnerArrayLength(list)).isGreaterThanOrEqualTo(20); for (int i = 0; i < 18; i++) { list.remove(1); // Delete element at the start of inner array multiple times } - assertThat(list.size(), is(2)); - assertThat(determineInnerArrayLength(list), is(10)); + assertThat(list.size()).isEqualTo(2); + assertThat(determineInnerArrayLength(list)).isEqualTo(10); } @SneakyThrows @@ -219,12 +216,12 @@ public void removeByValue() { var removeResult = list.remove("Ilya"); assertTrue(removeResult); - assertThat(list.size(), is(5)); - assertThat(list.get(0), is("Andrei")); - assertThat(list.get(1), is("Tikhon")); - assertThat(list.get(2), is("Elena")); - assertThat(list.get(3), is("Ilya")); - assertThat(list.get(4), is("Yulia")); + assertThat(list.size()).isEqualTo(5); + assertThat(list.get(0)).isEqualTo("Andrei"); + assertThat(list.get(1)).isEqualTo("Tikhon"); + assertThat(list.get(2)).isEqualTo("Elena"); + assertThat(list.get(3)).isEqualTo("Ilya"); + assertThat(list.get(4)).isEqualTo("Yulia"); } @Test @@ -233,14 +230,14 @@ public void removeByValueWhenArrayDecResizedExpected() { for (int i = 0; i < 20; i++) { list.add(String.valueOf(i * i)); } - assertThat(determineInnerArrayLength(list), greaterThanOrEqualTo(20)); + assertThat(determineInnerArrayLength(list)).isGreaterThanOrEqualTo(20); for (int i = 5; i < 20; i++) { assertTrue(list.remove(String.valueOf(i * i))); } - assertThat(list.size(), is(5)); - assertThat(determineInnerArrayLength(list), is(10)); + assertThat(list.size()).isEqualTo(5); + assertThat(determineInnerArrayLength(list)).isEqualTo(10); } @Test @@ -255,11 +252,11 @@ public void removeByValueWhenNullsPresent() { var removeResult = list.remove(null); assertTrue(removeResult); - assertThat(list.size(), is(4)); - assertThat(list.get(0), is("Andrei")); - assertThat(list.get(1), is("Tikhon")); - assertThat(list.get(2), is(nullValue())); - assertThat(list.get(3), is("Elena")); + assertThat(list.size()).isEqualTo(4); + assertThat(list.get(0)).isEqualTo("Andrei"); + assertThat(list.get(1)).isEqualTo("Tikhon"); + assertThat(list.get(2)).isNull(); + assertThat(list.get(3)).isEqualTo("Elena"); } @Test @@ -274,12 +271,12 @@ public void removeByValueWhenAbsent() { var removeResult = list.remove("Oksana"); assertFalse(removeResult); - assertThat(list.size(), is(5)); - assertThat(list.get(0), is("Andrei")); - assertThat(list.get(1), is("Tikhon")); - assertThat(list.get(2), is("Ilya")); - assertThat(list.get(3), is("Elena")); - assertThat(list.get(4), is("Yulia")); + assertThat(list.size()).isEqualTo(5); + assertThat(list.get(0)).isEqualTo("Andrei"); + assertThat(list.get(1)).isEqualTo("Tikhon"); + assertThat(list.get(2)).isEqualTo("Ilya"); + assertThat(list.get(3)).isEqualTo("Elena"); + assertThat(list.get(4)).isEqualTo("Yulia"); } @Test @@ -290,12 +287,12 @@ public void clear() { list.add(36); assertFalse(list.isEmpty()); - assertThat(list.size(), is(3)); + assertThat(list.size()).isEqualTo(3); list.clear(); assertTrue(list.isEmpty()); - assertThat(list.size(), is(0)); + assertThat(list.size()).isEqualTo(0); } @Test @@ -309,7 +306,7 @@ public void testForEach() { for (var item : list) { result.add(item); } - assertThat(result, is(List.of(3, 7, 12))); + assertThat(result).isEqualTo(List.of(3, 7, 12)); } @Test @@ -320,7 +317,7 @@ public void testForEachForEmptyList() { for (var item : list) { result.add(item); } - assertThat(result, is(List.of())); + assertThat(result).isEqualTo(List.of()); } @Test @@ -330,6 +327,6 @@ public void testToString() { list.add("Tikhon"); list.add("Ilya"); - assertThat(list.toString(), is("[Andrei, Tikhon, Ilya]")); + assertThat(list.toString()).isEqualTo("[Andrei, Tikhon, Ilya]"); } } diff --git a/src/test/java/by/andd3dfx/collections/custom/CustomHashMapTest.java b/src/test/java/by/andd3dfx/collections/custom/CustomHashMapTest.java index 6f28416e..8853869b 100644 --- a/src/test/java/by/andd3dfx/collections/custom/CustomHashMapTest.java +++ b/src/test/java/by/andd3dfx/collections/custom/CustomHashMapTest.java @@ -6,9 +6,7 @@ import java.util.List; import java.util.NoSuchElementException; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; @@ -17,19 +15,19 @@ public class CustomHashMapTest { @Test public void size() { - var map = new CustomHashMap(); - assertThat(map.size(), is(0)); + var map = new CustomHashMap<>(); + assertThat(map.size()).isEqualTo(0); map.put(2, 5); - assertThat(map.size(), is(1)); + assertThat(map.size()).isEqualTo(1); map.put(7, 45); - assertThat(map.size(), is(2)); + assertThat(map.size()).isEqualTo(2); map.put(7, 46); - assertThat(map.size(), is(2)); + assertThat(map.size()).isEqualTo(2); } @Test public void isEmpty() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); assertTrue(map.isEmpty()); map.put(2, 5); assertFalse(map.isEmpty()); @@ -37,7 +35,7 @@ public void isEmpty() { @Test public void containsKey() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); assertFalse(map.containsKey(2)); map.put(2, 5); map.put(7, 45); @@ -48,7 +46,7 @@ public void containsKey() { @Test public void containsValue() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); assertFalse(map.containsValue(5)); map.put(2, 5); map.put(7, 45); @@ -59,14 +57,14 @@ public void containsValue() { @Test public void getAndPut() { - var map = new CustomHashMap(); - assertThat(map.put(2, 5), is(nullValue())); - assertThat(map.put(7, 44), is(nullValue())); - assertThat(map.put(7, 45), is(44)); - - assertThat(map.get(2), is(5)); - assertThat(map.get(7), is(45)); - assertThat(map.get(156), is(nullValue())); + var map = new CustomHashMap<>(); + assertThat(map.put(2, 5)).isNull(); + assertThat(map.put(7, 44)).isNull(); + assertThat(map.put(7, 45)).isEqualTo(44); + + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(7)).isEqualTo(45); + assertThat(map.get(156)).isNull(); } @Test @@ -74,14 +72,14 @@ public void getAndPutWhenHashCollided() { CustomHashMap map = new CustomHashMap<>(); MyObject key1 = new MyObject(12); - assertThat(map.put(key1, 5), is(nullValue())); + assertThat(map.put(key1, 5)).isNull(); MyObject key2 = new MyObject(13); - assertThat(map.put(key2, 45), is(nullValue())); + assertThat(map.put(key2, 45)).isNull(); - assertThat(map.get(key1), is(5)); - assertThat(map.get(key2), is(45)); - assertThat(map.get(new MyObject(156)), is(nullValue())); + assertThat(map.get(key1)).isEqualTo(5); + assertThat(map.get(key2)).isEqualTo(45); + assertThat(map.get(new MyObject(156))).isNull(); } @AllArgsConstructor @@ -104,75 +102,75 @@ public boolean equals(Object o) { @Test public void getAndPutForNull() { - var map = new CustomHashMap(); - assertThat(map.put(2, 67), is(nullValue())); - assertThat(map.put(2, 5), is(67)); - assertThat(map.put(null, 45), is(nullValue())); - assertThat(map.put(7, 89), is(nullValue())); - - assertThat(map.get(2), is(5)); - assertThat(map.get(null), is(45)); - assertThat(map.get(7), is(89)); - assertThat(map.get(156), is(nullValue())); + var map = new CustomHashMap<>(); + assertThat(map.put(2, 67)).isNull(); + assertThat(map.put(2, 5)).isEqualTo(67); + assertThat(map.put(null, 45)).isNull(); + assertThat(map.put(7, 89)).isNull(); + + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(null)).isEqualTo(45); + assertThat(map.get(7)).isEqualTo(89); + assertThat(map.get(156)).isNull(); } @Test public void remove() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); map.put(2, 5); map.put(7, 45); map.put(9, 78); - assertThat(map.get(2), is(5)); - assertThat(map.get(7), is(45)); - assertThat(map.get(9), is(78)); + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(7)).isEqualTo(45); + assertThat(map.get(9)).isEqualTo(78); - assertThat(map.remove(7), is(45)); + assertThat(map.remove(7)).isEqualTo(45); - assertThat(map.size(), is(2)); - assertThat(map.get(2), is(5)); - assertThat(map.get(7), nullValue()); - assertThat(map.get(9), is(78)); + assertThat(map.size()).isEqualTo(2); + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(7)).isNull(); + assertThat(map.get(9)).isEqualTo(78); - assertThat(map.remove(9), is(78)); - assertThat(map.remove(9), is(nullValue())); + assertThat(map.remove(9)).isEqualTo(78); + assertThat(map.remove(9)).isNull(); - assertThat(map.size(), is(1)); - assertThat(map.get(2), is(5)); - assertThat(map.get(7), nullValue()); - assertThat(map.get(9), nullValue()); + assertThat(map.size()).isEqualTo(1); + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(7)).isNull(); + assertThat(map.get(9)).isNull(); } @Test public void removeForNull() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); map.put(2, 5); map.put(null, 45); - assertThat(map.get(2), is(5)); - assertThat(map.get(null), is(45)); + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(null)).isEqualTo(45); assertTrue(map.containsKey(2)); assertTrue(map.containsKey(null)); - assertThat(map.remove(null), is(45)); - assertThat(map.remove(null), is(nullValue())); + assertThat(map.remove(null)).isEqualTo(45); + assertThat(map.remove(null)).isNull(); assertFalse(map.containsKey(null)); } @Test public void clear() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); map.put(2, 5); map.put(7, 45); map.put(null, 90); - assertThat(map.get(2), is(5)); - assertThat(map.get(7), is(45)); - assertThat(map.get(null), is(90)); + assertThat(map.get(2)).isEqualTo(5); + assertThat(map.get(7)).isEqualTo(45); + assertThat(map.get(null)).isEqualTo(90); map.clear(); - assertThat(map.get(2), nullValue()); - assertThat(map.get(7), nullValue()); - assertThat(map.get(null), nullValue()); + assertThat(map.get(2)).isNull(); + assertThat(map.get(7)).isNull(); + assertThat(map.get(null)).isNull(); assertFalse(map.containsKey(2)); assertFalse(map.containsKey(7)); @@ -185,24 +183,24 @@ public void clear() { @Test public void keySetForEmptyMap() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); var result = map.keySet(); - assertThat(result.size(), is(0)); + assertThat(result.size()).isEqualTo(0); assertTrue(result.containsAll(List.of())); } @Test public void keySet() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); map.put(2, 5); map.put(7, 45); map.put(9, 78); var result = map.keySet(); - assertThat(result.size(), is(3)); + assertThat(result.size()).isEqualTo(3); assertTrue(result.containsAll(List.of(2, 7, 9))); } @@ -219,7 +217,7 @@ public void keyIterator() { var keyIterator = map.keyIterator(); while (keyIterator.hasNext()) { var item = keyIterator.next(); - assertThat(item, is(expectedKeys.get(index))); + assertThat(item).isEqualTo(expectedKeys.get(index)); index++; } assertThrows(NoSuchElementException.class, () -> keyIterator.next()); @@ -227,10 +225,10 @@ public void keyIterator() { @Test public void testToString() { - var map = new CustomHashMap(); + var map = new CustomHashMap<>(); map.put(2, 5); map.put(7, 45); - assertThat(map.toString(), is("{2->5, 7->45}")); + assertThat(map.toString()).isEqualTo("{2->5, 7->45}"); } } diff --git a/src/test/java/by/andd3dfx/collections/custom/CustomHashSetTest.java b/src/test/java/by/andd3dfx/collections/custom/CustomHashSetTest.java index d221d3f8..02d2bf62 100644 --- a/src/test/java/by/andd3dfx/collections/custom/CustomHashSetTest.java +++ b/src/test/java/by/andd3dfx/collections/custom/CustomHashSetTest.java @@ -4,8 +4,7 @@ import java.util.List; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -15,22 +14,22 @@ public class CustomHashSetTest { @Test public void size() { CustomHashSet set = new CustomHashSet<>(); - assertThat(set.size(), is(0)); + assertThat(set.size()).isEqualTo(0); set.add("One"); - assertThat(set.size(), is(1)); + assertThat(set.size()).isEqualTo(1); set.add("Two"); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.add("Two"); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.add("Three"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); set.add("One"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); } @Test @@ -76,22 +75,22 @@ public void remove() { set.add("One"); set.add("Two"); set.add("Three"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); assertTrue(set.remove("Two")); assertFalse(set.remove("Two")); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); assertFalse(set.remove("Four")); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.add("Two"); assertTrue(set.remove("Two")); assertFalse(set.remove("Two")); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); assertTrue(set.remove("One")); - assertThat(set.size(), is(1)); + assertThat(set.size()).isEqualTo(1); } @Test @@ -100,13 +99,13 @@ public void removeAll() { set.add("One"); set.add("Two"); set.add("Three"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); assertFalse(set.removeAll(List.of("Four", "Five"))); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); assertTrue(set.removeAll(List.of("One", "Three"))); - assertThat(set.size(), is(1)); + assertThat(set.size()).isEqualTo(1); } @Test @@ -114,11 +113,11 @@ public void clear() { CustomHashSet set = new CustomHashSet<>(); set.add("One"); set.add("Two"); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.clear(); - assertThat(set.size(), is(0)); + assertThat(set.size()).isEqualTo(0); assertTrue(set.isEmpty()); assertFalse(set.contains("One")); assertFalse(set.contains("Two")); @@ -136,7 +135,7 @@ public void forEach() { set.remove("Two"); var etalonList = List.of("One", "Three", "Four", "Five"); - assertThat(set.size(), is(etalonList.size())); + assertThat(set.size()).isEqualTo(etalonList.size()); for (var item : set) { assertTrue(etalonList.contains(item)); @@ -162,6 +161,6 @@ public void testToString() { set.add("Yulia"); set.add("Elena"); - assertThat(set.toString(), is("[Elena, Yulia, Andrei, Tikhon]")); + assertThat(set.toString()).isEqualTo("[Elena, Yulia, Andrei, Tikhon]"); } } diff --git a/src/test/java/by/andd3dfx/collections/custom/CustomLinkedHashSetTest.java b/src/test/java/by/andd3dfx/collections/custom/CustomLinkedHashSetTest.java index c3952c7a..48e30c1e 100644 --- a/src/test/java/by/andd3dfx/collections/custom/CustomLinkedHashSetTest.java +++ b/src/test/java/by/andd3dfx/collections/custom/CustomLinkedHashSetTest.java @@ -4,8 +4,7 @@ import java.util.List; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -15,22 +14,22 @@ public class CustomLinkedHashSetTest { @Test public void size() { CustomLinkedHashSet set = new CustomLinkedHashSet<>(); - assertThat(set.size(), is(0)); + assertThat(set.size()).isEqualTo(0); set.add("One"); - assertThat(set.size(), is(1)); + assertThat(set.size()).isEqualTo(1); set.add("Two"); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.add("Two"); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.add("Three"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); set.add("One"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); } @Test @@ -76,22 +75,22 @@ public void remove() { set.add("One"); set.add("Two"); set.add("Three"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); assertTrue(set.remove("Two")); assertFalse(set.remove("Two")); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); assertFalse(set.remove("Four")); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.add("Two"); assertTrue(set.remove("Two")); assertFalse(set.remove("Two")); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); assertTrue(set.remove("One")); - assertThat(set.size(), is(1)); + assertThat(set.size()).isEqualTo(1); } @Test @@ -100,13 +99,13 @@ public void removeAll() { set.add("One"); set.add("Two"); set.add("Three"); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); assertFalse(set.removeAll(List.of("Four", "Five"))); - assertThat(set.size(), is(3)); + assertThat(set.size()).isEqualTo(3); assertTrue(set.removeAll(List.of("One", "Three"))); - assertThat(set.size(), is(1)); + assertThat(set.size()).isEqualTo(1); } @Test @@ -114,11 +113,11 @@ public void clear() { CustomLinkedHashSet set = new CustomLinkedHashSet<>(); set.add("One"); set.add("Two"); - assertThat(set.size(), is(2)); + assertThat(set.size()).isEqualTo(2); set.clear(); - assertThat(set.size(), is(0)); + assertThat(set.size()).isEqualTo(0); assertTrue(set.isEmpty()); assertFalse(set.contains("One")); assertFalse(set.contains("Two")); @@ -136,11 +135,11 @@ public void forEach() { set.remove("Two"); var etalonList = List.of("One", "Three", "Four", "Five"); - assertThat(set.size(), is(etalonList.size())); + assertThat(set.size()).isEqualTo(etalonList.size()); var i = 0; for (var item : set) { - assertThat(item, is(etalonList.get(i))); + assertThat(item).isEqualTo(etalonList.get(i)); i++; } } @@ -164,6 +163,6 @@ public void testToString() { set.add("Yulia"); set.add("Elena"); - assertThat(set.toString(), is("[Andrei, Tikhon, Yulia, Elena]")); + assertThat(set.toString()).isEqualTo("[Andrei, Tikhon, Yulia, Elena]"); } } diff --git a/src/test/java/by/andd3dfx/collections/custom/CustomLinkedListTest.java b/src/test/java/by/andd3dfx/collections/custom/CustomLinkedListTest.java index 9c1f0abe..69ae7688 100644 --- a/src/test/java/by/andd3dfx/collections/custom/CustomLinkedListTest.java +++ b/src/test/java/by/andd3dfx/collections/custom/CustomLinkedListTest.java @@ -5,9 +5,7 @@ import java.util.ArrayList; import java.util.List; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThrows; import static org.junit.Assert.assertTrue; @@ -17,32 +15,32 @@ public class CustomLinkedListTest { @Test public void addNGet() { CustomLinkedList linkedList = new CustomLinkedList<>(); - assertThat(linkedList.size(), is(0)); + assertThat(linkedList.size()).isEqualTo(0); assertTrue(linkedList.isEmpty()); linkedList.add(3); linkedList.add(7); - assertThat(linkedList.size(), is(2)); - assertFalse(linkedList.isEmpty()); - assertThat(linkedList.get(0), is(3)); - assertThat(linkedList.get(1), is(7)); + assertThat(linkedList.size()).isEqualTo(2); + assertFalse(linkedList.isEmpty()); + assertThat(linkedList.get(0)).isEqualTo(3); + assertThat(linkedList.get(1)).isEqualTo(7); linkedList.add(12); linkedList.add(34); - assertThat(linkedList.size(), is(4)); + assertThat(linkedList.size()).isEqualTo(4); assertFalse(linkedList.isEmpty()); - assertThat(linkedList.get(0), is(3)); - assertThat(linkedList.get(1), is(7)); - assertThat(linkedList.get(2), is(12)); - assertThat(linkedList.get(3), is(34)); + assertThat(linkedList.get(0)).isEqualTo(3); + assertThat(linkedList.get(1)).isEqualTo(7); + assertThat(linkedList.get(2)).isEqualTo(12); + assertThat(linkedList.get(3)).isEqualTo(34); } @Test public void addNSetNGet() { CustomLinkedList linkedList = new CustomLinkedList<>(); - assertThat(linkedList.size(), is(0)); + assertThat(linkedList.size()).isEqualTo(0); assertTrue(linkedList.isEmpty()); linkedList.add(4); linkedList.add(5); @@ -50,11 +48,11 @@ public void addNSetNGet() { linkedList.add(12); linkedList.set(0, 31); - assertThat(linkedList.size(), is(3)); + assertThat(linkedList.size()).isEqualTo(3); assertFalse(linkedList.isEmpty()); - assertThat(linkedList.get(0), is(31)); - assertThat(linkedList.get(1), is(56)); - assertThat(linkedList.get(2), is(12)); + assertThat(linkedList.get(0)).isEqualTo(31); + assertThat(linkedList.get(1)).isEqualTo(56); + assertThat(linkedList.get(2)).isEqualTo(12); } @Test @@ -67,13 +65,13 @@ public void addByIndex() { linkedList.add(1, 34); // 3 34 7 67 12 linkedList.add(5, 102); // 3 34 7 67 12 102 - addition of new element at the right should pass - assertThat(linkedList.size(), is(6)); - assertThat(linkedList.get(0), is(3)); - assertThat(linkedList.get(1), is(34)); - assertThat(linkedList.get(2), is(7)); - assertThat(linkedList.get(3), is(67)); - assertThat(linkedList.get(4), is(12)); - assertThat(linkedList.get(5), is(102)); + assertThat(linkedList.size()).isEqualTo(6); + assertThat(linkedList.get(0)).isEqualTo(3); + assertThat(linkedList.get(1)).isEqualTo(34); + assertThat(linkedList.get(2)).isEqualTo(7); + assertThat(linkedList.get(3)).isEqualTo(67); + assertThat(linkedList.get(4)).isEqualTo(12); + assertThat(linkedList.get(5)).isEqualTo(102); } @Test @@ -118,19 +116,19 @@ public void reverse() { linkedList.add(12); linkedList.add(34); - assertThat(linkedList.size(), is(4)); - assertThat(linkedList.get(0), is(3)); - assertThat(linkedList.get(1), is(7)); - assertThat(linkedList.get(2), is(12)); - assertThat(linkedList.get(3), is(34)); + assertThat(linkedList.size()).isEqualTo(4); + assertThat(linkedList.get(0)).isEqualTo(3); + assertThat(linkedList.get(1)).isEqualTo(7); + assertThat(linkedList.get(2)).isEqualTo(12); + assertThat(linkedList.get(3)).isEqualTo(34); linkedList.reverse(); - assertThat(linkedList.size(), is(4)); - assertThat(linkedList.get(0), is(34)); - assertThat(linkedList.get(1), is(12)); - assertThat(linkedList.get(2), is(7)); - assertThat(linkedList.get(3), is(3)); + assertThat(linkedList.size()).isEqualTo(4); + assertThat(linkedList.get(0)).isEqualTo(34); + assertThat(linkedList.get(1)).isEqualTo(12); + assertThat(linkedList.get(2)).isEqualTo(7); + assertThat(linkedList.get(3)).isEqualTo(3); } @Test @@ -143,18 +141,18 @@ public void remove() { var removed = linkedList.remove(); - assertThat(removed, is(11)); - assertThat(linkedList.size(), is(3)); - assertThat(linkedList.get(0), is(7)); - assertThat(linkedList.get(1), is(12)); - assertThat(linkedList.get(2), is(34)); + assertThat(removed).isEqualTo(11); + assertThat(linkedList.size()).isEqualTo(3); + assertThat(linkedList.get(0)).isEqualTo(7); + assertThat(linkedList.get(1)).isEqualTo(12); + assertThat(linkedList.get(2)).isEqualTo(34); var removed2 = linkedList.remove(); - assertThat(removed2, is(7)); - assertThat(linkedList.size(), is(2)); - assertThat(linkedList.get(0), is(12)); - assertThat(linkedList.get(1), is(34)); + assertThat(removed2).isEqualTo(7); + assertThat(linkedList.size()).isEqualTo(2); + assertThat(linkedList.get(0)).isEqualTo(12); + assertThat(linkedList.get(1)).isEqualTo(34); } @Test @@ -167,18 +165,18 @@ public void removeByIndex() { var removed = linkedList.remove(2); - assertThat(removed, is(12)); - assertThat(linkedList.size(), is(3)); - assertThat(linkedList.get(0), is(11)); - assertThat(linkedList.get(1), is(7)); - assertThat(linkedList.get(2), is(34)); + assertThat(removed).isEqualTo(12); + assertThat(linkedList.size()).isEqualTo(3); + assertThat(linkedList.get(0)).isEqualTo(11); + assertThat(linkedList.get(1)).isEqualTo(7); + assertThat(linkedList.get(2)).isEqualTo(34); var removed2 = linkedList.remove(2); - assertThat(removed2, is(34)); - assertThat(linkedList.size(), is(2)); - assertThat(linkedList.get(0), is(11)); - assertThat(linkedList.get(1), is(7)); + assertThat(removed2).isEqualTo(34); + assertThat(linkedList.size()).isEqualTo(2); + assertThat(linkedList.get(0)).isEqualTo(11); + assertThat(linkedList.get(1)).isEqualTo(7); } @Test @@ -206,12 +204,12 @@ public void removeByValue() { var removeResult = linkedList.remove("Ilya"); assertTrue(removeResult); - assertThat(linkedList.size(), is(5)); - assertThat(linkedList.get(0), is("Andrei")); - assertThat(linkedList.get(1), is("Tikhon")); - assertThat(linkedList.get(2), is("Elena")); - assertThat(linkedList.get(3), is("Ilya")); // Only first 'Ilya' occurrence should be removed - assertThat(linkedList.get(4), is("Yulia")); + assertThat(linkedList.size()).isEqualTo(5); + assertThat(linkedList.get(0)).isEqualTo("Andrei"); + assertThat(linkedList.get(1)).isEqualTo("Tikhon"); + assertThat(linkedList.get(2)).isEqualTo("Elena"); + assertThat(linkedList.get(3)).isEqualTo("Ilya"); // Only first 'Ilya' occurrence should be removed + assertThat(linkedList.get(4)).isEqualTo("Yulia"); } @Test @@ -226,11 +224,11 @@ public void removeByValueWhenNullsPresent() { var removeResult = linkedList.remove(null); assertTrue(removeResult); - assertThat(linkedList.size(), is(4)); - assertThat(linkedList.get(0), is("Andrei")); - assertThat(linkedList.get(1), is("Tikhon")); - assertThat(linkedList.get(2), is(nullValue())); // Only first null occurrence should be removed - assertThat(linkedList.get(3), is("Elena")); + assertThat(linkedList.size()).isEqualTo(4); + assertThat(linkedList.get(0)).isEqualTo("Andrei"); + assertThat(linkedList.get(1)).isEqualTo("Tikhon"); + assertThat(linkedList.get(2)).isNull(); // Only first null occurrence should be removed + assertThat(linkedList.get(3)).isEqualTo("Elena"); } @Test @@ -245,12 +243,12 @@ public void removeByValueWhenAbsent() { var removeResult = linkedList.remove("Oksana"); assertFalse(removeResult); - assertThat(linkedList.size(), is(5)); - assertThat(linkedList.get(0), is("Andrei")); - assertThat(linkedList.get(1), is("Tikhon")); - assertThat(linkedList.get(2), is("Ilya")); - assertThat(linkedList.get(3), is("Elena")); - assertThat(linkedList.get(4), is("Yulia")); + assertThat(linkedList.size()).isEqualTo(5); + assertThat(linkedList.get(0)).isEqualTo("Andrei"); + assertThat(linkedList.get(1)).isEqualTo("Tikhon"); + assertThat(linkedList.get(2)).isEqualTo("Ilya"); + assertThat(linkedList.get(3)).isEqualTo("Elena"); + assertThat(linkedList.get(4)).isEqualTo("Yulia"); } @Test @@ -262,11 +260,11 @@ public void pushNPop() { linkedList.push(36); linkedList.push(39); - assertThat(linkedList.pop(), is(39)); - assertThat(linkedList.pop(), is(36)); - assertThat(linkedList.pop(), is(3)); + assertThat(linkedList.pop()).isEqualTo(39); + assertThat(linkedList.pop()).isEqualTo(36); + assertThat(linkedList.pop()).isEqualTo(3); assertFalse(linkedList.isEmpty()); - assertThat(linkedList.pop(), is(2)); + assertThat(linkedList.pop()).isEqualTo(2); assertTrue(linkedList.isEmpty()); } @@ -276,16 +274,16 @@ public void pushNPopNRemove() { linkedList.push(2); linkedList.push(3); linkedList.push(36); // 36 3 2 - assertThat(linkedList.remove(1), is(3)); // 36 2 + assertThat(linkedList.remove(1)).isEqualTo(3); // 36 2 linkedList.push(39); linkedList.push(43); linkedList.push(45); // 45 43 39 36 2 - assertThat(linkedList.remove(2), is(39)); // 45 43 36 2 + assertThat(linkedList.remove(2)).isEqualTo(39); // 45 43 36 2 - assertThat(linkedList.pop(), is(45)); - assertThat(linkedList.pop(), is(43)); - assertThat(linkedList.pop(), is(36)); - assertThat(linkedList.pop(), is(2)); + assertThat(linkedList.pop()).isEqualTo(45); + assertThat(linkedList.pop()).isEqualTo(43); + assertThat(linkedList.pop()).isEqualTo(36); + assertThat(linkedList.pop()).isEqualTo(2); assertTrue(linkedList.isEmpty()); } @@ -297,12 +295,12 @@ public void clear() { linkedList.add(36); assertFalse(linkedList.isEmpty()); - assertThat(linkedList.size(), is(3)); + assertThat(linkedList.size()).isEqualTo(3); linkedList.clear(); assertTrue(linkedList.isEmpty()); - assertThat(linkedList.size(), is(0)); + assertThat(linkedList.size()).isEqualTo(0); } @Test @@ -316,7 +314,7 @@ public void testForEach() { for (var item : linkedList) { result.add(item); } - assertThat(result, is(List.of(3, 7, 12))); + assertThat(result).isEqualTo(List.of(3, 7, 12)); } @Test @@ -327,7 +325,7 @@ public void testForEachForEmptyList() { for (var item : linkedList) { result.add(item); } - assertThat(result, is(List.of())); + assertThat(result).isEqualTo(List.of()); } @Test @@ -340,6 +338,6 @@ public void testToString() { var result = linkedList.toString(); - assertThat(result, is("CustomLinkedList{head={3, next={7, next={12, next={34}}}}}")); + assertThat(result).isEqualTo("CustomLinkedList{head={3, next={7, next={12, next={34}}}}}"); } } diff --git a/src/test/java/by/andd3dfx/common/ArrayRangesTest.java b/src/test/java/by/andd3dfx/common/ArrayRangesTest.java index 4ac93930..b897a429 100644 --- a/src/test/java/by/andd3dfx/common/ArrayRangesTest.java +++ b/src/test/java/by/andd3dfx/common/ArrayRangesTest.java @@ -3,8 +3,7 @@ import org.junit.Before; import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class ArrayRangesTest { @@ -17,26 +16,26 @@ public void setup() { @Test public void compactWhenOneNumber() { - assertThat(ranges.compact(new int[]{1}), is("1")); + assertThat(ranges.compact(new int[]{1})).isEqualTo("1"); } @Test public void compactWhenNoIntervals() { - assertThat(ranges.compact(new int[]{1, 4}), is("1,4")); + assertThat(ranges.compact(new int[]{1, 4})).isEqualTo("1,4"); } @Test public void compactForOneInterval() { - assertThat(ranges.compact(new int[]{1, 4, 3, 2}), is("1-4")); + assertThat(ranges.compact(new int[]{1, 4, 3, 2})).isEqualTo("1-4"); } @Test public void compactForIntervals() { - assertThat(ranges.compact(new int[]{1, 4, 5, 2, 3, 9, 8, 11, 0}), is("0-5,8-9,11")); + assertThat(ranges.compact(new int[]{1, 4, 5, 2, 3, 9, 8, 11, 0})).isEqualTo("0-5,8-9,11"); } @Test public void compactForIntervalsWithDuplicates() { - assertThat(ranges.compact(new int[]{1, 4, 5, 2, 3, 9, 5, 8, 2, 11, 0}), is("0-5,8-9,11")); + assertThat(ranges.compact(new int[]{1, 4, 5, 2, 3, 9, 5, 8, 2, 11, 0})).isEqualTo("0-5,8-9,11"); } } diff --git a/src/test/java/by/andd3dfx/common/CandiesTest.java b/src/test/java/by/andd3dfx/common/CandiesTest.java index 687c6116..182da458 100644 --- a/src/test/java/by/andd3dfx/common/CandiesTest.java +++ b/src/test/java/by/andd3dfx/common/CandiesTest.java @@ -2,15 +2,16 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static by.andd3dfx.common.Candies.countCandies; +import static org.assertj.core.api.Assertions.assertThat; + public class CandiesTest { @Test - public void countCandies() { - assertThat(Candies.countCandies(3, 2), is(5)); - assertThat(Candies.countCandies(1, 2), is(1)); - assertThat(Candies.countCandies(5, 2), is(9)); + public void testCountCandies() { + assertThat(countCandies(3, 2)).isEqualTo(5); + assertThat(countCandies(1, 2)).isEqualTo(1); + assertThat(countCandies(5, 2)).isEqualTo(9); } } diff --git a/src/test/java/by/andd3dfx/common/CountStreamersTest.java b/src/test/java/by/andd3dfx/common/CountStreamersTest.java index 34e35380..3e4ae573 100644 --- a/src/test/java/by/andd3dfx/common/CountStreamersTest.java +++ b/src/test/java/by/andd3dfx/common/CountStreamersTest.java @@ -3,8 +3,7 @@ import org.junit.Test; import static by.andd3dfx.common.CountStreamers.count; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class CountStreamersTest { @@ -15,7 +14,7 @@ public void countWithoutOverlapping() { {40, 50} }; - assertThat(count(times), is(1)); + assertThat(count(times)).isEqualTo(1); } @Test @@ -25,7 +24,7 @@ public void countWithOverlapping() { {20, 50} }; - assertThat(count(times), is(2)); + assertThat(count(times)).isEqualTo(2); } @Test @@ -40,6 +39,6 @@ public void countComplexCase() { {10, 120} }; - assertThat(count(times), is(4)); + assertThat(count(times)).isEqualTo(4); } } diff --git a/src/test/java/by/andd3dfx/common/CustomEnumTest.java b/src/test/java/by/andd3dfx/common/CustomEnumTest.java index 9771b498..27e67106 100644 --- a/src/test/java/by/andd3dfx/common/CustomEnumTest.java +++ b/src/test/java/by/andd3dfx/common/CustomEnumTest.java @@ -6,8 +6,7 @@ import static by.andd3dfx.common.CustomEnum.MONDAY; import static by.andd3dfx.common.CustomEnum.SUNDAY; import static by.andd3dfx.common.CustomEnum.WEDNESDAY; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class CustomEnumTest { @@ -15,27 +14,27 @@ public class CustomEnumTest { public void values() { CustomEnum[] values = CustomEnum.values(); - assertThat(values.length, is(7)); + assertThat(values.length).isEqualTo(7); - assertThat(values[0], is(MONDAY)); - assertThat(values[6], is(SUNDAY)); + assertThat(values[0]).isEqualTo(MONDAY); + assertThat(values[6]).isEqualTo(SUNDAY); } @Test public void valueOf() { - assertThat(CustomEnum.valueOf("FRIDAY"), is(FRIDAY)); - assertThat(CustomEnum.valueOf("SUNDAY"), is(SUNDAY)); + assertThat(CustomEnum.valueOf("FRIDAY")).isEqualTo(FRIDAY); + assertThat(CustomEnum.valueOf("SUNDAY")).isEqualTo(SUNDAY); } @Test public void ordinal() { - assertThat(MONDAY.ordinal(), is(0)); - assertThat(WEDNESDAY.ordinal(), is(2)); + assertThat(MONDAY.ordinal()).isEqualTo(0); + assertThat(WEDNESDAY.ordinal()).isEqualTo(2); } @Test public void name() { - assertThat(SUNDAY.name(), is("SUNDAY")); - assertThat(MONDAY.name(), is("MONDAY")); + assertThat(SUNDAY.name()).isEqualTo("SUNDAY"); + assertThat(MONDAY.name()).isEqualTo("MONDAY"); } } diff --git a/src/test/java/by/andd3dfx/common/FileSystemPathTest.java b/src/test/java/by/andd3dfx/common/FileSystemPathTest.java index 6ee21cf4..004d52d0 100644 --- a/src/test/java/by/andd3dfx/common/FileSystemPathTest.java +++ b/src/test/java/by/andd3dfx/common/FileSystemPathTest.java @@ -2,8 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class FileSystemPathTest { @@ -11,41 +10,47 @@ public class FileSystemPathTest { public void moveToParentDir() { FileSystemPath path = new FileSystemPath("/a/b/c/d"); path.cd("../x"); - assertThat(path.getPath(), is("/a/b/c/x")); + + assertThat(path.getPath()).isEqualTo("/a/b/c/x"); } @Test public void moveToParentDir2() { FileSystemPath path = new FileSystemPath("/a/b/c/d"); path.cd("../../x/d"); - assertThat(path.getPath(), is("/a/b/x/d")); + + assertThat(path.getPath()).isEqualTo("/a/b/x/d"); } @Test public void moveToPathFromRoot() { FileSystemPath path = new FileSystemPath("/a/b/c/d"); path.cd("/f/g/h"); - assertThat(path.getPath(), is("/f/g/h")); + + assertThat(path.getPath()).isEqualTo("/f/g/h"); } @Test public void moveToRootDirectly() { FileSystemPath path = new FileSystemPath("/a/b/c/d"); path.cd("/"); - assertThat(path.getPath(), is("/")); + + assertThat(path.getPath()).isEqualTo("/"); } @Test public void moveFromCurrentDir() { FileSystemPath path = new FileSystemPath("/a/b/c/d"); path.cd("./f/g"); - assertThat(path.getPath(), is("/a/b/c/d/f/g")); + + assertThat(path.getPath()).isEqualTo("/a/b/c/d/f/g"); } @Test public void moveFromCurrentDir2() { FileSystemPath path = new FileSystemPath("/a/b/c/d"); path.cd("f/g"); - assertThat(path.getPath(), is("/a/b/c/d/f/g")); + + assertThat(path.getPath()).isEqualTo("/a/b/c/d/f/g"); } } diff --git a/src/test/java/by/andd3dfx/common/InsuranceNumberTest.java b/src/test/java/by/andd3dfx/common/InsuranceNumberTest.java index 1e7aee00..86b6fc8b 100644 --- a/src/test/java/by/andd3dfx/common/InsuranceNumberTest.java +++ b/src/test/java/by/andd3dfx/common/InsuranceNumberTest.java @@ -4,56 +4,55 @@ import static by.andd3dfx.common.InsuranceNumber.changeFormat; import static by.andd3dfx.common.InsuranceNumber.changeFormatUsingRegExGroups; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class InsuranceNumberTest { - @Test - public void changeFormatNothingChanged() { - assertThat(changeFormat("Please quote your policy number."), - is("Please quote your policy number.")); - } - - @Test - public void changeFormatSimple() { - assertThat(changeFormat("Please quote your policy number: 112-39-8552."), - is("Please quote your policy number: 112/8552/39.")); - } - - @Test - public void changeFormatMultipleParagraphs() { - assertThat(changeFormat("Please quote your policy numbers: 112-39-8552 and 134-39-9552."), - is("Please quote your policy numbers: 112/8552/39 and 134/9552/39.")); - } - - @Test - public void changeFormatWithNewStringDelimiter() { - assertThat(changeFormat("Please quote your policy number: 112-39-\n8552."), - is("Please quote your policy number: 112/\n8552/39.")); - } - - @Test - public void changeFormatUsingRegExGroupsNothingChanged() { - assertThat(changeFormatUsingRegExGroups("Please quote your policy number."), - is("Please quote your policy number.")); - } - - @Test - public void changeFormatUsingRegExGroupsSimple() { - assertThat(changeFormatUsingRegExGroups("Please quote your policy number: 112-39-8552."), - is("Please quote your policy number: 112/8552/39.")); - } - - @Test - public void changeFormatUsingRegExGroupsMultipleParagraphs() { - assertThat(changeFormatUsingRegExGroups("Please quote your policy numbers: 112-39-8552 and 134-39-9552."), - is("Please quote your policy numbers: 112/8552/39 and 134/9552/39.")); - } - - @Test - public void changeFormatUsingRegExGroupsWithNewStringDelimiter() { - assertThat(changeFormatUsingRegExGroups("Please quote your policy number: 112-39-\n8552."), - is("Please quote your policy number: 112/\n8552/39.")); - } + @Test + public void changeFormatNothingChanged() { + assertThat(changeFormat("Please quote your policy number.")) + .isEqualTo("Please quote your policy number."); + } + + @Test + public void changeFormatSimple() { + assertThat(changeFormat("Please quote your policy number: 112-39-8552.")) + .isEqualTo("Please quote your policy number: 112/8552/39."); + } + + @Test + public void changeFormatMultipleParagraphs() { + assertThat(changeFormat("Please quote your policy numbers: 112-39-8552 and 134-39-9552.")) + .isEqualTo("Please quote your policy numbers: 112/8552/39 and 134/9552/39."); + } + + @Test + public void changeFormatWithNewStringDelimiter() { + assertThat(changeFormat("Please quote your policy number: 112-39-\n8552.")) + .isEqualTo("Please quote your policy number: 112/\n8552/39."); + } + + @Test + public void changeFormatUsingRegExGroupsNothingChanged() { + assertThat(changeFormatUsingRegExGroups("Please quote your policy number.")) + .isEqualTo("Please quote your policy number."); + } + + @Test + public void changeFormatUsingRegExGroupsSimple() { + assertThat(changeFormatUsingRegExGroups("Please quote your policy number: 112-39-8552.")) + .isEqualTo("Please quote your policy number: 112/8552/39."); + } + + @Test + public void changeFormatUsingRegExGroupsMultipleParagraphs() { + assertThat(changeFormatUsingRegExGroups("Please quote your policy numbers: 112-39-8552 and 134-39-9552.")) + .isEqualTo("Please quote your policy numbers: 112/8552/39 and 134/9552/39."); + } + + @Test + public void changeFormatUsingRegExGroupsWithNewStringDelimiter() { + assertThat(changeFormatUsingRegExGroups("Please quote your policy number: 112-39-\n8552.")) + .isEqualTo("Please quote your policy number: 112/\n8552/39."); + } } diff --git a/src/test/java/by/andd3dfx/common/NeedleTest.java b/src/test/java/by/andd3dfx/common/NeedleTest.java index bd71a78f..d8f2c358 100644 --- a/src/test/java/by/andd3dfx/common/NeedleTest.java +++ b/src/test/java/by/andd3dfx/common/NeedleTest.java @@ -6,8 +6,8 @@ import java.io.IOException; import java.io.InputStream; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static by.andd3dfx.common.Needle.count; +import static org.assertj.core.api.Assertions.assertThat; public class NeedleTest { @@ -15,8 +15,8 @@ public class NeedleTest { public void countOneLine() throws IOException { String inMessage = "Hello, there!"; - assertThat(Needle.count("there", buildStream(inMessage)), is(1)); - assertThat(Needle.count("small", buildStream(inMessage)), is(0)); + assertThat(count("there", buildStream(inMessage))).isEqualTo(1); + assertThat(count("small", buildStream(inMessage))).isEqualTo(0); } @Test @@ -25,12 +25,12 @@ public void countMultiLine() throws IOException { "How are you today?\n" + "Yes, you over there."; - assertThat(Needle.count("there", buildStream(inMessage)), is(2)); - assertThat(Needle.count("today", buildStream(inMessage)), is(1)); - assertThat(Needle.count("small", buildStream(inMessage)), is(0)); + assertThat(count("there", buildStream(inMessage))).isEqualTo(2); + assertThat(count("today", buildStream(inMessage))).isEqualTo(1); + assertThat(count("small", buildStream(inMessage))).isEqualTo(0); } private InputStream buildStream(String inMessage) { return new ByteArrayInputStream(inMessage.getBytes()); } -} \ No newline at end of file +} diff --git a/src/test/java/by/andd3dfx/common/PasswordBruteforceTest.java b/src/test/java/by/andd3dfx/common/PasswordBruteforceTest.java index 5f93fb26..faacb75d 100644 --- a/src/test/java/by/andd3dfx/common/PasswordBruteforceTest.java +++ b/src/test/java/by/andd3dfx/common/PasswordBruteforceTest.java @@ -6,8 +6,7 @@ import java.util.Random; import java.util.function.Function; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertNull; public class PasswordBruteforceTest { @@ -38,10 +37,10 @@ public void setUp() throws Exception { @Test public void encode() { // ☺Punko -> 012345 - assertThat(passwordBruteforce.encode(1), is("P")); // 1 = 1*6^0 = 1 = P - assertThat(passwordBruteforce.encode(2), is("u")); // 2 = 2*6^0 = 2 = u - assertThat(passwordBruteforce.encode(31), is("oP")); // 31 = 5*6^1 + 1*6^0 = 30 + 1 = oP - assertThat(passwordBruteforce.encode(59), is("Pno")); // 59 = 1*6^2 + 3*6^1 + 5*6^0 = 36 + 18 + 5 = Pno + assertThat(passwordBruteforce.encode(1)).isEqualTo("P"); // 1 = 1*6^0 = 1 = P + assertThat(passwordBruteforce.encode(2)).isEqualTo("u"); // 2 = 2*6^0 = 2 = u + assertThat(passwordBruteforce.encode(31)).isEqualTo("oP"); // 31 = 5*6^1 + 1*6^0 = 30 + 1 = oP + assertThat(passwordBruteforce.encode(59)).isEqualTo("Pno"); // 59 = 1*6^2 + 3*6^1 + 5*6^0 = 36 + 18 + 5 = Pno } @Test @@ -80,6 +79,6 @@ private String generatePassword() { private void decodeUsingDefinitePassword(String password) { String hash = hashFunction.apply(password); System.out.println("password=" + password + ", hash=" + hash); - assertThat(passwordBruteforce.decode(hash, password.length()), is(password)); + assertThat(passwordBruteforce.decode(hash, password.length())).isEqualTo(password); } } diff --git a/src/test/java/by/andd3dfx/common/PropertiesExtractorTest.java b/src/test/java/by/andd3dfx/common/PropertiesExtractorTest.java index e6deace7..356055b5 100644 --- a/src/test/java/by/andd3dfx/common/PropertiesExtractorTest.java +++ b/src/test/java/by/andd3dfx/common/PropertiesExtractorTest.java @@ -2,22 +2,25 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class PropertiesExtractorTest { @Test public void extractForPlanObject() throws IllegalAccessException { Person person = new Person("Andrei"); - assertThat(PropertiesExtractor.extract(person), is("Andrei")); + var result = PropertiesExtractor.extract(person); + + assertThat(result).isEqualTo("Andrei"); } @Test public void extractForComplexObject() throws IllegalAccessException { Person person = new Person("Andrei"); person.setCard(new Card("VISA", "123546")); - assertThat(PropertiesExtractor.extract(person), is("Andrei VISA 123546")); + var result = PropertiesExtractor.extract(person); + + assertThat(result).isEqualTo("Andrei VISA 123546"); } public static class Person { diff --git a/src/test/java/by/andd3dfx/common/SkipItemsByConditionTest.java b/src/test/java/by/andd3dfx/common/SkipItemsByConditionTest.java index 249a90ab..2b5c70e2 100644 --- a/src/test/java/by/andd3dfx/common/SkipItemsByConditionTest.java +++ b/src/test/java/by/andd3dfx/common/SkipItemsByConditionTest.java @@ -6,8 +6,7 @@ import java.util.HashMap; import java.util.Map; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class SkipItemsByConditionTest { @@ -24,8 +23,8 @@ public void filterUsingIterator1() { Map result = skipItemsByCondition.filterUsingIterator(map, key -> key % 2 == 1); - assertThat(result.size(), is(1)); - assertThat(result.get(2), is("table")); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(2)).isEqualTo("table"); } @Test @@ -34,9 +33,9 @@ public void filterUsingIterator2() { Map result = skipItemsByCondition.filterUsingIterator(map, key -> key % 2 == 0); - assertThat(result.size(), is(2)); - assertThat(result.get(1), is("penguin")); - assertThat(result.get(3), is("bubble")); + assertThat(result.size()).isEqualTo(2); + assertThat(result.get(1)).isEqualTo("penguin"); + assertThat(result.get(3)).isEqualTo("bubble"); } @Test @@ -45,8 +44,8 @@ public void filterUsingRemoveIf1() { Map result = skipItemsByCondition.filterUsingRemoveIf(map, key -> key % 2 == 1); - assertThat(result.size(), is(1)); - assertThat(result.get(2), is("table")); + assertThat(result.size()).isEqualTo(1); + assertThat(result.get(2)).isEqualTo("table"); } @Test @@ -55,9 +54,9 @@ public void filterUsingRemoveIf2() { Map result = skipItemsByCondition.filterUsingRemoveIf(map, key -> key % 2 == 0); - assertThat(result.size(), is(2)); - assertThat(result.get(1), is("penguin")); - assertThat(result.get(3), is("bubble")); + assertThat(result.size()).isEqualTo(2); + assertThat(result.get(1)).isEqualTo("penguin"); + assertThat(result.get(3)).isEqualTo("bubble"); } private static HashMap buildMap() { diff --git a/src/test/java/by/andd3dfx/common/TrainCompositionTest.java b/src/test/java/by/andd3dfx/common/TrainCompositionTest.java index a110bc90..28b39b34 100644 --- a/src/test/java/by/andd3dfx/common/TrainCompositionTest.java +++ b/src/test/java/by/andd3dfx/common/TrainCompositionTest.java @@ -3,8 +3,7 @@ import org.junit.Before; import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class TrainCompositionTest { @@ -23,9 +22,9 @@ public void testAttachDetach() { trainComposition.attachWagonFromLeft(34); // Now order is next: 34 13 7 45 - assertThat(trainComposition.detachWagonFromRight(), is(45)); - assertThat(trainComposition.detachWagonFromRight(), is(7)); - assertThat(trainComposition.detachWagonFromLeft(), is(34)); - assertThat(trainComposition.detachWagonFromLeft(), is(13)); + assertThat(trainComposition.detachWagonFromRight()).isEqualTo(45); + assertThat(trainComposition.detachWagonFromRight()).isEqualTo(7); + assertThat(trainComposition.detachWagonFromLeft()).isEqualTo(34); + assertThat(trainComposition.detachWagonFromLeft()).isEqualTo(13); } } diff --git a/src/test/java/by/andd3dfx/common/UrlShortenerTest.java b/src/test/java/by/andd3dfx/common/UrlShortenerTest.java index 39ac62a2..b2a8df2f 100644 --- a/src/test/java/by/andd3dfx/common/UrlShortenerTest.java +++ b/src/test/java/by/andd3dfx/common/UrlShortenerTest.java @@ -3,8 +3,7 @@ import org.junit.Before; import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class UrlShortenerTest { @@ -17,32 +16,38 @@ public void setup() { @Test public void testEncodeNDecodeStrings() { - assertThat(urlShortener.buildShortUrl("tut.by"), is("b")); - assertThat(urlShortener.buildShortUrl("dev.by"), is("c")); - assertThat(urlShortener.buildShortUrl("thg.ru"), is("d")); + assertThat(urlShortener.buildShortUrl("tut.by")).isEqualTo("b"); + assertThat(urlShortener.buildShortUrl("dev.by")).isEqualTo("c"); + assertThat(urlShortener.buildShortUrl("thg.ru")).isEqualTo("d"); - assertThat(urlShortener.restoreLongUrl("b"), is("tut.by")); - assertThat(urlShortener.restoreLongUrl("c"), is("dev.by")); - assertThat(urlShortener.restoreLongUrl("d"), is("thg.ru")); + assertThat(urlShortener.restoreLongUrl("b")).isEqualTo("tut.by"); + assertThat(urlShortener.restoreLongUrl("c")).isEqualTo("dev.by"); + assertThat(urlShortener.restoreLongUrl("d")).isEqualTo("thg.ru"); } @Test public void encodePrimaryKeyToShortString() { - assertThat("Wrong short string for PK=1", - urlShortener.encodePrimaryKeyToShortString(1L), is("b")); - assertThat("Wrong short string for PK=100", - urlShortener.encodePrimaryKeyToShortString(100L), is("bM")); - assertThat("Wrong short string for PK=101", - urlShortener.encodePrimaryKeyToShortString(101L), is("bN")); + assertThat(urlShortener.encodePrimaryKeyToShortString(1L)) + .as("Wrong short string for PK=1") + .isEqualTo("b"); + assertThat(urlShortener.encodePrimaryKeyToShortString(100L)) + .as("Wrong short string for PK=100") + .isEqualTo("bM"); + assertThat(urlShortener.encodePrimaryKeyToShortString(101L)) + .as("Wrong short string for PK=101") + .isEqualTo("bN"); } @Test public void decodeShortStringToPrimaryKey() { - assertThat("Wrong PK for shortString=b", - urlShortener.decodeShortStringToPrimaryKey("b"), is(1L)); - assertThat("Wrong PK for shortString=bM", - urlShortener.decodeShortStringToPrimaryKey("bM"), is(100L)); - assertThat("Wrong PK for shortString=bN", - urlShortener.decodeShortStringToPrimaryKey("bN"), is(101L)); + assertThat(urlShortener.decodeShortStringToPrimaryKey("b")) + .as("Wrong PK for shortString=b") + .isEqualTo(1L); + assertThat(urlShortener.decodeShortStringToPrimaryKey("bM")) + .as("Wrong PK for shortString=bM") + .isEqualTo(100L); + assertThat(urlShortener.decodeShortStringToPrimaryKey("bN")) + .as("Wrong PK for shortString=bN") + .isEqualTo(101L); } } diff --git a/src/test/java/by/andd3dfx/common/UserInputTest.java b/src/test/java/by/andd3dfx/common/UserInputTest.java index 42041d7e..5dfbf5aa 100644 --- a/src/test/java/by/andd3dfx/common/UserInputTest.java +++ b/src/test/java/by/andd3dfx/common/UserInputTest.java @@ -2,28 +2,27 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class UserInputTest { - @Test - public void testTextInput() { - UserInput.TextInput input = new UserInput.TextInput(); - input.add('1'); - input.add('a'); - input.add('0'); + @Test + public void testTextInput() { + UserInput.TextInput input = new UserInput.TextInput(); + input.add('1'); + input.add('a'); + input.add('0'); - assertThat("Unexpected string", input.getValue(), is("1a0")); - } + assertThat(input.getValue()).isEqualTo("1a0"); + } - @Test - public void testNumericInput() { - UserInput.TextInput input = new UserInput.NumericInput(); - input.add('1'); - input.add('a'); - input.add('0'); + @Test + public void testNumericInput() { + UserInput.TextInput input = new UserInput.NumericInput(); + input.add('1'); + input.add('a'); + input.add('0'); - assertThat("Unexpected string", input.getValue(), is("10")); - } -} \ No newline at end of file + assertThat(input.getValue()).isEqualTo("10"); + } +} diff --git a/src/test/java/by/andd3dfx/common/birdsfarm/BirdsFarmTest.java b/src/test/java/by/andd3dfx/common/birdsfarm/BirdsFarmTest.java index 7136c68d..f693c895 100644 --- a/src/test/java/by/andd3dfx/common/birdsfarm/BirdsFarmTest.java +++ b/src/test/java/by/andd3dfx/common/birdsfarm/BirdsFarmTest.java @@ -2,8 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -48,7 +47,7 @@ private void checkExceptionDuringSecondHatching(Egg egg) throws Exception { egg.hatch(); fail("Exception after second hatch should be thrown!"); } catch (IllegalStateException ise) { - assertThat("Wrong exception message", ise.getMessage(), is("This egg already hatched!")); + assertThat(ise.getMessage()).isEqualTo("This egg already hatched!"); } } } diff --git a/src/test/java/by/andd3dfx/core/GenericClassCreationTest.java b/src/test/java/by/andd3dfx/core/GenericClassCreationTest.java index 5fded92c..9198de92 100644 --- a/src/test/java/by/andd3dfx/core/GenericClassCreationTest.java +++ b/src/test/java/by/andd3dfx/core/GenericClassCreationTest.java @@ -5,9 +5,7 @@ import lombok.AllArgsConstructor; import org.junit.Test; -import static org.hamcrest.CoreMatchers.instanceOf; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertThrows; public class GenericClassCreationTest { @@ -16,28 +14,28 @@ public class GenericClassCreationTest { public void createStringBy_CreatorUsingDeclaredConstructor() { CreatorUsingDeclaredConstructor container = new CreatorUsingDeclaredConstructor<>(); - assertThat(container.createObject(String.class), is("")); + assertThat(container.createObject(String.class)).isEqualTo(""); } @Test public void createStringBy_CreatorUsingSupplier() { CreatorUsingSupplier container = new CreatorUsingSupplier<>(String::new); - assertThat(container.createObject(), is("")); + assertThat(container.createObject()).isEqualTo(""); } @Test public void createClassWithoutFieldsBy_CreatorUsingDeclaredConstructor() { CreatorUsingDeclaredConstructor container = new CreatorUsingDeclaredConstructor<>(); - assertThat(container.createObject(CustomClassWithoutFields.class), instanceOf(CustomClassWithoutFields.class)); + assertThat(container.createObject(CustomClassWithoutFields.class)).isInstanceOf(CustomClassWithoutFields.class); } @Test public void createClassWithoutFieldsBy_CreatorUsingSupplier() { CreatorUsingSupplier container = new CreatorUsingSupplier<>(CustomClassWithoutFields::new); - assertThat(container.createObject(), instanceOf(CustomClassWithoutFields.class)); + assertThat(container.createObject()).isInstanceOf(CustomClassWithoutFields.class); } @Test @@ -53,7 +51,7 @@ public void createClassWithFieldBy_CreatorUsingDeclaredConstructor() { public void createClassWithFieldBy_CreatorUsingSupplier() { CreatorUsingSupplier container = new CreatorUsingSupplier<>(() -> new CustomClassWithField(0)); - assertThat(container.createObject(), instanceOf(CustomClassWithField.class)); + assertThat(container.createObject()).isInstanceOf(CustomClassWithField.class); } public static class CustomClassWithoutFields { diff --git a/src/test/java/by/andd3dfx/dynamic/StoriesTest.java b/src/test/java/by/andd3dfx/dynamic/StoriesTest.java index cda35f1c..87261432 100644 --- a/src/test/java/by/andd3dfx/dynamic/StoriesTest.java +++ b/src/test/java/by/andd3dfx/dynamic/StoriesTest.java @@ -2,27 +2,26 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class StoriesTest { @Test public void combinations() { - assertThat(Stories.combinations(1), is(1)); - assertThat(Stories.combinations(2), is(2)); - assertThat(Stories.combinations(3), is(3)); - assertThat(Stories.combinations(4), is(5)); - assertThat(Stories.combinations(5), is(8)); + assertThat(Stories.combinations(1)).isEqualTo(1); + assertThat(Stories.combinations(2)).isEqualTo(2); + assertThat(Stories.combinations(3)).isEqualTo(3); + assertThat(Stories.combinations(4)).isEqualTo(5); + assertThat(Stories.combinations(5)).isEqualTo(8); } @Test public void fibonacci() { - assertThat(Stories.fibonacci(1), is(1)); - assertThat(Stories.fibonacci(2), is(1)); - assertThat(Stories.fibonacci(3), is(2)); - assertThat(Stories.fibonacci(4), is(3)); - assertThat(Stories.fibonacci(5), is(5)); - assertThat(Stories.fibonacci(6), is(8)); + assertThat(Stories.fibonacci(1)).isEqualTo(1); + assertThat(Stories.fibonacci(2)).isEqualTo(1); + assertThat(Stories.fibonacci(3)).isEqualTo(2); + assertThat(Stories.fibonacci(4)).isEqualTo(3); + assertThat(Stories.fibonacci(5)).isEqualTo(5); + assertThat(Stories.fibonacci(6)).isEqualTo(8); } } diff --git a/src/test/java/by/andd3dfx/iterators/EvenIteratorTest.java b/src/test/java/by/andd3dfx/iterators/EvenIteratorTest.java index 790eb5fa..3e45d04b 100644 --- a/src/test/java/by/andd3dfx/iterators/EvenIteratorTest.java +++ b/src/test/java/by/andd3dfx/iterators/EvenIteratorTest.java @@ -5,8 +5,7 @@ import java.util.Arrays; import java.util.NoSuchElementException; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; public class EvenIteratorTest { @@ -16,8 +15,8 @@ public void testWhenNoEvens() { var list = Arrays.asList(1, 3, 5, 7, 9); var evenIterator = new EvenIterator(list.iterator()); - assertThat(evenIterator.hasNext(), is(false)); - assertThat(evenIterator.hasNext(), is(false)); + assertThat(evenIterator.hasNext()).isEqualTo(false); + assertThat(evenIterator.hasNext()).isEqualTo(false); checkExceptionWhenNextOnEmptyIterator(evenIterator); } @@ -26,14 +25,14 @@ public void testWhenEvensOnly() { var list = Arrays.asList(2, 4, 8, 12); var evenIterator = new EvenIterator(list.iterator()); - assertThat(evenIterator.hasNext(), is(true)); - assertThat(evenIterator.next(), is(2)); - assertThat(evenIterator.next(), is(4)); - assertThat(evenIterator.hasNext(), is(true)); - assertThat(evenIterator.next(), is(8)); - assertThat(evenIterator.hasNext(), is(true)); - assertThat(evenIterator.next(), is(12)); - assertThat(evenIterator.hasNext(), is(false)); + assertThat(evenIterator.hasNext()).isEqualTo(true); + assertThat(evenIterator.next()).isEqualTo(2); + assertThat(evenIterator.next()).isEqualTo(4); + assertThat(evenIterator.hasNext()).isEqualTo(true); + assertThat(evenIterator.next()).isEqualTo(8); + assertThat(evenIterator.hasNext()).isEqualTo(true); + assertThat(evenIterator.next()).isEqualTo(12); + assertThat(evenIterator.hasNext()).isEqualTo(false); checkExceptionWhenNextOnEmptyIterator(evenIterator); } @@ -42,14 +41,14 @@ public void testWhenBothEvenNOdd() { var list = Arrays.asList(1, 2, 3, 4, 23, 8, 12, 91); var evenIterator = new EvenIterator(list.iterator()); - assertThat(evenIterator.hasNext(), is(true)); - assertThat(evenIterator.next(), is(2)); - assertThat(evenIterator.next(), is(4)); - assertThat(evenIterator.hasNext(), is(true)); - assertThat(evenIterator.next(), is(8)); - assertThat(evenIterator.hasNext(), is(true)); - assertThat(evenIterator.next(), is(12)); - assertThat(evenIterator.hasNext(), is(false)); + assertThat(evenIterator.hasNext()).isEqualTo(true); + assertThat(evenIterator.next()).isEqualTo(2); + assertThat(evenIterator.next()).isEqualTo(4); + assertThat(evenIterator.hasNext()).isEqualTo(true); + assertThat(evenIterator.next()).isEqualTo(8); + assertThat(evenIterator.hasNext()).isEqualTo(true); + assertThat(evenIterator.next()).isEqualTo(12); + assertThat(evenIterator.hasNext()).isEqualTo(false); checkExceptionWhenNextOnEmptyIterator(evenIterator); } @@ -58,10 +57,10 @@ public void testWhenBothEvenNOddButWithoutUsingHasNext() { var list = Arrays.asList(1, 2, 3, 4, 23, 8, 12, 91); var evenIterator = new EvenIterator(list.iterator()); - assertThat(evenIterator.next(), is(2)); - assertThat(evenIterator.next(), is(4)); - assertThat(evenIterator.next(), is(8)); - assertThat(evenIterator.next(), is(12)); + assertThat(evenIterator.next()).isEqualTo(2); + assertThat(evenIterator.next()).isEqualTo(4); + assertThat(evenIterator.next()).isEqualTo(8); + assertThat(evenIterator.next()).isEqualTo(12); checkExceptionWhenNextOnEmptyIterator(evenIterator); } @@ -70,7 +69,7 @@ private static void checkExceptionWhenNextOnEmptyIterator(EvenIterator evenItera evenIterator.next(); fail("Exception should be thrown"); } catch (NoSuchElementException nsee) { - assertThat(nsee.getMessage(), is("Iterator is empty!")); + assertThat(nsee.getMessage()).isEqualTo("Iterator is empty!"); } } } \ No newline at end of file diff --git a/src/test/java/by/andd3dfx/multithreading/AddMultithreadingTest.java b/src/test/java/by/andd3dfx/multithreading/AddMultithreadingTest.java index e77f206e..e353da8f 100644 --- a/src/test/java/by/andd3dfx/multithreading/AddMultithreadingTest.java +++ b/src/test/java/by/andd3dfx/multithreading/AddMultithreadingTest.java @@ -11,6 +11,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.awaitility.Awaitility.await; import static org.awaitility.Durations.ONE_HUNDRED_MILLISECONDS; +import static org.awaitility.Durations.TWO_SECONDS; public class AddMultithreadingTest { @@ -23,7 +24,7 @@ public void checkMultithreadingAbsence() throws ExecutionException, InterruptedE var future = CompletableFuture.supplyAsync(() -> aggregator.doRequestOld()); - await().atLeast(2, TimeUnit.SECONDS) + await().atLeast(TWO_SECONDS) .atMost(3, TimeUnit.SECONDS) .pollInterval(ONE_HUNDRED_MILLISECONDS) .until(() -> future.isDone()); diff --git a/src/test/java/by/andd3dfx/multithreading/CustomAtomicTest.java b/src/test/java/by/andd3dfx/multithreading/CustomAtomicTest.java index f6928141..495367b3 100644 --- a/src/test/java/by/andd3dfx/multithreading/CustomAtomicTest.java +++ b/src/test/java/by/andd3dfx/multithreading/CustomAtomicTest.java @@ -2,8 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class CustomAtomicTest { @@ -11,18 +10,30 @@ public class CustomAtomicTest { public void getAndIncrementWithoutFailedAttempts() { CustomAtomic customAtomic = new CustomAtomicImpl(34, 0); - assertThat("Initial value for current() expected", customAtomic.current(), is(34)); - assertThat("Initial value for getAndIncrement() expected", customAtomic.getAndIncrement(), is(34)); - assertThat("Incremented value for current() expected", customAtomic.current(), is(35)); + assertThat(customAtomic.current()) + .as("Initial value for current() expected") + .isEqualTo(34); + assertThat(customAtomic.getAndIncrement()) + .as("Initial value for getAndIncrement() expected") + .isEqualTo(34); + assertThat(customAtomic.current()) + .as("Incremented value for current() expected") + .isEqualTo(35); } @Test public void getAndIncrementWithFailedAttempts() { CustomAtomic customAtomic = new CustomAtomicImpl(34, 5); - assertThat("Initial value for current() expected", customAtomic.current(), is(34)); - assertThat("Initial value for getAndIncrement() expected", customAtomic.getAndIncrement(), is(34)); - assertThat("Incremented value for current() expected", customAtomic.current(), is(35)); + assertThat(customAtomic.current()) + .as("Initial value for current() expected") + .isEqualTo(34); + assertThat(customAtomic.getAndIncrement()) + .as("Initial value for getAndIncrement() expected") + .isEqualTo(34); + assertThat(customAtomic.current()) + .as("Incremented value for current() expected") + .isEqualTo(35); } class CustomAtomicImpl extends CustomAtomic { diff --git a/src/test/java/by/andd3dfx/multithreading/TwoLegsRobotTest.java b/src/test/java/by/andd3dfx/multithreading/TwoLegsRobotTest.java index 5d6b694b..c55aef2a 100644 --- a/src/test/java/by/andd3dfx/multithreading/TwoLegsRobotTest.java +++ b/src/test/java/by/andd3dfx/multithreading/TwoLegsRobotTest.java @@ -5,12 +5,10 @@ import java.util.Map; +import static org.assertj.core.api.Assertions.assertThat; import static org.awaitility.Awaitility.await; import static org.awaitility.Durations.ONE_HUNDRED_MILLISECONDS; import static org.awaitility.Durations.ONE_SECOND; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.greaterThan; public class TwoLegsRobotTest { @@ -39,11 +37,11 @@ public void testLogsOrder() { private void checkLogs(String logs) { String[] lines = logs.split("!"); - assertThat(lines.length, greaterThan(10)); + assertThat(lines.length).isGreaterThan(10); var index = false; for (var line : lines) { - assertThat(line, is(EXPECTED_STRING.get(index))); + assertThat(line).isEqualTo(EXPECTED_STRING.get(index)); index = !index; } } diff --git a/src/test/java/by/andd3dfx/multithreading/forkjoin/CommonRecursiveTaskTest.java b/src/test/java/by/andd3dfx/multithreading/forkjoin/CommonRecursiveTaskTest.java index d04afaf5..f188393c 100644 --- a/src/test/java/by/andd3dfx/multithreading/forkjoin/CommonRecursiveTaskTest.java +++ b/src/test/java/by/andd3dfx/multithreading/forkjoin/CommonRecursiveTaskTest.java @@ -10,8 +10,7 @@ import java.util.logging.Logger; import java.util.stream.Stream; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class CommonRecursiveTaskTest { @@ -31,7 +30,7 @@ public void commonRecursiveTaskViaSubmitOneElement() throws InterruptedException forkJoinPool.submit(commonRecursiveTask); - assertThat(commonRecursiveTask.get(), is(5L)); + assertThat(commonRecursiveTask.get()).isEqualTo(5L); } @Test @@ -40,7 +39,7 @@ public void commonRecursiveTaskViaSubmitTwoElements() throws InterruptedExceptio forkJoinPool.submit(commonRecursiveTask); - assertThat(commonRecursiveTask.get(), is(12L)); + assertThat(commonRecursiveTask.get()).isEqualTo(12L); } @Test @@ -49,7 +48,7 @@ public void testCommonRecursiveTaskViaSubmit() throws InterruptedException, Exec forkJoinPool.submit(commonRecursiveTask); - assertThat(commonRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(commonRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } @Test @@ -58,7 +57,7 @@ public void testCommonRecursiveTaskViaExecute() throws InterruptedException, Exe forkJoinPool.execute(commonRecursiveTask); - assertThat(commonRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(commonRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } @Test @@ -67,7 +66,7 @@ public void testCommonRecursiveTaskViaInvoke() throws InterruptedException, Exec forkJoinPool.invoke(commonRecursiveTask); - assertThat(commonRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(commonRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } @Test @@ -77,7 +76,7 @@ public void testCommonRecursiveTaskViaForkNJoin() throws InterruptedException, E commonRecursiveTask.fork(); commonRecursiveTask.join(); - assertThat(commonRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(commonRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } private class MyWorkContainer implements CommonRecursiveTask.IWorkContainer { @@ -137,7 +136,7 @@ public Long process(MyWorkContainer work) { String threadName = Thread.currentThread().getName(); logger.info(String.format("This result of work %s is equals to %d - was processed by thread %s", work, result, threadName)); - return Long.valueOf(result); + return (long) result; } } } diff --git a/src/test/java/by/andd3dfx/multithreading/forkjoin/CustomRecursiveTaskTest.java b/src/test/java/by/andd3dfx/multithreading/forkjoin/CustomRecursiveTaskTest.java index 32a31035..e7f0212c 100644 --- a/src/test/java/by/andd3dfx/multithreading/forkjoin/CustomRecursiveTaskTest.java +++ b/src/test/java/by/andd3dfx/multithreading/forkjoin/CustomRecursiveTaskTest.java @@ -6,8 +6,7 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.ForkJoinPool; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class CustomRecursiveTaskTest { @@ -27,7 +26,7 @@ public void testCustomRecursiveTaskViaSubmit() throws InterruptedException, Exec forkJoinPool.submit(customRecursiveTask); - assertThat(customRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(customRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } @Test @@ -36,7 +35,7 @@ public void testCustomRecursiveTaskViaExecute() throws InterruptedException, Exe forkJoinPool.execute(customRecursiveTask); - assertThat(customRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(customRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } @Test @@ -45,7 +44,7 @@ public void testCustomRecursiveTaskViaInvoke() throws InterruptedException, Exec forkJoinPool.invoke(customRecursiveTask); - assertThat(customRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(customRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } @Test @@ -55,6 +54,6 @@ public void testCustomRecursiveTaskViaForkNJoin() throws InterruptedException, E customRecursiveTask.fork(); customRecursiveTask.join(); - assertThat(customRecursiveTask.get(), is(EXPECTED_SUM)); + assertThat(customRecursiveTask.get()).isEqualTo(EXPECTED_SUM); } } diff --git a/src/test/java/by/andd3dfx/multithreading/future/FactorialSquareCalculatorTest.java b/src/test/java/by/andd3dfx/multithreading/future/FactorialSquareCalculatorTest.java index 7197d181..b9045476 100644 --- a/src/test/java/by/andd3dfx/multithreading/future/FactorialSquareCalculatorTest.java +++ b/src/test/java/by/andd3dfx/multithreading/future/FactorialSquareCalculatorTest.java @@ -5,8 +5,7 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.ForkJoinPool; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class FactorialSquareCalculatorTest { @@ -16,6 +15,6 @@ public void test() throws ExecutionException, InterruptedException { FactorialSquareCalculator calculator = new FactorialSquareCalculator(10); forkJoinPool.execute(calculator); - assertThat(calculator.get(), is(385)); + assertThat(calculator.get()).isEqualTo(385); } } diff --git a/src/test/java/by/andd3dfx/multithreading/future/SquareCalculatorTest.java b/src/test/java/by/andd3dfx/multithreading/future/SquareCalculatorTest.java index 26af5df7..50eb0c88 100644 --- a/src/test/java/by/andd3dfx/multithreading/future/SquareCalculatorTest.java +++ b/src/test/java/by/andd3dfx/multithreading/future/SquareCalculatorTest.java @@ -5,8 +5,7 @@ import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class SquareCalculatorTest { @@ -32,8 +31,8 @@ public void test() throws InterruptedException, ExecutionException { Integer result2 = future2.get(); System.out.println(result1 + " and " + result2); - assertThat(result1, is(100)); - assertThat(result2, is(10000)); + assertThat(result1).isEqualTo(100); + assertThat(result2).isEqualTo(10000); squareCalculator.shutdown(); } diff --git a/src/test/java/by/andd3dfx/multithreading/queue/AbstractBlockingQueueTest.java b/src/test/java/by/andd3dfx/multithreading/queue/AbstractBlockingQueueTest.java index c426e948..478d3b26 100644 --- a/src/test/java/by/andd3dfx/multithreading/queue/AbstractBlockingQueueTest.java +++ b/src/test/java/by/andd3dfx/multithreading/queue/AbstractBlockingQueueTest.java @@ -3,7 +3,6 @@ import lombok.AllArgsConstructor; import lombok.Data; import lombok.SneakyThrows; -import org.hamcrest.Matchers; import org.junit.Before; import org.junit.Test; @@ -14,10 +13,10 @@ import java.util.concurrent.Callable; import java.util.concurrent.CompletableFuture; +import static org.assertj.core.api.Assertions.assertThat; import static org.awaitility.Awaitility.await; import static org.awaitility.Durations.ONE_HUNDRED_MILLISECONDS; import static org.awaitility.Durations.ONE_SECOND; -import static org.hamcrest.MatcherAssert.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -136,7 +135,7 @@ public void testParallelism() { } } System.out.println(MessageFormat.format("valueA={0}, valueB={1}", valueA, valueB)); - assertThat(Math.abs(valueA - valueB), Matchers.lessThan(ITEMS_AMOUNT * ITEMS_AMOUNT / 2)); + assertThat(Math.abs(valueA - valueB)).isLessThan(ITEMS_AMOUNT * ITEMS_AMOUNT / 2); } @SneakyThrows diff --git a/src/test/java/by/andd3dfx/multithreading/stack/CustomConcurrentStackTest.java b/src/test/java/by/andd3dfx/multithreading/stack/CustomConcurrentStackTest.java index 7ac8cd5a..878fb9b0 100644 --- a/src/test/java/by/andd3dfx/multithreading/stack/CustomConcurrentStackTest.java +++ b/src/test/java/by/andd3dfx/multithreading/stack/CustomConcurrentStackTest.java @@ -5,8 +5,7 @@ import java.util.NoSuchElementException; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class CustomConcurrentStackTest { @@ -22,21 +21,21 @@ public void testStack() { stack.push(2); stack.push(3); stack.push(4); - assertThat(stack.pop(), is(4)); + assertThat(stack.pop()).isEqualTo(4); stack.push(5); stack.push(6); - assertThat(stack.peek(), is(6)); - assertThat(stack.peek(), is(6)); - assertThat(stack.pop(), is(6)); + assertThat(stack.peek()).isEqualTo(6); + assertThat(stack.peek()).isEqualTo(6); + assertThat(stack.pop()).isEqualTo(6); stack.push(7); stack.push(8); - assertThat(stack.pop(), is(8)); - assertThat(stack.pop(), is(7)); - assertThat(stack.pop(), is(5)); - assertThat(stack.pop(), is(3)); - assertThat(stack.isEmpty(), is(false)); - assertThat(stack.pop(), is(2)); - assertThat(stack.isEmpty(), is(true)); + assertThat(stack.pop()).isEqualTo(8); + assertThat(stack.pop()).isEqualTo(7); + assertThat(stack.pop()).isEqualTo(5); + assertThat(stack.pop()).isEqualTo(3); + assertThat(stack.isEmpty()).isEqualTo(false); + assertThat(stack.pop()).isEqualTo(2); + assertThat(stack.isEmpty()).isEqualTo(true); } @Test(expected = NoSuchElementException.class) diff --git a/src/test/java/by/andd3dfx/numeric/BestAverageScoreTest.java b/src/test/java/by/andd3dfx/numeric/BestAverageScoreTest.java index aeded86b..65813177 100644 --- a/src/test/java/by/andd3dfx/numeric/BestAverageScoreTest.java +++ b/src/test/java/by/andd3dfx/numeric/BestAverageScoreTest.java @@ -5,8 +5,7 @@ import java.util.List; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class BestAverageScoreTest { @@ -15,8 +14,8 @@ public void calculateUsingStreams() { var items = buildItemsList(); var items2 = buildBigItemsList(); - assertThat(BestAverageScore.calculateUsingStreams(items), is(70.0)); - assertThat(BestAverageScore.calculateUsingStreams(items2), is(500.0)); + assertThat(BestAverageScore.calculateUsingStreams(items)).isEqualTo(70.0); + assertThat(BestAverageScore.calculateUsingStreams(items2)).isEqualTo(500.0); } @Test @@ -24,8 +23,8 @@ public void calculateUsualWay() { var items = buildItemsList(); var items2 = buildBigItemsList(); - assertThat(BestAverageScore.calculateUsualWay(items), is(70.0)); - assertThat(BestAverageScore.calculateUsualWay(items2), is(500.0)); + assertThat(BestAverageScore.calculateUsualWay(items)).isEqualTo(70.0); + assertThat(BestAverageScore.calculateUsualWay(items2)).isEqualTo(500.0); } private List buildItemsList() { diff --git a/src/test/java/by/andd3dfx/numeric/BitsRowTest.java b/src/test/java/by/andd3dfx/numeric/BitsRowTest.java index e7357982..e2580db6 100644 --- a/src/test/java/by/andd3dfx/numeric/BitsRowTest.java +++ b/src/test/java/by/andd3dfx/numeric/BitsRowTest.java @@ -2,17 +2,16 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class BitsRowTest { - @Test - public void determineBit() { - assertThat("f(0)=1 expected", BitsRow.determineBit(0), is(1)); - assertThat("f(1)=0 expected", BitsRow.determineBit(1), is(0)); - assertThat("f(2)=1 expected", BitsRow.determineBit(2), is(1)); - assertThat("f(14)=1 expected", BitsRow.determineBit(14), is(1)); - assertThat("f(15)=0 expected", BitsRow.determineBit(15), is(0)); - } + @Test + public void determineBit() { + assertThat(BitsRow.determineBit(0)).isEqualTo(1); + assertThat(BitsRow.determineBit(1)).isEqualTo(0); + assertThat(BitsRow.determineBit(2)).isEqualTo(1); + assertThat(BitsRow.determineBit(14)).isEqualTo(1); + assertThat(BitsRow.determineBit(15)).isEqualTo(0); + } } diff --git a/src/test/java/by/andd3dfx/numeric/FibonacciTest.java b/src/test/java/by/andd3dfx/numeric/FibonacciTest.java index f368e2c0..2ec87f0f 100644 --- a/src/test/java/by/andd3dfx/numeric/FibonacciTest.java +++ b/src/test/java/by/andd3dfx/numeric/FibonacciTest.java @@ -4,60 +4,61 @@ import java.util.function.Function; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static by.andd3dfx.numeric.Fibonacci.calculateDownTop; +import static by.andd3dfx.numeric.Fibonacci.calculateTopDown; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; public class FibonacciTest { - @Test - public void calculate() { - assertThat("Expected F(2) = 1", Fibonacci.calculate(2), is(1)); - assertThat("Expected F(4) = 3", Fibonacci.calculate(4), is(3)); - assertThat("Expected F(1) = 1", Fibonacci.calculate(1), is(1)); - assertThat("Expected F(0) = 0", Fibonacci.calculate(0), is(0)); - assertThat("Expected F(8) = 21", Fibonacci.calculate(8), is(21)); - assertThat("Expected F(9) = 34", Fibonacci.calculate(9), is(34)); - assertThat("Expected F(3) = 2", Fibonacci.calculate(3), is(2)); - assertThat("Expected F(7) = 13", Fibonacci.calculate(7), is(13)); - assertThat("Expected F(10) = 55", Fibonacci.calculate(10), is(55)); - assertThat("Expected F(6) = 8", Fibonacci.calculate(6), is(8)); - assertThat("Expected F(5) = 5", Fibonacci.calculate(5), is(5)); - } - - @Test - public void calculate2() { - assertThat("Expected F(2) = 1", Fibonacci.calculate2(2), is(1)); - assertThat("Expected F(4) = 3", Fibonacci.calculate2(4), is(3)); - assertThat("Expected F(1) = 1", Fibonacci.calculate2(1), is(1)); - assertThat("Expected F(0) = 0", Fibonacci.calculate2(0), is(0)); - assertThat("Expected F(8) = 21", Fibonacci.calculate2(8), is(21)); - assertThat("Expected F(9) = 34", Fibonacci.calculate2(9), is(34)); - assertThat("Expected F(3) = 2", Fibonacci.calculate2(3), is(2)); - assertThat("Expected F(7) = 13", Fibonacci.calculate2(7), is(13)); - assertThat("Expected F(10) = 55", Fibonacci.calculate2(10), is(55)); - assertThat("Expected F(6) = 8", Fibonacci.calculate2(6), is(8)); - assertThat("Expected F(5) = 5", Fibonacci.calculate2(5), is(5)); - } - - @Test - public void calculateForWrongParam() { - checkIsExceptionThrown(Fibonacci::calculate, -1); - checkIsExceptionThrown(Fibonacci::calculate, -10); - } - - @Test - public void calculate2ForWrongParam() { - checkIsExceptionThrown(Fibonacci::calculate2, -1); - checkIsExceptionThrown(Fibonacci::calculate2, -10); - } - - private void checkIsExceptionThrown(Function function, int n) { - try { - function.apply(n); - fail("Exception should be thrown"); - } catch (IllegalArgumentException iae) { - assertThat("Wrong message", iae.getMessage(), is("Number should be not less than 0!")); + @Test + public void testCalculateTopDown() { + assertThat(calculateTopDown(2)).isEqualTo(1); + assertThat(calculateTopDown(4)).isEqualTo(3); + assertThat(calculateTopDown(1)).isEqualTo(1); + assertThat(calculateTopDown(0)).isEqualTo(0); + assertThat(calculateTopDown(8)).isEqualTo(21); + assertThat(calculateTopDown(9)).isEqualTo(34); + assertThat(calculateTopDown(3)).isEqualTo(2); + assertThat(calculateTopDown(7)).isEqualTo(13); + assertThat(calculateTopDown(10)).isEqualTo(55); + assertThat(calculateTopDown(6)).isEqualTo(8); + assertThat(calculateTopDown(5)).isEqualTo(5); + } + + @Test + public void testCalculateDownTop() { + assertThat(calculateDownTop(2)).isEqualTo(1); + assertThat(calculateDownTop(4)).isEqualTo(3); + assertThat(calculateDownTop(1)).isEqualTo(1); + assertThat(calculateDownTop(0)).isEqualTo(0); + assertThat(calculateDownTop(8)).isEqualTo(21); + assertThat(calculateDownTop(9)).isEqualTo(34); + assertThat(calculateDownTop(3)).isEqualTo(2); + assertThat(calculateDownTop(7)).isEqualTo(13); + assertThat(calculateDownTop(10)).isEqualTo(55); + assertThat(calculateDownTop(6)).isEqualTo(8); + assertThat(calculateDownTop(5)).isEqualTo(5); + } + + @Test + public void calculateTopDownForWrongParam() { + checkIsExceptionThrown(Fibonacci::calculateTopDown, -1); + checkIsExceptionThrown(Fibonacci::calculateTopDown, -10); + } + + @Test + public void calculateDownTopForWrongParam() { + checkIsExceptionThrown(Fibonacci::calculateDownTop, -1); + checkIsExceptionThrown(Fibonacci::calculateDownTop, -10); + } + + private void checkIsExceptionThrown(Function function, int n) { + try { + function.apply(n); + fail("Exception should be thrown"); + } catch (IllegalArgumentException iae) { + assertThat(iae.getMessage()).isEqualTo("Number should be not less than 0!"); + } } - } } diff --git a/src/test/java/by/andd3dfx/numeric/FindNumberWhichAppearsOnceTest.java b/src/test/java/by/andd3dfx/numeric/FindNumberWhichAppearsOnceTest.java index ba0aaedc..31170204 100644 --- a/src/test/java/by/andd3dfx/numeric/FindNumberWhichAppearsOnceTest.java +++ b/src/test/java/by/andd3dfx/numeric/FindNumberWhichAppearsOnceTest.java @@ -4,7 +4,7 @@ import static by.andd3dfx.numeric.FindNumberWhichAppearsOnce.find; import static by.andd3dfx.numeric.FindNumberWhichAppearsOnce.findSubOptimal; -import static org.assertj.core.api.AssertionsForClassTypes.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class FindNumberWhichAppearsOnceTest { diff --git a/src/test/java/by/andd3dfx/numeric/GreatestCommonDivisorTest.java b/src/test/java/by/andd3dfx/numeric/GreatestCommonDivisorTest.java index 9314bc4e..9fe03fb1 100644 --- a/src/test/java/by/andd3dfx/numeric/GreatestCommonDivisorTest.java +++ b/src/test/java/by/andd3dfx/numeric/GreatestCommonDivisorTest.java @@ -2,22 +2,23 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static by.andd3dfx.numeric.GreatestCommonDivisor.determineUsingLoop; +import static by.andd3dfx.numeric.GreatestCommonDivisor.determineUsingRecursion; +import static org.assertj.core.api.Assertions.assertThat; public class GreatestCommonDivisorTest { @Test - public void determineUsingRecursion() { - assertThat(GreatestCommonDivisor.determineUsingRecursion(30, 21), is(3)); - assertThat(GreatestCommonDivisor.determineUsingRecursion(31, 17), is(1)); - assertThat(GreatestCommonDivisor.determineUsingRecursion(64, 48), is(16)); + public void testDetermineUsingRecursion() { + assertThat(determineUsingRecursion(30, 21)).isEqualTo(3); + assertThat(determineUsingRecursion(31, 17)).isEqualTo(1); + assertThat(determineUsingRecursion(64, 48)).isEqualTo(16); } @Test - public void determineUsingLoop() { - assertThat(GreatestCommonDivisor.determineUsingLoop(30, 21), is(3)); - assertThat(GreatestCommonDivisor.determineUsingLoop(31, 17), is(1)); - assertThat(GreatestCommonDivisor.determineUsingLoop(64, 48), is(16)); + public void testDetermineUsingLoop() { + assertThat(determineUsingLoop(30, 21)).isEqualTo(3); + assertThat(determineUsingLoop(31, 17)).isEqualTo(1); + assertThat(determineUsingLoop(64, 48)).isEqualTo(16); } } diff --git a/src/test/java/by/andd3dfx/numeric/IntDividerTest.java b/src/test/java/by/andd3dfx/numeric/IntDividerTest.java index 7030993d..7843564c 100644 --- a/src/test/java/by/andd3dfx/numeric/IntDividerTest.java +++ b/src/test/java/by/andd3dfx/numeric/IntDividerTest.java @@ -2,28 +2,27 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class IntDividerTest { @Test public void divide() { - assertThat(IntDivider.divide(5, 2), is(2)); - assertThat(IntDivider.divide(36, 4), is(9)); - assertThat(IntDivider.divide(45, 7), is(6)); - assertThat(IntDivider.divide(500, 2), is(250)); - assertThat(IntDivider.divide(100, 1), is(100)); - assertThat(IntDivider.divide(3, 5), is(0)); + assertThat(IntDivider.divide(5, 2)).isEqualTo(2); + assertThat(IntDivider.divide(36, 4)).isEqualTo(9); + assertThat(IntDivider.divide(45, 7)).isEqualTo(6); + assertThat(IntDivider.divide(500, 2)).isEqualTo(250); + assertThat(IntDivider.divide(100, 1)).isEqualTo(100); + assertThat(IntDivider.divide(3, 5)).isEqualTo(0); } @Test public void divideOptimized() { - assertThat(IntDivider.divideOptimized(5, 2), is(2)); - assertThat(IntDivider.divideOptimized(36, 4), is(9)); - assertThat(IntDivider.divideOptimized(45, 7), is(6)); - assertThat(IntDivider.divideOptimized(500, 2), is(250)); - assertThat(IntDivider.divideOptimized(100, 1), is(100)); - assertThat(IntDivider.divideOptimized(3, 5), is(0)); + assertThat(IntDivider.divideOptimized(5, 2)).isEqualTo(2); + assertThat(IntDivider.divideOptimized(36, 4)).isEqualTo(9); + assertThat(IntDivider.divideOptimized(45, 7)).isEqualTo(6); + assertThat(IntDivider.divideOptimized(500, 2)).isEqualTo(250); + assertThat(IntDivider.divideOptimized(100, 1)).isEqualTo(100); + assertThat(IntDivider.divideOptimized(3, 5)).isEqualTo(0); } } diff --git a/src/test/java/by/andd3dfx/numeric/LargestPitTest.java b/src/test/java/by/andd3dfx/numeric/LargestPitTest.java index 65d260ac..c130e9b5 100644 --- a/src/test/java/by/andd3dfx/numeric/LargestPitTest.java +++ b/src/test/java/by/andd3dfx/numeric/LargestPitTest.java @@ -2,20 +2,20 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static by.andd3dfx.numeric.LargestPit.find; +import static org.assertj.core.api.Assertions.assertThat; public class LargestPitTest { @Test - public void find() { - assertThat(LargestPit.find(new int[]{}), is(0)); - assertThat(LargestPit.find(new int[]{1}), is(0)); - assertThat(LargestPit.find(new int[]{1, 2}), is(0)); - assertThat(LargestPit.find(new int[]{4, 4, 3, 2, 1, 0}), is(-1)); - assertThat(LargestPit.find(new int[]{0, 0, 1, 2, 3, 4}), is(-1)); - assertThat(LargestPit.find(new int[]{2, 1, 2, -1, 3}), is(3)); - assertThat(LargestPit.find(new int[]{1, 0, 1, -2, 0}), is(2)); - assertThat(LargestPit.find(new int[]{0, -1, 1, -2, 0, -3, 1, -4, 0, -5}), is(4)); + public void testFind() { + assertThat(find(new int[]{})).isEqualTo(0); + assertThat(find(new int[]{1})).isEqualTo(0); + assertThat(find(new int[]{1, 2})).isEqualTo(0); + assertThat(find(new int[]{4, 4, 3, 2, 1, 0})).isEqualTo(-1); + assertThat(find(new int[]{0, 0, 1, 2, 3, 4})).isEqualTo(-1); + assertThat(find(new int[]{2, 1, 2, -1, 3})).isEqualTo(3); + assertThat(find(new int[]{1, 0, 1, -2, 0})).isEqualTo(2); + assertThat(find(new int[]{0, -1, 1, -2, 0, -3, 1, -4, 0, -5})).isEqualTo(4); } } diff --git a/src/test/java/by/andd3dfx/numeric/MaxMultiplicationOf3InArrayTest.java b/src/test/java/by/andd3dfx/numeric/MaxMultiplicationOf3InArrayTest.java index ae29f3c7..5988f78d 100644 --- a/src/test/java/by/andd3dfx/numeric/MaxMultiplicationOf3InArrayTest.java +++ b/src/test/java/by/andd3dfx/numeric/MaxMultiplicationOf3InArrayTest.java @@ -3,8 +3,7 @@ import org.junit.Test; import static by.andd3dfx.numeric.MaxMultiplicationOf3InArray.find; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class MaxMultiplicationOf3InArrayTest { @@ -20,9 +19,17 @@ public void findWhenLessThan3ElementsInArray() { @Test public void testFind() { - assertThat("All positive", find(new int[]{1, 4, 3, 8, 1}), is(96L)); - assertThat("One negative", find(new int[]{1, -3, 4, 8, 2}), is(64L)); - assertThat("Two negative", find(new int[]{-1, 3, 4, -2, 1}), is(12L)); - assertThat("All negative", find(new int[]{-1, -3, -4, -2, -1}), is(-2L)); + assertThat(find(new int[]{1, 4, 3, 8, 1})) + .as("All positive") + .isEqualTo(96L); + assertThat(find(new int[]{1, -3, 4, 8, 2})) + .as("One negative") + .isEqualTo(64L); + assertThat(find(new int[]{-1, 3, 4, -2, 1})) + .as("Two negative") + .isEqualTo(12L); + assertThat(find(new int[]{-1, -3, -4, -2, -1})) + .as("All negative") + .isEqualTo(-2L); } } diff --git a/src/test/java/by/andd3dfx/numeric/RaiseToPowerTest.java b/src/test/java/by/andd3dfx/numeric/RaiseToPowerTest.java index 2b4c587d..0290a7f8 100644 --- a/src/test/java/by/andd3dfx/numeric/RaiseToPowerTest.java +++ b/src/test/java/by/andd3dfx/numeric/RaiseToPowerTest.java @@ -2,44 +2,67 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class RaiseToPowerTest { @Test public void applyForZero() { - assertThat("3^0 = 1", RaiseToPower.apply(3f, 0), is(1f)); + assertThat(RaiseToPower.apply(3f, 0)) + .as("3^0 = 1") + .isEqualTo(1f); } @Test public void applyForPositive() { - assertThat("3^3 = 9", RaiseToPower.apply(3f, 3), is(27f)); - assertThat("3^5 = 243", RaiseToPower.apply(3f, 5), is(243f)); - assertThat("2^13 = 8192", RaiseToPower.apply(2f, 13), is(8192f)); + assertThat(RaiseToPower.apply(3f, 3)) + .as("3^3 = 9") + .isEqualTo(27f); + assertThat(RaiseToPower.apply(3f, 5)) + .as("3^5 = 243") + .isEqualTo(243f); + assertThat(RaiseToPower.apply(2f, 13)) + .as("2^13 = 8192") + .isEqualTo(8192f); } @Test public void applyForNegative() { - assertThat("2^-2 = 0.25", RaiseToPower.apply(2f, -2), is(0.25f)); - assertThat("3^-3 = 0.037037037", RaiseToPower.apply(3f, -3), is(0.037037037f)); + assertThat(RaiseToPower.apply(2f, -2)) + .as("2^-2 = 0.25") + .isEqualTo(0.25f); + assertThat(RaiseToPower.apply(3f, -3)) + .as("3^-3 = 0.037037037") + .isEqualTo(0.037037037f); } @Test public void applyEnhancedForZero() { - assertThat("3^0 = 1", RaiseToPower.applyEnhanced(3f, 0), is(1f)); + assertThat(RaiseToPower.applyEnhanced(3f, 0)) + .as("3^0 = 1") + .isEqualTo(1f); } @Test public void applyEnhancedForPositive() { - assertThat("3^3 = 9", RaiseToPower.applyEnhanced(3f, 3), is(27f)); - assertThat("3^5 = 243", RaiseToPower.applyEnhanced(3f, 5), is(243f)); - assertThat("2^13 = 8192", RaiseToPower.applyEnhanced(2f, 13), is(8192f)); + assertThat(RaiseToPower.applyEnhanced(3f, 3)) + .as("3^3 = 9") + .isEqualTo(27f); + assertThat(RaiseToPower.applyEnhanced(3f, 5)) + .as("3^5 = 243") + .isEqualTo(243f); + assertThat(RaiseToPower.applyEnhanced(2f, 13)) + .as("2^13 = 8192") + .isEqualTo(8192f); } @Test public void applyEnhancedForNegative() { - assertThat("2^-2 = 0.25", RaiseToPower.applyEnhanced(2f, -2), is(0.25f)); - assertThat("3^-3 = 0.037037037", RaiseToPower.applyEnhanced(3f, -3), is(0.037037037f)); + assertThat(RaiseToPower.applyEnhanced(2f, -2)) + .as("2^-2 = 0.25") + .isEqualTo(0.25f); + assertThat(RaiseToPower.applyEnhanced(3f, -3)) + .as("3^-3 = 0.037037037") + .isEqualTo(0.037037037f); } } diff --git a/src/test/java/by/andd3dfx/numeric/SecondLargestElementTest.java b/src/test/java/by/andd3dfx/numeric/SecondLargestElementTest.java index b65fa939..39d643bf 100644 --- a/src/test/java/by/andd3dfx/numeric/SecondLargestElementTest.java +++ b/src/test/java/by/andd3dfx/numeric/SecondLargestElementTest.java @@ -2,26 +2,25 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class SecondLargestElementTest { @Test public void find_NlogN() { int[] array = {3, 1, 2, 4}; - assertThat(SecondLargestElement.find_NlogN(array), is(3)); + assertThat(SecondLargestElement.find_NlogN(array)).isEqualTo(3); int[] array2 = {3, 1, 2, 5, 8, 3, 7}; - assertThat(SecondLargestElement.find_NlogN(array2), is(7)); + assertThat(SecondLargestElement.find_NlogN(array2)).isEqualTo(7); } @Test public void find_N() { int[] array = {3, 1, 2, 4}; - assertThat(SecondLargestElement.find_N(array), is(3)); + assertThat(SecondLargestElement.find_N(array)).isEqualTo(3); int[] array2 = {3, 1, 2, 5, 8, 3, 7}; - assertThat(SecondLargestElement.find_N(array2), is(7)); + assertThat(SecondLargestElement.find_N(array2)).isEqualTo(7); } -} \ No newline at end of file +} diff --git a/src/test/java/by/andd3dfx/numeric/SumOfTwoInArrayTest.java b/src/test/java/by/andd3dfx/numeric/SumOfTwoInArrayTest.java index 440ca9c2..7a998242 100644 --- a/src/test/java/by/andd3dfx/numeric/SumOfTwoInArrayTest.java +++ b/src/test/java/by/andd3dfx/numeric/SumOfTwoInArrayTest.java @@ -2,10 +2,7 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.anyOf; -import static org.hamcrest.CoreMatchers.equalTo; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class SumOfTwoInArrayTest { @@ -13,55 +10,57 @@ public class SumOfTwoInArrayTest { public void testFind_2N() { var result = SumOfTwoInArray.find_2N(new int[]{1, 3, 5, 7, 9}, 12); - assertThat(result, anyOf( - equalTo(new int[]{1, 4}), - equalTo(new int[]{2, 3}), - equalTo(new int[]{3, 2}), - equalTo(new int[]{4, 1}))); + assertThat(result).satisfiesAnyOf( + items -> assertThat(items).isEqualTo(new int[]{1, 4}), + items -> assertThat(items).isEqualTo(new int[]{2, 3}), + items -> assertThat(items).isEqualTo(new int[]{3, 2}), + items -> assertThat(items).isEqualTo(new int[]{4, 1}) + ); } @Test public void testFind_N2() { var result = SumOfTwoInArray.find_N2(new int[]{1, 3, 5, 7, 9}, 12); - assertThat(result, anyOf( - equalTo(new int[]{1, 4}), - equalTo(new int[]{2, 3}), - equalTo(new int[]{3, 2}), - equalTo(new int[]{4, 1}))); + assertThat(result).satisfiesAnyOf( + items -> assertThat(items).isEqualTo(new int[]{1, 4}), + items -> assertThat(items).isEqualTo(new int[]{2, 3}), + items -> assertThat(items).isEqualTo(new int[]{3, 2}), + items -> assertThat(items).isEqualTo(new int[]{4, 1}) + ); } @Test public void testFind_2NForSameNumbers() { var result = SumOfTwoInArray.find_2N(new int[]{1, 1, 6, 6, 1}, 12); - assertThat(result, anyOf( - equalTo(new int[]{2, 3}), - equalTo(new int[]{3, 2}) - )); + assertThat(result).satisfiesAnyOf( + items -> assertThat(items).isEqualTo(new int[]{2, 3}), + items -> assertThat(items).isEqualTo(new int[]{3, 2}) + ); } @Test public void testFind_N2ForSameNumbers() { var result = SumOfTwoInArray.find_N2(new int[]{1, 1, 6, 6, 1}, 12); - assertThat(result, anyOf( - equalTo(new int[]{2, 3}), - equalTo(new int[]{3, 2}) - )); + assertThat(result).satisfiesAnyOf( + items -> assertThat(items).isEqualTo(new int[]{2, 3}), + items -> assertThat(items).isEqualTo(new int[]{3, 2}) + ); } @Test public void testFind_2NForAbsentSolution() { var result = SumOfTwoInArray.find_2N(new int[]{1, 1, 6, 3, 1}, 12); - assertThat(result, nullValue()); + assertThat(result).isNull(); } @Test public void testFind_N2ForAbsentSolution() { var result = SumOfTwoInArray.find_N2(new int[]{1, 1, 6, 3, 1}, 12); - assertThat(result, nullValue()); + assertThat(result).isNull(); } } diff --git a/src/test/java/by/andd3dfx/numeric/factorial/AbstractFactorialTest.java b/src/test/java/by/andd3dfx/numeric/factorial/AbstractFactorialTest.java index 47900764..26c63854 100644 --- a/src/test/java/by/andd3dfx/numeric/factorial/AbstractFactorialTest.java +++ b/src/test/java/by/andd3dfx/numeric/factorial/AbstractFactorialTest.java @@ -3,8 +3,7 @@ import org.junit.Before; import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertThrows; public abstract class AbstractFactorialTest { @@ -20,18 +19,18 @@ public void setUp() throws Exception { @Test public void calc() { - assertThat("0!=1", instance.calc(0), is(1L)); - assertThat("1!=1", instance.calc(1), is(1L)); - assertThat("2!=2", instance.calc(2), is(2L)); - assertThat("3!=6", instance.calc(3), is(6L)); - assertThat("4!=24", instance.calc(4), is(24L)); - assertThat("8!=40320", instance.calc(8), is(40320L)); + assertThat(instance.calc(0)).as("0!=1").isEqualTo(1L); + assertThat(instance.calc(1)).as("1!=1").isEqualTo(1L); + assertThat(instance.calc(2)).as("2!=2").isEqualTo(2L); + assertThat(instance.calc(3)).as("3!=6").isEqualTo(6L); + assertThat(instance.calc(4)).as("4!=24").isEqualTo(24L); + assertThat(instance.calc(8)).as("8!=40320").isEqualTo(40320L); } @Test public void calcForNegative() { var ex = assertThrows(IllegalArgumentException.class, () -> instance.calc(-1)); - assertThat(ex.getMessage(), is("n should be greater than 0")); + assertThat(ex.getMessage()).isEqualTo("n should be greater than 0"); } } diff --git a/src/test/java/by/andd3dfx/parser/xml/FolderNamesXmlParserTest.java b/src/test/java/by/andd3dfx/parser/xml/FolderNamesXmlParserTest.java index c6940438..0a1ded91 100644 --- a/src/test/java/by/andd3dfx/parser/xml/FolderNamesXmlParserTest.java +++ b/src/test/java/by/andd3dfx/parser/xml/FolderNamesXmlParserTest.java @@ -5,9 +5,7 @@ import java.util.Collection; -import static org.hamcrest.CoreMatchers.hasItems; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class FolderNamesXmlParserTest { @@ -31,7 +29,7 @@ public void folderNames() throws Exception { Collection result = parser.folderNames(xml, 'u'); - assertThat(result.size(), is(2)); - assertThat(result, hasItems("uninstall information", "users")); + assertThat(result.size()).isEqualTo(2); + assertThat(result).containsExactlyInAnyOrder("uninstall information", "users"); } } diff --git a/src/test/java/by/andd3dfx/parser/xml/LogsXmlParserTest.java b/src/test/java/by/andd3dfx/parser/xml/LogsXmlParserTest.java index efb8ce43..770f231d 100644 --- a/src/test/java/by/andd3dfx/parser/xml/LogsXmlParserTest.java +++ b/src/test/java/by/andd3dfx/parser/xml/LogsXmlParserTest.java @@ -5,9 +5,7 @@ import java.util.Collection; -import static org.hamcrest.CoreMatchers.hasItems; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertTrue; public class LogsXmlParserTest { @@ -40,8 +38,8 @@ public void getIdsByMessage() throws Exception { Collection ids = parser.getIdsByMessage(xml, "Application ended"); - assertThat(ids.size(), is(2)); - assertThat(ids, hasItems(2, 24)); + assertThat(ids.size()).isEqualTo(2); + assertThat(ids).containsExactlyInAnyOrder(2, 24); } @Test diff --git a/src/test/java/by/andd3dfx/proxy/ProxyCreationByInterfacesTest.java b/src/test/java/by/andd3dfx/proxy/ProxyCreationByInterfacesTest.java index cc95cb6a..dd44a19a 100644 --- a/src/test/java/by/andd3dfx/proxy/ProxyCreationByInterfacesTest.java +++ b/src/test/java/by/andd3dfx/proxy/ProxyCreationByInterfacesTest.java @@ -4,8 +4,7 @@ import java.lang.reflect.Proxy; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; /** * Dynamic proxy usage example @@ -21,7 +20,11 @@ public void performAction() { new DynamicInvocationHandler() ); - assertThat("x2 value expected", ((SomeInterface1) proxyInstance).performActionOne(10), is(20)); - assertThat("x4 value expected", ((SomeInterface2) proxyInstance).performActionTwo(10), is(100)); + assertThat(((SomeInterface1) proxyInstance).performActionOne(10)) + .as("x2 value expected") + .isEqualTo(20); + assertThat(((SomeInterface2) proxyInstance).performActionTwo(10)) + .as("x4 value expected") + .isEqualTo(100); } } diff --git a/src/test/java/by/andd3dfx/recursion/BrickPyramidTest.java b/src/test/java/by/andd3dfx/recursion/BrickPyramidTest.java index e5c3cd7a..e143d847 100644 --- a/src/test/java/by/andd3dfx/recursion/BrickPyramidTest.java +++ b/src/test/java/by/andd3dfx/recursion/BrickPyramidTest.java @@ -2,28 +2,27 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.fail; public class BrickPyramidTest { @Test public void w() { - assertThat(BrickPyramid.w(0, 0), is(0.0)); - assertThat(BrickPyramid.w(1, 0), is(0.5)); - assertThat(BrickPyramid.w(1, 1), is(0.5)); + assertThat(BrickPyramid.w(0, 0)).isEqualTo(0.0); + assertThat(BrickPyramid.w(1, 0)).isEqualTo(0.5); + assertThat(BrickPyramid.w(1, 1)).isEqualTo(0.5); - assertThat(BrickPyramid.w(2, 0), is(0.75)); - assertThat(BrickPyramid.w(2, 1), is(1.5)); - assertThat(BrickPyramid.w(2, 2), is(0.75)); + assertThat(BrickPyramid.w(2, 0)).isEqualTo(0.75); + assertThat(BrickPyramid.w(2, 1)).isEqualTo(1.5); + assertThat(BrickPyramid.w(2, 2)).isEqualTo(0.75); - assertThat(BrickPyramid.w(3, 0), is(0.875)); - assertThat(BrickPyramid.w(3, 1), is(2.125)); - assertThat(BrickPyramid.w(3, 2), is(2.125)); - assertThat(BrickPyramid.w(3, 3), is(0.875)); + assertThat(BrickPyramid.w(3, 0)).isEqualTo(0.875); + assertThat(BrickPyramid.w(3, 1)).isEqualTo(2.125); + assertThat(BrickPyramid.w(3, 2)).isEqualTo(2.125); + assertThat(BrickPyramid.w(3, 3)).isEqualTo(0.875); - assertThat(BrickPyramid.w(322, 156), is(306.48749781747574)); + assertThat(BrickPyramid.w(322, 156)).isEqualTo(306.48749781747574); } @Test @@ -39,7 +38,8 @@ private static void checkWExceptionPresenceWithWrongParams(int row, int pos) { BrickPyramid.w(row, pos); fail("Exception should be thrown!"); } catch (IllegalArgumentException iae) { - assertThat(iae.getMessage(), is("row and pos should satisfy conditions: row>=0, pos>=0, row>=pos")); + assertThat(iae.getMessage()) + .isEqualTo("row and pos should satisfy conditions: row>=0, pos>=0, row>=pos"); } } } \ No newline at end of file diff --git a/src/test/java/by/andd3dfx/recursion/EightQueensTest.java b/src/test/java/by/andd3dfx/recursion/EightQueensTest.java index 37ade712..b050ecfc 100644 --- a/src/test/java/by/andd3dfx/recursion/EightQueensTest.java +++ b/src/test/java/by/andd3dfx/recursion/EightQueensTest.java @@ -3,8 +3,7 @@ import org.junit.Before; import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -23,9 +22,9 @@ public void solveFor1x1() { assertTrue(solution.isFound()); checkAmountOfPositionedQueens(solution, 1); - assertThat(solution.prettyPrint(), is(new int[][]{ + assertThat(solution.prettyPrint()).isEqualTo(new int[][]{ {1} - })); + }); } @Test @@ -48,12 +47,12 @@ public void solveFor4x4() { assertTrue(solution.isFound()); checkAmountOfPositionedQueens(solution, 4); - assertThat(solution.prettyPrint(), is(new int[][]{ + assertThat(solution.prettyPrint()).isEqualTo(new int[][]{ {0, 1, 0, 0}, {0, 0, 0, 1}, {1, 0, 0, 0}, {0, 0, 1, 0} - })); + }); } @Test @@ -62,13 +61,13 @@ public void solveFor5x5() { assertTrue(solution.isFound()); checkAmountOfPositionedQueens(solution, 5); - assertThat(solution.prettyPrint(), is(new int[][]{ + assertThat(solution.prettyPrint()).isEqualTo(new int[][]{ {1, 0, 0, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 0, 1}, {0, 1, 0, 0, 0}, {0, 0, 0, 1, 0} - })); + }); } @Test @@ -77,7 +76,7 @@ public void solveFor8x8() { assertTrue(solution.isFound()); checkAmountOfPositionedQueens(solution, 8); - assertThat(solution.prettyPrint(), is(new int[][]{ + assertThat(solution.prettyPrint()).isEqualTo(new int[][]{ {1, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 1}, @@ -86,7 +85,7 @@ public void solveFor8x8() { {0, 0, 0, 0, 0, 0, 1, 0}, {0, 1, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 0, 0, 0, 0} - })); + }); } @Test @@ -96,10 +95,10 @@ public void prettyPrint() { {false, true} }); - assertThat(solution.prettyPrint(), is(new int[][]{ + assertThat(solution.prettyPrint()).isEqualTo(new int[][]{ {1, 0}, {0, 1} - })); + }); } @Test @@ -151,6 +150,6 @@ private void checkAmountOfPositionedQueens(EightQueens.Solution solution, int si } } } - assertThat(queensAmount, is(size)); + assertThat(queensAmount).isEqualTo(size); } } \ No newline at end of file diff --git a/src/test/java/by/andd3dfx/recursion/HanoiTowersTest.java b/src/test/java/by/andd3dfx/recursion/HanoiTowersTest.java index ebae5d7c..74f25edf 100644 --- a/src/test/java/by/andd3dfx/recursion/HanoiTowersTest.java +++ b/src/test/java/by/andd3dfx/recursion/HanoiTowersTest.java @@ -3,10 +3,8 @@ import org.junit.Test; import java.util.List; -import java.util.stream.Collectors; -import static org.hamcrest.MatcherAssert.assertThat; -import static org.hamcrest.Matchers.lessThan; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertTrue; public class HanoiTowersTest { @@ -38,10 +36,9 @@ private void checkIsFinished(HanoiTowers ht) { List disks = ht.getRight().getStack().stream().toList(); for (int i = 1; i < disks.size(); i++) { - assertThat("Disk " + (i - 1) + " should be less than disk " + i, - disks.get(i - 1), - lessThan(disks.get(i)) - ); + assertThat(disks.get(i - 1)) + .as("Disk " + (i - 1) + " should be less than disk " + i) + .isLessThan(disks.get(i)); } } } diff --git a/src/test/java/by/andd3dfx/regexp/RegExpCheckerTest.java b/src/test/java/by/andd3dfx/regexp/RegExpCheckerTest.java index dfc9b0ac..ff0f92c7 100644 --- a/src/test/java/by/andd3dfx/regexp/RegExpCheckerTest.java +++ b/src/test/java/by/andd3dfx/regexp/RegExpCheckerTest.java @@ -6,8 +6,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; /** * For replacement example @@ -19,71 +18,74 @@ public class RegExpCheckerTest { @Test public void ipAddressRegExp() { assertThat(extractStringByRegExp("((\\d{1,2}|1\\d{2}|2[0-5]{2})\\.){3}((\\d{1,2}|1\\d{2}|2[0-5]{2}))", - "Bla, some ip-address 192.168.1.1 here."), is("192.168.1.1")); + "Bla, some ip-address 192.168.1.1 here.")) + .isEqualTo("192.168.1.1"); } @Test public void repeatableExpressions() { - assertThat("Color should be found", - extractStringByRegExp("#[0-9A-Fa-f]{6}", "RGB color: #FF3E20"), - is("#FF3E20")); + assertThat(extractStringByRegExp("#[0-9A-Fa-f]{6}", "RGB color: #FF3E20")) + .as("Color should be found") + .isEqualTo("#FF3E20"); } @Test public void digitAndSpaceAndWordBound() { - assertThat("Amount of shirts should be found", - extractStringByRegExp("\\d+", "We bought 2 shirts for 30$ and socks for 9$."), - is("2")); - assertThat("Amount of shirts should be found with space chars", - extractStringByRegExp("\\s\\d+\\s", "We bought\t2 shirts for 30$ and socks for 9$."), - is("\t2 ")); - assertThat("All text should be found (word bounds and hungry quantifiers)", - extractStringByRegExp("\\w\\d+\\w", "We bought 2 shirts for 30$ and socks for 9$."), - is("We bought 2 shirts for 30$ and socks for 9$.")); - assertThat("Amount of shirts should be found (word bounds and lazy quantifiers)", - extractStringByRegExp("\\w?\\d+\\w?", "We bought\t2 shirts for 30$ and socks for 9$."), - is("2")); + assertThat(extractStringByRegExp("\\d+", "We bought 2 shirts for 30$ and socks for 9$.")) + .as("Amount of shirts should be found") + .isEqualTo("2"); + assertThat(extractStringByRegExp("\\s\\d+\\s", "We bought\t2 shirts for 30$ and socks for 9$.")) + .as("Amount of shirts should be found with space chars") + .isEqualTo("\t2 "); + assertThat(extractStringByRegExp("\\w\\d+\\w", "We bought 2 shirts for 30$ and socks for 9$.")) + .as("All text should be found (word bounds and hungry quantifiers)") + .isEqualTo("We bought 2 shirts for 30$ and socks for 9$."); + assertThat(extractStringByRegExp("\\w?\\d+\\w?", "We bought\t2 shirts for 30$ and socks for 9$.")) + .as("Amount of shirts should be found (word bounds and lazy quantifiers)") + .isEqualTo("2"); } @Test public void reuseAlreadyDeclaredExpressionWithLink() { - assertThat("Tag h1 with its content should be found", - extractStringByRegExp("<([hH][1-6])>.*", "Bla, some

test string

here."), - is("

test string

")); + assertThat(extractStringByRegExp("<([hH][1-6])>.*", "Bla, some

test string

here.")) + .as("Tag h1 with its content should be found") + .isEqualTo("

test string

"); } @Test public void lookForwardAndBackward() { - assertThat("Color without '#' should be found", - extractStringByRegExp("(?<=#)[0-9A-F]{6}", "RGB color: #FF3E20"), - is("FF3E20")); - assertThat("First price without '$' sign should be found", - extractStringByRegExp("\\d+(?=\\$)", "We bought 2 shirts for 30$ and socks for 9$."), - is("30")); + assertThat(extractStringByRegExp("(?<=#)[0-9A-F]{6}", "RGB color: #FF3E20")) + .as("Color without '#' should be found") + .isEqualTo("FF3E20"); + assertThat(extractStringByRegExp("\\d+(?=\\$)", "We bought 2 shirts for 30$ and socks for 9$.")) + .as("First price without '$' sign should be found") + .isEqualTo("30"); } @Test public void reuseAlreadyDeclaredExpressionWithLinkAndLookForwardAndBackward() { - assertThat("Inner content of tag

should be found", - extractStringByRegExp("(?<=<([hH][1-6])>).*(?=)", "Bla, some

test string

here."), - is("test string")); + assertThat(extractStringByRegExp("(?<=<([hH][1-6])>).*(?=)", "Bla, some

test string

here.")) + .as("Inner content of tag

should be found") + .isEqualTo("test string"); } @Test public void compositeExpression() { - assertThat("Phone in +ddd-dd-ddd-dd-dd format should be found", - extractStringByRegExp("\\+\\d{3}-\\d{2}-\\d{3}-\\d{2}-\\d{2}", "bla +375-29-861-86-28 bla-bla"), - is("+375-29-861-86-28")); - assertThat("Phone in +ddd-dd-ddd-dd-dd format should be found", - extractStringByRegExp("\\(\\d{3}\\)\\d{2} \\d{3}-\\d{2}-\\d{2}", "bla (375)29 861-86-28 bla-bla"), - is("(375)29 861-86-28")); + assertThat(extractStringByRegExp("\\+\\d{3}-\\d{2}-\\d{3}-\\d{2}-\\d{2}", "bla +375-29-861-86-28 bla-bla")) + .as("Phone in +ddd-dd-ddd-dd-dd format should be found") + .isEqualTo("+375-29-861-86-28"); + assertThat(extractStringByRegExp("\\(\\d{3}\\)\\d{2} \\d{3}-\\d{2}-\\d{2}", "bla (375)29 861-86-28 bla-bla")) + .as("Phone in +ddd-dd-ddd-dd-dd format should be found") + .isEqualTo("(375)29 861-86-28"); - assertThat("Phone in +ddd-dd-ddd-dd-dd format should be found for regex with 2 cases", - extractStringByRegExp("((\\+\\d{3}-\\d{2})|(\\(\\d{3}\\)\\d{2}))[- ]\\d{3}-\\d{2}-\\d{2}", - "bla +375-29-861-86-28 bla-bla"), is("+375-29-861-86-28")); - assertThat("Phone in +ddd-dd-ddd-dd-dd format should be found for regex with 2 cases", - extractStringByRegExp("((\\+\\d{3}-\\d{2})|(\\(\\d{3}\\)\\d{2}))[- ]\\d{3}-\\d{2}-\\d{2}", - "bla (375)29 861-86-28 bla-bla"), is("(375)29 861-86-28")); + assertThat(extractStringByRegExp("((\\+\\d{3}-\\d{2})|(\\(\\d{3}\\)\\d{2}))[- ]\\d{3}-\\d{2}-\\d{2}", + "bla +375-29-861-86-28 bla-bla")) + .as("Phone in +ddd-dd-ddd-dd-dd format should be found for regex with 2 cases") + .isEqualTo("+375-29-861-86-28"); + assertThat(extractStringByRegExp("((\\+\\d{3}-\\d{2})|(\\(\\d{3}\\)\\d{2}))[- ]\\d{3}-\\d{2}-\\d{2}", + "bla (375)29 861-86-28 bla-bla")) + .as("Phone in +ddd-dd-ddd-dd-dd format should be found for regex with 2 cases") + .isEqualTo("(375)29 861-86-28"); } private String extractStringByRegExp(String regExp, String testString) { diff --git a/src/test/java/by/andd3dfx/search/FindAmountOfElementsLessThanTest.java b/src/test/java/by/andd3dfx/search/FindAmountOfElementsLessThanTest.java index e773e9e3..6d8b82d3 100644 --- a/src/test/java/by/andd3dfx/search/FindAmountOfElementsLessThanTest.java +++ b/src/test/java/by/andd3dfx/search/FindAmountOfElementsLessThanTest.java @@ -5,44 +5,55 @@ import static by.andd3dfx.search.FindAmountOfElementsLessThan.usingBinarySearch; import static by.andd3dfx.search.FindAmountOfElementsLessThan.usingInterpolationSearch; import static by.andd3dfx.search.FindAmountOfElementsLessThan.usingPrimitiveIteration; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class FindAmountOfElementsLessThanTest { @Test public void testUsingPrimitiveIteration() { - assertThat("When array doesn't contain target item", - usingPrimitiveIteration(new int[]{1, 2, 3, 5, 7}, 4), is(3)); - assertThat("When array contains target item", - usingPrimitiveIteration(new int[]{1, 3, 4, 4, 5, 7}, 4), is(2)); - assertThat("When all items are greater than target item", - usingPrimitiveIteration(new int[]{5, 6, 7, 8}, 4), is(0)); - assertThat("When all items are less than target item", - usingPrimitiveIteration(new int[]{1, 2, 3, 3}, 4), is(4)); + assertThat(usingPrimitiveIteration(new int[]{1, 2, 3, 5, 7}, 4)) + .as("When array doesn't contain target item") + .isEqualTo(3); + assertThat(usingPrimitiveIteration(new int[]{1, 3, 4, 4, 5, 7}, 4)) + .as("When array contains target item") + .isEqualTo(2); + assertThat(usingPrimitiveIteration(new int[]{5, 6, 7, 8}, 4)) + .as("When all items are greater than target item") + .isEqualTo(0); + assertThat(usingPrimitiveIteration(new int[]{1, 2, 3, 3}, 4)) + .as("When all items are less than target item") + .isEqualTo(4); } @Test public void testUsingBinarySearch() { - assertThat("When array doesn't contain target item", - usingBinarySearch(new int[]{1, 2, 3, 5, 7}, 4), is(3)); - assertThat("When array contains target item", - usingBinarySearch(new int[]{1, 3, 4, 4, 5, 7}, 4), is(2)); - assertThat("When all items are greater than target item", - usingBinarySearch(new int[]{5, 6, 7, 8}, 4), is(0)); - assertThat("When all items are less than target item", - usingBinarySearch(new int[]{1, 2, 3, 3}, 4), is(4)); + assertThat(usingBinarySearch(new int[]{1, 2, 3, 5, 7}, 4)) + .as("When array doesn't contain target item") + .isEqualTo(3); + assertThat(usingBinarySearch(new int[]{1, 3, 4, 4, 5, 7}, 4)) + .as("When array contains target item") + .isEqualTo(2); + assertThat(usingBinarySearch(new int[]{5, 6, 7, 8}, 4)) + .as("When all items are greater than target item") + .isEqualTo(0); + assertThat(usingBinarySearch(new int[]{1, 2, 3, 3}, 4)) + .as("When all items are less than target item") + .isEqualTo(4); } @Test public void testUsingInterpolationSearch() { - assertThat("When array doesn't contain target item", - usingInterpolationSearch(new int[]{1, 2, 3, 5, 7}, 4), is(3)); - assertThat("When array contains target item", - usingInterpolationSearch(new int[]{1, 3, 4, 4, 5, 7}, 4), is(2)); - assertThat("When all items are greater than target item", - usingInterpolationSearch(new int[]{5, 6, 7, 8}, 4), is(0)); - assertThat("When all items are less than target item", - usingInterpolationSearch(new int[]{1, 2, 3, 3}, 4), is(4)); + assertThat(usingInterpolationSearch(new int[]{1, 2, 3, 5, 7}, 4)) + .as("When array doesn't contain target item") + .isEqualTo(3); + assertThat(usingInterpolationSearch(new int[]{1, 3, 4, 4, 5, 7}, 4)) + .as("When array contains target item") + .isEqualTo(2); + assertThat(usingInterpolationSearch(new int[]{5, 6, 7, 8}, 4)) + .as("When all items are greater than target item") + .isEqualTo(0); + assertThat(usingInterpolationSearch(new int[]{1, 2, 3, 3}, 4)) + .as("When all items are less than target item") + .isEqualTo(4); } } diff --git a/src/test/java/by/andd3dfx/search/FindElementsOfArrayWhichNotPresentInAnotherArrayTest.java b/src/test/java/by/andd3dfx/search/FindElementsOfArrayWhichNotPresentInAnotherArrayTest.java index f179786c..dea464f1 100644 --- a/src/test/java/by/andd3dfx/search/FindElementsOfArrayWhichNotPresentInAnotherArrayTest.java +++ b/src/test/java/by/andd3dfx/search/FindElementsOfArrayWhichNotPresentInAnotherArrayTest.java @@ -3,28 +3,31 @@ import org.junit.Test; import static by.andd3dfx.search.FindElementsOfArrayWhichNotPresentInAnotherArray.find; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class FindElementsOfArrayWhichNotPresentInAnotherArrayTest { @Test public void findUsual() { - assertThat(find(new Integer[]{-1, 2, 2, 5, 7}, new Integer[]{2, 5, 8, 8, 8}), is(new Integer[]{-1, 7})); + assertThat(find(new Integer[]{-1, 2, 2, 5, 7}, new Integer[]{2, 5, 8, 8, 8})) + .isEqualTo(new Integer[]{-1, 7}); } @Test public void findWhenMultipleRepeatableElementsInFirstArrayWhichNotPresentInSecondArray() { - assertThat(find(new Integer[]{-1, -1, 0, 1, 2, 4, 4}, new Integer[]{-1, 0, 2}), is(new Integer[]{1, 4, 4})); + assertThat(find(new Integer[]{-1, -1, 0, 1, 2, 4, 4}, new Integer[]{-1, 0, 2})) + .isEqualTo(new Integer[]{1, 4, 4}); } @Test public void findWhenSameArrays() { - assertThat(find(new Integer[]{-1, 2, 3}, new Integer[]{-1, 2, 3}), is(new Integer[]{})); + assertThat(find(new Integer[]{-1, 2, 3}, new Integer[]{-1, 2, 3})) + .isEqualTo(new Integer[]{}); } @Test public void findWhenFirstArrayIsEmpty() { - assertThat(find(new Integer[]{}, new Integer[]{-1, 2, 3}), is(new Integer[]{})); + assertThat(find(new Integer[]{}, new Integer[]{-1, 2, 3})) + .isEqualTo(new Integer[]{}); } } diff --git a/src/test/java/by/andd3dfx/search/InterpolationSearchTest.java b/src/test/java/by/andd3dfx/search/InterpolationSearchTest.java index 518fd453..a4f8d7d3 100644 --- a/src/test/java/by/andd3dfx/search/InterpolationSearchTest.java +++ b/src/test/java/by/andd3dfx/search/InterpolationSearchTest.java @@ -2,26 +2,31 @@ import org.junit.Test; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class InterpolationSearchTest { @Test public void perform() { - assertThat(InterpolationSearch.perform(new int[]{1, 2, 3, 4, 5}, 4), is(3)); - assertThat(InterpolationSearch.perform(new int[]{1, 2, 2, 3, 4, 8}, 2), is(1)); - assertThat(InterpolationSearch.perform(new int[]{-2, -1, 1, 2, 5, 8, 9, 12, 15}, 12), is(7)); + assertThat(InterpolationSearch.perform(new int[]{1, 2, 3, 4, 5}, 4)) + .isEqualTo(3); + assertThat(InterpolationSearch.perform(new int[]{1, 2, 2, 3, 4, 8}, 2)) + .isEqualTo(1); + assertThat(InterpolationSearch.perform(new int[]{-2, -1, 1, 2, 5, 8, 9, 12, 15}, 12)) + .isEqualTo(7); } @Test public void performWhenNothingFound() { - assertThat(InterpolationSearch.perform(new int[]{1, 2, 3, 4, 5}, 41), is(-1)); + assertThat(InterpolationSearch.perform(new int[]{1, 2, 3, 4, 5}, 41)) + .isEqualTo(-1); } @Test public void determineMid() { - assertThat(InterpolationSearch.determineMid(new int[]{0, 1, 2, 3, 4, 5}, 3, 0, 5), is(3)); - assertThat(InterpolationSearch.determineMid(new int[]{0, 1, 2, 3, 4, 25}, 3, 0, 5), is(0)); + assertThat(InterpolationSearch.determineMid(new int[]{0, 1, 2, 3, 4, 5}, 3, 0, 5)) + .isEqualTo(3); + assertThat(InterpolationSearch.determineMid(new int[]{0, 1, 2, 3, 4, 25}, 3, 0, 5)) + .isEqualTo(0); } } diff --git a/src/test/java/by/andd3dfx/string/MakeStringCompactTest.java b/src/test/java/by/andd3dfx/string/MakeStringCompactTest.java index b28c4acf..8c9f0dd4 100644 --- a/src/test/java/by/andd3dfx/string/MakeStringCompactTest.java +++ b/src/test/java/by/andd3dfx/string/MakeStringCompactTest.java @@ -3,21 +3,20 @@ import org.junit.Test; import static by.andd3dfx.string.MakeStringCompact.transform; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class MakeStringCompactTest { @Test public void testTransform() { - assertThat(transform(null), is(nullValue())); - assertThat(transform(""), is("")); - assertThat(transform("a"), is("a")); - assertThat(transform("aaa"), is("a3")); - assertThat(transform("aaabbc"), is("a3b2c")); - assertThat(transform("aaacbb"), is("a3cb2")); - assertThat(transform("aaacbbccc"), is("a3cb2c3")); - assertThat(transform("AAAABBBCCXYZDDDDEEEFFFAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBB"), is("A4B3C2XYZD4E3F3A6B28")); + assertThat(transform(null)).isNull(); + assertThat(transform("")).isEqualTo(""); + assertThat(transform("a")).isEqualTo("a"); + assertThat(transform("aaa")).isEqualTo("a3"); + assertThat(transform("aaabbc")).isEqualTo("a3b2c"); + assertThat(transform("aaacbb")).isEqualTo("a3cb2"); + assertThat(transform("aaacbbccc")).isEqualTo("a3cb2c3"); + assertThat(transform("AAAABBBCCXYZDDDDEEEFFFAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBB")) + .isEqualTo("A4B3C2XYZD4E3F3A6B28"); } } diff --git a/src/test/java/by/andd3dfx/string/PalindromeTest.java b/src/test/java/by/andd3dfx/string/PalindromeTest.java index 4cfd8774..207a20a1 100644 --- a/src/test/java/by/andd3dfx/string/PalindromeTest.java +++ b/src/test/java/by/andd3dfx/string/PalindromeTest.java @@ -9,8 +9,7 @@ import static by.andd3dfx.string.Palindrome.longestPalindromeSubstring; import static by.andd3dfx.string.Palindrome.removeNthPalindrome; import static by.andd3dfx.string.Palindrome.removePalindromes; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; @@ -18,44 +17,48 @@ public class PalindromeTest { @Test public void testIsPalindrome() { - assertThat(isPalindrome("ertglgtre"), is(true)); - assertThat(isPalindrome("Anna"), is(false)); - assertThat(isPalindrome("anna"), is(true)); - assertThat(isPalindrome("Dumb"), is(false)); + assertThat(isPalindrome("ertglgtre")).isEqualTo(true); + assertThat(isPalindrome("Anna")).isEqualTo(false); + assertThat(isPalindrome("anna")).isEqualTo(true); + assertThat(isPalindrome("Dumb")).isEqualTo(false); } @Test public void testIsPalindromeIgnoreCase() { - assertThat(isPalindromeIgnoreCase("ertglgtre"), is(true)); - assertThat(isPalindromeIgnoreCase("Anna"), is(true)); - assertThat(isPalindromeIgnoreCase("Dumb"), is(false)); + assertThat(isPalindromeIgnoreCase("ertglgtre")).isEqualTo(true); + assertThat(isPalindromeIgnoreCase("Anna")).isEqualTo(true); + assertThat(isPalindromeIgnoreCase("Dumb")).isEqualTo(false); } @Test public void testRemovePalindromes() { - assertThat(removePalindromes("assa Rome Anna all liquid small mom"), is("Rome all liquid small")); - assertThat(removePalindromes("assa Rome, Anna, all liquid small mom"), is("Rome, all liquid small")); + assertThat(removePalindromes("assa Rome Anna all liquid small mom")).isEqualTo("Rome all liquid small"); + assertThat(removePalindromes("assa Rome, Anna, all liquid small mom")).isEqualTo("Rome, all liquid small"); } @Test public void testRemoveNthPalindrome() { - assertThat("Second palindrome should be removed", - removeNthPalindrome("All assa Rome Anna small mom", 2), is("All assa Rome small mom")); - assertThat("String should should not be changed", - removeNthPalindrome("All assa Rome Anna small mom", 5), is("All assa Rome Anna small mom")); + assertThat(removeNthPalindrome("All assa Rome Anna small mom", 2)) + .as("Second palindrome should be removed") + .isEqualTo("All assa Rome small mom"); + assertThat(removeNthPalindrome("All assa Rome Anna small mom", 5)) + .as("String should should not be changed") + .isEqualTo("All assa Rome Anna small mom"); - assertThat("Second palindrome should be removed", - removeNthPalindrome("All assa Rome, Anna, small mom", 2), is("All assa Rome, small mom")); - assertThat("String should should not be changed", - removeNthPalindrome("All assa Rome, Anna, small mom", 5), is("All assa Rome, Anna, small mom")); + assertThat(removeNthPalindrome("All assa Rome, Anna, small mom", 2)) + .as("Second palindrome should be removed") + .isEqualTo("All assa Rome, small mom"); + assertThat(removeNthPalindrome("All assa Rome, Anna, small mom", 5)) + .as("String should should not be changed") + .isEqualTo("All assa Rome, Anna, small mom"); } @Test public void testLongestPalindromeSubstring() { - Assertions.assertThat(longestPalindromeSubstring("forgeeksskeegfor")).isEqualTo("geeksskeeg"); - Assertions.assertThat(longestPalindromeSubstring("Geeks")).isEqualTo("ee"); - Assertions.assertThat(longestPalindromeSubstring("Composition")).isEqualTo("iti"); - Assertions.assertThat(longestPalindromeSubstring("abbaerrtrre1ll1")).isEqualTo("errtrre"); + assertThat(longestPalindromeSubstring("forgeeksskeegfor")).isEqualTo("geeksskeeg"); + assertThat(longestPalindromeSubstring("Geeks")).isEqualTo("ee"); + assertThat(longestPalindromeSubstring("Composition")).isEqualTo("iti"); + assertThat(longestPalindromeSubstring("abbaerrtrre1ll1")).isEqualTo("errtrre"); } @Test diff --git a/src/test/java/by/andd3dfx/string/ReverseStringTest.java b/src/test/java/by/andd3dfx/string/ReverseStringTest.java index 8fd3923e..29e0e174 100644 --- a/src/test/java/by/andd3dfx/string/ReverseStringTest.java +++ b/src/test/java/by/andd3dfx/string/ReverseStringTest.java @@ -3,15 +3,14 @@ import org.junit.Test; import static by.andd3dfx.string.ReverseString.apply; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class ReverseStringTest { @Test public void testApply() { - assertThat(apply(""), is("")); - assertThat(apply("A"), is("A")); - assertThat(apply("aBc deF"), is("Fed cBa")); + assertThat(apply("")).isEqualTo(""); + assertThat(apply("A")).isEqualTo("A"); + assertThat(apply("aBc deF")).isEqualTo("Fed cBa"); } } diff --git a/src/test/java/by/andd3dfx/string/ShiftCharactersAndCapitalizeVowelsTest.java b/src/test/java/by/andd3dfx/string/ShiftCharactersAndCapitalizeVowelsTest.java index 9f3c00c5..ecc97043 100644 --- a/src/test/java/by/andd3dfx/string/ShiftCharactersAndCapitalizeVowelsTest.java +++ b/src/test/java/by/andd3dfx/string/ShiftCharactersAndCapitalizeVowelsTest.java @@ -3,18 +3,17 @@ import org.junit.Test; import static by.andd3dfx.string.ShiftCharactersAndCapitalizeVowels.apply; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class ShiftCharactersAndCapitalizeVowelsTest { @Test public void capitalizingNotNeeded() { - assertThat(apply("mama 45"), is("nbnb 45")); + assertThat(apply("mama 45")).isEqualTo("nbnb 45"); } @Test public void capitalizingRequired() { - assertThat(apply("tower"), is("Upxfs")); + assertThat(apply("tower")).isEqualTo("Upxfs"); } } diff --git a/src/test/java/by/andd3dfx/tree/BinaryTreeWalkingTest.java b/src/test/java/by/andd3dfx/tree/BinaryTreeWalkingTest.java index 7c1f8f01..31a99746 100644 --- a/src/test/java/by/andd3dfx/tree/BinaryTreeWalkingTest.java +++ b/src/test/java/by/andd3dfx/tree/BinaryTreeWalkingTest.java @@ -1,13 +1,12 @@ package by.andd3dfx.tree; +import by.andd3dfx.tree.BinaryTreeWalking.Node; import org.junit.Before; import org.junit.Test; import java.util.List; -import java.util.stream.Collectors; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class BinaryTreeWalkingTest { @@ -20,44 +19,43 @@ public void setUp() throws Exception { @Test public void breadthWalk() { - BinaryTreeWalking.Node root = buildTree(); + Node root = buildTree(); - List> result = binaryTreeWalking.breadthWalk(root); + List> result = binaryTreeWalking.breadthWalk(root); - checkResultList(result, new int[]{5, 4, 12, 11, 9, 34, 7}); + checkResultList(result, List.of(5, 4, 12, 11, 9, 34, 7)); } @Test public void forwardVerticalWalk() { - BinaryTreeWalking.Node root = buildTree(); + Node root = buildTree(); - List> result = binaryTreeWalking.forwardVerticalWalk(root); + List> result = binaryTreeWalking.forwardVerticalWalk(root); - checkResultList(result, new int[]{5, 4, 11, 12, 9, 7, 34}); + checkResultList(result, List.of(5, 4, 11, 12, 9, 7, 34)); } @Test public void symmetricVerticalWalk() { - BinaryTreeWalking.Node root = buildTree(); + Node root = buildTree(); - List> result = binaryTreeWalking.symmetricVerticalWalk(root); + List> result = binaryTreeWalking.symmetricVerticalWalk(root); - checkResultList(result, new int[]{4, 11, 5, 7, 9, 12, 34}); + checkResultList(result, List.of(4, 11, 5, 7, 9, 12, 34)); } @Test public void backwardVerticalWalk() { - BinaryTreeWalking.Node root = buildTree(); + Node root = buildTree(); - List> result = binaryTreeWalking.backwardVerticalWalk(root); + List> result = binaryTreeWalking.backwardVerticalWalk(root); - checkResultList(result, new int[]{11, 4, 7, 9, 34, 12, 5}); + checkResultList(result, List.of(11, 4, 7, 9, 34, 12, 5)); } - private void checkResultList(List> result, int[] expectation) { - List values = result.stream().map(BinaryTreeWalking.Node::getValue).toList(); - assertThat(values.size(), is(expectation.length)); - assertThat(values.toArray(), is(expectation)); + private void checkResultList(List> result, List expectation) { + var values = result.stream().map(Node::getValue).toList(); + assertThat(values).isEqualTo(expectation); } /** @@ -68,15 +66,15 @@ private void checkResultList(List> result, int[] * 7 * */ - private BinaryTreeWalking.Node buildTree() { - BinaryTreeWalking.Node eleven = new BinaryTreeWalking.Node(11, null, null); - BinaryTreeWalking.Node four = new BinaryTreeWalking.Node(4, null, eleven); + private Node buildTree() { + var eleven = new Node<>(11, null, null); + var four = new Node<>(4, null, eleven); - BinaryTreeWalking.Node seven = new BinaryTreeWalking.Node(7, null, null); - BinaryTreeWalking.Node nine = new BinaryTreeWalking.Node(9, seven, null); - BinaryTreeWalking.Node thirtyFour = new BinaryTreeWalking.Node(34, null, null); - BinaryTreeWalking.Node twelve = new BinaryTreeWalking.Node(12, nine, thirtyFour); + var seven = new Node<>(7, null, null); + var nine = new Node<>(9, seven, null); + var thirtyFour = new Node<>(34, null, null); + var twelve = new Node<>(12, nine, thirtyFour); - return new BinaryTreeWalking.Node(5, four, twelve); + return new Node<>(5, four, twelve); } } \ No newline at end of file diff --git a/src/test/java/by/andd3dfx/tree/NextNodeForBinarySearchTreeTest.java b/src/test/java/by/andd3dfx/tree/NextNodeForBinarySearchTreeTest.java index 03ce3319..b1815f10 100644 --- a/src/test/java/by/andd3dfx/tree/NextNodeForBinarySearchTreeTest.java +++ b/src/test/java/by/andd3dfx/tree/NextNodeForBinarySearchTreeTest.java @@ -3,8 +3,7 @@ import org.junit.Test; import static by.andd3dfx.tree.NextNodeForBinarySearchTree.next; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class NextNodeForBinarySearchTreeTest { @@ -41,12 +40,12 @@ public void testNext() { _7.setLeft(_6); _7.setRight(_11); - assertThat("Wrong node for 3", next(_3), is(_3_5)); - assertThat("Wrong node for 4", next(_4), is(_4_5)); - assertThat("Wrong node for 4.5", next(_4_5), is(_5)); - assertThat("Wrong node for 7", next(_7), is(_11)); - assertThat("Wrong node for 11", next(_11), is(_20)); - assertThat("Wrong node for 20", next(_20), is(_20)); + assertThat(next(_3)).as("Wrong node for 3").isEqualTo(_3_5); + assertThat(next(_4)).as("Wrong node for 4").isEqualTo(_4_5); + assertThat(next(_4_5)).as("Wrong node for 4.5").isEqualTo(_5); + assertThat(next(_7)).as("Wrong node for 7").isEqualTo(_11); + assertThat(next(_11)).as("Wrong node for 11").isEqualTo(_20); + assertThat(next(_20)).as("Wrong node for 20").isEqualTo(_20); } class NodeImpl implements NextNodeForBinarySearchTree.Node { diff --git a/src/test/java/by/andd3dfx/tree/equivalent/EquivalentNodesOfTreeTest.java b/src/test/java/by/andd3dfx/tree/equivalent/EquivalentNodesOfTreeTest.java index 3e59a901..10c7c580 100644 --- a/src/test/java/by/andd3dfx/tree/equivalent/EquivalentNodesOfTreeTest.java +++ b/src/test/java/by/andd3dfx/tree/equivalent/EquivalentNodesOfTreeTest.java @@ -5,10 +5,7 @@ import java.util.List; -import static org.hamcrest.CoreMatchers.hasItems; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.nullValue; -import static org.hamcrest.MatcherAssert.assertThat; +import static org.assertj.core.api.Assertions.assertThat; public class EquivalentNodesOfTreeTest { @@ -21,7 +18,7 @@ public void setUp() { @Test public void findEquivalentNodesForNull() { - assertThat(equivalentNodesOfTree.findEquivalentNodes(null), is(nullValue())); + assertThat(equivalentNodesOfTree.findEquivalentNodes(null)).isNull(); } /** @@ -32,7 +29,7 @@ public void findEquivalentNodesForNull() { @Test public void findEquivalentNodesForRootNodeOnly() { Node node = new Node('A'); - assertThat(equivalentNodesOfTree.findEquivalentNodes(node), is(nullValue())); + assertThat(equivalentNodesOfTree.findEquivalentNodes(node)).isNull(); } /** @@ -46,7 +43,7 @@ public void findEquivalentNodesForRootNodeOnly() { public void findEquivalentNodesWhenNoCandidates() { Node node = new Node('A'); node.left = new Node('B'); - assertThat(equivalentNodesOfTree.findEquivalentNodes(node), is(nullValue())); + assertThat(equivalentNodesOfTree.findEquivalentNodes(node)).isNull(); } /** @@ -64,8 +61,8 @@ public void findEquivalentNodesWhenOneCandidate() { List result = equivalentNodesOfTree.findEquivalentNodes(node); - assertThat(result.size(), is(2)); - assertThat(result, hasItems(node.left, node.right)); + assertThat(result.size()).isEqualTo(2); + assertThat(result).containsExactlyInAnyOrder(node.left, node.right); } /** @@ -87,8 +84,8 @@ public void findEquivalentNodesSymmetricCase() { List result = equivalentNodesOfTree.findEquivalentNodes(node); - assertThat(result.size(), is(2)); - assertThat(result, hasItems(node.left, node.right)); + assertThat(result.size()).isEqualTo(2); + assertThat(result).containsExactlyInAnyOrder(node.left, node.right); } /** @@ -113,8 +110,8 @@ public void findEquivalentNodesAsymmetricCase() { List result = equivalentNodesOfTree.findEquivalentNodes(node); - assertThat(result.size(), is(2)); - assertThat(result, hasItems(node.left, node.right.right)); + assertThat(result.size()).isEqualTo(2); + assertThat(result).containsExactlyInAnyOrder(node.left, node.right.right); } /** @@ -139,8 +136,8 @@ public void findEquivalentNodesAsymmetricCaseShouldChooseNodesWithMaxSubtreeSize List result = equivalentNodesOfTree.findEquivalentNodes(node); - assertThat(result.size(), is(2)); - assertThat(result, hasItems(node.left, node.right)); + assertThat(result.size()).isEqualTo(2); + assertThat(result).containsExactlyInAnyOrder(node.left, node.right); } /** @@ -177,7 +174,7 @@ public void findEquivalentNodesComplexCase() { List result = equivalentNodesOfTree.findEquivalentNodes(root); - assertThat("Two nodes expected", result.size(), is(2)); - assertThat(result, hasItems(root.right.right, root.right.right.right)); + assertThat(result.size()).as("Two nodes expected").isEqualTo(2); + assertThat(result).containsExactlyInAnyOrder(root.right.right, root.right.right.right); } }