(#1212) Fixed SetOf, which discarded all elements after duplicated occurrence

src/main/java/org/cactoos/set/SetOf.java

@@ -26,6 +26,7 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.Set;
+import org.cactoos.Proc;
 import org.cactoos.iterable.IterableOf;
 import org.cactoos.scalar.And;
 
@@ -60,7 +61,7 @@ public SetOf(final T... array) {
     public SetOf(final Iterable<T> src) {
         super(() -> {
             final Set<T> tmp = new HashSet<>();
-            new And(tmp::add, src)
+            new And((Proc<T>) tmp::add, src)
                 .value();
             return Collections.unmodifiableSet(tmp);
         });

src/test/java/org/cactoos/set/SetOfTest.java

@@ -23,27 +23,93 @@
  */
 package org.cactoos.set;
 
-import org.hamcrest.MatcherAssert;
+import org.cactoos.iterable.IterableOf;
+import org.cactoos.iterable.Joined;
+import org.hamcrest.Matcher;
+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;
+import org.llorllale.cactoos.matchers.HasSize;
 
 /**
  * Test case for {@link SetOf}.
- *
  * @since 0.49.2
  * @checkstyle MagicNumber (500 line)
+ * @checkstyle JavadocMethodCheck (500 lines)
+ * @checkstyle ClassDataAbstractionCouplingCheck (500 lines)
  */
 @SuppressWarnings("PMD.AvoidDuplicateLiterals")
 public final class SetOfTest {
 
-    /**
-     * Ensures that SetOf behaves as set, which means no duplicates.
-     */
     @Test
-    public void behavesAsSet() {
-        MatcherAssert.assertThat(
-            "Can't behave as a set",
+    public void behaveAsSetWithOriginalDuplicationsInTheTail() {
+        new Assertion<>(
+            "Must keep unique numbers",
             new SetOf<>(1, 2, 2),
-            new BehavesAsSet<>(2)
-        );
+            new AllOf<>(
+                new IterableOf<Matcher<? super SetOf<Integer>>>(
+                    new HasSize(2),
+                    new IsCollectionContaining<>(new IsEqual<>(1)),
+                    new IsCollectionContaining<>(new IsEqual<>(2))
+                )
+            )
+        ).affirm();
+    }
+
+    @Test
+    public void behaveAsSetWithOriginalDuplicationsInTheHead() {
+        new Assertion<>(
+            "Must keep unique numbers",
+            new SetOf<>(1, 1, 2, 3),
+            new AllOf<>(
+                new IterableOf<Matcher<? super SetOf<Integer>>>(
+                    new HasSize(3),
+                    new IsCollectionContaining<>(new IsEqual<>(1)),
+                    new IsCollectionContaining<>(new IsEqual<>(2)),
+                    new IsCollectionContaining<>(new IsEqual<>(3))
+                )
+            )
+        ).affirm();
+    }
+
+    @Test
+    public void behaveAsSetWithOriginalDuplicationsInTheMiddle() {
+        new Assertion<>(
+            "Must keep unique numbers",
+            new SetOf<>(1, 2, 2, 3),
+            new AllOf<>(
+                new IterableOf<Matcher<? super SetOf<Integer>>>(
+                    new HasSize(3),
+                    new IsCollectionContaining<>(new IsEqual<>(1)),
+                    new IsCollectionContaining<>(new IsEqual<>(2)),
+                    new IsCollectionContaining<>(new IsEqual<>(3))
+                )
+            )
+        ).affirm();
+    }
+
+    @Test
+    public void behaveAsSetWithOriginalMergedCollectionsWithDuplicates() {
+        new Assertion<>(
+            "Must keep unique string literals",
+            new SetOf<String>(
+                new Joined<String>(
+                    new IterableOf<>("cc", "ff"),
+                    new IterableOf<>("aa", "bb", "cc", "dd")
+                )
+            ),
+            new AllOf<>(
+                new IterableOf<Matcher<? super SetOf<String>>>(
+                    new HasSize(5),
+                    new IsCollectionContaining<>(new IsEqual<>("aa")),
+                    new IsCollectionContaining<>(new IsEqual<>("bb")),
+                    new IsCollectionContaining<>(new IsEqual<>("cc")),
+                    new IsCollectionContaining<>(new IsEqual<>("dd")),
+                    new IsCollectionContaining<>(new IsEqual<>("ff"))
+                )
+            )
+        ).affirm();
     }
 }