diff --git a/pom.xml b/pom.xml
index 26c4003d3c..d9ddf89b6f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -162,7 +162,7 @@ The MIT License (MIT)
                 <signaturesFile>./src/test/resources/forbidden-apis.txt</signaturesFile>
               </signaturesFiles>
               <!--
-               @todo #951:30min In the continuation of #588, all the calls
+               @todo #1082:30min In the continuation of #588, all the calls
                 to Matchers should be replaced with their OO counterparts.
                 This todo should be updated with a new one until everything is
                 done. The newly covered classes should be added to the include
@@ -174,6 +174,7 @@ The MIT License (MIT)
                 <include>org/cactoos/bytes/*.class</include>
                 <include>org/cactoos/map/*.class</include>
                 <include>org/cactoos/time/*.class</include>
+                <include>org/cactoos/collection/*.class</include>
               </includes>
             </configuration>
             <executions>
diff --git a/src/test/java/org/cactoos/collection/BehavesAsCollection.java b/src/test/java/org/cactoos/collection/BehavesAsCollection.java
index b63da3a150..d11168a47d 100644
--- a/src/test/java/org/cactoos/collection/BehavesAsCollection.java
+++ b/src/test/java/org/cactoos/collection/BehavesAsCollection.java
@@ -26,13 +26,13 @@
 import java.util.Collection;
 import org.cactoos.list.ListOf;
 import org.hamcrest.Description;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.TypeSafeMatcher;
 import org.hamcrest.collection.IsCollectionWithSize;
 import org.hamcrest.collection.IsEmptyCollection;
 import org.hamcrest.core.IsCollectionContaining;
 import org.hamcrest.core.IsEqual;
 import org.hamcrest.core.IsNot;
+import org.llorllale.cactoos.matchers.Assertion;
 import org.llorllale.cactoos.matchers.MatcherOf;
 
 /**
@@ -40,6 +40,7 @@
  * @param <E> Type of source item
  * @since 0.23
  * @checkstyle JavadocMethodCheck (500 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 public final class BehavesAsCollection<E> extends
     TypeSafeMatcher<Collection<E>>  {
@@ -61,28 +62,54 @@ public BehavesAsCollection(final E item) {
     @Override
     @SuppressWarnings({ "unchecked", "PMD.ClassCastExceptionWithToArray" })
     public boolean matchesSafely(final Collection<E> col) {
-        MatcherAssert.assertThat(
-            col, new IsCollectionContaining<>(new IsEqual<>(this.sample))
-        );
-        MatcherAssert.assertThat(
-            col, new IsNot<>(new IsEmptyCollection<>())
-        );
-        MatcherAssert.assertThat(
-            col, new IsCollectionWithSize<>(new MatcherOf<>(s -> s > 0))
-        );
-        MatcherAssert.assertThat(
-            new ListOf<>((E[]) col.toArray()),
-            new IsCollectionContaining<>(new IsEqual<>(this.sample))
-        );
+        new Assertion<>(
+            "Must contain item",
+            () -> col,
+            new IsCollectionContaining<>(
+                new IsEqual<>(
+                    this.sample
+                )
+            )
+        ).affirm();
+        new Assertion<>(
+            "Must not be empty",
+            () -> col,
+            new IsNot<>(
+                new IsEmptyCollection<>()
+            )
+        ).affirm();
+        new Assertion<>(
+            "Size must be more than 0",
+            () -> col,
+            new IsCollectionWithSize<>(
+                new MatcherOf<>(s -> s > 0)
+            )
+        ).affirm();
+        new Assertion<>(
+            "Array must contain item",
+            () -> new ListOf<>(
+                (E[]) col.toArray()
+            ),
+            new IsCollectionContaining<>(
+                new IsEqual<>(this.sample)
+            )
+        ).affirm();
         final E[] array = (E[]) new Object[col.size()];
         col.toArray(array);
-        MatcherAssert.assertThat(
-            new ListOf<>(array),
-            new IsCollectionContaining<>(new IsEqual<>(this.sample))
-        );
-        MatcherAssert.assertThat(
-            col.containsAll(new ListOf<>(this.sample)), new IsEqual<>(true)
-        );
+        new Assertion<>(
+            "Array from collection must contain item",
+            () -> new ListOf<>(array),
+            new IsCollectionContaining<>(
+                new IsEqual<>(this.sample)
+            )
+        ).affirm();
+        new Assertion<>(
+            "Must contain list with the item",
+            () -> col.containsAll(
+                new ListOf<>(this.sample)
+            ),
+            new IsEqual<>(true)
+        ).affirm();
         return true;
     }
 
diff --git a/src/test/java/org/cactoos/collection/CollectionEnvelopeTest.java b/src/test/java/org/cactoos/collection/CollectionEnvelopeTest.java
index 44a4eb31b7..4ff0fc3561 100644
--- a/src/test/java/org/cactoos/collection/CollectionEnvelopeTest.java
+++ b/src/test/java/org/cactoos/collection/CollectionEnvelopeTest.java
@@ -30,7 +30,6 @@
 import java.util.LinkedList;
 import java.util.List;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.core.IsEqual;
 import org.hamcrest.core.IsNot;
 import org.junit.Test;
@@ -60,29 +59,29 @@ public void returnsIteratorWithUnsupportedRemove() {
 
     @Test
     public void notEqualToObjectOfAnotherType() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Collection is equal to object of different type",
-            new CollectionOf<>(),
+            () -> new CollectionOf<>(),
             new IsNot<>(new IsEqual<>("a"))
-        );
+        ).affirm();
     }
 
     @Test
     public void notEqualToCollectionOfDifferentSize() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Collection is equal to a collection of different size",
-            new CollectionOf<>(),
+            () -> new CollectionOf<>(),
             new IsNot<>(new IsEqual<>(new CollectionOf<>("b")))
-        );
+        ).affirm();
     }
 
     @Test
     public void notEqualToCollectionOfDifferentElements() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Collection is equal to a collection with different content",
-            new CollectionOf<>("a", "b"),
+            () -> new CollectionOf<>("a", "b"),
             new IsNot<>(new IsEqual<>(new CollectionOf<>("a", "c")))
-        );
+        ).affirm();
     }
 
     @Test
@@ -97,65 +96,65 @@ public void equalToItself() {
 
     @Test
     public void equalToCollectionWithIdenticalContent() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Collection is not equal to a collection with identical content",
-            new CollectionOf<>("val1", "val2"),
+            () -> new CollectionOf<>("val1", "val2"),
             new IsEqual<>(new CollectionOf<>("val1", "val2"))
-        );
+        ).affirm();
     }
 
     @Test
     public void equalToListWithIdenticalContent() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Collection not equal to a list with identical content",
-            new CollectionOf<>("a"),
+            () -> new CollectionOf<>("a"),
             new IsEqual<>(new ListOf<>("a"))
-        );
+        ).affirm();
     }
 
     @Test
     public void equalToDerivedCollection() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Collection not equal to derived collection with identical content",
-            new CollectionOf<>("a"),
+            () -> new CollectionOf<>("a"),
             new IsEqual<>(new CollectionEnvelopeTest.CustomCollection("a"))
-        );
+        ).affirm();
     }
 
     @Test
     public void equalToEmptyCollection() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Empty collection not equal with empty collection",
-            new CollectionOf<>(),
+            () -> new CollectionOf<>(),
             new IsEqual<>(new CollectionOf<>())
-        );
+        ).affirm();
     }
 
     @Test
     public void notEqualToNull() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Empty collection equal to null",
-            new CollectionOf<>(),
+            () -> new CollectionOf<>(),
             new IsNot<>(new IsEqual<>(null))
-        );
+        ).affirm();
     }
 
     @Test
     public void hashCodeEqual() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "HashCode returns different results for same entries",
-            new CollectionOf<>("a", "b").hashCode(),
+            () -> new CollectionOf<>("a", "b").hashCode(),
             new IsEqual<>(new CollectionOf<>("a", "b").hashCode())
-        );
+        ).affirm();
     }
 
     @Test
     public void differentHashCode() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "HashCode returns identical results for different entries",
-            new CollectionOf<>("a", "b").hashCode(),
+            () -> new CollectionOf<>("a", "b").hashCode(),
             new IsNot<>(new IsEqual<>(new CollectionOf<>("b", "a").hashCode()))
-        );
+        ).affirm();
     }
 
     @Test
diff --git a/src/test/java/org/cactoos/collection/CollectionOfTest.java b/src/test/java/org/cactoos/collection/CollectionOfTest.java
index f579964032..ce289596bf 100644
--- a/src/test/java/org/cactoos/collection/CollectionOfTest.java
+++ b/src/test/java/org/cactoos/collection/CollectionOfTest.java
@@ -25,9 +25,9 @@
 
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test Case for {@link CollectionOf}.
@@ -38,39 +38,45 @@
 public final class CollectionOfTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new CollectionOf<>(1, 2, 0, -1),
+            () -> new CollectionOf<>(1, 2, 0, -1),
             new BehavesAsCollection<>(-1)
-        );
+        ).affirm();
     }
 
     @Test
-    public void buildsCollectionFromIterable() throws Exception {
-        MatcherAssert.assertThat(
+    public void buildsCollectionFromIterable() {
+        new Assertion<>(
             "Can't build a collection from iterable",
-            new CollectionOf<>(new ListOf<>(new IterableOf<>(1, 2, 0, -1))),
+            () -> new CollectionOf<>(
+                new ListOf<>(
+                    new IterableOf<>(1, 2, 0, -1)
+                )
+            ),
             new BehavesAsCollection<>(-1)
-        );
+        ).affirm();
     }
 
     @Test
-    public void testToString() throws Exception {
-        MatcherAssert.assertThat(
+    public void testToString() {
+        new Assertion<>(
             "Wrong toString output. Expected \"[1, 2, 0, -1]\".",
-            new CollectionOf<>(new ListOf<>(1, 2, 0, -1)).toString(),
+            () -> new CollectionOf<>(
+                new ListOf<>(1, 2, 0, -1)
+            ).toString(),
             new IsEqual<>("[1, 2, 0, -1]")
-        );
+        ).affirm();
     }
 
     @Test
-    public void testToStringEmpty() throws Exception {
-        MatcherAssert.assertThat(
+    public void testToStringEmpty() {
+        new Assertion<>(
             "Wrong toString output. Expected \"[]\".",
-            new CollectionOf<>(new ListOf<>()).toString(),
+            () -> new CollectionOf<>(new ListOf<>()).toString(),
             new IsEqual<>("[]")
-        );
+        ).affirm();
     }
 
 }
diff --git a/src/test/java/org/cactoos/collection/FilteredTest.java b/src/test/java/org/cactoos/collection/FilteredTest.java
index 76f681fdb8..d8f543177c 100644
--- a/src/test/java/org/cactoos/collection/FilteredTest.java
+++ b/src/test/java/org/cactoos/collection/FilteredTest.java
@@ -25,12 +25,11 @@
 
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.cactoos.scalar.LengthOf;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.collection.IsEmptyCollection;
 import org.hamcrest.core.IsEqual;
 import org.hamcrest.core.IsNot;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test case for {@link org.cactoos.collection.Filtered}.
@@ -43,68 +42,59 @@
 public final class FilteredTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Filtered<Integer>(i -> i < 2, 1, 2, 0, -1),
+            () -> new Filtered<Integer>(i -> i < 2, 1, 2, 0, -1),
             new BehavesAsCollection<>(-1)
-        );
-    }
-
-    @Test
-    public void filterList() {
-        MatcherAssert.assertThat(
-            new LengthOf(
-                new Filtered<String>(
-                    input -> input.length() > 4,
-                    new IterableOf<>("hello", "world", "друг")
-                )
-            ).intValue(),
-            new IsEqual<>(2)
-        );
+        ).affirm();
     }
 
     @Test
     public void filterEmptyList() {
-        MatcherAssert.assertThat(
-            new Filtered<String>(
+        new Assertion<>(
+            "Filter must work on empty collection",
+            () -> new Filtered<String>(
                 input -> input.length() > 4,
                 new ListOf<>()
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test
-    public void size() throws Exception {
-        MatcherAssert.assertThat(
-            new Filtered<String>(
+    public void size() {
+        new Assertion<>(
+            "Size must be equal to number of items matching the filter",
+            () -> new Filtered<String>(
                 input -> input.length() >= 4,
                 new IterableOf<>("some", "text", "yes")
             ).size(),
             new IsEqual<>(2)
-        );
+        ).affirm();
     }
 
     @Test
-    public void withItemsNotEmpty() throws Exception {
-        MatcherAssert.assertThat(
-            new Filtered<String>(
+    public void withItemsNotEmpty() {
+        new Assertion<>(
+            "Must not be empty with items",
+            () -> new Filtered<String>(
                 input -> input.length() > 4,
                 new IterableOf<>("first", "second")
             ),
             new IsNot<>(new IsEmptyCollection<>())
-        );
+        ).affirm();
     }
 
     @Test
-    public void withoutItemsIsEmpty() throws Exception {
-        MatcherAssert.assertThat(
-            new Filtered<String>(
+    public void withoutItemsIsEmpty() {
+        new Assertion<>(
+            "Must be empty without items",
+            () -> new Filtered<String>(
                 input -> input.length() > 16,
                 new IterableOf<>("third", "fourth")
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/HeadOfTest.java b/src/test/java/org/cactoos/collection/HeadOfTest.java
index d9cf93b0f9..3deb29909d 100644
--- a/src/test/java/org/cactoos/collection/HeadOfTest.java
+++ b/src/test/java/org/cactoos/collection/HeadOfTest.java
@@ -24,9 +24,12 @@
 
 package org.cactoos.collection;
 
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import org.cactoos.iterable.IterableOf;
+import org.hamcrest.core.AllOf;
+import org.hamcrest.core.IsCollectionContaining;
+import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test Case for {@link HeadOf}.
@@ -38,18 +41,20 @@ public final class HeadOfTest {
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
-    public void headCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void headCollection() {
+        new Assertion<>(
             "Can't skip elements in iterable",
-            new HeadOf<>(
+            () -> new HeadOf<>(
                 3,
                 "one", "two", "three", "four"
             ),
-            Matchers.contains(
-                "one",
-                "two",
-                "three"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super HeadOf<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("one")),
+                    new IsCollectionContaining<>(new IsEqual<>("two")),
+                    new IsCollectionContaining<>(new IsEqual<>("three"))
+                )
             )
-        );
+        ).affirm();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/JoinedTest.java b/src/test/java/org/cactoos/collection/JoinedTest.java
index 39d05c5fd1..2980754082 100644
--- a/src/test/java/org/cactoos/collection/JoinedTest.java
+++ b/src/test/java/org/cactoos/collection/JoinedTest.java
@@ -26,15 +26,15 @@
 import java.util.Collections;
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.collection.IsCollectionWithSize;
 import org.hamcrest.collection.IsEmptyCollection;
 import org.hamcrest.core.IsEqual;
 import org.hamcrest.core.IsNot;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
- * Test case for {@link Limited}.
+ * Test case for {@link Joined}.
  *
  * @since 0.16
  * @checkstyle JavadocMethodCheck (500 lines)
@@ -45,63 +45,67 @@
 public final class JoinedTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Joined<Integer>(
+            () -> new Joined<Integer>(
                 new IterableOf<>(1, -1, 2, 0),
                 new IterableOf<>(1, -1, 2, 0),
                 new IterableOf<>(1, -1, 2, 0)
             ),
             new BehavesAsCollection<>(-1)
-        );
+        ).affirm();
     }
 
     @Test
     public void size() {
-        MatcherAssert.assertThat(
-            new Joined<String>(
+        new Assertion<>(
+            "Must have correct size",
+            () -> new Joined<String>(
                 new IterableOf<>("hello", "world", "друг"),
                 new IterableOf<>("how", "are", "you"),
                 new IterableOf<>("what's", "up")
             ),
             new IsCollectionWithSize<>(new IsEqual<>(8))
-        );
+        ).affirm();
     }
 
     @Test
     public void sizeEmptyReturnZero() {
-        MatcherAssert.assertThat(
-            new Joined<String>(
+        new Assertion<>(
+            "Size must be 0",
+            () -> new Joined<String>(
                 Collections.emptyList()
             ),
             new IsCollectionWithSize<>(new IsEqual<>(0))
-        );
+        ).affirm();
     }
 
     @Test
-    public void withItemsNotEmpty() throws Exception {
-        MatcherAssert.assertThat(
-            new Joined<String>(
+    public void withItemsNotEmpty() {
+        new Assertion<>(
+            "Must be not empty",
+            () -> new Joined<String>(
                 new IterableOf<>("1", "2"),
                 new IterableOf<>("3", "4")
             ),
             new IsNot<>(new IsEmptyCollection<>())
-        );
+        ).affirm();
     }
 
     @Test
-    public void withoutItemsIsEmpty() throws Exception {
-        MatcherAssert.assertThat(
-            new Joined<String>(
+    public void withoutItemsIsEmpty() {
+        new Assertion<>(
+            "Must be empty",
+            () -> new Joined<String>(
                 Collections.emptyList()
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testAdd() throws Exception {
+    public void testAdd() {
         new Joined<Integer>(
             new IterableOf<>(1, 2),
             new IterableOf<>(3, 4),
@@ -110,7 +114,7 @@ public void testAdd() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRemove() throws Exception {
+    public void testRemove() {
         new Joined<String>(
             new IterableOf<>("w", "a"),
             new IterableOf<>("b", "c")
@@ -118,7 +122,7 @@ public void testRemove() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testAddAll() throws Exception {
+    public void testAddAll() {
         new Joined<Integer>(
             new IterableOf<>(111),
             new IterableOf<>(222),
@@ -127,7 +131,7 @@ public void testAddAll() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRemoveAll() throws Exception {
+    public void testRemoveAll() {
         new Joined<Integer>(
             new IterableOf<>(111, 222),
             new IterableOf<>(444)
@@ -135,7 +139,7 @@ public void testRemoveAll() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRetainAll() throws Exception {
+    public void testRetainAll() {
         new Joined<Integer>(
             new IterableOf<>(22),
             new IterableOf<>(11)
@@ -143,7 +147,7 @@ public void testRetainAll() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testClear() throws Exception {
+    public void testClear() {
         new Joined<Integer>(
             new IterableOf<>(10),
             new IterableOf<>(20)
diff --git a/src/test/java/org/cactoos/collection/MappedTest.java b/src/test/java/org/cactoos/collection/MappedTest.java
index 411d2d8e97..6c3e713e33 100644
--- a/src/test/java/org/cactoos/collection/MappedTest.java
+++ b/src/test/java/org/cactoos/collection/MappedTest.java
@@ -31,11 +31,11 @@
 import org.cactoos.list.ListOf;
 import org.cactoos.text.TextOf;
 import org.cactoos.text.Upper;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.collection.IsCollectionWithSize;
 import org.hamcrest.collection.IsEmptyCollection;
 import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test case for {@link Mapped}.
@@ -47,57 +47,58 @@
 public final class MappedTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Mapped<Integer, Integer>(
+            () -> new Mapped<Integer, Integer>(
                 i -> i + 1,
                 new IterableOf<>(-1, 1, 2)
             ),
             new BehavesAsCollection<>(0)
-        );
+        ).affirm();
     }
 
     @Test
-    public void transformsList() throws Exception {
-        MatcherAssert.assertThat(
+    public void transformsList() {
+        new Assertion<>(
             "Can't transform an iterable",
-            new Mapped<String, Text>(
+            () -> new Mapped<String, Text>(
                 input -> new Upper(new TextOf(input)),
                 new IterableOf<>("hello", "world", "друг")
             ).iterator().next().asString(),
             new IsEqual<>("HELLO")
-        );
+        ).affirm();
     }
 
     @Test
     public void transformsEmptyList() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't transform an empty iterable",
-            new Mapped<String, Text>(
+            () -> new Mapped<String, Text>(
                 input -> new Upper(new TextOf(input)),
                 new ListOf<>()
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test
     public void string() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't convert to string",
-            new Mapped<Integer, Integer>(
+            () -> new Mapped<Integer, Integer>(
                 x -> x * 2,
                 new ListOf<>(1, 2, 3)
             ).toString(),
             new IsEqual<>("2, 4, 6")
-        );
+        ).affirm();
     }
 
     @Test
     public void transformsEndlessCollection() {
-        MatcherAssert.assertThat(
-            new Mapped<>(
+        new Assertion<>(
+            "Size must be 1",
+            () -> new Mapped<>(
                 String::trim,
                 new AbstractCollection<String>() {
                     @Override
@@ -111,7 +112,7 @@ public int size() {
                 }
             ),
             new IsCollectionWithSize<>(new IsEqual<>(1))
-        );
+        ).affirm();
     }
 
 }
diff --git a/src/test/java/org/cactoos/collection/ReversedTest.java b/src/test/java/org/cactoos/collection/ReversedTest.java
index 97dff1631c..8003f2dc8b 100644
--- a/src/test/java/org/cactoos/collection/ReversedTest.java
+++ b/src/test/java/org/cactoos/collection/ReversedTest.java
@@ -26,11 +26,12 @@
 import java.util.ArrayList;
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import org.hamcrest.collection.IsArrayContaining;
 import org.hamcrest.collection.IsEmptyCollection;
+import org.hamcrest.core.AllOf;
 import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test case for {@link org.cactoos.collection.Reversed}.
@@ -38,85 +39,91 @@
  * @since 0.16
  * @checkstyle JavadocMethodCheck (500 lines)
  * @checkstyle MagicNumber (500 line)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 @SuppressWarnings("PMD.TooManyMethods")
 public final class ReversedTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new NoNulls<>(
+            () -> new NoNulls<>(
                 new Reversed<>(
                     new IterableOf<Integer>(0, -1, 2)
                 )
             ),
             new BehavesAsCollection<>(0)
-        );
+        ).affirm();
     }
 
     @Test
-    public void reverseList() throws Exception {
+    public void reverseList() {
         final String last = "last";
-        MatcherAssert.assertThat(
-            new Reversed<>(
+        new Assertion<>(
+            "Must reverse list",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     "item", last
                 )
             ).iterator().next(),
             new IsEqual<>(last)
-        );
+        ).affirm();
     }
 
     @Test
-    public void reverseEmptyList() throws Exception {
-        MatcherAssert.assertThat(
-            new Reversed<>(
+    public void reverseEmptyList() {
+        new Assertion<>(
+            "Must reverse empty list",
+            () -> new Reversed<>(
                 new ListOf<>()
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test
-    public void size() throws Exception {
-        MatcherAssert.assertThat(
-            new Reversed<>(
+    public void size() {
+        new Assertion<>(
+            "Size must be the same",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     "0", "1", "2"
                 )
             ).size(),
-            Matchers.equalTo(3)
-        );
+            new IsEqual<>(3)
+        ).affirm();
     }
 
     @Test
-    public void isEmpty() throws Exception {
-        MatcherAssert.assertThat(
-            new Reversed<>(
+    public void isEmpty() {
+        new Assertion<>(
+            "Must be not empty",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     6, 16
                 )
             ).isEmpty(),
-            Matchers.equalTo(false)
-        );
+            new IsEqual<>(false)
+        ).affirm();
     }
 
     @Test
-    public void contains() throws Exception {
+    public void contains() {
         final String word = "objects";
-        MatcherAssert.assertThat(
-            new Reversed<>(
+        new Assertion<>(
+            "Must contain element",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     "hello", "elegant", word
                 )
             ).contains(word),
-            Matchers.equalTo(true)
-        );
+            new IsEqual<>(true)
+        ).affirm();
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testAdd() throws Exception {
+    public void testAdd() {
         new Reversed<>(
             new IterableOf<>(
                 1, 2, 3, 4
@@ -125,7 +132,7 @@ public void testAdd() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRemove() throws Exception {
+    public void testRemove() {
         new Reversed<>(
             new IterableOf<>(
                 1, 2, 3, 4
@@ -134,7 +141,7 @@ public void testRemove() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testAddAll() throws Exception {
+    public void testAddAll() {
         new Reversed<>(
             new IterableOf<>(
                 1, 2, 3, 4
@@ -143,7 +150,7 @@ public void testAddAll() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRemoveAll() throws Exception {
+    public void testRemoveAll() {
         new Reversed<>(
             new IterableOf<>(
                 1, 2, 3, 4
@@ -152,7 +159,7 @@ public void testRemoveAll() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRetainAll() throws Exception {
+    public void testRetainAll() {
         new Reversed<>(
             new IterableOf<>(
                 1, 2, 3, 4
@@ -161,7 +168,7 @@ public void testRetainAll() throws Exception {
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testClear() throws Exception {
+    public void testClear() {
         new Reversed<>(
             new IterableOf<>(
                 1, 2, 3, 4
@@ -170,40 +177,58 @@ public void testClear() throws Exception {
     }
 
     @Test
-    public void toArray() throws Exception {
-        MatcherAssert.assertThat(
-            new Reversed<>(
+    public void toArray() {
+        new Assertion<>(
+            "Array must contain element",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     1, 2, 3, 4
                 )
             ).toArray(),
-            Matchers.arrayContaining(4, 3, 2, 1)
-        );
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Object[]>>(
+                    new IsArrayContaining<>(new IsEqual<>(4)),
+                    new IsArrayContaining<>(new IsEqual<>(3)),
+                    new IsArrayContaining<>(new IsEqual<>(2)),
+                    new IsArrayContaining<>(new IsEqual<>(1))
+                )
+            )
+        ).affirm();
     }
 
     @Test
-    public void toArrayWithArray() throws Exception {
-        MatcherAssert.assertThat(
-            new Reversed<>(
+    public void toArrayWithArray() {
+        new Assertion<>(
+            "Array for Reversed must contain elements",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     1, 2, 3, 4, 5
                 )
             ).toArray(new Integer[]{5, 6}),
-            Matchers.arrayContaining(5, 4, 3, 2, 1)
-        );
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Integer[]>>(
+                    new IsArrayContaining<>(new IsEqual<>(5)),
+                    new IsArrayContaining<>(new IsEqual<>(4)),
+                    new IsArrayContaining<>(new IsEqual<>(3)),
+                    new IsArrayContaining<>(new IsEqual<>(2)),
+                    new IsArrayContaining<>(new IsEqual<>(1))
+                )
+            )
+        ).affirm();
     }
 
     @Test
-    public void containsAll() throws Exception {
+    public void containsAll() {
         final String first = "first";
         final String second = "second";
-        MatcherAssert.assertThat(
-            new Reversed<>(
+        new Assertion<>(
+            "Must contains all elements",
+            () -> new Reversed<>(
                 new IterableOf<>(
                     first, second, "third"
                 )
             ).containsAll(new ListOf<>(first, second)),
-            Matchers.equalTo(true)
-        );
+            new IsEqual<>(true)
+        ).affirm();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/ShuffledTest.java b/src/test/java/org/cactoos/collection/ShuffledTest.java
index 91fc5539d2..128d3d1dcc 100644
--- a/src/test/java/org/cactoos/collection/ShuffledTest.java
+++ b/src/test/java/org/cactoos/collection/ShuffledTest.java
@@ -25,10 +25,10 @@
 
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.core.IsCollectionContaining;
 import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test Case for {@link Shuffled}.
@@ -38,39 +38,39 @@
 public final class ShuffledTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Shuffled<>(new ListOf<Integer>(1, 2, 0, -1)),
+            () -> new Shuffled<>(new ListOf<Integer>(1, 2, 0, -1)),
             new BehavesAsCollection<>(0)
-        );
+        ).affirm();
     }
 
     @Test
-    public void shufflesCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void shufflesCollection() {
+        new Assertion<>(
             "Can't shuffle elements in collection",
-            new Shuffled<>(new ListOf<Integer>(1, 2, 0, -1)),
+            () -> new Shuffled<>(new ListOf<Integer>(1, 2, 0, -1)),
             new IsCollectionContaining<>(new IsEqual<>(-1))
-        );
+        ).affirm();
     }
 
     @Test
-    public void shufflesArray() throws Exception {
-        MatcherAssert.assertThat(
+    public void shufflesArray() {
+        new Assertion<>(
             "Can't shuffle elements in array",
-            new Shuffled<>(1, 2, 0, -1),
+            () -> new Shuffled<>(1, 2, 0, -1),
             new IsCollectionContaining<>(new IsEqual<>(-1))
-        );
+        ).affirm();
     }
 
     @Test
-    public void shufflesIterable() throws Exception {
-        MatcherAssert.assertThat(
+    public void shufflesIterable() {
+        new Assertion<>(
             "Can't shuffle elements in iterable",
-            new Shuffled<>(new IterableOf<>(1, 2, 0, -1)),
+            () -> new Shuffled<>(new IterableOf<>(1, 2, 0, -1)),
             new IsCollectionContaining<>(new IsEqual<>(-1))
-        );
+        ).affirm();
     }
 
 }
diff --git a/src/test/java/org/cactoos/collection/SkippedTest.java b/src/test/java/org/cactoos/collection/SkippedTest.java
index fdb41a4ac3..1414a55a58 100644
--- a/src/test/java/org/cactoos/collection/SkippedTest.java
+++ b/src/test/java/org/cactoos/collection/SkippedTest.java
@@ -25,103 +25,117 @@
 package org.cactoos.collection;
 
 import org.cactoos.iterable.IterableOf;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
 import org.hamcrest.collection.IsEmptyCollection;
+import org.hamcrest.core.AllOf;
+import org.hamcrest.core.IsCollectionContaining;
+import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test Case for {@link Skipped}.
  *
  * @since 0.34
  * @checkstyle JavadocMethodCheck (500 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 public final class SkippedTest {
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
     public void skipIterable() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't skip elements in iterable",
-            new Skipped<>(
+            () -> new Skipped<>(
                 2,
                 new IterableOf<>("one", "two", "three", "four")
             ),
-            Matchers.contains(
-                "three",
-                "four"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Skipped<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("three")),
+                    new IsCollectionContaining<>(new IsEqual<>("four"))
+                )
             )
-        );
+        ).affirm();
     }
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
     public void skipArray() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't skip elements in array",
-            new Skipped<>(
+            () -> new Skipped<>(
                 2,
                 "one", "two", "three", "four"
             ),
-            Matchers.contains(
-                "three",
-                "four"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Skipped<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("three")),
+                    new IsCollectionContaining<>(new IsEqual<>("four"))
+                )
             )
-        );
+        ).affirm();
     }
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
     public void skipCollection() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't skip elements in collection",
-            new Skipped<>(
+            () -> new Skipped<>(
                 2,
                 new CollectionOf<>("one", "two", "three", "four")
             ),
-            Matchers.contains(
-                "three",
-                "four"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Skipped<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("three")),
+                    new IsCollectionContaining<>(new IsEqual<>("four"))
+                )
             )
-        );
+        ).affirm();
     }
 
     @Test
     public void skippedAllElements() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't skip all elements",
-            new Skipped<>(
+            () -> new Skipped<>(
                 2,
                 "one", "two"
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test
     public void skippedMoreThanExists() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't skip more than exists",
-            new Skipped<>(
+            () -> new Skipped<>(
                 Integer.MAX_VALUE,
                 "one", "two"
             ),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
     public void skippedNegativeSize() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't process negative skipped size",
-            new Skipped<>(
+            () -> new Skipped<>(
                 -1,
                 "one", "two", "three", "four"
             ),
-            Matchers.contains(
-                "one", "two", "three", "four"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Skipped<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("one")),
+                    new IsCollectionContaining<>(new IsEqual<>("two")),
+                    new IsCollectionContaining<>(new IsEqual<>("three")),
+                    new IsCollectionContaining<>(new IsEqual<>("four"))
+                )
             )
-        );
+        ).affirm();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/SolidTest.java b/src/test/java/org/cactoos/collection/SolidTest.java
index cba7a09af7..dbf4d51fa5 100644
--- a/src/test/java/org/cactoos/collection/SolidTest.java
+++ b/src/test/java/org/cactoos/collection/SolidTest.java
@@ -26,10 +26,10 @@
 import java.util.Collection;
 import org.cactoos.Scalar;
 import org.cactoos.iterable.IterableOf;
-import org.hamcrest.MatcherAssert;
 import org.hamcrest.collection.IsCollectionWithSize;
 import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 import org.llorllale.cactoos.matchers.RunsInThreads;
 
 /**
@@ -37,60 +37,67 @@
  * @since 0.24
  * @checkstyle JavadocMethodCheck (500 lines)
  * @checkstyle MagicNumber (500 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 public final class SolidTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Solid<>(1, 2, 0, -1),
+            () -> new Solid<>(1, 2, 0, -1),
             new BehavesAsCollection<>(-1)
-        );
+        ).affirm();
     }
 
     @Test
-    public void makesListFromMappedIterable() throws Exception {
+    public void makesListFromMappedIterable() {
         final Collection<Integer> list = new Solid<>(
             new org.cactoos.list.Mapped<>(
                 i -> i + 1,
                 new IterableOf<>(1, -1, 0, 1)
             )
         );
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't turn a mapped iterable into a list",
-            list, new IsCollectionWithSize<>(new IsEqual<>(4))
-        );
-        MatcherAssert.assertThat(
+            () -> list,
+            new IsCollectionWithSize<>(new IsEqual<>(4))
+        ).affirm();
+        new Assertion<>(
             "Can't turn a mapped iterable into a list, again",
-            list, new IsCollectionWithSize<>(new IsEqual<>(4))
-        );
+            () -> list,
+            new IsCollectionWithSize<>(new IsEqual<>(4))
+        ).affirm();
     }
 
     @Test
-    public void mapsToSameObjects() throws Exception {
+    public void mapsToSameObjects() {
         final Iterable<Scalar<Integer>> list = new Solid<>(
             new org.cactoos.list.Mapped<>(
                 i -> (Scalar<Integer>) () -> i,
                 new IterableOf<>(1, -1, 0, 1)
             )
         );
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't map only once",
-            list.iterator().next(),
+            () -> list.iterator().next(),
             new IsEqual<>(list.iterator().next())
-        );
+        ).affirm();
     }
 
     @Test
     public void worksInThreads() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't behave as a collection in multiple threads",
-            list -> {
-                MatcherAssert.assertThat(list, new BehavesAsCollection<>(0));
+            () -> list -> {
+                new Assertion<>(
+                    "Must behave as collection",
+                    () -> list,
+                    new BehavesAsCollection<>(0)
+                ).affirm();
                 return true;
             },
             new RunsInThreads<>(new Solid<>(1, 0, -1, -1, 2))
-        );
+        ).affirm();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/SortedTest.java b/src/test/java/org/cactoos/collection/SortedTest.java
index 005e507a65..1d8ee1a16a 100644
--- a/src/test/java/org/cactoos/collection/SortedTest.java
+++ b/src/test/java/org/cactoos/collection/SortedTest.java
@@ -23,41 +23,50 @@
  */
 package org.cactoos.collection;
 
+import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import org.hamcrest.core.AllOf;
+import org.hamcrest.core.IsCollectionContaining;
+import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test Case for {@link Sorted}.
  * @since 0.19
  * @checkstyle JavadocMethodCheck (500 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 public final class SortedTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Sorted<>(new ListOf<Integer>(1, 2, 0, -1)),
+            () -> new Sorted<>(new ListOf<Integer>(1, 2, 0, -1)),
             new BehavesAsCollection<>(0)
-        );
+        ).affirm();
     }
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
-    public void sortsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void sortsCollection() {
+        new Assertion<>(
             "Can't sort elements in collection",
-            new Sorted<>(
+            () -> new Sorted<>(
                 new ListOf<>(
                     "one", "two", "three", "four"
                 )
             ),
-            Matchers.contains(
-                "four", "one", "three", "two"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Sorted<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("four")),
+                    new IsCollectionContaining<>(new IsEqual<>("one")),
+                    new IsCollectionContaining<>(new IsEqual<>("three")),
+                    new IsCollectionContaining<>(new IsEqual<>("two"))
+                )
             )
-        );
+        ).affirm();
     }
 
 }
diff --git a/src/test/java/org/cactoos/collection/StickyTest.java b/src/test/java/org/cactoos/collection/StickyTest.java
index 0d85ce48d3..5028178e89 100644
--- a/src/test/java/org/cactoos/collection/StickyTest.java
+++ b/src/test/java/org/cactoos/collection/StickyTest.java
@@ -27,123 +27,141 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.concurrent.atomic.AtomicInteger;
+import org.cactoos.iterable.IterableOf;
 import org.cactoos.list.ListOf;
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import org.hamcrest.collection.IsArrayContaining;
 import org.hamcrest.collection.IsCollectionWithSize;
 import org.hamcrest.collection.IsEmptyCollection;
+import org.hamcrest.core.AllOf;
 import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test case for {@link Sticky}.
  * @since 0.16
  * @checkstyle JavadocMethodCheck (500 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 @SuppressWarnings("PMD.TooManyMethods")
 public final class StickyTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Sticky<>(new ListOf<>(1, 2, 0, -1)),
+            () -> new Sticky<>(new ListOf<>(1, 2, 0, -1)),
             new BehavesAsCollection<>(0)
-        );
+        ).affirm();
     }
 
     @Test
-    public void ignoresChangesInIterable() throws Exception {
+    public void ignoresChangesInIterable() {
         final AtomicInteger size = new AtomicInteger(2);
         final Collection<Integer> list = new Sticky<>(
             new ListOf<>(
                 () -> Collections.nCopies(size.incrementAndGet(), 0).iterator()
             )
         );
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't ignore the changes in the underlying iterable",
-            list.size(),
+            () -> list.size(),
             new IsEqual<>(list.size())
-        );
+        ).affirm();
     }
 
     @Test
-    public void decoratesArray() throws Exception {
-        MatcherAssert.assertThat(
+    public void decoratesArray() {
+        new Assertion<>(
             "Can't decorate an array of numbers",
-            new Sticky<>(-1, 0),
+            () -> new Sticky<>(-1, 0),
             new IsCollectionWithSize<>(new IsEqual<>(2))
-        );
+        ).affirm();
     }
 
     @Test
     public void testEmpty() {
-        MatcherAssert.assertThat(
-            new Sticky<>(),
+        new Assertion<>(
+            "Must be empty",
+            () -> new Sticky<>(),
             new IsEmptyCollection<>()
-        );
+        ).affirm();
     }
 
     @Test
     public void testContains() {
-        MatcherAssert.assertThat(
-            new Sticky<>(1, 2).contains(1),
+        new Assertion<>(
+            "Must contain element",
+            () -> new Sticky<>(1, 2).contains(1),
             new IsEqual<>(true)
-        );
+        ).affirm();
     }
 
     @Test
     public void testToArray() {
-        MatcherAssert.assertThat(
-            new Sticky<>(1, 2).toArray(),
-            Matchers.arrayContaining(1, 2)
-        );
+        new Assertion<>(
+            "Array must contain elements",
+            () -> new Sticky<>(1, 2).toArray(),
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Object[]>>(
+                    new IsArrayContaining<>(new IsEqual<>(1)),
+                    new IsArrayContaining<>(new IsEqual<>(2))
+                )
+            )
+        ).affirm();
     }
 
     @Test
     public void testToArrayIntoArray() {
         final Integer[] arr = new Integer[2];
-        MatcherAssert.assertThat(
-            new Sticky<>(1, 2).toArray(arr),
-            Matchers.arrayContaining(1, 2)
-        );
+        new Assertion<>(
+            "Array from Sticky must contain elements",
+            () -> new Sticky<>(1, 2).toArray(arr),
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super Integer[]>>(
+                    new IsArrayContaining<>(new IsEqual<>(1)),
+                    new IsArrayContaining<>(new IsEqual<>(2))
+                )
+            )
+        ).affirm();
     }
 
     @Test
     public void testContainsAll() {
-        MatcherAssert.assertThat(
-            new Sticky<>(1, 2).containsAll(new ListOf<>(1, 2)),
+        new Assertion<>(
+            "Must contains all",
+            () -> new Sticky<>(1, 2).containsAll(new ListOf<>(1, 2)),
             new IsEqual<>(true)
-        );
+        ).affirm();
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testAdd() throws Exception {
+    public void testAdd() {
         new Sticky<>(1, 2).add(1);
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRemove() throws Exception {
+    public void testRemove() {
         new Sticky<>(1, 2).remove(1);
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testAddAll() throws Exception {
+    public void testAddAll() {
         new Sticky<>(1, 2).addAll(new ArrayList<>(2));
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRemoveAll() throws Exception {
+    public void testRemoveAll() {
         new Sticky<>(1, 2).removeAll(new ArrayList<>(2));
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testRetainAll() throws Exception {
+    public void testRetainAll() {
         new Sticky<>(1, 2).retainAll(new ArrayList<>(2));
     }
 
     @Test(expected = UnsupportedOperationException.class)
-    public void testClear() throws Exception {
+    public void testClear() {
         new Sticky<>(1, 2).clear();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/SyncedTest.java b/src/test/java/org/cactoos/collection/SyncedTest.java
index ef9a1fa4a0..d2c911f6dd 100644
--- a/src/test/java/org/cactoos/collection/SyncedTest.java
+++ b/src/test/java/org/cactoos/collection/SyncedTest.java
@@ -23,8 +23,8 @@
  */
 package org.cactoos.collection;
 
-import org.hamcrest.MatcherAssert;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 import org.llorllale.cactoos.matchers.RunsInThreads;
 
 /**
@@ -35,23 +35,27 @@
 public final class SyncedTest {
 
     @Test
-    public void behavesAsCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void behavesAsCollection() {
+        new Assertion<>(
             "Can't behave as a collection",
-            new Synced<>(1, 2, 0, -1),
+            () -> new Synced<>(1, 2, 0, -1),
             new BehavesAsCollection<>(-1)
-        );
+        ).affirm();
     }
 
     @Test
     public void worksInThreads() {
-        MatcherAssert.assertThat(
+        new Assertion<>(
             "Can't behave as a collection in multiple threads",
-            list -> {
-                MatcherAssert.assertThat(list, new BehavesAsCollection<>(0));
+            () -> list -> {
+                new Assertion<>(
+                    "Must contain 0",
+                    () -> list,
+                    new BehavesAsCollection<>(0)
+                ).affirm();
                 return true;
             },
             new RunsInThreads<>(new Synced<>(1, 0, -1, -1, 2))
-        );
+        ).affirm();
     }
 }
diff --git a/src/test/java/org/cactoos/collection/TailOfTest.java b/src/test/java/org/cactoos/collection/TailOfTest.java
index 37fae826ab..129fbe5452 100644
--- a/src/test/java/org/cactoos/collection/TailOfTest.java
+++ b/src/test/java/org/cactoos/collection/TailOfTest.java
@@ -23,9 +23,12 @@
  */
 package org.cactoos.collection;
 
-import org.hamcrest.MatcherAssert;
-import org.hamcrest.Matchers;
+import org.cactoos.iterable.IterableOf;
+import org.hamcrest.core.AllOf;
+import org.hamcrest.core.IsCollectionContaining;
+import org.hamcrest.core.IsEqual;
 import org.junit.Test;
+import org.llorllale.cactoos.matchers.Assertion;
 
 /**
  * Test case for {@link TailOf}.
@@ -37,17 +40,19 @@ public final class TailOfTest {
 
     @Test
     @SuppressWarnings("PMD.AvoidDuplicateLiterals")
-    public void tailCollection() throws Exception {
-        MatcherAssert.assertThat(
+    public void tailCollection() {
+        new Assertion<>(
             "Can't get tail portion of collection",
-            new TailOf<>(
+            () -> new TailOf<>(
                 2,
                 "one", "two", "three", "four"
             ),
-            Matchers.contains(
-                "three",
-                "four"
+            new AllOf<>(
+                new IterableOf<org.hamcrest.Matcher<? super TailOf<String>>>(
+                    new IsCollectionContaining<>(new IsEqual<>("three")),
+                    new IsCollectionContaining<>(new IsEqual<>("four"))
+                )
             )
-        );
+        ).affirm();
     }
 }