feat(predicates): add doesNotContainAllOf

Author: Reko Jokelainen

src/main/java/com/nitorcreations/predicates/NCollectionPredicates.java

@@ -124,4 +124,29 @@ public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAnyOf(T... e
     public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAnyOf(Iterable<T> elements) {
         return NPredicates.<S>notNull().and(not(containsAny(elements)));
     }
+
+    /**
+     * Checks that iterable is non-null and does not contain all of the target elements. Will return {@code true} if some of the elements are present
+     *
+     * @param elements elements to find
+     * @param <T> type of an element
+     * @param <S> type of the iterable
+     * @return predicate
+     */
+    @SafeVarargs
+    public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAllOf(T... elements) {
+        return doesNotContainAllOf(asList(elements));
+    }
+
+    /**
+     * Checks that iterable is non-null and does not contain all of the target elements. Will return {@code true} if some of the elements are present
+     *
+     * @param elements
+     * @param <T> type of an element
+     * @param <S> type of the iterable
+     * @return predicate
+     */
+    public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAllOf(Iterable<T> elements) {
+        return NPredicates.<S>notNull().and(not(containsAll(elements)));
+    }
 }

src/main/java/com/nitorcreations/predicates/NStringPredicates.java

@@ -1,6 +1,5 @@
 package com.nitorcreations.predicates;
 
-import java.util.List;
 import java.util.Objects;
 import java.util.function.Predicate;
 
@@ -80,9 +79,9 @@ public static Predicate<String> containsAll(String... substring) {
      * @return predicate
      * @param substrings
      */
-    public static Predicate<String> containsAll(List<String> substrings) {
+    public static Predicate<String> containsAll(Iterable<String> substrings) {
         return NPredicates.<String> notNull()
-                .and(s -> substrings.stream()
+                .and(s -> asStream(substrings)
                         .filter(Objects::nonNull)
                         .map(s::contains)
                         .reduce(true, Boolean::logicalAnd));
@@ -143,4 +142,26 @@ public static Predicate<String> doesNotContainAnyOf(String... substring) {
     public static Predicate<String> doesNotContainAnyOf(Iterable<String> substrings) {
         return not(containsAny(substrings)).and(notNull());
     }
+
+    /**
+     * Check that the non-null string does not contain any of the the substrings. The predicate will return {@code false}
+     * is target is {@code null}
+     *
+     * @param substring the string to find
+     * @return predicate
+     */
+    public static Predicate<String> doesNotContainAllOf(String... substring) {
+        return doesNotContainAllOf(asList(substring));
+    }
+
+    /**
+     * Check that the non-null string does not contain any of the the substrings. The predicate will return {@code false}
+     * is target is {@code null}
+     *
+     * @return predicate
+     * @param substrings
+     */
+    public static Predicate<String> doesNotContainAllOf(Iterable<String> substrings) {
+        return not(containsAll(substrings)).and(notNull());
+    }
 }

src/test/java/com/nitorcreations/predicates/NCollectionPredicatesTest.java

@@ -12,6 +12,7 @@
 import static com.nitorcreations.predicates.PredicateAssert.assertThat;
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
 
 public class NCollectionPredicatesTest {
 
@@ -24,55 +25,61 @@ public void forCoverage() throws InvocationTargetException, NoSuchMethodExceptio
     public void testEmpty() {
         assertThat(empty())
                 .matchesAll(new HashSet<>(), new ArrayList<>())
-                .matchesNone(null, asList(1), asSet(1));
+                .matchesNone(null, singletonList(1), asSet(1));
     }
 
     @Test
     public void testNotEmpty() {
         assertThat(notEmpty())
-                .matchesAll(asList(1), asSet(1))
+                .matchesAll(singletonList(1), asSet(1))
                 .matchesNone(null, new HashSet<>(), new ArrayList<>());
     }
 
     @Test
     public void testContains() {
-        final Long num = 666_666l;
+        final Long num = 666_666L;
         assertThat(contains(num))
-                .matchesAll(asList(1l, num), asSet(num), asList(666_666l))
-                .matchesNone(null, emptyList(), asList(113l));
+                .matchesAll(asList(1L, num), asSet(num), singletonList(666_666L))
+                .matchesNone(null, emptyList(), singletonList(113L));
     }
 
     @Test
     public void testContainsAll() {
-        final Long n1 = 123_123l;
-        final Long n2 = 321_321l;
+        final Long n1 = 123_123L;
+        final Long n2 = 321_321L;
         assertThat(containsAll(n1, n2))
                 .matchesAll(asList(n1, n2), asList(n2, n1), asSet(n1, n2))
-                .matchesNone(null, emptyList(), asList(113l));
+                .matchesNone(null, emptyList(), singletonList(113L));
     }
 
     @Test
     public void testContainsAny() {
-        final Long n1 = 123_123l;
-        final Long n2 = 321_321l;
+        final Long n1 = 123_123L;
+        final Long n2 = 321_321L;
         assertThat(containsAny(n1, n2))
-                .matchesAll(asList(n1), asList(n2), asList(n1, n2), asList(n2, n1), asSet(n1, n2))
-                .matchesNone(null, emptyList(), asList(113l));
+                .matchesAll(singletonList(n1), singletonList(n2), asList(n1, n2), asList(n2, n1), asSet(n1, n2))
+                .matchesNone(null, emptyList(), singletonList(113L));
     }
 
     @Test
     public void testDoesNotContain() {
-        final Long num = 666_666l;
+        final Long num = 666_666L;
         assertThat(doesNotContain(num))
-                .matchesAll(emptyList(), asList(113l))
-                .matchesNone(null, asList(1l, num), asSet(num), asList(666_666l));
+                .matchesAll(emptyList(), singletonList(113L))
+                .matchesNone(null, asList(1L, num), asSet(num), singletonList(666_666L));
     }
 
     @Test
     public void testDoesNotContainAnyOf() {
-        assertThat(doesNotContainAnyOf(123l, 321l))
-                .matchesAll(emptyList(), asList(113l))
-                .matchesNone(null, asList(1l, 123l), asSet(321l), asList(2l, 3l, 123l, 321l));
+        assertThat(doesNotContainAnyOf(123L, 321L))
+                .matchesAll(emptyList(), singletonList(113L))
+                .matchesNone(null, asList(1L, 123L), asSet(321L), asList(2L, 3L, 123L, 321L));
     }
 
+    @Test
+    public void testDoesNotContainAllOf() {
+        assertThat(doesNotContainAllOf(123L, 321L))
+                .matchesAll(emptyList(), singletonList(123L), singletonList(321L))
+                .matchesNone(null, asList(2L, 3L, 123L, 321L));
+    }
 }

src/test/java/com/nitorcreations/predicates/NStringPredicatesTest.java

@@ -85,4 +85,11 @@ public void testDoesNotContainAnyOf() {
                 .matchesNone(null, "foo", "bar", "foobar", "ooffoo", "barfoo", "barfooazx");
     }
 
+    @Test
+    public void testDoesNotContainAllOf() {
+        assertThat(doesNotContainAllOf("foo", "bar"))
+                .matchesAll("", "baz", "of", "fo", "fo of", "foo ba", "fo bar", "foo", "bar")
+                .matchesNone(null, "foobar", "barfoo", "barfooazx");
+    }
+
 }