diff --git a/src/test/java/com/nitorcreations/predicates/NCollectionPredicates.java b/src/main/java/com/nitorcreations/predicates/NCollectionPredicates.java
similarity index 55%
rename from src/test/java/com/nitorcreations/predicates/NCollectionPredicates.java
rename to src/main/java/com/nitorcreations/predicates/NCollectionPredicates.java
index f9f11a0..c7febe0 100644
--- a/src/test/java/com/nitorcreations/predicates/NCollectionPredicates.java
+++ b/src/main/java/com/nitorcreations/predicates/NCollectionPredicates.java
@@ -2,12 +2,12 @@
 
 import java.util.Arrays;
 import java.util.function.Predicate;
-import java.util.stream.Stream;
 
 import static com.nitorcreations.predicates.NPredicates.*;
 import static com.nitorcreations.streams.NStreams.asStream;
+import static java.util.Arrays.asList;
 
-public class NCollectionPredicates {
+public final class NCollectionPredicates {
     private NCollectionPredicates() { /** prevent instantiation */}
 
 
@@ -47,8 +47,20 @@ public static <T, S extends Iterable<T>> Predicate<S> contains(T element) {
      * @param <S> type of the iterable
      * @return predicate
      */
+    @SafeVarargs
     public static <T, S extends Iterable<T>> Predicate<S> containsAll(T... elements) {
-        final Predicate<S> allmatch = Stream.of(elements)
+        return containsAll(asList(elements));
+    }
+
+    /**
+     * Checks that the iterable is non-null and contains all of the target elements (comparison by {@code #equals})
+     * @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> containsAll(Iterable<T> elements) {
+        final Predicate<S> allmatch = asStream(elements)
                 .map(NCollectionPredicates::<T, S>contains)
                 .reduce(notEmpty(), (p1, p2) -> p1.and(p2));
         return  NPredicates.<S>notNull().and(allmatch);
@@ -60,16 +72,28 @@ public static <T, S extends Iterable<T>> Predicate<S> containsAll(T... elements)
      * @param <S> type of the iterable
      * @return predicate
      */
+    @SafeVarargs
     public static <T, S extends Iterable<T>> Predicate<S> containsAny(T... elements) {
-        final Predicate<S> anyMatches = Arrays.stream(elements)
+        return containsAny(asList(elements));
+    }
+
+    /**
+     * Checks that the iterable is non-null and contains any of the target elements (comparison by {@code #equals})
+     * @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> containsAny(Iterable<T> elements) {
+        final Predicate<S> anyMatches = asStream(elements)
                 .map(NCollectionPredicates::<T, S>contains)
                 .reduce(never(), (p1, p2) -> p1.or(p2));
         return NPredicates.<S>notNull().and(anyMatches);
     }
 
-
     /**
      * Checks that the iterable is non-null and does not contain the target element (comparison by {@code #equals})
+     * @param element the element
      * @param <T> type of an element
      * @param <S> type of the iterable
      * @return predicate
@@ -80,11 +104,49 @@ public static <T, S extends Iterable<T>> Predicate<S> doesNotContain(T element)
 
     /**
      * Checks that the iterable is non-null and contains none of target elements
+     * @param elements elements
      * @param <T> type of an element
      * @param <S> type of the iterable
      * @return predicate
      */
+    @SafeVarargs
     public static <T, S extends Iterable<T>> Predicate<S> doesNotContainAnyOf(T... elements) {
+        return doesNotContainAnyOf(Arrays.asList(elements));
+    }
+
+    /**
+     * Checks that the iterable is non-null and contains none of target elements
+     * @param elements elements
+     * @param <T> type of an element
+     * @param <S> type of the iterable
+     * @return predicate
+     */
+    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)));
+    }
 }
diff --git a/src/test/java/com/nitorcreations/predicates/NComparablePredicates.java b/src/main/java/com/nitorcreations/predicates/NComparablePredicates.java
similarity index 100%
rename from src/test/java/com/nitorcreations/predicates/NComparablePredicates.java
rename to src/main/java/com/nitorcreations/predicates/NComparablePredicates.java
diff --git a/src/main/java/com/nitorcreations/predicates/NOptionalPredicates.java b/src/main/java/com/nitorcreations/predicates/NOptionalPredicates.java
index 309de79..92ecd5a 100644
--- a/src/main/java/com/nitorcreations/predicates/NOptionalPredicates.java
+++ b/src/main/java/com/nitorcreations/predicates/NOptionalPredicates.java
@@ -66,4 +66,23 @@ public static <T> Predicate<Optional<? extends T>> havingValue(T value) {
         return havingValue(equalTo(value));
     }
 
+    /**
+     * Shorthand for {@code havingValue(not(predicate))}
+     * @param predicate the predicate to apply to the optional's contents
+     * @param <T> type of containing optional
+     * @return the predicate
+     */
+    public static <T> Predicate<Optional<? extends T>> notHavingValue(Predicate<T> predicate) {
+        return havingValue(not(predicate));
+    }
+
+    /**
+     * Shorthand for {@code havingValue(not(equalTo(value)))}
+     * @param value the value to compare the contents to
+     * @param <T> type of containing optional
+     * @return the predicate
+     */
+    public static <T> Predicate<Optional<? extends T>> notHavingValue(T value) {
+        return notHavingValue(equalTo(value));
+    }
 }
diff --git a/src/main/java/com/nitorcreations/predicates/NStringPredicates.java b/src/main/java/com/nitorcreations/predicates/NStringPredicates.java
index 9b1339f..f9b0c9c 100644
--- a/src/main/java/com/nitorcreations/predicates/NStringPredicates.java
+++ b/src/main/java/com/nitorcreations/predicates/NStringPredicates.java
@@ -1,11 +1,12 @@
 package com.nitorcreations.predicates;
 
-import java.util.Arrays;
 import java.util.Objects;
 import java.util.function.Predicate;
 
 import static com.nitorcreations.predicates.NPredicates.not;
 import static com.nitorcreations.predicates.NPredicates.notNull;
+import static com.nitorcreations.streams.NStreams.asStream;
+import static java.util.Arrays.asList;
 
 public final class NStringPredicates {
     private NStringPredicates() { /** prevent instantiation */}
@@ -69,8 +70,18 @@ public static Predicate<String> contains(String substring) {
      * @return predicate
      */
     public static Predicate<String> containsAll(String... substring) {
+        return containsAll(asList(substring));
+    }
+
+    /**
+     * Check that the non-null string contains all of the substrings in any order
+     *
+     * @return predicate
+     * @param substrings
+     */
+    public static Predicate<String> containsAll(Iterable<String> substrings) {
         return NPredicates.<String> notNull()
-                .and(s -> Arrays.stream(substring)
+                .and(s -> asStream(substrings)
                         .filter(Objects::nonNull)
                         .map(s::contains)
                         .reduce(true, Boolean::logicalAnd));
@@ -83,8 +94,18 @@ public static Predicate<String> containsAll(String... substring) {
      * @return predicate
      */
     public static Predicate<String> containsAny(String... substring) {
+        return containsAny(asList(substring));
+    }
+
+    /**
+     * Check that the non-null string contains any of the substrings
+     *
+     * @return predicate
+     * @param substrings
+     */
+    public static Predicate<String> containsAny(Iterable<String> substrings) {
         return NPredicates.<String> notNull()
-                .and(s -> Arrays.stream(substring)
+                .and(s -> asStream(substrings)
                         .filter(Objects::nonNull)
                         .anyMatch(s::contains));
     }
@@ -108,6 +129,39 @@ public static Predicate<String> doesNotContain(String substring) {
      * @return predicate
      */
     public static Predicate<String> doesNotContainAnyOf(String... substring) {
-        return not(containsAny(substring)).and(notNull());
+        return doesNotContainAnyOf(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> 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());
     }
 }
diff --git a/src/main/java/com/nitorcreations/streams/NStreams.java b/src/main/java/com/nitorcreations/streams/NStreams.java
index 83244c1..4085556 100644
--- a/src/main/java/com/nitorcreations/streams/NStreams.java
+++ b/src/main/java/com/nitorcreations/streams/NStreams.java
@@ -76,7 +76,9 @@ public static <T> Stream<T> asStream(Iterable<T> iterable) {
      * @return a stream containing the values of the iterable
      */
     public static <T> Stream<T> asStream(Iterable<T> iterable, boolean parallel) {
-        return StreamSupport.stream(iterable.spliterator(), parallel);
+        return Optional.ofNullable(iterable)
+                .map(it -> StreamSupport.stream(it.spliterator(), parallel))
+                .orElse(Stream.empty());
     }
 
     /**
diff --git a/src/test/java/com/nitorcreations/collections/NMapsTest.java b/src/test/java/com/nitorcreations/collections/NMapsTest.java
index 45737ac..22a5dd6 100644
--- a/src/test/java/com/nitorcreations/collections/NMapsTest.java
+++ b/src/test/java/com/nitorcreations/collections/NMapsTest.java
@@ -1,6 +1,5 @@
 package com.nitorcreations.collections;
 
-import com.nitorcreations.collections.NMaps;
 import org.junit.Test;
 
 import java.lang.reflect.InvocationTargetException;
@@ -9,10 +8,10 @@
 import static com.nitorcreations.streams.NMappers.entryOf;
 import static com.nitorcreations.collections.NMaps.*;
 import static com.nitorcreations.collections.NSets.asSet;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static java.util.Arrays.asList;
 import static java.util.function.Function.identity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NMapsTest {
 
diff --git a/src/test/java/com/nitorcreations/collections/NSetsTest.java b/src/test/java/com/nitorcreations/collections/NSetsTest.java
index 43fc5a1..6ed1ad8 100644
--- a/src/test/java/com/nitorcreations/collections/NSetsTest.java
+++ b/src/test/java/com/nitorcreations/collections/NSetsTest.java
@@ -5,10 +5,10 @@
 import java.lang.reflect.InvocationTargetException;
 import java.util.Set;
 
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static com.nitorcreations.collections.NSets.asSet;
 import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NSetsTest {
 
diff --git a/src/test/java/com/nitorcreations/predicates/NCollectionPredicatesTest.java b/src/test/java/com/nitorcreations/predicates/NCollectionPredicatesTest.java
index 2b890c8..e352a44 100644
--- a/src/test/java/com/nitorcreations/predicates/NCollectionPredicatesTest.java
+++ b/src/test/java/com/nitorcreations/predicates/NCollectionPredicatesTest.java
@@ -6,12 +6,13 @@
 import java.util.ArrayList;
 import java.util.HashSet;
 
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static com.nitorcreations.collections.NSets.asSet;
 import static com.nitorcreations.predicates.NCollectionPredicates.*;
-import static com.nitorcreations.predicates.PredicateAssert.assertThat;
+import static com.nitorcreations.test.Assertions.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));
+    }
 }
\ No newline at end of file
diff --git a/src/test/java/com/nitorcreations/predicates/NComparablePredicatesTest.java b/src/test/java/com/nitorcreations/predicates/NComparablePredicatesTest.java
index ee86128..f6aed3c 100644
--- a/src/test/java/com/nitorcreations/predicates/NComparablePredicatesTest.java
+++ b/src/test/java/com/nitorcreations/predicates/NComparablePredicatesTest.java
@@ -4,9 +4,9 @@
 
 import java.lang.reflect.InvocationTargetException;
 
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static com.nitorcreations.predicates.NComparablePredicates.*;
-import static com.nitorcreations.predicates.PredicateAssert.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NComparablePredicatesTest {
 
diff --git a/src/test/java/com/nitorcreations/predicates/NOptionalPredicatesTest.java b/src/test/java/com/nitorcreations/predicates/NOptionalPredicatesTest.java
index 92a2e83..ef0421f 100644
--- a/src/test/java/com/nitorcreations/predicates/NOptionalPredicatesTest.java
+++ b/src/test/java/com/nitorcreations/predicates/NOptionalPredicatesTest.java
@@ -26,9 +26,9 @@
 
 import static com.nitorcreations.predicates.NOptionalPredicates.*;
 import static com.nitorcreations.predicates.NPredicates.having;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static java.util.stream.Collectors.toList;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NOptionalPredicatesTest {
 
@@ -42,22 +42,28 @@ public void forCoverage() throws NoSuchMethodException, IllegalAccessException,
 
     @Test
     public void testEmpty() {
-        assertThat(empty().test(emptyOpt)).isTrue();
-        assertThat(empty().test(opt)).isFalse();
+        assertThat(empty()).matches(emptyOpt).doesNotMatch(opt);
     }
 
     @Test
     public void testPresent() {
-        assertThat(present().test(opt)).isTrue();
-        assertThat(present().test(emptyOpt)).isFalse();
+        assertThat(present()).matches(opt).doesNotMatch(emptyOpt);
     }
 
     @Test
     public void testHavingValue() {
-        assertThat(havingValue("Foo").test(opt)).isTrue();
-        assertThat(havingValue("Bar").test(opt)).isFalse();
+        assertThat(havingValue("Foo")).matches(opt);
+        assertThat(havingValue("Bar")).doesNotMatch(opt);
 
-        assertThat(havingValue((String) null).test(opt)).isFalse();
+        assertThat(havingValue((String) null)).doesNotMatch(opt);
+    }
+
+    @Test
+    public void testNotHavingValue() {
+        assertThat(notHavingValue("Foo")).doesNotMatch(opt);
+        assertThat(notHavingValue("Bar")).matches(opt);
+
+        assertThat(notHavingValue((String) null)).matches(opt);
     }
 
     @Test
diff --git a/src/test/java/com/nitorcreations/predicates/NPredicatesTest.java b/src/test/java/com/nitorcreations/predicates/NPredicatesTest.java
index 270b5dc..5f15db4 100644
--- a/src/test/java/com/nitorcreations/predicates/NPredicatesTest.java
+++ b/src/test/java/com/nitorcreations/predicates/NPredicatesTest.java
@@ -23,8 +23,8 @@
 import java.lang.reflect.InvocationTargetException;
 
 import static com.nitorcreations.predicates.NPredicates.*;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 
 public class NPredicatesTest {
     final Object o2 = new Object();
@@ -118,14 +118,14 @@ public void testNotHavingShorthand() {
 
     @Test
     public void testAllOf() {
-        PredicateAssert.assertThat(allOf(notNull(), is(123l)))
+        assertThat(allOf(notNull(), is(123l)))
                 .matches(123l)
                 .matchesNone(null, 122l);
     }
 
     @Test
     public void testAnyOf() {
-        PredicateAssert.assertThat(anyOf(is(123l), isNull()))
+        assertThat(anyOf(is(123l), isNull()))
                 .matchesAll(null, 123l)
                 .matchesNone(122l);
     }
diff --git a/src/test/java/com/nitorcreations/predicates/NStringPredicatesTest.java b/src/test/java/com/nitorcreations/predicates/NStringPredicatesTest.java
index 99db7ca..816a967 100644
--- a/src/test/java/com/nitorcreations/predicates/NStringPredicatesTest.java
+++ b/src/test/java/com/nitorcreations/predicates/NStringPredicatesTest.java
@@ -4,9 +4,9 @@
 
 import java.lang.reflect.InvocationTargetException;
 
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static com.nitorcreations.predicates.NStringPredicates.*;
-import static com.nitorcreations.predicates.PredicateAssert.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NStringPredicatesTest {
 
@@ -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");
+    }
+
 }
\ No newline at end of file
diff --git a/src/test/java/com/nitorcreations/streams/NCollectorsTest.java b/src/test/java/com/nitorcreations/streams/NCollectorsTest.java
index c719e72..7f3cf6b 100644
--- a/src/test/java/com/nitorcreations/streams/NCollectorsTest.java
+++ b/src/test/java/com/nitorcreations/streams/NCollectorsTest.java
@@ -28,8 +28,8 @@
 import static com.nitorcreations.streams.Fixture.listWithDuplicates;
 import static com.nitorcreations.streams.NCollectors.countingOccurrences;
 import static com.nitorcreations.streams.NCollectors.entriesToMap;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.Assertions.assertThat;
 import static org.assertj.core.util.Lists.emptyList;
 
 public class NCollectorsTest {
diff --git a/src/test/java/com/nitorcreations/streams/NExtractorsTest.java b/src/test/java/com/nitorcreations/streams/NExtractorsTest.java
index 194c22d..a10f462 100644
--- a/src/test/java/com/nitorcreations/streams/NExtractorsTest.java
+++ b/src/test/java/com/nitorcreations/streams/NExtractorsTest.java
@@ -23,10 +23,10 @@
 
 import static com.nitorcreations.streams.Fixture.linkedMap;
 import static com.nitorcreations.streams.NExtractors.*;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static java.util.Collections.emptyMap;
 import static java.util.function.Function.identity;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NExtractorsTest {
 
diff --git a/src/test/java/com/nitorcreations/streams/NMappersTest.java b/src/test/java/com/nitorcreations/streams/NMappersTest.java
index 03d5933..dbb579a 100644
--- a/src/test/java/com/nitorcreations/streams/NMappersTest.java
+++ b/src/test/java/com/nitorcreations/streams/NMappersTest.java
@@ -27,9 +27,9 @@
 import static com.nitorcreations.streams.Fixture.linkedMap;
 import static com.nitorcreations.streams.NCollectors.entriesToMap;
 import static com.nitorcreations.streams.NMappers.*;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static java.util.stream.Collectors.toList;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NMappersTest {
 
diff --git a/src/test/java/com/nitorcreations/streams/NStreamsTest.java b/src/test/java/com/nitorcreations/streams/NStreamsTest.java
index f88924a..79f070a 100644
--- a/src/test/java/com/nitorcreations/streams/NStreamsTest.java
+++ b/src/test/java/com/nitorcreations/streams/NStreamsTest.java
@@ -24,12 +24,14 @@
 import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Optional;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
 import static com.nitorcreations.streams.NStreams.asStream;
-import static com.nitorcreations.TestUtils.invokePrivateConstructor;
+import static com.nitorcreations.test.TestUtils.invokePrivateConstructor;
 import static java.util.Arrays.asList;
 import static java.util.stream.Collectors.toList;
-import static org.assertj.core.api.Assertions.assertThat;
+import static com.nitorcreations.test.Assertions.assertThat;
 
 public class NStreamsTest {
 
@@ -61,6 +63,12 @@ public void iteratorToStream() {
         assertThat(actual).containsExactlyElementsOf(list);
     }
 
+    @Test
+    public void nullToEmptyStream() {
+        final Stream<String> actual = asStream((Iterable<String>) null);
+        assertThat(actual.collect(Collectors.toList())).isEmpty();
+    }
+
     @Test
     public void iteratorToStream_parallel() {
         final List<Integer> actual = asStream(list.iterator(), true).collect(toList());
diff --git a/src/test/java/com/nitorcreations/test/Assertions.java b/src/test/java/com/nitorcreations/test/Assertions.java
new file mode 100644
index 0000000..be874e0
--- /dev/null
+++ b/src/test/java/com/nitorcreations/test/Assertions.java
@@ -0,0 +1,10 @@
+package com.nitorcreations.test;
+
+import java.util.function.Predicate;
+
+public class Assertions extends org.assertj.core.api.Assertions {
+
+    public static <T> PredicateAssert<T> assertThat(Predicate<T> predicate) {
+        return PredicateAssert.assertThat(predicate);
+    }
+}
diff --git a/src/test/java/com/nitorcreations/predicates/PredicateAssert.java b/src/test/java/com/nitorcreations/test/PredicateAssert.java
similarity index 91%
rename from src/test/java/com/nitorcreations/predicates/PredicateAssert.java
rename to src/test/java/com/nitorcreations/test/PredicateAssert.java
index 395bda6..0486abe 100644
--- a/src/test/java/com/nitorcreations/predicates/PredicateAssert.java
+++ b/src/test/java/com/nitorcreations/test/PredicateAssert.java
@@ -1,4 +1,4 @@
-package com.nitorcreations.predicates;
+package com.nitorcreations.test;
 
 import org.assertj.core.api.AbstractAssert;
 
@@ -11,11 +11,11 @@
 
 public class PredicateAssert<T> extends AbstractAssert<PredicateAssert<T>, Predicate<T>> {
 
-    public PredicateAssert(Predicate<T> actual) {
+    PredicateAssert(Predicate<T> actual) {
         super(actual, PredicateAssert.class);
     }
 
-    public static <T> PredicateAssert<T> assertThat(Predicate<T> predicate) {
+    static <T> PredicateAssert<T> assertThat(Predicate<T> predicate) {
         return new PredicateAssert<>(predicate);
     }
 
diff --git a/src/test/java/com/nitorcreations/TestUtils.java b/src/test/java/com/nitorcreations/test/TestUtils.java
similarity index 93%
rename from src/test/java/com/nitorcreations/TestUtils.java
rename to src/test/java/com/nitorcreations/test/TestUtils.java
index f356df2..7304ef0 100644
--- a/src/test/java/com/nitorcreations/TestUtils.java
+++ b/src/test/java/com/nitorcreations/test/TestUtils.java
@@ -1,4 +1,4 @@
-package com.nitorcreations;
+package com.nitorcreations.test;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;