diff --git a/src/main/java/org/assertj/core/api/AbstractIterableAssert.java b/src/main/java/org/assertj/core/api/AbstractIterableAssert.java
index f56aed463b..dc5eb14f82 100644
--- a/src/main/java/org/assertj/core/api/AbstractIterableAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractIterableAssert.java
@@ -139,7 +139,6 @@ protected static <T> Iterable<T> toLazyIterable(Iterator<T> actual) {
    * @return a new {@link AbstractListAssert}.
    */
   protected <E> AbstractListAssert<?, List<? extends E>, E, ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual) {
-    // this might not be the best implementation (SoftAssertion needs to override this).
     return new ListAssert<>(newActual);
   }
 
@@ -1355,7 +1354,7 @@ public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object
     List<Object> result = actualStream.flatMap(element -> Stream.of(extractors)
                                                                 .map(extractor -> extractor.extract(element)))
                                       .collect(Collectors.toList());
-    return new ListAssert<>(result);
+    return newListAssertInstance(result);
   }
 
   /**
@@ -1399,7 +1398,7 @@ public <EXCEPTION extends Exception> AbstractListAssert<?, List<? extends Object
     List<Object> result = actualStream.flatMap(element -> Stream.of(extractors)
                                                                 .map(extractor -> extractor.extract(element)))
                                       .collect(Collectors.toList());
-    return new ListAssert<>(result);
+    return newListAssertInstance(result);
   }
 
   /**
@@ -2077,9 +2076,11 @@ public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEM
    */
   @CheckReturnValue
   public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOnNull(String propertyOrFieldName) {
-    // need to cast nulll to Object otherwise it calls :
-    // filteredOn(String propertyOrFieldName, FilterOperation<?> filterOperation)
-    return filteredOn(propertyOrFieldName, (Object) null);
+    // can't call filteredOn(String propertyOrFieldName, null) as it does not work with soft assertions proxying
+    // mechanism, it would lead to double proxying which is not handle properly (improvements needed in our proxy mechanism)
+    Filters<? extends ELEMENT> filter = filter((Iterable<? extends ELEMENT>) actual);
+    Iterable<? extends ELEMENT> filteredIterable = filter.with(propertyOrFieldName, null).get();
+    return newListAssertInstance(newArrayList(filteredIterable));
   }
 
   /**
@@ -2234,6 +2235,8 @@ public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEM
    * // assertion fails
    * assertThat(hobbits, StringAssert.class).first()
    *                                        .startsWith("pip");</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    *
    * @return the assertion on the first element
    * @throws AssertionError if the actual {@link Iterable} is empty.
@@ -2281,6 +2284,8 @@ public ELEMENT_ASSERT first() {
    * // assertion fails
    * assertThat(hobbits, StringAssert.class).last()
    *                                        .startsWith("fro");</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    *
    * @return the assertion on the first element
    * @throws AssertionError if the actual {@link Iterable} is empty.
@@ -2341,6 +2346,8 @@ private ELEMENT lastElement() {
    * // assertion fails
    * assertThat(hobbits, StringAssert.class).element(1)
    *                                        .startsWith("fro");</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    *
    * @param index the element's index
    * @return the assertion on the given element
@@ -2401,7 +2408,7 @@ private static String removeAssert(String text) {
    */
   public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOn(Predicate<? super ELEMENT> predicate) {
     checkArgument(predicate != null, "The filter predicate should not be null");
-    return new ListAssert<>(stream(actual.spliterator(), false).filter(predicate).collect(toList()));
+    return newListAssertInstance(stream(actual.spliterator(), false).filter(predicate).collect(toList()));
   }
 
   /**
@@ -2680,6 +2687,8 @@ public SELF withThreadDumpOnError() {
    *
    * // assertion will fail:
    * assertThat(elvesRings).size().isGreaterThan(3);</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    *
    * @return AbstractIterableSizeAssert built with the {@code Iterable}'s size.
    * @throws NullPointerException if the given {@code Iterable} is {@code null}.
diff --git a/src/main/java/org/assertj/core/api/AbstractMapAssert.java b/src/main/java/org/assertj/core/api/AbstractMapAssert.java
index 26c8c49590..fa8cfa1ed8 100644
--- a/src/main/java/org/assertj/core/api/AbstractMapAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractMapAssert.java
@@ -13,7 +13,9 @@
 package org.assertj.core.api;
 
 import static org.assertj.core.data.MapEntry.entry;
+import static org.assertj.core.description.Description.mostRelevantDescription;
 import static org.assertj.core.extractor.Extractors.byName;
+import static org.assertj.core.extractor.Extractors.extractedDescriptionOf;
 import static org.assertj.core.util.Arrays.array;
 import static org.assertj.core.util.Arrays.isArray;
 import static org.assertj.core.util.IterableUtil.toCollection;
@@ -1191,6 +1193,8 @@ public SELF withThreadDumpOnError() {
    * 
    * // assertion will fail:
    * assertThat(ringBearers).size().isGreaterThan(5);</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    *
    * @return a {@link AbstractMapSizeAssert} to allow assertions on the the number of key-value mappings in this map
    * @throws NullPointerException if the given map is {@code null}.
@@ -1229,7 +1233,7 @@ public AbstractMapSizeAssert<SELF, ACTUAL, K, V> size() {
    */
   @CheckReturnValue
   @Override
-  public AbstractObjectArrayAssert<?, Object> extracting(String... keys) {
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(String... keys) {
     return super.extracting(keys);
   }
 
@@ -1255,7 +1259,7 @@ public AbstractObjectArrayAssert<?, Object> extracting(String... keys) {
    * assertThat(map).flatExtracting("name","job","city", "rank")
    *                .containsExactly("Dave", "Jeff", 
    *                                 "Plumber", "Builder", 
-   *                                 "Dover", "Boston", "Paris"
+   *                                 "Dover", "Boston", "Paris",
    *                                 1, 2, 3);
    *                
    * // the order of values in the resulting array is the order of map keys then key values:                
@@ -1279,10 +1283,12 @@ public AbstractObjectArrayAssert<?, Object> extracting(String... keys) {
    * @return a new assertion object whose object under test is the array containing the extracted flattened map values
    */
   @CheckReturnValue
-  public AbstractObjectArrayAssert<?, Object> flatExtracting(String... keys) {
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> flatExtracting(String... keys) {
     Tuple values = byName(keys).extract(actual);
     List<Object> valuesFlattened = flatten(values.toList());
-    return extracting(valuesFlattened, keys);
+    String extractedPropertiesOrFieldsDescription = extractedDescriptionOf(keys);
+    String description = mostRelevantDescription(info.description(), extractedPropertiesOrFieldsDescription);
+    return newListAssertInstance(valuesFlattened).as(description);
   }
 
   private static List<Object> flatten(Iterable<Object> collectionToFlatten) {
diff --git a/src/main/java/org/assertj/core/api/AbstractObjectArrayAssert.java b/src/main/java/org/assertj/core/api/AbstractObjectArrayAssert.java
index a37b8f542a..d41388c093 100644
--- a/src/main/java/org/assertj/core/api/AbstractObjectArrayAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractObjectArrayAssert.java
@@ -13,6 +13,7 @@
 package org.assertj.core.api;
 
 import static java.util.Arrays.stream;
+import static java.util.stream.Collectors.toList;
 import static org.assertj.core.api.filter.Filters.filter;
 import static org.assertj.core.description.Description.mostRelevantDescription;
 import static org.assertj.core.extractor.Extractors.byName;
@@ -65,7 +66,6 @@
 import org.assertj.core.internal.TypeComparators;
 import org.assertj.core.presentation.PredicateDescription;
 import org.assertj.core.util.CheckReturnValue;
-import org.assertj.core.util.IterableUtil;
 import org.assertj.core.util.VisibleForTesting;
 import org.assertj.core.util.introspection.IntrospectionError;
 
@@ -1821,8 +1821,8 @@ public SELF usingElementComparatorIgnoringFields(String... fields) {
   }
 
   /**
-   * Extract the values of given field or property from the array's elements under test into a new array, this new array
-   * becoming the array under test.
+   * Extract the values of given field or property from the array's elements under test into a new list, this new list
+   * becoming the object under test.
    * <p>
    * It allows you to test a field/property of the array's elements instead of testing the elements themselves, which can
    * be much less work !
@@ -1859,20 +1859,20 @@ public SELF usingElementComparatorIgnoringFields(String... fields) {
    * Note that the order of extracted field/property values is consistent with the array order.
    *
    * @param fieldOrProperty the field/property to extract from the array under test
-   * @return a new assertion object whose object under test is the array of extracted field/property values.
+   * @return a new assertion object whose object under test is the list of extracted field/property values.
    * @throws IntrospectionError if no field or property exists with the given name
    */
   @CheckReturnValue
-  public ObjectArrayAssert<Object> extracting(String fieldOrProperty) {
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(String fieldOrProperty) {
     Object[] values = FieldsOrPropertiesExtractor.extract(actual, byName(fieldOrProperty));
     String extractedDescription = extractedDescriptionOf(fieldOrProperty);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return new ObjectArrayAssert<>(values).as(description);
+    return newListAssertInstance(newArrayList(values)).as(description);
   }
 
   /**
-   * Extract the values of given field or property from the array's elements under test into a new array, this new array
-   * becoming the array under test with type.
+   * Extract the values of given field or property from the array's elements under test into a new list, this new list of the provided type
+   * becoming the object under test.
    * <p>
    * It allows you to test a field/property of the array's elements instead of testing the elements themselves, which can
    * be much less work !
@@ -1911,21 +1911,22 @@ public ObjectArrayAssert<Object> extracting(String fieldOrProperty) {
    * @param <P> the type of elements to extract.
    * @param fieldOrProperty the field/property to extract from the array under test
    * @param extractingType type to return
-   * @return a new assertion object whose object under test is the array of extracted field/property values.
+   * @return a new assertion object whose object under test is the list of extracted field/property values.
    * @throws IntrospectionError if no field or property exists with the given name
    */
   @CheckReturnValue
-  public <P> ObjectArrayAssert<P> extracting(String fieldOrProperty, Class<P> extractingType) {
+  public <P> AbstractListAssert<?, List<? extends P>, P, ObjectAssert<P>> extracting(String fieldOrProperty,
+                                                                                     Class<P> extractingType) {
     @SuppressWarnings("unchecked")
-    P[] values = (P[]) FieldsOrPropertiesExtractor.extract(actual, byName(fieldOrProperty));
+    List<P> values = (List<P>) FieldsOrPropertiesExtractor.extract(Arrays.asList(actual), byName(fieldOrProperty));
     String extractedDescription = extractedDescriptionOf(fieldOrProperty);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return new ObjectArrayAssert<>(values).as(description);
+    return newListAssertInstance(values).as(description);
   }
 
   /**
-   * Extract the values of given fields/properties from the array's elements under test into a new array composed of
-   * Tuple (a simple data structure), this new array becoming the array under test.
+   * Extract the values of given fields/properties from the array's elements under test into a list composed of
+   * Tuple (a simple data structure), this new list becoming the object under test.
    * <p>
    * It allows you to test fields/properties of the the array's elements instead of testing the elements themselves, it
    * can be sometimes much less work !
@@ -1970,26 +1971,22 @@ public <P> ObjectArrayAssert<P> extracting(String fieldOrProperty, Class<P> extr
    * test.
    *
    * @param propertiesOrFields the properties/fields to extract from the initial array under test
-   * @return a new assertion object whose object under test is the list of Tuple with extracted properties/fields values
-   *         as data.
-   * @throws IntrospectionError if one of the given name does not match a field or property in one of the initial
-   *         Iterable's element.
+   * @return a new assertion object whose object under test is the list of Tuple with extracted properties/fields values as data.
+   * @throws IntrospectionError if one of the given name does not match a field or property in one of the initial Iterable's element.
    */
   @CheckReturnValue
-  public ObjectArrayAssert<Tuple> extracting(String... propertiesOrFields) {
-    Object[] values = FieldsOrPropertiesExtractor.extract(actual, byName(propertiesOrFields));
-    Tuple[] result = Arrays.copyOf(values, values.length, Tuple[].class);
-    String extractedPropertiesOrFieldsDescription = extractedDescriptionOf(propertiesOrFields);
-    String description = mostRelevantDescription(info.description(), extractedPropertiesOrFieldsDescription);
-    return new ObjectArrayAssert<>(result).as(description);
+  public AbstractListAssert<?, List<? extends Tuple>, Tuple, ObjectAssert<Tuple>> extracting(String... propertiesOrFields) {
+    List<Tuple> values = FieldsOrPropertiesExtractor.extract(Arrays.asList(actual), byName(propertiesOrFields));
+    String extractedDescription = extractedDescriptionOf(propertiesOrFields);
+    String description = mostRelevantDescription(info.description(), extractedDescription);
+    return newListAssertInstance(values).as(description);
   }
 
   /**
-   * Extract the values from the array's elements by applying an extracting function on them. The returned
-   * array becomes a new object under test.
+   * Extract the values from the array's elements by applying an extracting function on them, the resulting list becomes  
+   * the new object under test.
    * <p>
-   * It allows to test values from the elements in safer way than by using {@link #extracting(String)}, as it
-   * doesn't utilize introspection.
+   * This method is similar to {@link #extracting(String)} but more refactoring friendly as it does not use introspection.
    * <p>
    * Let's take a look an example:
    * <pre><code class='java'> // Build a list of TolkienCharacter, a TolkienCharacter has a name, and age and a Race (a specific class)
@@ -2014,23 +2011,22 @@ public ObjectArrayAssert<Tuple> extracting(String... propertiesOrFields) {
    *
    * @param <U> the type of elements to extract.
    * @param extractor the object transforming input object to desired one
-   * @return a new assertion object whose object under test is the list of values extracted
+   * @return a new assertion object whose object under test is the list of extracted values. 
    */
   @CheckReturnValue
-  public <U> ObjectArrayAssert<U> extracting(Extractor<? super ELEMENT, U> extractor) {
-    U[] extracted = FieldsOrPropertiesExtractor.extract(actual, extractor);
-
-    return new ObjectArrayAssert<>(extracted);
+  public <U> AbstractListAssert<?, List<? extends U>, U, ObjectAssert<U>> extracting(Extractor<? super ELEMENT, U> extractor) {
+    List<U> values = FieldsOrPropertiesExtractor.extract(Arrays.asList(actual), extractor);
+    return newListAssertInstance(values);
   }
 
   /**
    * Extract the values from the array's elements by applying an extracting function (which might throw an exception)
-   * on them. The returned array becomes a new object under test.
+   * on them, the resulting list of extracted values becomes a new object under test.
    * <p>
    * Any checked exception raised in the extractor is rethrown wrapped in a {@link RuntimeException}.
    * <p>
    * It allows to test values from the elements in safer way than by using {@link #extracting(String)}, as it
-   * doesn't utilize introspection.
+   * doesn't use introspection.
    * <p>
    * Let's take a look an example:
    * <pre><code class='java'> // Build a list of TolkienCharacter, a TolkienCharacter has a name, and age and a Race (a specific class)
@@ -2052,26 +2048,24 @@ public <U> ObjectArrayAssert<U> extracting(Extractor<? super ELEMENT, U> extract
    *   }
    *   return input.getName();
    * }).contains("Frodo");</code></pre>
+   * <p>
+   * Note that the order of extracted property/field values is consistent with the iteration order of the array under test.
    *
-   * Note that the order of extracted property/field values is consistent with the iteration order of the Iterable under
-   * test, for example if it's a {@link HashSet}, you won't be able to make any assumptions on the extracted values
-   * order.
-   *
-   * @param <U> the type of elements to extract.
+   * @param <V> the type of elements to extract.
    * @param <EXCEPTION> the exception type of {@link ThrowingExtractor}
    * @param extractor the object transforming input object to desired one
-   * @return a new assertion object whose object under test is the list of values extracted
+   * @return a new assertion object whose object under test is the list of extracted values 
    * @since 3.7.0
    */
-  public <U, EXCEPTION extends Exception> ObjectArrayAssert<U> extracting(ThrowingExtractor<? super ELEMENT, U, EXCEPTION> extractor) {
-    U[] extracted = FieldsOrPropertiesExtractor.extract(actual, extractor);
-
-    return new ObjectArrayAssert<>(extracted);
+  @CheckReturnValue
+  public <V, EXCEPTION extends Exception> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> extracting(ThrowingExtractor<? super ELEMENT, V, EXCEPTION> extractor) {
+    List<V> values = FieldsOrPropertiesExtractor.extract(newArrayList(actual), extractor);
+    return newListAssertInstance(values);
   }
 
   /**
-   * Use the given {@link Function}s to extract the values from the array's elements into a new array
-   * composed of {@link Tuple}s (a simple data structure containing the extracted values), this new array becoming the
+   * Use the given {@link Function}s to extract the values from the array's elements into a new list
+   * composed of {@link Tuple}s (a simple data structure containing the extracted values), this new list becoming the
    * object under test.
    * <p>
    * It allows you to test values from the array's elements instead of testing the elements themselves, which sometimes can be
@@ -2079,8 +2073,7 @@ public <U, EXCEPTION extends Exception> ObjectArrayAssert<U> extracting(Throwing
    * <p>
    * The {@link Tuple} data corresponds to the extracted values from the arrays's elements, for instance if you pass functions
    * extracting "id", "name" and "email" values then each {@link Tuple}'s data will be composed of an id, a name and an email
-   * extracted from the element of the initial array (the Tuple's data order is the same as the given functions
-   * order).
+   * extracted from the element of the initial array (the Tuple's data order is the same as the given functions order).
    * <p>
    * Let's take a look at an example to make things clearer :
    * <pre><code class='java'> // Build an array of TolkienCharacter, a TolkienCharacter has a name (String) and a Race (a class)
@@ -2116,16 +2109,16 @@ public <U, EXCEPTION extends Exception> ObjectArrayAssert<U> extracting(Throwing
    * for example if it's a {@link HashSet}, you won't be able to make any assumptions on the extracted tuples order.
    *
    * @param extractors the extractor functions to extract a value from an element of the array under test.
-   * @return a new assertion object whose object under test is the array of Tuples containing the extracted values.
+   * @return a new assertion object whose object under test is the list of Tuples containing the extracted values.
    */
   @CheckReturnValue
-  public ObjectArrayAssert<Tuple> extracting(@SuppressWarnings("unchecked") Function<ELEMENT, ?>... extractors) {
+  public AbstractListAssert<?, List<? extends Tuple>, Tuple, ObjectAssert<Tuple>> extracting(@SuppressWarnings("unchecked") Function<ELEMENT, ?>... extractors) {
 
     Function<ELEMENT, Tuple> tupleExtractor = objectToExtractValueFrom -> new Tuple(Stream.of(extractors)
                                                                                           .map(extractor -> extractor.apply(objectToExtractValueFrom))
                                                                                           .toArray());
-    Tuple[] tuples = stream(actual).map(tupleExtractor).toArray(size -> new Tuple[size]);
-    return new ObjectArrayAssert<>(tuples);
+    List<Tuple> tuples = stream(actual).map(tupleExtractor).collect(toList());
+    return newListAssertInstance(tuples).as(info.description());
   }
 
   /**
@@ -2159,7 +2152,7 @@ public ObjectArrayAssert<Tuple> extracting(@SuppressWarnings("unchecked") Functi
    * @return a new assertion object whose object under test is the list of values extracted
    */
   @CheckReturnValue
-  public <U, C extends Collection<U>> ObjectArrayAssert<U> flatExtracting(Extractor<? super ELEMENT, C> extractor) {
+  public <V, C extends Collection<V>> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> flatExtracting(Extractor<? super ELEMENT, C> extractor) {
     return doFlatExtracting(extractor);
   }
 
@@ -2193,7 +2186,7 @@ public <U, C extends Collection<U>> ObjectArrayAssert<U> flatExtracting(Extracto
    * The order of extracted values is consisted with both the order of the collection itself, as well as the extracted
    * collections.
    *
-   * @param <U> the type of elements to extract.
+   * @param <V> the type of elements to extract.
    * @param <C> the type of collection to flat/extract.
    * @param <EXCEPTION> the exception type of {@link ThrowingExtractor}
    * @param extractor the object transforming input object to an Iterable of desired ones
@@ -2201,19 +2194,19 @@ public <U, C extends Collection<U>> ObjectArrayAssert<U> flatExtracting(Extracto
    * @since 3.7.0
    */
   @CheckReturnValue
-  public <U, C extends Collection<U>, EXCEPTION extends Exception> ObjectArrayAssert<U> flatExtracting(ThrowingExtractor<? super ELEMENT, C, EXCEPTION> extractor) {
+  public <V, C extends Collection<V>, EXCEPTION extends Exception> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> flatExtracting(ThrowingExtractor<? super ELEMENT, C, EXCEPTION> extractor) {
     return doFlatExtracting(extractor);
   }
 
-  private <U, C extends Collection<U>> ObjectArrayAssert<U> doFlatExtracting(Extractor<? super ELEMENT, C> extractor) {
+  private <V, C extends Collection<V>> AbstractListAssert<?, List<? extends V>, V, ObjectAssert<V>> doFlatExtracting(Extractor<? super ELEMENT, C> extractor) {
     final List<C> extractedValues = FieldsOrPropertiesExtractor.extract(Arrays.asList(actual), extractor);
 
-    final List<U> result = newArrayList();
+    final List<V> result = newArrayList();
     for (C e : extractedValues) {
       result.addAll(e);
     }
 
-    return new ObjectArrayAssert<>(IterableUtil.toArray(result));
+    return newListAssertInstance(result);
   }
 
   /**
@@ -2246,7 +2239,7 @@ private <U, C extends Collection<U>> ObjectArrayAssert<U> doFlatExtracting(Extra
    * @throws IllegalArgumentException if one of the extracted property value was not an array or an iterable.
    */
   @CheckReturnValue
-  public ObjectArrayAssert<Object> flatExtracting(String propertyName) {
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> flatExtracting(String propertyName) {
     List<Object> extractedValues = newArrayList();
     List<?> extractedGroups = FieldsOrPropertiesExtractor.extract(Arrays.asList(actual), byName(propertyName));
     for (Object group : extractedGroups) {
@@ -2265,12 +2258,12 @@ public ObjectArrayAssert<Object> flatExtracting(String propertyName) {
         CommonErrors.wrongElementTypeForFlatExtracting(group);
       }
     }
-    return new ObjectArrayAssert<>(extractedValues.toArray());
+    return newListAssertInstance(extractedValues);
   }
 
   /**
-   * Extract the result of given method invocation from the array's elements under test into a new array, this new array
-   * becoming the array under test.
+   * Extract the result of given method invocation from the array's elements under test into a list, this list becoming 
+   * the object under test.
    * <p>
    * It allows you to test a method results of the array's elements instead of testing the elements themselves, which can be
    * much less work!
@@ -2301,21 +2294,21 @@ public ObjectArrayAssert<Object> flatExtracting(String propertyName) {
    * Note that the order of extracted values is consistent with the order of the array under test.
    *
    * @param method the name of the method which result is to be extracted from the array under test
-   * @return a new assertion object whose object under test is the array of extracted values.
+   * @return a new assertion object whose object under test is the list of extracted values.
    * @throws IllegalArgumentException if no method exists with the given name, or method is not public, or method does
    *           return void, or method accepts arguments.
    */
   @CheckReturnValue
-  public ObjectArrayAssert<Object> extractingResultOf(String method) {
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extractingResultOf(String method) {
     Object[] values = FieldsOrPropertiesExtractor.extract(actual, resultOf(method));
     String extractedDescription = extractedDescriptionOfMethod(method);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return new ObjectArrayAssert<>(values).as(description);
+    return newListAssertInstance(newArrayList(values)).as(description);
   }
 
   /**
-   * Extract the result of given method invocation from the array's elements under test into a new array, this new array
-   * becoming the array under test.
+   * Extract the result of given method invocation from the array's elements under test into a list, this list becoming 
+   * the object under test.
    * <p>
    * It allows you to test a method results of the array's elements instead of testing the elements themselves, which can be
    * much less work!
@@ -2348,17 +2341,18 @@ public ObjectArrayAssert<Object> extractingResultOf(String method) {
    * @param <P> the type of elements extracted.
    * @param method the name of the method which result is to be extracted from the array under test
    * @param extractingType type to return
-   * @return a new assertion object whose object under test is the array of extracted values.
+   * @return a new assertion object whose object under test is the list of extracted values.
    * @throws IllegalArgumentException if no method exists with the given name, or method is not public, or method does
    *           return void, or method accepts arguments.
    */
   @CheckReturnValue
-  public <P> ObjectArrayAssert<P> extractingResultOf(String method, Class<P> extractingType) {
+  public <P> AbstractListAssert<?, List<? extends P>, P, ObjectAssert<P>> extractingResultOf(String method,
+                                                                                             Class<P> extractingType) {
     @SuppressWarnings("unchecked")
     P[] values = (P[]) FieldsOrPropertiesExtractor.extract(actual, resultOf(method));
     String extractedDescription = extractedDescriptionOfMethod(method);
     String description = mostRelevantDescription(info.description(), extractedDescription);
-    return new ObjectArrayAssert<>(values).as(description);
+    return newListAssertInstance(newArrayList(values)).as(description);
   }
 
   /**
@@ -2401,8 +2395,8 @@ public SELF inBinary() {
   }
 
   /**
-   * Filter the array under test keeping only elements having a property or field equal to {@code expectedValue}, the
-   * property/field is specified by {@code propertyOrFieldName} parameter.
+   * Filter the array under test into a list composed of the elements elements having a property or field equal to 
+   * {@code expectedValue}, the property/field is specified by {@code propertyOrFieldName} parameter.
    * <p>
    * The filter first tries to get the value from a property (named {@code propertyOrFieldName}), if no such property
    * exists it tries to read the value from a field. Reading private fields is supported by default, this can be
@@ -2447,26 +2441,28 @@ public SELF inBinary() {
    * assertThat(fellowshipOfTheRing).filteredOn("race.name", "Man")
    *                                .filteredOn("name", not("Boromir"))
    *                                .containsOnly(aragorn);</code></pre>
-   * If you need more complex filter, use {@link #filteredOn(Condition)} and provide a {@link Condition} to specify the
-   * filter to apply.
+   * <p>
+   * If you need more complex filter, use {@link #filteredOn(Condition)} or {@link #filteredOn(Predicate)} and 
+   * provide a {@link Condition} or {@link Predicate} to specify the filter to apply.
    *
    * @param propertyOrFieldName the name of the property or field to read
    * @param expectedValue the value to compare element's property or field with
-   * @return a new assertion object with the filtered array under test
+   * @return a new assertion object with the filtered list under test
    * @throws IllegalArgumentException if the given propertyOrFieldName is {@code null} or empty.
    * @throws IntrospectionError if the given propertyOrFieldName can't be found in one of the array elements.
    */
-  @SuppressWarnings("unchecked")
   @CheckReturnValue
-  public SELF filteredOn(String propertyOrFieldName, Object expectedValue) {
+  public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOn(String propertyOrFieldName,
+                                                                                                   Object expectedValue) {
     Iterable<? extends ELEMENT> filteredIterable = filter(actual).with(propertyOrFieldName, expectedValue).get();
-    return (SELF) new ObjectArrayAssert<>(toArray(filteredIterable));
+    return newListAssertInstance(newArrayList(filteredIterable));
   }
 
   /**
-   * Filter the array under test keeping only elements whose property or field specified by {@code propertyOrFieldName}
-   * is null.
+   * Filter the array under test into a list composed of the elements whose property or field specified 
+   * by {@code propertyOrFieldName} are null.
    * <p>
+   * The filter first tries to get the value from a property (named {@code propertyOrFieldName}), if no such property
    * exists it tries to read the value from a field. Reading private fields is supported by default, this can be
    * globally disabled by calling {@link Assertions#setAllowExtractingPrivateFields(boolean)
    * Assertions.setAllowExtractingPrivateFields(false)}.
@@ -2493,23 +2489,21 @@ public SELF filteredOn(String propertyOrFieldName, Object expectedValue) {
    *
    * An {@link IntrospectionError} is thrown if the given propertyOrFieldName can't be found in one of the array
    * elements.
-   * <p>
-   * If you need more complex filter, use {@link #filteredOn(Condition)} and provide a {@link Condition} to specify the
-   * filter to apply.
    *
    * @param propertyOrFieldName the name of the property or field to read
-   * @return a new assertion object with the filtered array under test
+   * @return a new assertion object with the filtered list under test
    * @throws IntrospectionError if the given propertyOrFieldName can't be found in one of the array elements.
    */
   @CheckReturnValue
-  public SELF filteredOnNull(String propertyOrFieldName) {
-    // need to cast nulll to Object otherwise it calls :
-    // filteredOn(String propertyOrFieldName, FilterOperation<?> filterOperation)
-    return filteredOn(propertyOrFieldName, (Object) null);
+  public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOnNull(String propertyOrFieldName) {
+    // can't call filteredOn(String propertyOrFieldName, null) as it does not work with soft assertions proxying
+    // mechanism, it would lead to double proxying which is not handle properly (improvements needed in our proxy mechanism)
+    Iterable<? extends ELEMENT> filteredIterable = filter(actual).with(propertyOrFieldName, null).get();
+    return newListAssertInstance(newArrayList(filteredIterable));
   }
 
   /**
-   * Filter the array under test keeping only elements having a property or field matching the filter expressed with
+   * Filter the array under test into a list composed of elements having a property or field matching the filter expressed with
    * the {@link FilterOperator}, the property/field is specified by {@code propertyOrFieldName} parameter.
    * <p>
    * The existing filters are :
@@ -2527,7 +2521,6 @@ public SELF filteredOnNull(String propertyOrFieldName) {
    * When reading <b>nested</b> property/field, if an intermediate value is null the whole nested property/field is
    * considered to be null, thus reading "address.street.name" value will return null if "street" value is null.
    * <p>
-   *
    * As an example, let's check stuff on some special employees :
    * <pre><code class='java'> Employee yoda   = new Employee(1L, new Name("Yoda"), 800);
    * Employee obiwan = new Employee(2L, new Name("Obiwan"), 800);
@@ -2564,26 +2557,27 @@ public SELF filteredOnNull(String propertyOrFieldName) {
    * assertThat(fellowshipOfTheRing).filteredOn("race.name", "Man")
    *                                .filteredOn("name", not("Boromir"))
    *                                .containsOnly(aragorn);</code></pre>
-   *
-   * If you need more complex filter, use {@link #filteredOn(Condition)} and provide a {@link Condition} to specify the
-   * filter to apply.
+   * <p>
+   * If you need more complex filter, use {@link #filteredOn(Condition)} or {@link #filteredOn(Predicate)} and 
+   * provide a {@link Condition} or {@link Predicate} to specify the filter to apply.
    *
    * @param propertyOrFieldName the name of the property or field to read
    * @param filterOperator the filter operator to apply
-   * @return a new assertion object with the filtered array under test
+   * @return a new assertion object with the filtered list under test
    * @throws IllegalArgumentException if the given propertyOrFieldName is {@code null} or empty.
    */
-  @SuppressWarnings("unchecked")
   @CheckReturnValue
-  public SELF filteredOn(String propertyOrFieldName, FilterOperator<?> filterOperator) {
+  public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOn(String propertyOrFieldName,
+                                                                                                   FilterOperator<?> filterOperator) {
     checkNotNull(filterOperator);
     Filters<? extends ELEMENT> filter = filter(actual).with(propertyOrFieldName);
     filterOperator.applyOn(filter);
-    return (SELF) new ObjectArrayAssert<>(toArray(filter.get()));
+    return newListAssertInstance(newArrayList(filter.get()));
   }
 
   /**
-   * Filter the array under test keeping only elements matching the given {@link Condition}.
+   * Filter the array under test into a list composed of the elements matching the given {@link Condition}, 
+   * allowing to perform assertions on the filtered list.
    * <p>
    * Let's check old employees whose age &gt; 100:
    * <pre><code class='java'> Employee yoda   = new Employee(1L, new Name("Yoda"), 800);
@@ -2611,18 +2605,18 @@ public SELF filteredOn(String propertyOrFieldName, FilterOperator<?> filterOpera
    *                      .contains(luke, noname);</code></pre>
    *
    * @param condition the filter condition / predicate
-   * @return a new assertion object with the filtered array under test
+   * @return a new assertion object with the filtered list under test
    * @throws IllegalArgumentException if the given condition is {@code null}.
    */
-  @SuppressWarnings("unchecked")
   @CheckReturnValue
-  public SELF filteredOn(Condition<? super ELEMENT> condition) {
+  public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOn(Condition<? super ELEMENT> condition) {
     Iterable<? extends ELEMENT> filteredIterable = filter(actual).being(condition).get();
-    return (SELF) new ObjectArrayAssert<>(toArray(filteredIterable));
+    return newListAssertInstance(newArrayList(filteredIterable));
   }
 
   /**
-   * Filter the iterable under test keeping only elements matching the given {@link Predicate}.
+   * Filter the array under test into a list composed of the elements matching the given {@link Predicate}, 
+   * allowing to perform assertions on the filtered list.
    * <p>
    * Example : check old employees whose age &gt; 100:
    *
@@ -2636,13 +2630,13 @@ public SELF filteredOn(Condition<? super ELEMENT> condition) {
    *                      .containsOnly(yoda, obiwan);</code></pre>
    *
    * @param predicate the filter predicate
-   * @return a new assertion object with the filtered array under test
+   * @return a new assertion object with the filtered list under test
    * @throws IllegalArgumentException if the given predicate is {@code null}.
    */
-  @SuppressWarnings("unchecked")
-  public SELF filteredOn(Predicate<? super ELEMENT> predicate) {
+  public AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> filteredOn(Predicate<? super ELEMENT> predicate) {
     checkArgument(predicate != null, "The filter predicate should not be null");
-    return (SELF) new ObjectArrayAssert<>(stream(actual).filter(predicate).toArray());
+    List<ELEMENT> filtered = stream(actual).filter(predicate).collect(toList());
+    return newListAssertInstance(filtered);
   }
 
   /**
@@ -2848,4 +2842,21 @@ public SELF noneMatch(Predicate<? super ELEMENT> predicate) {
     iterables.assertNoneMatch(info, newArrayList(actual), predicate, PredicateDescription.GIVEN);
     return myself;
   }
+
+  /**
+   * Create a friendly soft or "hard" assertion.
+   * <p>
+   * Implementations need to redefine it so that some methods, such as {@link #extracting(Extractor)}, are able
+   * to build the appropriate list assert (eg: {@link ListAssert} versus {@link ProxyableListAssert}).
+   * <p>
+   * The default implementation will assume that this concrete implementation is NOT a soft assertion.
+   *
+   * @param <E> the type of elements.
+   * @param newActual new value
+   * @return a new {@link AbstractListAssert}.
+   */
+  protected <E> AbstractListAssert<?, List<? extends E>, E, ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual) {
+    return new ListAssert<>(newActual);
+  }
+
 }
diff --git a/src/main/java/org/assertj/core/api/AbstractObjectAssert.java b/src/main/java/org/assertj/core/api/AbstractObjectAssert.java
index 01dc1a4ff0..f8d504c759 100644
--- a/src/main/java/org/assertj/core/api/AbstractObjectAssert.java
+++ b/src/main/java/org/assertj/core/api/AbstractObjectAssert.java
@@ -23,8 +23,10 @@
 import java.util.Map;
 import java.util.TreeMap;
 import java.util.function.Function;
+import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import org.assertj.core.api.iterable.Extractor;
 import org.assertj.core.description.Description;
 import org.assertj.core.groups.Tuple;
 import org.assertj.core.internal.TypeComparators;
@@ -506,11 +508,11 @@ public SELF hasFieldOrPropertyWithValue(String name, Object value) {
   }
 
   /**
-   * Extract the values of given fields/properties from the object under test into an array, this new array becoming
+   * Extract the values of given fields/properties from the object under test into a list, this new list becoming
    * the object under test.
    * <p>
-   * If you extract "id", "name" and "email" fields/properties then the array will contain the id, name and email values
-   * of the object under test, you can then perform array assertions on the extracted values.
+   * If you extract "id", "name" and "email" fields/properties then the list will contain the id, name and email values
+   * of the object under test, you can then perform list assertions on the extracted values.
    * <p>
    * Nested fields/properties are supported, specifying "adress.street.number" is equivalent to get the value
    * corresponding to actual.getAdress().getStreet().getNumber()
@@ -528,33 +530,28 @@ public SELF hasFieldOrPropertyWithValue(String name, Object value) {
    *                  .containsExactly(&quot;Frodo&quot;, 33, "Hobbit");</code></pre>
    *
    * A property with the given name is looked for first, if it doesn't exist then a field with the given name is looked
-   * for, if the field is not accessible (i.e. does not exist) an IntrospectionError is thrown.
+   * for, if the field is not accessible (i.e. does not exist) an {@link IntrospectionError} is thrown.
    * <p>
-   * Note that the order of extracted property/field values is consistent with the iteration order of the array under
-   * test.
+   * Note that the order of extracted values is consistent with the order of the given property/field.
    *
    * @param propertiesOrFields the properties/fields to extract from the initial object under test
-   * @return a new assertion object whose object under test is the array containing the extracted properties/fields values
+   * @return a new assertion object whose object under test is the list containing the extracted properties/fields values
    * @throws IntrospectionError if one of the given name does not match a field or property
    */
   @CheckReturnValue
-  public AbstractObjectArrayAssert<?, Object> extracting(String... propertiesOrFields) {
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(String... propertiesOrFields) {
     Tuple values = byName(propertiesOrFields).extract(actual);
-    return extracting(values.toList(), propertiesOrFields);
-  }
-
-  AbstractObjectArrayAssert<?, Object> extracting(List<Object> values, String... propertiesOrFields) {
     String extractedPropertiesOrFieldsDescription = extractedDescriptionOf(propertiesOrFields);
     String description = mostRelevantDescription(info.description(), extractedPropertiesOrFieldsDescription);
-    return new ObjectArrayAssert<>(values.toArray()).as(description);
+    return newListAssertInstance(values.toList()).as(description);
   }
 
   /**
-   * Use the given {@link Function}s to extract the values from the object under test into an array, this new array becoming
+   * Use the given {@link Function}s to extract the values from the object under test into a list, this new list becoming 
    * the object under test. 
    * <p>
-   * If the given {@link Function}s extract the id, name and email values then the array will contain the id, name and email values 
-   * of the object under test, you can then perform array assertions on the extracted values.
+   * If the given {@link Function}s extract the id, name and email values then the list will contain the id, name and email values 
+   * of the object under test, you can then perform list assertions on the extracted values.
    * <p>
    * Example:
    * <pre><code class='java'> // Create frodo, setting its name, age and Race (Race having a name property)
@@ -566,17 +563,17 @@ AbstractObjectArrayAssert<?, Object> extracting(List<Object> values, String... p
    *                              character -&gt; character.getRace().getName())
    *                  .containsExactly(&quot;Frodo&quot;, 33, "Hobbit");</code></pre>
    * <p>
-   * Note that the order of extracted values is consistent with the iteration order of the array under test.
+   * Note that the order of extracted values is consistent with the order of given extractor functions.
    *
    * @param extractors the extractor functions to extract a value from an element of the Iterable under test.
-   * @return a new assertion object whose object under test is the array containing the extracted values
+   * @return a new assertion object whose object under test is the list containing the extracted values
    */
   @CheckReturnValue
-  public AbstractObjectArrayAssert<?, Object> extracting(@SuppressWarnings("unchecked") Function<? super ACTUAL, Object>... extractors) {
-    Object[] values = Stream.of(extractors)
-                            .map(extractor -> extractor.apply(actual))
-                            .toArray();
-    return new ObjectArrayAssert<>(values);
+  public AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(@SuppressWarnings("unchecked") Function<? super ACTUAL, Object>... extractors) {
+    List<Object> values = Stream.of(extractors)
+                                .map(extractor -> extractor.apply(actual))
+                                .collect(Collectors.toList());
+    return newListAssertInstance(values).as(info.description());
   }
 
   /**
@@ -677,4 +674,21 @@ public <T> SELF returns(T expected, Function<ACTUAL, T> from) {
     objects.assertEqual(info, from.apply(actual), expected);
     return myself;
   }
+
+  /**
+   * Create a friendly soft or "hard" assertion.
+   * <p>
+   * Implementations need to redefine it so that some methods, such as {@link #extracting(Extractor)}, are able
+   * to build the appropriate list assert (eg: {@link ListAssert} versus {@link ProxyableListAssert}).
+   * <p>
+   * The default implementation will assume that this concrete implementation is NOT a soft assertion.
+   *
+   * @param <E> the type of elements.
+   * @param newActual new value
+   * @return a new {@link AbstractListAssert}.
+   */
+  protected <E> AbstractListAssert<?, List<? extends E>, E, ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual) {
+    return new ListAssert<>(newActual);
+  }
+
 }
diff --git a/src/main/java/org/assertj/core/api/Assert.java b/src/main/java/org/assertj/core/api/Assert.java
index f066a9409e..24fca628fe 100644
--- a/src/main/java/org/assertj/core/api/Assert.java
+++ b/src/main/java/org/assertj/core/api/Assert.java
@@ -537,6 +537,8 @@ public interface Assert<SELF extends Assert<SELF, ACTUAL>, ACTUAL> extends Descr
    * 
    * // assertion will fail
    * assertThat(unsortedListAsObject).asList().isSorted();</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    * 
    * @return a list assertion object
    */
@@ -555,6 +557,8 @@ public interface Assert<SELF extends Assert<SELF, ACTUAL>, ACTUAL> extends Descr
    * 
    * // assertion will fail
    * assertThat(stringAsObject).asString().contains("holla");</code></pre>
+   * <p>
+   * <b>Warning: this method does not work with soft assertions or assumptions.</b> 
    * 
    * @return a string assertion object
    */
diff --git a/src/main/java/org/assertj/core/api/Assertions.java b/src/main/java/org/assertj/core/api/Assertions.java
index 3c086d1c50..5b9d2b2c52 100644
--- a/src/main/java/org/assertj/core/api/Assertions.java
+++ b/src/main/java/org/assertj/core/api/Assertions.java
@@ -415,7 +415,7 @@ public static AbstractCharacterAssert<?> assertThat(Character actual) {
    * @return the created assertion object.
    */
   @CheckReturnValue
-  public static AbstractClassAssert<?> assertThat(Class<?> actual) {
+  public static ClassAssert assertThat(Class<?> actual) {
     return AssertionsForClassTypes.assertThat(actual);
   }
 
diff --git a/src/main/java/org/assertj/core/api/AssertionsForClassTypes.java b/src/main/java/org/assertj/core/api/AssertionsForClassTypes.java
index 7e0c19859b..72dfe838a1 100644
--- a/src/main/java/org/assertj/core/api/AssertionsForClassTypes.java
+++ b/src/main/java/org/assertj/core/api/AssertionsForClassTypes.java
@@ -272,7 +272,7 @@ public static AbstractCharacterAssert<?> assertThat(Character actual) {
    * @return the created assertion object.
    */
   @CheckReturnValue
-  public static AbstractClassAssert<?> assertThat(Class<?> actual) {
+  public static ClassAssert assertThat(Class<?> actual) {
     return new ClassAssert(actual);
   }
 
diff --git a/src/main/java/org/assertj/core/api/Assumptions.java b/src/main/java/org/assertj/core/api/Assumptions.java
index 8e9c6f194a..6bc8326911 100644
--- a/src/main/java/org/assertj/core/api/Assumptions.java
+++ b/src/main/java/org/assertj/core/api/Assumptions.java
@@ -12,7 +12,6 @@
  */
 package org.assertj.core.api;
 
-import static net.bytebuddy.matcher.ElementMatchers.any;
 import static org.assertj.core.api.Assertions.catchThrowable;
 import static org.assertj.core.util.Arrays.array;
 
@@ -76,6 +75,7 @@
 import net.bytebuddy.implementation.bind.annotation.RuntimeType;
 import net.bytebuddy.implementation.bind.annotation.SuperCall;
 import net.bytebuddy.implementation.bind.annotation.This;
+import net.bytebuddy.matcher.ElementMatchers;
 
 /**
  * Entry point for assumption methods for different types, which allow to skip test execution on failed assumptions.
@@ -1150,8 +1150,9 @@ private static <ASSERTION> ASSERTION asAssumption(final Class<ASSERTION> asserti
   }
 
   private static <ASSERTION> Class<? extends ASSERTION> createAssumption(Class<ASSERTION> assertionType) {
+    // TODO ignore special methods like extracting ?
     return new ByteBuddy().subclass(assertionType)
-                          .method(any())
+                          .method(ElementMatchers.any())
                           .intercept(MethodDelegation.to(new AssumptionMethodInterceptor()))
                           .make()
                           .load(Assumptions.class.getClassLoader())
@@ -1191,8 +1192,9 @@ private static Object asAssumption(AbstractAssert<?, ?> assertion) {
     if (assertion instanceof FactoryBasedNavigableListAssert) {
       return asAssumption(ProxyableListAssert.class, List.class, actual);
     }
-    if (assertion instanceof ObjectArrayAssert) return asAssumption(ObjectArrayAssert.class, Object[].class, actual);
-    if (assertion instanceof IterableSizeAssert) {
+    if (assertion instanceof AbstractObjectArrayAssert)
+      return asAssumption(ProxyableObjectArrayAssert.class, Object[].class, actual);
+    if (assertion instanceof IterableSizeAssert) { // TODO should likely return a proxyable class
       @SuppressWarnings("rawtypes")
       IterableSizeAssert iterableSizeAssert = (IterableSizeAssert) assertion;
       Class<?>[] constructorTypes = array(AbstractIterableAssert.class, Integer.class);
diff --git a/src/main/java/org/assertj/core/api/BDDAssertions.java b/src/main/java/org/assertj/core/api/BDDAssertions.java
index 550d3eb591..c558153faf 100644
--- a/src/main/java/org/assertj/core/api/BDDAssertions.java
+++ b/src/main/java/org/assertj/core/api/BDDAssertions.java
@@ -326,7 +326,7 @@ public static AbstractCharacterAssert<?> then(Character actual) {
    * @return the created assertion object.
    */
   @CheckReturnValue
-  public static AbstractClassAssert<?> then(Class<?> actual) {
+  public static ClassAssert then(Class<?> actual) {
     return assertThat(actual);
   }
 
diff --git a/src/main/java/org/assertj/core/api/MapAssert.java b/src/main/java/org/assertj/core/api/MapAssert.java
index 431b76ac84..268d8e56ba 100644
--- a/src/main/java/org/assertj/core/api/MapAssert.java
+++ b/src/main/java/org/assertj/core/api/MapAssert.java
@@ -89,4 +89,5 @@ public final MapAssert<KEY, VALUE> doesNotContainKeys(KEY... keys) {
   public final MapAssert<KEY, VALUE> doesNotContain(Map.Entry<? extends KEY, ? extends VALUE>... entries) {
     return super.doesNotContain(entries);
   }
+
 }
diff --git a/src/main/java/org/assertj/core/api/ObjectArrayAssert.java b/src/main/java/org/assertj/core/api/ObjectArrayAssert.java
index 33652ff9e7..adbc11f16c 100644
--- a/src/main/java/org/assertj/core/api/ObjectArrayAssert.java
+++ b/src/main/java/org/assertj/core/api/ObjectArrayAssert.java
@@ -14,6 +14,7 @@
 
 import static org.assertj.core.util.Arrays.array;
 
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReferenceArray;
 import java.util.function.Function;
 
@@ -45,8 +46,86 @@ public ObjectArrayAssert(AtomicReferenceArray<ELEMENT> actual) {
 
   @Override
   @SafeVarargs
-  public final ObjectArrayAssert<Tuple> extracting(Function<ELEMENT, ?>... extractors) {
+  public final AbstractListAssert<?, List<? extends Tuple>, Tuple, ObjectAssert<Tuple>> extracting(Function<ELEMENT, ?>... extractors) {
     return super.extracting(extractors);
   }
 
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> contains(ELEMENT... values) {
+    return super.contains(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsOnly(ELEMENT... values) {
+    return super.containsOnly(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsOnlyOnce(ELEMENT... values) {
+    return super.containsOnlyOnce(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsExactly(ELEMENT... values) {
+    return super.containsExactly(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsExactlyInAnyOrder(ELEMENT... values) {
+    return super.containsExactlyInAnyOrder(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsAnyOf(ELEMENT... values) {
+    return super.containsAnyOf(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> isSubsetOf(ELEMENT... values) {
+    return super.isSubsetOf(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsSequence(ELEMENT... sequence) {
+    return super.containsSequence(sequence);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> doesNotContainSequence(ELEMENT... sequence) {
+    return super.doesNotContainSequence(sequence);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> containsSubsequence(ELEMENT... sequence) {
+    return super.containsSubsequence(sequence);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> doesNotContainSubsequence(ELEMENT... sequence) {
+    return super.doesNotContainSubsequence(sequence);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> doesNotContain(ELEMENT... values) {
+    return super.doesNotContain(values);
+  }
+
+  @Override
+  @SafeVarargs
+  public final ObjectArrayAssert<ELEMENT> endsWith(ELEMENT first, ELEMENT... rest) {
+    return super.endsWith(first, rest);
+  }
+
 }
diff --git a/src/main/java/org/assertj/core/api/ObjectAssert.java b/src/main/java/org/assertj/core/api/ObjectAssert.java
index ad07d14997..95a3d094fe 100644
--- a/src/main/java/org/assertj/core/api/ObjectAssert.java
+++ b/src/main/java/org/assertj/core/api/ObjectAssert.java
@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api;
 
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
 
@@ -42,7 +43,7 @@ public ObjectAssert(AtomicReference<ACTUAL> actual) {
   @Override
   @CheckReturnValue
   @SafeVarargs
-  public final AbstractObjectArrayAssert<?, Object> extracting(Function<? super ACTUAL, Object>... extractors) {
+  public final AbstractListAssert<?, List<? extends Object>, Object, ObjectAssert<Object>> extracting(Function<? super ACTUAL, Object>... extractors) {
     return super.extracting(extractors);
   }
 
diff --git a/src/main/java/org/assertj/core/api/ProxyableMapAssert.java b/src/main/java/org/assertj/core/api/ProxyableMapAssert.java
index 8efe8cdbf4..93a7d9d704 100644
--- a/src/main/java/org/assertj/core/api/ProxyableMapAssert.java
+++ b/src/main/java/org/assertj/core/api/ProxyableMapAssert.java
@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api;
 
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -23,4 +24,9 @@ public ProxyableMapAssert(Map<KEY, VALUE> actual) {
     super(actual, ProxyableMapAssert.class);
   }
 
+  @Override
+  protected <ELEMENT> AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> newListAssertInstance(List<? extends ELEMENT> newActual) {
+    return new ProxyableListAssert<>(newActual);
+  }
+
 }
diff --git a/src/main/java/org/assertj/core/api/ProxyableObjectArrayAssert.java b/src/main/java/org/assertj/core/api/ProxyableObjectArrayAssert.java
index 088e3414d5..51b0f4b203 100644
--- a/src/main/java/org/assertj/core/api/ProxyableObjectArrayAssert.java
+++ b/src/main/java/org/assertj/core/api/ProxyableObjectArrayAssert.java
@@ -14,6 +14,7 @@
 
 import static org.assertj.core.util.Arrays.array;
 
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReferenceArray;
 
 /**
@@ -29,4 +30,9 @@ public ProxyableObjectArrayAssert(AtomicReferenceArray<ELEMENT> actual) {
     this(array(actual));
   }
 
+  @Override
+  protected <E> AbstractListAssert<?, List<? extends E>, E, ObjectAssert<E>> newListAssertInstance(List<? extends E> newActual) {
+    return new ProxyableListAssert<>(newActual);
+  }
+
 }
diff --git a/src/main/java/org/assertj/core/api/ProxyableObjectAssert.java b/src/main/java/org/assertj/core/api/ProxyableObjectAssert.java
index b0991d7e6f..8cba1760a9 100644
--- a/src/main/java/org/assertj/core/api/ProxyableObjectAssert.java
+++ b/src/main/java/org/assertj/core/api/ProxyableObjectAssert.java
@@ -12,6 +12,7 @@
  */
 package org.assertj.core.api;
 
+import java.util.List;
 import java.util.concurrent.atomic.AtomicReference;
 
 /**
@@ -27,4 +28,9 @@ public ProxyableObjectAssert(AtomicReference<ACTUAL> actual) {
     this(actual == null ? null: actual.get());
   }
 
+  @Override
+  protected <ELEMENT> AbstractListAssert<?, List<? extends ELEMENT>, ELEMENT, ObjectAssert<ELEMENT>> newListAssertInstance(List<? extends ELEMENT> newActual) {
+    return new ProxyableListAssert<>(newActual);
+  }
+
 }
diff --git a/src/main/java/org/assertj/core/api/SoftProxies.java b/src/main/java/org/assertj/core/api/SoftProxies.java
index f2eabee25b..5e36aac1bf 100644
--- a/src/main/java/org/assertj/core/api/SoftProxies.java
+++ b/src/main/java/org/assertj/core/api/SoftProxies.java
@@ -44,9 +44,9 @@ List<Throwable> errorsCollected() {
   <V, T> V create(final Class<V> assertClass, Class<T> actualClass, T actual) {
 
     try {
-      Class<V> proxyClass = (Class<V>) cache
-                                            .findOrInsert(getClass().getClassLoader(), new SimpleKey(assertClass),
-                                                          () -> createProxy(assertClass, collector));
+      ClassLoader classLoader = getClass().getClassLoader();
+      SimpleKey key = new SimpleKey(assertClass);
+      Class<V> proxyClass = (Class<V>) cache.findOrInsert(classLoader, key, () -> createProxy(assertClass, collector));
 
       Constructor<? extends V> constructor = proxyClass.getConstructor(actualClass);
       return constructor.newInstance(actual);
diff --git a/src/main/java/org/assertj/core/api/WithAssertions.java b/src/main/java/org/assertj/core/api/WithAssertions.java
index 429108ba0c..a8d3660528 100644
--- a/src/main/java/org/assertj/core/api/WithAssertions.java
+++ b/src/main/java/org/assertj/core/api/WithAssertions.java
@@ -593,7 +593,7 @@ default AbstractShortAssert<?> assertThat(final Short actual) {
    * @return the created assertion object.
    */
   @CheckReturnValue
-  default AbstractClassAssert<?> assertThat(final Class<?> actual) {
+  default ClassAssert assertThat(final Class<?> actual) {
     return Assertions.assertThat(actual);
   }
 
diff --git a/src/test/java/org/assertj/core/api/BDDSoftAssertionsTest.java b/src/test/java/org/assertj/core/api/BDDSoftAssertionsTest.java
index ff74df2899..5544171577 100644
--- a/src/test/java/org/assertj/core/api/BDDSoftAssertionsTest.java
+++ b/src/test/java/org/assertj/core/api/BDDSoftAssertionsTest.java
@@ -19,6 +19,7 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.entry;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.in;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.assertj.core.api.SoftAssertions.assertSoftly;
 import static org.assertj.core.test.Maps.mapOf;
@@ -35,7 +36,9 @@
 import java.time.LocalTime;
 import java.time.OffsetTime;
 import java.time.ZoneOffset;
+import java.util.Collection;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -54,6 +57,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.atomic.AtomicReferenceArray;
 import java.util.function.DoublePredicate;
+import java.util.function.Function;
 import java.util.function.IntPredicate;
 import java.util.function.LongPredicate;
 import java.util.function.Predicate;
@@ -66,6 +70,8 @@
 import org.assertj.core.api.ClassAssertBaseTest.AnotherAnnotation;
 import org.assertj.core.api.ClassAssertBaseTest.MyAnnotation;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.assertj.core.api.iterable.Extractor;
+import org.assertj.core.api.iterable.ThrowingExtractor;
 import org.assertj.core.api.test.ComparableExample;
 import org.assertj.core.data.MapEntry;
 import org.assertj.core.test.CartoonCharacter;
@@ -85,6 +91,17 @@ public class BDDSoftAssertionsTest extends BaseAssertionsTest {
   private CartoonCharacter maggie;
   private CartoonCharacter bart;
 
+  private Map<String, Object> iterableMap;
+
+  private ThrowingExtractor<Name, String, Exception> throwingFirstNameExtractor;
+  private ThrowingExtractor<Name, String, Exception> throwingLastNameExtractor;
+  private Extractor<Name, String> firstNameExtractor;
+  private Extractor<Name, String> lastNameExtractor;
+  private Function<Name, String> firstNameFunction;
+  private Function<Name, String> lastNameFunction;
+
+  private Extractor<? super CartoonCharacter, ? extends Collection<CartoonCharacter>> childrenExtractor;
+
   @Before
   public void setup() {
     softly = new BDDSoftAssertions();
@@ -101,6 +118,26 @@ public void setup() {
     CartoonCharacter pebbles = new CartoonCharacter("Pebbles Flintstone");
     fred = new CartoonCharacter("Fred Flintstone");
     fred.getChildren().add(pebbles);
+
+    List<String> names = asList("Dave", "Jeff");
+    LinkedHashSet<String> jobs = newLinkedHashSet("Plumber", "Builder");
+    Iterable<String> cities = asList("Dover", "Boston", "Paris");
+    int[] ranks = { 1, 2, 3 };
+
+    iterableMap = new LinkedHashMap<>();
+    iterableMap.put("name", names);
+    iterableMap.put("job", jobs);
+    iterableMap.put("city", cities);
+    iterableMap.put("rank", ranks);
+
+    throwingFirstNameExtractor = Name::getFirst;
+    throwingLastNameExtractor = Name::getLast;
+    firstNameFunction = Name::getFirst;
+    lastNameFunction = Name::getLast;
+    firstNameExtractor = Name::getFirst;
+    lastNameExtractor = Name::getLast;
+
+    childrenExtractor = CartoonCharacter::getChildren;
   }
 
   @Test
@@ -922,23 +959,22 @@ public void should_fix_bug_1146() {
     }
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_iterable_assertion_final_methods_should_work_with_soft_assertions() {
+  public void iterable_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Iterable<Name> names = asList(name("John", "Doe"), name("Jane", "Doe"));
     Iterable<CartoonCharacter> characters = asList(homer, fred);
-    // WHEN
     softly.then(names)
-          .extracting(Name::getFirst)
+          .extracting(throwingFirstNameExtractor)
           .contains("gandalf")
           .contains("frodo");
     softly.then(names)
           .extracting("last")
           .containsExactly("foo", "bar");
     softly.then(characters)
-          .flatExtracting(CartoonCharacter::getChildren)
+          .flatExtracting(childrenExtractor)
           .as("using flatExtracting on Iterable")
           .hasSize(1)
           .containsAnyOf(homer, fred);
@@ -967,12 +1003,75 @@ public void all_iterable_assertion_final_methods_should_work_with_soft_assertion
     softly.then(characters)
           .endsWith(bart);
     softly.then(names)
-          .extracting(Name::getFirst, Name::getLast)
+          .extracting(firstNameFunction, lastNameFunction)
           .contains(tuple("John", "Doe"))
           .contains(tuple("Frodo", "Baggins"));
+    softly.then(names)
+          .extracting("first", "last")
+          .contains(tuple("John", "Doe"))
+          .contains(tuple("Bilbo", "Baggins"));
+    softly.then(names)
+          .extracting(firstNameExtractor)
+          .contains("John")
+          .contains("sam");
+    softly.then(names)
+          .extracting("first", String.class)
+          .contains("John")
+          .contains("Aragorn");
+    softly.then(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .hasSize(123);
+    softly.then(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .extracting(firstNameExtractor)
+          .contains("Sauron");
+    softly.then(names)
+          .flatExtracting(firstNameExtractor, lastNameExtractor)
+          .as("flatExtracting with multiple Extractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.then(names)
+          .flatExtracting(throwingFirstNameExtractor, throwingLastNameExtractor)
+          .as("flatExtracting with multiple ThrowingExtractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.then(names)
+          .extractingResultOf("getFirst")
+          .contains("John", "Jane")
+          .contains("Sam", "Aragorn");
+    softly.then(names)
+          .extractingResultOf("getFirst", String.class)
+          .contains("John", "Jane")
+          .contains("Messi", "Ronaldo");
+    softly.then(names)
+          .filteredOn(new Condition<>(name -> name.first.startsWith("Jo"), "startsWith Jo"))
+          .as("filteredOn with condition")
+          .hasSize(5);
+    softly.then(names)
+          .filteredOn("first", in("John", "Frodo"))
+          .as("filteredOn firstName in {John, Frodo}")
+          .isEmpty();
+    softly.then(names)
+          .filteredOn("first", "John")
+          .as("filteredOn firstName = John")
+          .isEmpty();
+    softly.then(names)
+          .filteredOnNull("first")
+          .as("filteredOn firstName = null")
+          .isNotEmpty();
+    softly.then(names)
+          .flatExtracting("first", "last")
+          .as("using flatExtracting(String... fieldOrPropertyNames)")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.then(characters)
+          .flatExtracting("children")
+          .as("using flatExtracting(String fieldOrPropertyName)")
+          .contains(bart, maggie)
+          .contains("Sauron");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(17);
+    assertThat(errorsCollected).hasSize(32);
     assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
     assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
     assertThat(errorsCollected.get(2)).hasMessageContaining("foo")
@@ -991,12 +1090,27 @@ public void all_iterable_assertion_final_methods_should_work_with_soft_assertion
     assertThat(errorsCollected.get(14)).hasMessageContaining(fred.toString());
     assertThat(errorsCollected.get(15)).hasMessageContaining(bart.toString());
     assertThat(errorsCollected.get(16)).hasMessageContaining("Baggins");
+    assertThat(errorsCollected.get(17)).hasMessageContaining("Bilbo");
+    assertThat(errorsCollected.get(18)).hasMessageContaining("sam");
+    assertThat(errorsCollected.get(19)).hasMessageContaining("Aragorn");
+    assertThat(errorsCollected.get(20)).hasMessageContaining("123");
+    assertThat(errorsCollected.get(21)).hasMessageContaining("Sauron");
+    assertThat(errorsCollected.get(22)).hasMessageContaining("flatExtracting with multiple Extractors");
+    assertThat(errorsCollected.get(23)).hasMessageContaining("flatExtracting with multiple ThrowingExtractors");
+    assertThat(errorsCollected.get(24)).hasMessageContaining("Sam");
+    assertThat(errorsCollected.get(25)).hasMessageContaining("Ronaldo");
+    assertThat(errorsCollected.get(26)).hasMessageContaining("filteredOn with condition");
+    assertThat(errorsCollected.get(27)).hasMessageContaining("filteredOn firstName in {John, Frodo}");
+    assertThat(errorsCollected.get(28)).hasMessageContaining("filteredOn firstName = John");
+    assertThat(errorsCollected.get(29)).hasMessageContaining("filteredOn firstName = null");
+    assertThat(errorsCollected.get(30)).hasMessageContaining("using flatExtracting(String... fieldOrPropertyNames)");
+    assertThat(errorsCollected.get(31)).hasMessageContaining("using flatExtracting(String fieldOrPropertyName)");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_list_assertion_final_methods_should_work_with_soft_assertions() {
+  public void list_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     List<Name> names = asList(name("John", "Doe"), name("Jane", "Doe"));
     List<CartoonCharacter> characters = asList(homer, fred);
@@ -1041,9 +1155,72 @@ public void all_list_assertion_final_methods_should_work_with_soft_assertions()
           .extracting(Name::getFirst, Name::getLast)
           .contains(tuple("John", "Doe"))
           .contains(tuple("Frodo", "Baggins"));
+    softly.then(names)
+          .extracting("first", "last")
+          .contains(tuple("John", "Doe"))
+          .contains(tuple("Bilbo", "Baggins"));
+    softly.then(names)
+          .extracting(firstNameExtractor)
+          .contains("John")
+          .contains("sam");
+    softly.then(names)
+          .extracting("first", String.class)
+          .contains("John")
+          .contains("Aragorn");
+    softly.then(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .hasSize(123);
+    softly.then(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .extracting(firstNameExtractor)
+          .contains("Sauron");
+    softly.then(names)
+          .flatExtracting(firstNameExtractor, lastNameExtractor)
+          .as("flatExtracting with multiple Extractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.then(names)
+          .flatExtracting(throwingFirstNameExtractor, throwingLastNameExtractor)
+          .as("flatExtracting with multiple ThrowingExtractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.then(names)
+          .extractingResultOf("getFirst")
+          .contains("John", "Jane")
+          .contains("Sam", "Aragorn");
+    softly.then(names)
+          .extractingResultOf("getFirst", String.class)
+          .contains("John", "Jane")
+          .contains("Messi", "Ronaldo");
+    softly.then(names)
+          .filteredOn(new Condition<>(name -> name.first.startsWith("Jo"), "startsWith Jo"))
+          .as("filteredOn with condition")
+          .hasSize(5);
+    softly.then(names)
+          .filteredOn("first", in("John", "Frodo"))
+          .as("filteredOn firstName in {John, Frodo}")
+          .isEmpty();
+    softly.then(names)
+          .filteredOn("first", "John")
+          .as("filteredOn firstName = John")
+          .isEmpty();
+    softly.then(names)
+          .filteredOnNull("first")
+          .as("filteredOn firstName = null")
+          .isNotEmpty();
+    softly.then(names)
+          .flatExtracting("first", "last")
+          .as("using flatExtracting(String... fieldOrPropertyNames)")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.then(characters)
+          .flatExtracting("children")
+          .as("using flatExtracting(String fieldOrPropertyName)")
+          .contains(bart, maggie)
+          .contains("Sauron");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(17);
+    assertThat(errorsCollected).hasSize(32);
     assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
     assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
     assertThat(errorsCollected.get(2)).hasMessageContaining("foo")
@@ -1062,12 +1239,27 @@ public void all_list_assertion_final_methods_should_work_with_soft_assertions()
     assertThat(errorsCollected.get(14)).hasMessageContaining(fred.toString());
     assertThat(errorsCollected.get(15)).hasMessageContaining(bart.toString());
     assertThat(errorsCollected.get(16)).hasMessageContaining("Baggins");
+    assertThat(errorsCollected.get(17)).hasMessageContaining("Bilbo");
+    assertThat(errorsCollected.get(18)).hasMessageContaining("sam");
+    assertThat(errorsCollected.get(19)).hasMessageContaining("Aragorn");
+    assertThat(errorsCollected.get(20)).hasMessageContaining("123");
+    assertThat(errorsCollected.get(21)).hasMessageContaining("Sauron");
+    assertThat(errorsCollected.get(22)).hasMessageContaining("flatExtracting with multiple Extractors");
+    assertThat(errorsCollected.get(23)).hasMessageContaining("flatExtracting with multiple ThrowingExtractors");
+    assertThat(errorsCollected.get(24)).hasMessageContaining("Sam");
+    assertThat(errorsCollected.get(25)).hasMessageContaining("Ronaldo");
+    assertThat(errorsCollected.get(26)).hasMessageContaining("filteredOn with condition");
+    assertThat(errorsCollected.get(27)).hasMessageContaining("filteredOn firstName in {John, Frodo}");
+    assertThat(errorsCollected.get(28)).hasMessageContaining("filteredOn firstName = John");
+    assertThat(errorsCollected.get(29)).hasMessageContaining("filteredOn firstName = null");
+    assertThat(errorsCollected.get(30)).hasMessageContaining("using flatExtracting(String... fieldOrPropertyNames)");
+    assertThat(errorsCollected.get(31)).hasMessageContaining("using flatExtracting(String fieldOrPropertyName)");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_object_array_assertion_final_methods_should_work_with_soft_assertions() {
+  public void object_array_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Name[] names = array(name("John", "Doe"), name("Jane", "Doe"));
     CartoonCharacter[] characters = array(homer, fred);
@@ -1112,9 +1304,57 @@ public void all_object_array_assertion_final_methods_should_work_with_soft_asser
           .extracting(Name::getFirst, Name::getLast)
           .contains(tuple("John", "Doe"))
           .contains(tuple("Frodo", "Baggins"));
+    softly.then(names)
+          .extracting("first", "last")
+          .contains(tuple("John", "Doe"))
+          .contains(tuple("Bilbo", "Baggins"));
+    softly.then(names)
+          .extracting(firstNameExtractor)
+          .contains("John")
+          .contains("sam");
+    softly.then(names)
+          .extracting("first", String.class)
+          .contains("John")
+          .contains("Aragorn");
+    softly.then(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .hasSize(123);
+    softly.then(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .extracting(firstNameExtractor)
+          .contains("Sauron");
+    softly.then(names)
+          .extractingResultOf("getFirst")
+          .contains("John", "Jane")
+          .contains("Sam", "Aragorn");
+    softly.then(names)
+          .extractingResultOf("getFirst", String.class)
+          .contains("John", "Jane")
+          .contains("Messi", "Ronaldo");
+    softly.then(names)
+          .filteredOn(new Condition<>(name -> name.first.startsWith("Jo"), "startsWith Jo"))
+          .as("filteredOn with condition")
+          .hasSize(5);
+    softly.then(names)
+          .filteredOn("first", in("John", "Frodo"))
+          .as("filteredOn firstName in {John, Frodo}")
+          .isEmpty();
+    softly.then(names)
+          .filteredOn("first", "John")
+          .as("filteredOn firstName = John")
+          .isEmpty();
+    softly.then(names)
+          .filteredOnNull("first")
+          .as("filteredOn firstName = null")
+          .isNotEmpty();
+    softly.then(characters)
+          .flatExtracting("children")
+          .as("using flatExtracting(String fieldOrPropertyName)")
+          .contains(bart, maggie)
+          .contains("Sauron");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(17);
+    assertThat(errorsCollected).hasSize(29);
     assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
     assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
     assertThat(errorsCollected.get(2)).hasMessageContaining("foo")
@@ -1133,12 +1373,24 @@ public void all_object_array_assertion_final_methods_should_work_with_soft_asser
     assertThat(errorsCollected.get(14)).hasMessageContaining(fred.toString());
     assertThat(errorsCollected.get(15)).hasMessageContaining(bart.toString());
     assertThat(errorsCollected.get(16)).hasMessageContaining("Baggins");
+    assertThat(errorsCollected.get(17)).hasMessageContaining("Bilbo");
+    assertThat(errorsCollected.get(18)).hasMessageContaining("sam");
+    assertThat(errorsCollected.get(19)).hasMessageContaining("Aragorn");
+    assertThat(errorsCollected.get(20)).hasMessageContaining("123");
+    assertThat(errorsCollected.get(21)).hasMessageContaining("Sauron");
+    assertThat(errorsCollected.get(22)).hasMessageContaining("Sam");
+    assertThat(errorsCollected.get(23)).hasMessageContaining("Ronaldo");
+    assertThat(errorsCollected.get(24)).hasMessageContaining("filteredOn with condition");
+    assertThat(errorsCollected.get(25)).hasMessageContaining("filteredOn firstName in {John, Frodo}");
+    assertThat(errorsCollected.get(26)).hasMessageContaining("filteredOn firstName = John");
+    assertThat(errorsCollected.get(27)).hasMessageContaining("filteredOn firstName = null");
+    assertThat(errorsCollected.get(28)).hasMessageContaining("using flatExtracting(String fieldOrPropertyName)");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_class_assertion_final_methods_should_work_with_soft_assertions() {
+  public void class_soft_assertions_should_report_errors_on_final_methods() {
     // GIVEN
     Class<AnnotatedClass> actual = AnnotatedClass.class;
     // WHEN
@@ -1152,27 +1404,32 @@ public void all_class_assertion_final_methods_should_work_with_soft_assertions()
                                       .hasMessageContaining("VisibleForTesting");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_object_assertion_final_methods_should_work_with_soft_assertions() {
+  public void object_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Name name = name("John", "Doe");
     // WHEN
+    softly.then(name)
+          .extracting("first", "last")
+          .contains("John")
+          .contains("gandalf");
     softly.then(name)
           .extracting(Name::getFirst, Name::getLast)
           .contains("John")
           .contains("frodo");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(1);
-    assertThat(errorsCollected.get(0)).hasMessageContaining("frodo");
+    assertThat(errorsCollected).hasSize(2);
+    assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
+    assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_map_assertion_final_methods_should_work_with_soft_assertions() {
+  public void map_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Map<String, String> map = mapOf(entry("a", "1"), entry("b", "2"), entry("c", "3"));
     // WHEN
@@ -1185,9 +1442,14 @@ public void all_map_assertion_final_methods_should_work_with_soft_assertions() {
     softly.then(map).containsValues("V1", "V2");
     softly.then(map).doesNotContain(entry("a", "1"), entry("abc", "ABC"));
     softly.then(map).doesNotContainKeys("a", "b");
+    softly.then(map).extracting("a", "b").contains("456");
+    softly.then(iterableMap)
+          .flatExtracting("name", "job", "city", "rank")
+          .contains("Unexpected", "Builder", "Dover", "Boston", "Paris", 1, 2, 3);
+    // softly.then(map).size().isGreaterThan(1000); not yet supported
     // THEN
     List<Throwable> errors = softly.errorsCollected();
-    assertThat(errors).hasSize(10);
+    assertThat(errors).hasSize(12);
     assertThat(errors.get(0)).hasMessageContaining("MapEntry[key=\"abc\", value=\"ABC\"]");
     assertThat(errors.get(1)).hasMessageContaining("empty");
     assertThat(errors.get(2)).hasMessageContaining("gh")
@@ -1199,11 +1461,13 @@ public void all_map_assertion_final_methods_should_work_with_soft_assertions() {
     assertThat(errors.get(7)).hasMessageContaining("V2");
     assertThat(errors.get(8)).hasMessageContaining("ABC");
     assertThat(errors.get(9)).hasMessageContaining("b");
+    assertThat(errors.get(10)).hasMessageContaining("456");
+    assertThat(errors.get(11)).hasMessageContaining("Unexpected");
   }
 
   @SuppressWarnings("unchecked")
   @Test
-  public void all_predicate_assertion_final_methods_should_work_with_soft_assertions() {
+  public void predicate_soft_assertions_should_report_errors_on_final_methods() {
     // GIVEN
     Predicate<MapEntry<String, String>> ballSportPredicate = sport -> sport.value.contains("ball");
     // WHEN
diff --git a/src/test/java/org/assertj/core/api/MapAssertBaseTest.java b/src/test/java/org/assertj/core/api/MapAssertBaseTest.java
index 3877c57fa4..eb0565ca31 100644
--- a/src/test/java/org/assertj/core/api/MapAssertBaseTest.java
+++ b/src/test/java/org/assertj/core/api/MapAssertBaseTest.java
@@ -44,7 +44,7 @@ protected void inject_internal_objects() {
   }
   
   protected <K,V> Map.Entry<K, V> javaMapEntry(K key, V value) {
-    return new SimpleImmutableEntry<K, V>(key, value);
+    return new SimpleImmutableEntry<>(key, value);
   }
   
   protected <K, V> Map<K, V> map(K key, V value) {
@@ -52,7 +52,7 @@ protected <K, V> Map<K, V> map(K key, V value) {
   }
   
   protected <K, V> Map<K, V> map(K k1, V v1, K k2, V v2) {
-    Map<K, V> map = new LinkedHashMap<K, V>();
+    Map<K, V> map = new LinkedHashMap<>();
     map.put(k1, v1);
     map.put(k2, v2);
     return map;
diff --git a/src/test/java/org/assertj/core/api/SoftAssertionsTest.java b/src/test/java/org/assertj/core/api/SoftAssertionsTest.java
index 261cb8cfbd..fef0f8f1f5 100644
--- a/src/test/java/org/assertj/core/api/SoftAssertionsTest.java
+++ b/src/test/java/org/assertj/core/api/SoftAssertionsTest.java
@@ -19,6 +19,7 @@
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.assertj.core.api.Assertions.entry;
 import static org.assertj.core.api.Assertions.fail;
+import static org.assertj.core.api.Assertions.in;
 import static org.assertj.core.api.Assertions.tuple;
 import static org.assertj.core.api.SoftAssertions.assertSoftly;
 import static org.assertj.core.test.Maps.mapOf;
@@ -35,7 +36,9 @@
 import java.time.LocalTime;
 import java.time.OffsetTime;
 import java.time.ZoneOffset;
+import java.util.Collection;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
@@ -54,6 +57,7 @@
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.atomic.AtomicReferenceArray;
 import java.util.function.DoublePredicate;
+import java.util.function.Function;
 import java.util.function.IntPredicate;
 import java.util.function.LongPredicate;
 import java.util.function.Predicate;
@@ -66,6 +70,8 @@
 import org.assertj.core.api.ClassAssertBaseTest.AnotherAnnotation;
 import org.assertj.core.api.ClassAssertBaseTest.MyAnnotation;
 import org.assertj.core.api.ThrowableAssert.ThrowingCallable;
+import org.assertj.core.api.iterable.Extractor;
+import org.assertj.core.api.iterable.ThrowingExtractor;
 import org.assertj.core.api.test.ComparableExample;
 import org.assertj.core.data.MapEntry;
 import org.assertj.core.test.CartoonCharacter;
@@ -90,6 +96,17 @@ public class SoftAssertionsTest extends BaseAssertionsTest {
   private CartoonCharacter maggie;
   private CartoonCharacter bart;
 
+  private Map<String, Object> iterableMap;
+
+  private ThrowingExtractor<Name, String, Exception> throwingFirstNameExtractor;
+  private ThrowingExtractor<Name, String, Exception> throwingLastNameExtractor;
+  private Extractor<Name, String> firstNameExtractor;
+  private Extractor<Name, String> lastNameExtractor;
+  private Function<Name, String> firstNameFunction;
+  private Function<Name, String> lastNameFunction;
+
+  private Extractor<? super CartoonCharacter, ? extends Collection<CartoonCharacter>> childrenExtractor;
+
   @Before
   public void setup() {
     softly = new SoftAssertions();
@@ -106,6 +123,26 @@ public void setup() {
     CartoonCharacter pebbles = new CartoonCharacter("Pebbles Flintstone");
     fred = new CartoonCharacter("Fred Flintstone");
     fred.getChildren().add(pebbles);
+
+    List<String> names = asList("Dave", "Jeff");
+    LinkedHashSet<String> jobs = newLinkedHashSet("Plumber", "Builder");
+    Iterable<String> cities = asList("Dover", "Boston", "Paris");
+    int[] ranks = { 1, 2, 3 };
+
+    iterableMap = new LinkedHashMap<>();
+    iterableMap.put("name", names);
+    iterableMap.put("job", jobs);
+    iterableMap.put("city", cities);
+    iterableMap.put("rank", ranks);
+
+    throwingFirstNameExtractor = Name::getFirst;
+    throwingLastNameExtractor = Name::getLast;
+    firstNameFunction = Name::getFirst;
+    lastNameFunction = Name::getLast;
+    firstNameExtractor = Name::getFirst;
+    lastNameExtractor = Name::getLast;
+
+    childrenExtractor = CartoonCharacter::getChildren;
   }
 
   @Test
@@ -926,23 +963,22 @@ public void should_fix_bug_1146() {
     }
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_iterable_assertion_final_methods_should_work_with_soft_assertions() {
+  public void iterable_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Iterable<Name> names = asList(name("John", "Doe"), name("Jane", "Doe"));
     Iterable<CartoonCharacter> characters = asList(homer, fred);
-    // WHEN
     softly.assertThat(names)
-          .extracting(Name::getFirst)
+          .extracting(throwingFirstNameExtractor)
           .contains("gandalf")
           .contains("frodo");
     softly.assertThat(names)
           .extracting("last")
           .containsExactly("foo", "bar");
     softly.assertThat(characters)
-          .flatExtracting(CartoonCharacter::getChildren)
+          .flatExtracting(childrenExtractor)
           .as("using flatExtracting on Iterable")
           .hasSize(1)
           .containsAnyOf(homer, fred);
@@ -971,12 +1007,75 @@ public void all_iterable_assertion_final_methods_should_work_with_soft_assertion
     softly.assertThat(characters)
           .endsWith(bart);
     softly.assertThat(names)
-          .extracting(Name::getFirst, Name::getLast)
+          .extracting(firstNameFunction, lastNameFunction)
           .contains(tuple("John", "Doe"))
           .contains(tuple("Frodo", "Baggins"));
+    softly.assertThat(names)
+          .extracting("first", "last")
+          .contains(tuple("John", "Doe"))
+          .contains(tuple("Bilbo", "Baggins"));
+    softly.assertThat(names)
+          .extracting(firstNameExtractor)
+          .contains("John")
+          .contains("sam");
+    softly.assertThat(names)
+          .extracting("first", String.class)
+          .contains("John")
+          .contains("Aragorn");
+    softly.assertThat(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .hasSize(123);
+    softly.assertThat(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .extracting(firstNameExtractor)
+          .contains("Sauron");
+    softly.assertThat(names)
+          .flatExtracting(firstNameExtractor, lastNameExtractor)
+          .as("flatExtracting with multiple Extractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.assertThat(names)
+          .flatExtracting(throwingFirstNameExtractor, throwingLastNameExtractor)
+          .as("flatExtracting with multiple ThrowingExtractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.assertThat(names)
+          .extractingResultOf("getFirst")
+          .contains("John", "Jane")
+          .contains("Sam", "Aragorn");
+    softly.assertThat(names)
+          .extractingResultOf("getFirst", String.class)
+          .contains("John", "Jane")
+          .contains("Messi", "Ronaldo");
+    softly.assertThat(names)
+          .filteredOn(new Condition<>(name -> name.first.startsWith("Jo"), "startsWith Jo"))
+          .as("filteredOn with condition")
+          .hasSize(5);
+    softly.assertThat(names)
+          .filteredOn("first", in("John", "Frodo"))
+          .as("filteredOn firstName in {John, Frodo}")
+          .isEmpty();
+    softly.assertThat(names)
+          .filteredOn("first", "John")
+          .as("filteredOn firstName = John")
+          .isEmpty();
+    softly.assertThat(names)
+          .filteredOnNull("first")
+          .as("filteredOn firstName = null")
+          .isNotEmpty();
+    softly.assertThat(names)
+          .flatExtracting("first", "last")
+          .as("using flatExtracting(String... fieldOrPropertyNames)")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.assertThat(characters)
+          .flatExtracting("children")
+          .as("using flatExtracting(String fieldOrPropertyName)")
+          .contains(bart, maggie)
+          .contains("Sauron");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(17);
+    assertThat(errorsCollected).hasSize(32);
     assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
     assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
     assertThat(errorsCollected.get(2)).hasMessageContaining("foo")
@@ -995,12 +1094,27 @@ public void all_iterable_assertion_final_methods_should_work_with_soft_assertion
     assertThat(errorsCollected.get(14)).hasMessageContaining(fred.toString());
     assertThat(errorsCollected.get(15)).hasMessageContaining(bart.toString());
     assertThat(errorsCollected.get(16)).hasMessageContaining("Baggins");
+    assertThat(errorsCollected.get(17)).hasMessageContaining("Bilbo");
+    assertThat(errorsCollected.get(18)).hasMessageContaining("sam");
+    assertThat(errorsCollected.get(19)).hasMessageContaining("Aragorn");
+    assertThat(errorsCollected.get(20)).hasMessageContaining("123");
+    assertThat(errorsCollected.get(21)).hasMessageContaining("Sauron");
+    assertThat(errorsCollected.get(22)).hasMessageContaining("flatExtracting with multiple Extractors");
+    assertThat(errorsCollected.get(23)).hasMessageContaining("flatExtracting with multiple ThrowingExtractors");
+    assertThat(errorsCollected.get(24)).hasMessageContaining("Sam");
+    assertThat(errorsCollected.get(25)).hasMessageContaining("Ronaldo");
+    assertThat(errorsCollected.get(26)).hasMessageContaining("filteredOn with condition");
+    assertThat(errorsCollected.get(27)).hasMessageContaining("filteredOn firstName in {John, Frodo}");
+    assertThat(errorsCollected.get(28)).hasMessageContaining("filteredOn firstName = John");
+    assertThat(errorsCollected.get(29)).hasMessageContaining("filteredOn firstName = null");
+    assertThat(errorsCollected.get(30)).hasMessageContaining("using flatExtracting(String... fieldOrPropertyNames)");
+    assertThat(errorsCollected.get(31)).hasMessageContaining("using flatExtracting(String fieldOrPropertyName)");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_list_assertion_final_methods_should_work_with_soft_assertions() {
+  public void list_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     List<Name> names = asList(name("John", "Doe"), name("Jane", "Doe"));
     List<CartoonCharacter> characters = asList(homer, fred);
@@ -1045,9 +1159,72 @@ public void all_list_assertion_final_methods_should_work_with_soft_assertions()
           .extracting(Name::getFirst, Name::getLast)
           .contains(tuple("John", "Doe"))
           .contains(tuple("Frodo", "Baggins"));
+    softly.assertThat(names)
+          .extracting("first", "last")
+          .contains(tuple("John", "Doe"))
+          .contains(tuple("Bilbo", "Baggins"));
+    softly.assertThat(names)
+          .extracting(firstNameExtractor)
+          .contains("John")
+          .contains("sam");
+    softly.assertThat(names)
+          .extracting("first", String.class)
+          .contains("John")
+          .contains("Aragorn");
+    softly.assertThat(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .hasSize(123);
+    softly.assertThat(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .extracting(firstNameExtractor)
+          .contains("Sauron");
+    softly.assertThat(names)
+          .flatExtracting(firstNameExtractor, lastNameExtractor)
+          .as("flatExtracting with multiple Extractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.assertThat(names)
+          .flatExtracting(throwingFirstNameExtractor, throwingLastNameExtractor)
+          .as("flatExtracting with multiple ThrowingExtractors")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.assertThat(names)
+          .extractingResultOf("getFirst")
+          .contains("John", "Jane")
+          .contains("Sam", "Aragorn");
+    softly.assertThat(names)
+          .extractingResultOf("getFirst", String.class)
+          .contains("John", "Jane")
+          .contains("Messi", "Ronaldo");
+    softly.assertThat(names)
+          .filteredOn(new Condition<>(name -> name.first.startsWith("Jo"), "startsWith Jo"))
+          .as("filteredOn with condition")
+          .hasSize(5);
+    softly.assertThat(names)
+          .filteredOn("first", in("John", "Frodo"))
+          .as("filteredOn firstName in {John, Frodo}")
+          .isEmpty();
+    softly.assertThat(names)
+          .filteredOn("first", "John")
+          .as("filteredOn firstName = John")
+          .isEmpty();
+    softly.assertThat(names)
+          .filteredOnNull("first")
+          .as("filteredOn firstName = null")
+          .isNotEmpty();
+    softly.assertThat(names)
+          .flatExtracting("first", "last")
+          .as("using flatExtracting(String... fieldOrPropertyNames)")
+          .contains("John", "Jane", "Doe")
+          .contains("Sauron");
+    softly.assertThat(characters)
+          .flatExtracting("children")
+          .as("using flatExtracting(String fieldOrPropertyName)")
+          .contains(bart, maggie)
+          .contains("Sauron");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(17);
+    assertThat(errorsCollected).hasSize(32);
     assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
     assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
     assertThat(errorsCollected.get(2)).hasMessageContaining("foo")
@@ -1066,12 +1243,27 @@ public void all_list_assertion_final_methods_should_work_with_soft_assertions()
     assertThat(errorsCollected.get(14)).hasMessageContaining(fred.toString());
     assertThat(errorsCollected.get(15)).hasMessageContaining(bart.toString());
     assertThat(errorsCollected.get(16)).hasMessageContaining("Baggins");
+    assertThat(errorsCollected.get(17)).hasMessageContaining("Bilbo");
+    assertThat(errorsCollected.get(18)).hasMessageContaining("sam");
+    assertThat(errorsCollected.get(19)).hasMessageContaining("Aragorn");
+    assertThat(errorsCollected.get(20)).hasMessageContaining("123");
+    assertThat(errorsCollected.get(21)).hasMessageContaining("Sauron");
+    assertThat(errorsCollected.get(22)).hasMessageContaining("flatExtracting with multiple Extractors");
+    assertThat(errorsCollected.get(23)).hasMessageContaining("flatExtracting with multiple ThrowingExtractors");
+    assertThat(errorsCollected.get(24)).hasMessageContaining("Sam");
+    assertThat(errorsCollected.get(25)).hasMessageContaining("Ronaldo");
+    assertThat(errorsCollected.get(26)).hasMessageContaining("filteredOn with condition");
+    assertThat(errorsCollected.get(27)).hasMessageContaining("filteredOn firstName in {John, Frodo}");
+    assertThat(errorsCollected.get(28)).hasMessageContaining("filteredOn firstName = John");
+    assertThat(errorsCollected.get(29)).hasMessageContaining("filteredOn firstName = null");
+    assertThat(errorsCollected.get(30)).hasMessageContaining("using flatExtracting(String... fieldOrPropertyNames)");
+    assertThat(errorsCollected.get(31)).hasMessageContaining("using flatExtracting(String fieldOrPropertyName)");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_object_array_assertion_final_methods_should_work_with_soft_assertions() {
+  public void object_array_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Name[] names = array(name("John", "Doe"), name("Jane", "Doe"));
     CartoonCharacter[] characters = array(homer, fred);
@@ -1116,9 +1308,57 @@ public void all_object_array_assertion_final_methods_should_work_with_soft_asser
           .extracting(Name::getFirst, Name::getLast)
           .contains(tuple("John", "Doe"))
           .contains(tuple("Frodo", "Baggins"));
+    softly.assertThat(names)
+          .extracting("first", "last")
+          .contains(tuple("John", "Doe"))
+          .contains(tuple("Bilbo", "Baggins"));
+    softly.assertThat(names)
+          .extracting(firstNameExtractor)
+          .contains("John")
+          .contains("sam");
+    softly.assertThat(names)
+          .extracting("first", String.class)
+          .contains("John")
+          .contains("Aragorn");
+    softly.assertThat(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .hasSize(123);
+    softly.assertThat(names)
+          .filteredOn(name -> name.first.startsWith("Jo"))
+          .extracting(firstNameExtractor)
+          .contains("Sauron");
+    softly.assertThat(names)
+          .extractingResultOf("getFirst")
+          .contains("John", "Jane")
+          .contains("Sam", "Aragorn");
+    softly.assertThat(names)
+          .extractingResultOf("getFirst", String.class)
+          .contains("John", "Jane")
+          .contains("Messi", "Ronaldo");
+    softly.assertThat(names)
+          .filteredOn(new Condition<>(name -> name.first.startsWith("Jo"), "startsWith Jo"))
+          .as("filteredOn with condition")
+          .hasSize(5);
+    softly.assertThat(names)
+          .filteredOn("first", in("John", "Frodo"))
+          .as("filteredOn firstName in {John, Frodo}")
+          .isEmpty();
+    softly.assertThat(names)
+          .filteredOn("first", "John")
+          .as("filteredOn firstName = John")
+          .isEmpty();
+    softly.assertThat(names)
+          .filteredOnNull("first")
+          .as("filteredOn firstName = null")
+          .isNotEmpty();
+    softly.assertThat(characters)
+          .flatExtracting("children")
+          .as("using flatExtracting(String fieldOrPropertyName)")
+          .contains(bart, maggie)
+          .contains("Sauron");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(17);
+    assertThat(errorsCollected).hasSize(29);
     assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
     assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
     assertThat(errorsCollected.get(2)).hasMessageContaining("foo")
@@ -1137,12 +1377,24 @@ public void all_object_array_assertion_final_methods_should_work_with_soft_asser
     assertThat(errorsCollected.get(14)).hasMessageContaining(fred.toString());
     assertThat(errorsCollected.get(15)).hasMessageContaining(bart.toString());
     assertThat(errorsCollected.get(16)).hasMessageContaining("Baggins");
+    assertThat(errorsCollected.get(17)).hasMessageContaining("Bilbo");
+    assertThat(errorsCollected.get(18)).hasMessageContaining("sam");
+    assertThat(errorsCollected.get(19)).hasMessageContaining("Aragorn");
+    assertThat(errorsCollected.get(20)).hasMessageContaining("123");
+    assertThat(errorsCollected.get(21)).hasMessageContaining("Sauron");
+    assertThat(errorsCollected.get(22)).hasMessageContaining("Sam");
+    assertThat(errorsCollected.get(23)).hasMessageContaining("Ronaldo");
+    assertThat(errorsCollected.get(24)).hasMessageContaining("filteredOn with condition");
+    assertThat(errorsCollected.get(25)).hasMessageContaining("filteredOn firstName in {John, Frodo}");
+    assertThat(errorsCollected.get(26)).hasMessageContaining("filteredOn firstName = John");
+    assertThat(errorsCollected.get(27)).hasMessageContaining("filteredOn firstName = null");
+    assertThat(errorsCollected.get(28)).hasMessageContaining("using flatExtracting(String fieldOrPropertyName)");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_class_assertion_final_methods_should_work_with_soft_assertions() {
+  public void class_soft_assertions_should_report_errors_on_final_methods() {
     // GIVEN
     Class<AnnotatedClass> actual = AnnotatedClass.class;
     // WHEN
@@ -1156,27 +1408,32 @@ public void all_class_assertion_final_methods_should_work_with_soft_assertions()
                                       .hasMessageContaining("VisibleForTesting");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_object_assertion_final_methods_should_work_with_soft_assertions() {
+  public void object_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Name name = name("John", "Doe");
     // WHEN
+    softly.assertThat(name)
+          .extracting("first", "last")
+          .contains("John")
+          .contains("gandalf");
     softly.assertThat(name)
           .extracting(Name::getFirst, Name::getLast)
           .contains("John")
           .contains("frodo");
     // THEN
     List<Throwable> errorsCollected = softly.errorsCollected();
-    assertThat(errorsCollected).hasSize(1);
-    assertThat(errorsCollected.get(0)).hasMessageContaining("frodo");
+    assertThat(errorsCollected).hasSize(2);
+    assertThat(errorsCollected.get(0)).hasMessageContaining("gandalf");
+    assertThat(errorsCollected.get(1)).hasMessageContaining("frodo");
   }
 
-  // the test would if any method was not proxyable as the assertion error would not be softly caught
+  // the test would fail if any method was not proxyable as the assertion error would not be softly caught
   @SuppressWarnings("unchecked")
   @Test
-  public void all_map_assertion_final_methods_should_work_with_soft_assertions() {
+  public void map_soft_assertions_should_report_errors_on_final_methods_and_methods_that_change_the_object_under_test() {
     // GIVEN
     Map<String, String> map = mapOf(entry("a", "1"), entry("b", "2"), entry("c", "3"));
     // WHEN
@@ -1189,9 +1446,14 @@ public void all_map_assertion_final_methods_should_work_with_soft_assertions() {
     softly.assertThat(map).containsValues("V1", "V2");
     softly.assertThat(map).doesNotContain(entry("a", "1"), entry("abc", "ABC"));
     softly.assertThat(map).doesNotContainKeys("a", "b");
+    softly.assertThat(map).extracting("a", "b").contains("456");
+    softly.assertThat(iterableMap)
+          .flatExtracting("name", "job", "city", "rank")
+          .contains("Unexpected", "Builder", "Dover", "Boston", "Paris", 1, 2, 3);
+    // softly.assertThat(map).size().isGreaterThan(1000); not yet supported
     // THEN
     List<Throwable> errors = softly.errorsCollected();
-    assertThat(errors).hasSize(10);
+    assertThat(errors).hasSize(12);
     assertThat(errors.get(0)).hasMessageContaining("MapEntry[key=\"abc\", value=\"ABC\"]");
     assertThat(errors.get(1)).hasMessageContaining("empty");
     assertThat(errors.get(2)).hasMessageContaining("gh")
@@ -1203,11 +1465,13 @@ public void all_map_assertion_final_methods_should_work_with_soft_assertions() {
     assertThat(errors.get(7)).hasMessageContaining("V2");
     assertThat(errors.get(8)).hasMessageContaining("ABC");
     assertThat(errors.get(9)).hasMessageContaining("b");
+    assertThat(errors.get(10)).hasMessageContaining("456");
+    assertThat(errors.get(11)).hasMessageContaining("Unexpected");
   }
 
   @SuppressWarnings("unchecked")
   @Test
-  public void all_predicate_assertion_final_methods_should_work_with_soft_assertions() {
+  public void predicate_soft_assertions_should_report_errors_on_final_methods() {
     // GIVEN
     Predicate<MapEntry<String, String>> ballSportPredicate = sport -> sport.value.contains("ball");
     // WHEN
diff --git a/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java b/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java
index 7e3d880a05..bc30476f20 100644
--- a/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java
+++ b/src/test/java/org/assertj/core/api/assumptions/BaseAssumptionsRunnerTest.java
@@ -14,10 +14,14 @@
 
 import static org.assertj.core.api.Assertions.fail;
 
+import java.util.Collection;
+import java.util.function.Function;
+
 import org.assertj.core.api.Assertions;
 import org.assertj.core.api.iterable.Extractor;
 import org.assertj.core.api.iterable.ThrowingExtractor;
 import org.assertj.core.data.TolkienCharacter;
+import org.assertj.core.data.TolkienCharacter.Race;
 import org.assertj.core.test.CartoonCharacter;
 import org.junit.Test;
 
@@ -27,15 +31,21 @@ public abstract class BaseAssumptionsRunnerTest {
     Assertions.setRemoveAssertJRelatedElementsFromStackTrace(false);
   }
 
+  protected static TolkienCharacter frodo;
+  protected static TolkienCharacter sam;
   protected static CartoonCharacter homer;
   protected static CartoonCharacter fred;
   protected static CartoonCharacter lisa;
   protected static CartoonCharacter maggie;
   protected static CartoonCharacter bart;
-  protected static ThrowingExtractor<? super TolkienCharacter, ?, RuntimeException> throwingNameExtractor;
-  protected static ThrowingExtractor<? super TolkienCharacter, ?, RuntimeException> throwingAgeExtractor;
-  protected static Extractor<? super TolkienCharacter, ?> nameExtractor;
-  protected static Extractor<? super TolkienCharacter, ?> ageExtractor;
+  protected static ThrowingExtractor<? super TolkienCharacter, String, Exception> throwingNameExtractor;
+  protected static ThrowingExtractor<? super TolkienCharacter, Integer, Exception> throwingAgeExtractor;
+  protected static Extractor<? super TolkienCharacter, String> nameExtractor;
+  protected static Extractor<? super TolkienCharacter, Integer> ageExtractor;
+  protected static Function<TolkienCharacter, String> nameExtractorFunction;
+  protected static Function<TolkienCharacter, Integer> ageExtractorFunction;
+  protected static Extractor<? super CartoonCharacter, ? extends Collection<CartoonCharacter>> childrenExtractor;
+
   protected AssumptionRunner<?> assumptionRunner;
 
   public BaseAssumptionsRunnerTest(AssumptionRunner<?> assumptionRunner) {
@@ -60,6 +70,12 @@ public static void setupData() {
     throwingAgeExtractor = TolkienCharacter::getAge;
     nameExtractor = TolkienCharacter::getName;
     ageExtractor = TolkienCharacter::getAge;
+    nameExtractorFunction = TolkienCharacter::getName;
+    ageExtractorFunction = TolkienCharacter::getAge;
+
+    frodo = TolkienCharacter.of("Frodo", 33, Race.HOBBIT);
+    sam = TolkienCharacter.of("Sam", 35, Race.HOBBIT);
+    childrenExtractor = CartoonCharacter::getChildren;
   }
 
   @Test
diff --git a/src/test/java/org/assertj/core/api/assumptions/Iterable_final_method_assertions_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/Iterable_final_method_assertions_in_assumptions_Test.java
deleted file mode 100644
index f7385a8948..0000000000
--- a/src/test/java/org/assertj/core/api/assumptions/Iterable_final_method_assertions_in_assumptions_Test.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
- * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- *
- * Copyright 2012-2018 the original author or authors.
- */
-package org.assertj.core.api.assumptions;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.tuple;
-import static org.assertj.core.api.Assumptions.assumeThat;
-import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
-import static org.assertj.core.util.IterableUtil.iterable;
-
-import org.assertj.core.api.IterableAssert;
-import org.assertj.core.api.ProxyableIterableAssert;
-import org.assertj.core.data.TolkienCharacter;
-import org.assertj.core.data.TolkienCharacter.Race;
-import org.assertj.core.test.CartoonCharacter;
-import org.junit.AfterClass;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-/**
- * verify that assertions final methods in {@link IterableAssert} work with assumptions (i.e. that they are proxied correctly in {@link ProxyableIterableAssert}).
- */
-@RunWith(Parameterized.class)
-public class Iterable_final_method_assertions_in_assumptions_Test extends BaseAssumptionsRunnerTest {
-
-  protected static int ranTests = 0;
-
-  public Iterable_final_method_assertions_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
-    super(assumptionRunner);
-  }
-
-  @Override
-  protected void incrementRunTests() {
-    ranTests++;
-  }
-
-  @SuppressWarnings("unchecked")
-  @Parameters
-  public static Object[][] provideAssumptionsRunners() {
-    setupData();
-    return new AssumptionRunner[][] {
-        run(iterable(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
-                                      .contains(tuple("Frodo", 33)),
-            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
-                                      .contains(tuple("Gandalf", 1000))),
-        run(iterable(homer, fred),
-            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
-                                      .containsAnyOf(bart, lisa),
-            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
-                                      .containsAnyOf(homer, fred)),
-        run(iterable(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
-                                      .contains("Frodo", 33),
-            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
-                                      .contains("Gandalf", 1000)),
-        run(iterable(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
-                                      .contains("Frodo", 33),
-            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
-                                      .contains("Gandalf", 1000)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).contains(1, 2),
-            value -> assumeThat(value).contains(4)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).containsAnyOf(1, 10, 20),
-            value -> assumeThat(value).containsAnyOf(0, 5, 10)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).containsExactly(1, 2, 3),
-            value -> assumeThat(value).containsExactly(4)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).containsExactlyInAnyOrder(2, 1, 3),
-            value -> assumeThat(value).containsExactlyInAnyOrder(1, 2)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).containsOnly(2, 1, 3, 2),
-            value -> assumeThat(value).containsOnly(1, 2, 4)),
-        run(iterable(2, 4, 2),
-            value -> assumeThat(value).containsOnlyOnce(4),
-            value -> assumeThat(value).containsOnlyOnce(2)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).containsSequence(1, 2),
-            value -> assumeThat(value).containsSequence(1, 3)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).containsSubsequence(1, 3),
-            value -> assumeThat(value).containsSubsequence(2, 1)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).doesNotContain(4, 5),
-            value -> assumeThat(value).doesNotContain(2, 1)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).doesNotContainSequence(1, 3),
-            value -> assumeThat(value).doesNotContainSequence(1, 2)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).doesNotContainSubsequence(2, 1),
-            value -> assumeThat(value).doesNotContainSubsequence(1, 3)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).isSubsetOf(1, 2, 3, 4),
-            value -> assumeThat(value).isSubsetOf(2, 4, 6)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).startsWith(1, 2),
-            value -> assumeThat(value).startsWith(2, 3)),
-        run(iterable(1, 2, 3),
-            value -> assumeThat(value).endsWith(2, 3),
-            value -> assumeThat(value).endsWith(2, 4))
-    };
-  }
-
-  @AfterClass
-  public static void afterClass() {
-    assertThat(ranTests).as("number of tests run").isEqualTo(provideAssumptionsRunners().length);
-  }
-
-}
diff --git a/src/test/java/org/assertj/core/api/assumptions/Iterable_special_assertion_methods_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/Iterable_special_assertion_methods_in_assumptions_Test.java
new file mode 100644
index 0000000000..e3f31deb01
--- /dev/null
+++ b/src/test/java/org/assertj/core/api/assumptions/Iterable_special_assertion_methods_in_assumptions_Test.java
@@ -0,0 +1,218 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2018 the original author or authors.
+ */
+package org.assertj.core.api.assumptions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.in;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
+import static org.assertj.core.util.IterableUtil.iterable;
+
+import org.assertj.core.api.Condition;
+import org.assertj.core.api.IterableAssert;
+import org.assertj.core.api.ProxyableIterableAssert;
+import org.assertj.core.data.TolkienCharacter;
+import org.assertj.core.test.CartoonCharacter;
+import org.junit.AfterClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * verify that assertions final methods or methods changing the object under test in {@link IterableAssert} work with assumptions 
+ * (i.e. that they are proxied correctly in {@link ProxyableIterableAssert}).
+ */
+@RunWith(Parameterized.class)
+public class Iterable_special_assertion_methods_in_assumptions_Test extends BaseAssumptionsRunnerTest {
+
+  protected static int ranTests = 0;
+
+  public Iterable_special_assertion_methods_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
+    super(assumptionRunner);
+  }
+
+  @Override
+  protected void incrementRunTests() {
+    ranTests++;
+  }
+
+  @SuppressWarnings("unchecked")
+  @Parameters
+  public static Object[][] provideAssumptionsRunners() {
+    setupData();
+
+    return new AssumptionRunner[][] {
+        // extracting methods
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting(throwingNameExtractor)
+                                      .contains("Frodo"),
+            value -> assumeThat(value).extracting(throwingNameExtractor)
+                                      .contains("Gandalf")),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting(nameExtractor)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting(nameExtractor)
+                                      .contains("Gandalf", "Sam")),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting("name")
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting("name")
+                                      .contains("Gandalf", "Sam")),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting("name", String.class)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting("name", String.class)
+                                      .contains("Gandalf", "Sam")),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains(tuple("Gandalf", 1000))),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting(nameExtractorFunction, ageExtractorFunction)
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting(nameExtractorFunction, ageExtractorFunction)
+                                      .contains(tuple("Gandalf", 1000))),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains(tuple("Gandalf", 1000))),
+        // extractingResultOf methods
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extractingResultOf("getName")
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extractingResultOf("getName")
+                                      .contains("Gandalf", "Sam")),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).extractingResultOf("getName", String.class)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extractingResultOf("getName", String.class)
+                                      .contains("Gandalf", "Sam")),
+        // flatExtracting methods
+        run(iterable(homer, fred),
+            value -> assumeThat(value).flatExtracting("children")
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting("children")
+                                      .containsAnyOf(homer, fred)),
+        run(iterable(homer, fred),
+            value -> assumeThat(value).flatExtracting(childrenExtractor)
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting(childrenExtractor)
+                                      .containsAnyOf(homer, fred)),
+        run(iterable(homer, fred),
+            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
+                                      .containsAnyOf(homer, fred)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
+                                      .contains("Gandalf", 1000)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
+                                      .contains("Gandalf", 1000)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).flatExtracting("name", "age")
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).flatExtracting("name", "age")
+                                      .contains("Gandalf", 1000)),
+        // filteredOn methods
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .contains(sam)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).filteredOn(new Condition<>(hero -> hero.getName().startsWith("Fro"), "startsWith Fro"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn(new Condition<>(hero -> hero.getName().startsWith("Fro"), "startsWith Fro"))
+                                      .contains(sam)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).filteredOn("name", "Frodo")
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn("name", "Frodo")
+                                      .contains(sam)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).filteredOnNull("name")
+                                      .isEmpty(),
+            value -> assumeThat(value).filteredOnNull("name")
+                                      .contains(sam)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).filteredOn("name", in("John", "Frodo"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn("name", in("John", "Frodo"))
+                                      .contains(sam)),
+        run(iterable(frodo, sam),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .extracting("name", "age")
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .extracting("name", "age")
+                                      .contains(tuple("Sam", 35))),
+        // final methods
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).contains(1, 2),
+            value -> assumeThat(value).contains(4)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).containsAnyOf(1, 10, 20),
+            value -> assumeThat(value).containsAnyOf(0, 5, 10)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).containsExactly(1, 2, 3),
+            value -> assumeThat(value).containsExactly(4)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).containsExactlyInAnyOrder(2, 1, 3),
+            value -> assumeThat(value).containsExactlyInAnyOrder(1, 2)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).containsOnly(2, 1, 3, 2),
+            value -> assumeThat(value).containsOnly(1, 2, 4)),
+        run(iterable(2, 4, 2),
+            value -> assumeThat(value).containsOnlyOnce(4),
+            value -> assumeThat(value).containsOnlyOnce(2)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).containsSequence(1, 2),
+            value -> assumeThat(value).containsSequence(1, 3)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).containsSubsequence(1, 3),
+            value -> assumeThat(value).containsSubsequence(2, 1)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).doesNotContain(4, 5),
+            value -> assumeThat(value).doesNotContain(2, 1)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).doesNotContainSequence(1, 3),
+            value -> assumeThat(value).doesNotContainSequence(1, 2)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).doesNotContainSubsequence(2, 1),
+            value -> assumeThat(value).doesNotContainSubsequence(1, 3)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).isSubsetOf(1, 2, 3, 4),
+            value -> assumeThat(value).isSubsetOf(2, 4, 6)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).startsWith(1, 2),
+            value -> assumeThat(value).startsWith(2, 3)),
+        run(iterable(1, 2, 3),
+            value -> assumeThat(value).endsWith(2, 3),
+            value -> assumeThat(value).endsWith(2, 4))
+    };
+  }
+
+  @AfterClass
+  public static void afterClass() {
+    assertThat(ranTests).as("number of tests run").isEqualTo(provideAssumptionsRunners().length);
+  }
+
+}
diff --git a/src/test/java/org/assertj/core/api/assumptions/List_final_method_assertions_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/List_final_method_assertions_in_assumptions_Test.java
deleted file mode 100644
index 7ae3b32827..0000000000
--- a/src/test/java/org/assertj/core/api/assumptions/List_final_method_assertions_in_assumptions_Test.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
- * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- *
- * Copyright 2012-2018 the original author or authors.
- */
-package org.assertj.core.api.assumptions;
-
-import static java.util.Arrays.asList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.tuple;
-import static org.assertj.core.api.Assumptions.assumeThat;
-import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
-
-import org.assertj.core.api.ListAssert;
-import org.assertj.core.api.ProxyableListAssert;
-import org.assertj.core.data.TolkienCharacter;
-import org.assertj.core.data.TolkienCharacter.Race;
-import org.assertj.core.test.CartoonCharacter;
-import org.junit.AfterClass;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-/**
- * verify that assertions final methods in {@link ListAssert} work with assumptions (i.e. that they are proxied correctly in {@link ProxyableListAssert}).
- */
-@RunWith(Parameterized.class)
-public class List_final_method_assertions_in_assumptions_Test extends BaseAssumptionsRunnerTest {
-
-  private static int ranTests = 0;
-
-  public List_final_method_assertions_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
-    super(assumptionRunner);
-  }
-
-  @Override
-  protected void incrementRunTests() {
-    ranTests++;
-  }
-
-  @SuppressWarnings("unchecked")
-  @Parameters
-  public static Object[][] provideAssumptionsRunners() {
-    setupData();
-    return new AssumptionRunner[][] {
-        run(asList(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
-                                      .contains(tuple("Frodo", 33)),
-            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
-                                      .contains(tuple("Gandalf", 1000))),
-        run(asList(homer, fred),
-            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
-                                      .containsAnyOf(bart, lisa),
-            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
-                                      .containsAnyOf(homer, fred)),
-        run(asList(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
-                                      .contains("Frodo", 33),
-            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
-                                      .contains("Gandalf", 1000)),
-        run(asList(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
-                                      .contains("Frodo", 33),
-            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
-                                      .contains("Gandalf", 1000)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).contains(1, 2),
-            value -> assumeThat(value).contains(4)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).containsAnyOf(1, 10, 20),
-            value -> assumeThat(value).containsAnyOf(0, 5, 10)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).containsExactly(1, 2, 3),
-            value -> assumeThat(value).containsExactly(4)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).containsExactlyInAnyOrder(2, 1, 3),
-            value -> assumeThat(value).containsExactlyInAnyOrder(1, 2)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).containsOnly(2, 1, 3, 2),
-            value -> assumeThat(value).containsOnly(1, 2, 4)),
-        run(asList(2, 4, 2),
-            value -> assumeThat(value).containsOnlyOnce(4),
-            value -> assumeThat(value).containsOnlyOnce(2)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).containsSequence(1, 2),
-            value -> assumeThat(value).containsSequence(1, 3)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).containsSubsequence(1, 3),
-            value -> assumeThat(value).containsSubsequence(2, 1)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).doesNotContain(4, 5),
-            value -> assumeThat(value).doesNotContain(2, 1)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).doesNotContainSequence(1, 3),
-            value -> assumeThat(value).doesNotContainSequence(1, 2)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).doesNotContainSubsequence(2, 1),
-            value -> assumeThat(value).doesNotContainSubsequence(1, 3)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).isSubsetOf(1, 2, 3, 4),
-            value -> assumeThat(value).isSubsetOf(2, 4, 6)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).startsWith(1, 2),
-            value -> assumeThat(value).startsWith(2, 3)),
-        run(asList(1, 2, 3),
-            value -> assumeThat(value).endsWith(2, 3),
-            value -> assumeThat(value).endsWith(2, 4))
-    };
-  };
-
-  @AfterClass
-  public static void afterClass() {
-    assertThat(ranTests).as("number of tests run").isEqualTo(provideAssumptionsRunners().length);
-  }
-
-}
diff --git a/src/test/java/org/assertj/core/api/assumptions/List_special_assertion_methods_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/List_special_assertion_methods_in_assumptions_Test.java
new file mode 100644
index 0000000000..190aea1dcb
--- /dev/null
+++ b/src/test/java/org/assertj/core/api/assumptions/List_special_assertion_methods_in_assumptions_Test.java
@@ -0,0 +1,216 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2018 the original author or authors.
+ */
+package org.assertj.core.api.assumptions;
+
+import static java.util.Arrays.asList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.in;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
+
+import org.assertj.core.api.Condition;
+import org.assertj.core.api.ListAssert;
+import org.assertj.core.api.ProxyableListAssert;
+import org.assertj.core.data.TolkienCharacter;
+import org.assertj.core.test.CartoonCharacter;
+import org.junit.AfterClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * verify that assertions final methods or methods changing the object under test in {@link ListAssert} work with assumptions 
+ * (i.e. that they are proxied correctly in {@link ProxyableListAssert}).
+ */
+@RunWith(Parameterized.class)
+public class List_special_assertion_methods_in_assumptions_Test extends BaseAssumptionsRunnerTest {
+
+  private static int ranTests = 0;
+
+  public List_special_assertion_methods_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
+    super(assumptionRunner);
+  }
+
+  @Override
+  protected void incrementRunTests() {
+    ranTests++;
+  }
+
+  @SuppressWarnings("unchecked")
+  @Parameters
+  public static Object[][] provideAssumptionsRunners() {
+    setupData();
+    return new AssumptionRunner[][] {
+        // extracting methods
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting(throwingNameExtractor)
+                                      .contains("Frodo"),
+            value -> assumeThat(value).extracting(throwingNameExtractor)
+                                      .contains("Gandalf")),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting(nameExtractor)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting(nameExtractor)
+                                      .contains("Gandalf", "Sam")),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting("name")
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting("name")
+                                      .contains("Gandalf", "Sam")),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting("name", String.class)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting("name", String.class)
+                                      .contains("Gandalf", "Sam")),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains(tuple("Gandalf", 1000))),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting(nameExtractorFunction, ageExtractorFunction)
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting(nameExtractorFunction, ageExtractorFunction)
+                                      .contains(tuple("Gandalf", 1000))),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains(tuple("Gandalf", 1000))),
+        // extractingResultOf methods
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extractingResultOf("getName")
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extractingResultOf("getName")
+                                      .contains("Gandalf", "Sam")),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).extractingResultOf("getName", String.class)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extractingResultOf("getName", String.class)
+                                      .contains("Gandalf", "Sam")),
+        // flatExtracting methods
+        run(asList(homer, fred),
+            value -> assumeThat(value).flatExtracting("children")
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting("children")
+                                      .containsAnyOf(homer, fred)),
+        run(asList(homer, fred),
+            value -> assumeThat(value).flatExtracting(childrenExtractor)
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting(childrenExtractor)
+                                      .containsAnyOf(homer, fred)),
+        run(asList(homer, fred),
+            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
+                                      .containsAnyOf(homer, fred)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).flatExtracting(throwingNameExtractor, throwingAgeExtractor)
+                                      .contains("Gandalf", 1000)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).flatExtracting(nameExtractor, ageExtractor)
+                                      .contains("Gandalf", 1000)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).flatExtracting("name", "age")
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).flatExtracting("name", "age")
+                                      .contains("Gandalf", 1000)),
+        // filteredOn methods
+        run(asList(frodo, sam),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .contains(sam)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).filteredOn(new Condition<>(hero -> hero.getName().startsWith("Fro"), "startsWith Fro"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn(new Condition<>(hero -> hero.getName().startsWith("Fro"), "startsWith Fro"))
+                                      .contains(sam)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).filteredOn("name", "Frodo")
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn("name", "Frodo")
+                                      .contains(sam)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).filteredOnNull("name")
+                                      .isEmpty(),
+            value -> assumeThat(value).filteredOnNull("name")
+                                      .contains(sam)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).filteredOn("name", in("John", "Frodo"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn("name", in("John", "Frodo"))
+                                      .contains(sam)),
+        run(asList(frodo, sam),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .extracting("name", "age")
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .extracting("name", "age")
+                                      .contains(tuple("Sam", 35))),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).contains(1, 2),
+            value -> assumeThat(value).contains(4)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).containsAnyOf(1, 10, 20),
+            value -> assumeThat(value).containsAnyOf(0, 5, 10)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).containsExactly(1, 2, 3),
+            value -> assumeThat(value).containsExactly(4)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).containsExactlyInAnyOrder(2, 1, 3),
+            value -> assumeThat(value).containsExactlyInAnyOrder(1, 2)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).containsOnly(2, 1, 3, 2),
+            value -> assumeThat(value).containsOnly(1, 2, 4)),
+        run(asList(2, 4, 2),
+            value -> assumeThat(value).containsOnlyOnce(4),
+            value -> assumeThat(value).containsOnlyOnce(2)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).containsSequence(1, 2),
+            value -> assumeThat(value).containsSequence(1, 3)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).containsSubsequence(1, 3),
+            value -> assumeThat(value).containsSubsequence(2, 1)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).doesNotContain(4, 5),
+            value -> assumeThat(value).doesNotContain(2, 1)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).doesNotContainSequence(1, 3),
+            value -> assumeThat(value).doesNotContainSequence(1, 2)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).doesNotContainSubsequence(2, 1),
+            value -> assumeThat(value).doesNotContainSubsequence(1, 3)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).isSubsetOf(1, 2, 3, 4),
+            value -> assumeThat(value).isSubsetOf(2, 4, 6)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).startsWith(1, 2),
+            value -> assumeThat(value).startsWith(2, 3)),
+        run(asList(1, 2, 3),
+            value -> assumeThat(value).endsWith(2, 3),
+            value -> assumeThat(value).endsWith(2, 4))
+    };
+  };
+
+  @AfterClass
+  public static void afterClass() {
+    assertThat(ranTests).as("number of tests run").isEqualTo(provideAssumptionsRunners().length);
+  }
+
+}
diff --git a/src/test/java/org/assertj/core/api/assumptions/Map_final_method_assertions_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/Map_special_assertion_methods_in_assumptions_Test.java
similarity index 66%
rename from src/test/java/org/assertj/core/api/assumptions/Map_final_method_assertions_in_assumptions_Test.java
rename to src/test/java/org/assertj/core/api/assumptions/Map_special_assertion_methods_in_assumptions_Test.java
index d4a3f4e7c5..aafb2ce022 100644
--- a/src/test/java/org/assertj/core/api/assumptions/Map_final_method_assertions_in_assumptions_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Map_special_assertion_methods_in_assumptions_Test.java
@@ -12,30 +12,36 @@
  */
 package org.assertj.core.api.assumptions;
 
+import static java.util.Arrays.asList;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.entry;
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
 import static org.assertj.core.test.Maps.mapOf;
+import static org.assertj.core.util.Sets.newLinkedHashSet;
 
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
 import java.util.Map;
 
-import org.assertj.core.api.ClassAssert;
-import org.assertj.core.api.ProxyableClassAssert;
+import org.assertj.core.api.MapAssert;
+import org.assertj.core.api.ProxyableMapAssert;
 import org.junit.AfterClass;
 import org.junit.runner.RunWith;
 import org.junit.runners.Parameterized;
 import org.junit.runners.Parameterized.Parameters;
 
 /**
- * verify that assertions final methods in {@link ClassAssert} work with assumptions (i.e. that they are proxied correctly in {@link ProxyableClassAssert}).
+ * verify that assertions final methods or methods changing the object under test in {@link MapAssert} work with assumptions 
+ * (i.e. that they are proxied correctly in {@link ProxyableMapAssert}).
  */
 @RunWith(Parameterized.class)
-public class Map_final_method_assertions_in_assumptions_Test extends BaseAssumptionsRunnerTest {
+public class Map_special_assertion_methods_in_assumptions_Test extends BaseAssumptionsRunnerTest {
 
   private static int ranTests = 0;
 
-  public Map_final_method_assertions_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
+  public Map_special_assertion_methods_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
     super(assumptionRunner);
   }
 
@@ -47,7 +53,19 @@ protected void incrementRunTests() {
   @SuppressWarnings("unchecked")
   @Parameters
   public static Object[][] provideAssumptionsRunners() {
+
+    List<String> names = asList("Dave", "Jeff");
+    LinkedHashSet<String> jobs = newLinkedHashSet("Plumber", "Builder");
+    Iterable<String> cities = asList("Dover", "Boston", "Paris");
+    int[] ranks = { 1, 2, 3 };
+    Map<String, Object> iterableMap = new LinkedHashMap<>();
+    iterableMap.put("name", names);
+    iterableMap.put("job", jobs);
+    iterableMap.put("city", cities);
+    iterableMap.put("rank", ranks);
+
     Map<String, String> map = mapOf(entry("a", "1"), entry("b", "2"), entry("c", "3"));
+
     return new AssumptionRunner[][] {
         run(map,
             value -> assumeThat(value).contains(entry("a", "1"), entry("c", "3")),
@@ -76,6 +94,14 @@ public static Object[][] provideAssumptionsRunners() {
         run(map,
             value -> assumeThat(value).doesNotContainKeys("d", "e", "f"),
             value -> assumeThat(value).doesNotContainKeys("a", "e", "f")),
+        run(map,
+            value -> assumeThat(value).extracting("a", "b").contains("1", "2"),
+            value -> assumeThat(value).extracting("a", "b").contains("456")),
+        run(iterableMap,
+            value -> assumeThat(value).flatExtracting("name", "job", "city", "rank")
+                                      .contains("Jeff", "Builder", "Dover", "Boston", "Paris", 1, 2, 3),
+            value -> assumeThat(value).flatExtracting("name", "job", "city", "rank")
+                                      .contains("Unexpected", "Builder", "Dover", "Boston", "Paris", 1, 2, 3)),
     };
   };
 
diff --git a/src/test/java/org/assertj/core/api/assumptions/ObjectArray_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/ObjectArray_assumptions_Test.java
deleted file mode 100644
index a5f5655a62..0000000000
--- a/src/test/java/org/assertj/core/api/assumptions/ObjectArray_assumptions_Test.java
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
- * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations under the License.
- *
- * Copyright 2012-2018 the original author or authors.
- */
-package org.assertj.core.api.assumptions;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.tuple;
-import static org.assertj.core.api.Assumptions.assumeThat;
-import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
-import static org.assertj.core.util.Arrays.array;
-
-import org.assertj.core.data.TolkienCharacter;
-import org.assertj.core.data.TolkienCharacter.Race;
-import org.junit.AfterClass;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
-
-/**
- * verify that assertions including final methods in work with assumptions.
- */
-@RunWith(Parameterized.class)
-public class ObjectArray_assumptions_Test extends BaseAssumptionsRunnerTest {
-
-  private static int ranTests = 0;
-
-  public ObjectArray_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
-    super(assumptionRunner);
-  }
-
-  @Override
-  protected void incrementRunTests() {
-    ranTests++;
-  }
-
-  @SuppressWarnings("unchecked")
-  @Parameters
-  public static Object[][] provideAssumptionsRunners() {
-    return new AssumptionRunner[][] {
-        run(array(TolkienCharacter.of("Frodo", 33, Race.HOBBIT), TolkienCharacter.of("Sam", 35, Race.HOBBIT)),
-            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
-                                      .contains(tuple("Frodo", 33)),
-            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
-                                      .contains(tuple("Gandalf", 1000))),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).contains(1, 2),
-            value -> assumeThat(value).contains(4)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).containsAnyOf(1, 10, 20),
-            value -> assumeThat(value).containsAnyOf(0, 5, 10)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).containsExactly(1, 2, 3),
-            value -> assumeThat(value).containsExactly(4)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).containsExactlyInAnyOrder(2, 1, 3),
-            value -> assumeThat(value).containsExactlyInAnyOrder(1, 2)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).containsOnly(2, 1, 3, 2),
-            value -> assumeThat(value).containsOnly(1, 2, 4)),
-        run(array(2, 4, 2),
-            value -> assumeThat(value).containsOnlyOnce(4),
-            value -> assumeThat(value).containsOnlyOnce(2)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).containsSequence(1, 2),
-            value -> assumeThat(value).containsSequence(1, 3)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).containsSubsequence(1, 3),
-            value -> assumeThat(value).containsSubsequence(2, 1)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).doesNotContain(4, 5),
-            value -> assumeThat(value).doesNotContain(2, 1)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).doesNotContainSequence(1, 3),
-            value -> assumeThat(value).doesNotContainSequence(1, 2)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).doesNotContainSubsequence(2, 1),
-            value -> assumeThat(value).doesNotContainSubsequence(1, 3)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).isSubsetOf(1, 2, 3, 4),
-            value -> assumeThat(value).isSubsetOf(2, 4, 6)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).startsWith(1, 2),
-            value -> assumeThat(value).startsWith(2, 3)),
-        run(array(1, 2, 3),
-            value -> assumeThat(value).endsWith(2, 3),
-            value -> assumeThat(value).endsWith(2, 4))
-    };
-  };
-
-  @AfterClass
-  public static void afterClass() {
-    assertThat(ranTests).as("number of tests run").isEqualTo(provideAssumptionsRunners().length);
-  }
-
-}
diff --git a/src/test/java/org/assertj/core/api/assumptions/ObjectArray_special_assertion_methods_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/ObjectArray_special_assertion_methods_in_assumptions_Test.java
new file mode 100644
index 0000000000..3260413141
--- /dev/null
+++ b/src/test/java/org/assertj/core/api/assumptions/ObjectArray_special_assertion_methods_in_assumptions_Test.java
@@ -0,0 +1,201 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * Copyright 2012-2018 the original author or authors.
+ */
+package org.assertj.core.api.assumptions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.in;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.assertj.core.api.Assumptions.assumeThat;
+import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
+import static org.assertj.core.util.Arrays.array;
+
+import org.assertj.core.api.Condition;
+import org.assertj.core.api.ObjectArrayAssert;
+import org.assertj.core.api.ProxyableObjectArrayAssert;
+import org.assertj.core.data.TolkienCharacter;
+import org.assertj.core.test.CartoonCharacter;
+import org.junit.AfterClass;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+/**
+ * verify that assertions final methods or methods changing the object under test in {@link ObjectArrayAssert} work with assumptions 
+ * (i.e. that they are proxied correctly in {@link ProxyableObjectArrayAssert}).
+ */
+@RunWith(Parameterized.class)
+public class ObjectArray_special_assertion_methods_in_assumptions_Test extends BaseAssumptionsRunnerTest {
+
+  private static int ranTests = 0;
+
+  public ObjectArray_special_assertion_methods_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
+    super(assumptionRunner);
+  }
+
+  @Override
+  protected void incrementRunTests() {
+    ranTests++;
+  }
+
+  @SuppressWarnings("unchecked")
+  @Parameters
+  public static Object[][] provideAssumptionsRunners() {
+    setupData();
+    return new AssumptionRunner[][] {
+        // extracting methods
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting(throwingNameExtractor)
+                                      .contains("Frodo"),
+            value -> assumeThat(value).extracting(throwingNameExtractor)
+                                      .contains("Gandalf")),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting(nameExtractor)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting(nameExtractor)
+                                      .contains("Gandalf", "Sam")),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting("name")
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting("name")
+                                      .contains("Gandalf", "Sam")),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting("name", String.class)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extracting("name", String.class)
+                                      .contains("Gandalf", "Sam")),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains(tuple("Gandalf", 1000))),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting(nameExtractorFunction, ageExtractorFunction)
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting(nameExtractorFunction, ageExtractorFunction)
+                                      .contains(tuple("Gandalf", 1000))),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains(tuple("Gandalf", 1000))),
+        // extractingResultOf methods
+        run(array(frodo, sam),
+            value -> assumeThat(value).extractingResultOf("getName")
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extractingResultOf("getName")
+                                      .contains("Gandalf", "Sam")),
+        run(array(frodo, sam),
+            value -> assumeThat(value).extractingResultOf("getName", String.class)
+                                      .contains("Frodo", "Sam"),
+            value -> assumeThat(value).extractingResultOf("getName", String.class)
+                                      .contains("Gandalf", "Sam")),
+        // flatExtracting methods
+        run(array(homer, fred),
+            value -> assumeThat(value).flatExtracting("children")
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting("children")
+                                      .containsAnyOf(homer, fred)),
+        run(array(homer, fred),
+            value -> assumeThat(value).flatExtracting(childrenExtractor)
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting(childrenExtractor)
+                                      .containsAnyOf(homer, fred)),
+        run(array(homer, fred),
+            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
+                                      .containsAnyOf(bart, lisa),
+            value -> assumeThat(value).flatExtracting(CartoonCharacter::getChildren)
+                                      .containsAnyOf(homer, fred)),
+        // filteredOn methods
+        run(array(frodo, sam),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .contains(sam)),
+        run(array(frodo, sam),
+            value -> assumeThat(value).filteredOn(new Condition<>(hero -> hero.getName().startsWith("Fro"), "startsWith Fro"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn(new Condition<>(hero -> hero.getName().startsWith("Fro"), "startsWith Fro"))
+                                      .contains(sam)),
+        run(array(frodo, sam),
+            value -> assumeThat(value).filteredOn("name", "Frodo")
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn("name", "Frodo")
+                                      .contains(sam)),
+        run(array(frodo, sam),
+            value -> assumeThat(value).filteredOnNull("name")
+                                      .isEmpty(),
+            value -> assumeThat(value).filteredOnNull("name")
+                                      .contains(sam)),
+        run(array(frodo, sam),
+            value -> assumeThat(value).filteredOn("name", in("John", "Frodo"))
+                                      .contains(frodo),
+            value -> assumeThat(value).filteredOn("name", in("John", "Frodo"))
+                                      .contains(sam)),
+        run(array(frodo, sam),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .extracting("name", "age")
+                                      .contains(tuple("Frodo", 33)),
+            value -> assumeThat(value).filteredOn(hero -> hero.getName().startsWith("Fro"))
+                                      .extracting("name", "age")
+                                      .contains(tuple("Sam", 35))),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).contains(1, 2),
+            value -> assumeThat(value).contains(4)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).containsAnyOf(1, 10, 20),
+            value -> assumeThat(value).containsAnyOf(0, 5, 10)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).containsExactly(1, 2, 3),
+            value -> assumeThat(value).containsExactly(4)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).containsExactlyInAnyOrder(2, 1, 3),
+            value -> assumeThat(value).containsExactlyInAnyOrder(1, 2)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).containsOnly(2, 1, 3, 2),
+            value -> assumeThat(value).containsOnly(1, 2, 4)),
+        run(array(2, 4, 2),
+            value -> assumeThat(value).containsOnlyOnce(4),
+            value -> assumeThat(value).containsOnlyOnce(2)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).containsSequence(1, 2),
+            value -> assumeThat(value).containsSequence(1, 3)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).containsSubsequence(1, 3),
+            value -> assumeThat(value).containsSubsequence(2, 1)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).doesNotContain(4, 5),
+            value -> assumeThat(value).doesNotContain(2, 1)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).doesNotContainSequence(1, 3),
+            value -> assumeThat(value).doesNotContainSequence(1, 2)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).doesNotContainSubsequence(2, 1),
+            value -> assumeThat(value).doesNotContainSubsequence(1, 3)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).isSubsetOf(1, 2, 3, 4),
+            value -> assumeThat(value).isSubsetOf(2, 4, 6)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).startsWith(1, 2),
+            value -> assumeThat(value).startsWith(2, 3)),
+        run(array(1, 2, 3),
+            value -> assumeThat(value).endsWith(2, 3),
+            value -> assumeThat(value).endsWith(2, 4))
+    };
+  };
+
+  @AfterClass
+  public static void afterClass() {
+    assertThat(ranTests).as("number of tests run").isEqualTo(provideAssumptionsRunners().length);
+  }
+
+}
diff --git a/src/test/java/org/assertj/core/api/assumptions/Object_final_method_assertions_in_assumptions_Test.java b/src/test/java/org/assertj/core/api/assumptions/Object_special_assertion_methods_in_assumptions_Test.java
similarity index 70%
rename from src/test/java/org/assertj/core/api/assumptions/Object_final_method_assertions_in_assumptions_Test.java
rename to src/test/java/org/assertj/core/api/assumptions/Object_special_assertion_methods_in_assumptions_Test.java
index b2b3546439..b9785a0782 100644
--- a/src/test/java/org/assertj/core/api/assumptions/Object_final_method_assertions_in_assumptions_Test.java
+++ b/src/test/java/org/assertj/core/api/assumptions/Object_special_assertion_methods_in_assumptions_Test.java
@@ -16,8 +16,8 @@
 import static org.assertj.core.api.Assumptions.assumeThat;
 import static org.assertj.core.api.assumptions.BaseAssumptionRunner.run;
 
-import org.assertj.core.api.ClassAssert;
-import org.assertj.core.api.ProxyableClassAssert;
+import org.assertj.core.api.ObjectAssert;
+import org.assertj.core.api.ProxyableObjectAssert;
 import org.assertj.core.data.TolkienCharacter;
 import org.assertj.core.data.TolkienCharacter.Race;
 import org.junit.AfterClass;
@@ -26,14 +26,15 @@
 import org.junit.runners.Parameterized.Parameters;
 
 /**
- * verify that assertions final methods in {@link ClassAssert} work with assumptions (i.e. that they are proxied correctly in {@link ProxyableClassAssert}).
+ * verify that assertions final methods or methods changing the object under test in {@link ObjectAssert} work with assumptions 
+ * (i.e. that they are proxied correctly in {@link ProxyableObjectAssert}).
  */
 @RunWith(Parameterized.class)
-public class Object_final_method_assertions_in_assumptions_Test extends BaseAssumptionsRunnerTest {
+public class Object_special_assertion_methods_in_assumptions_Test extends BaseAssumptionsRunnerTest {;
 
   private static int ranTests = 0;
 
-  public Object_final_method_assertions_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
+  public Object_special_assertion_methods_in_assumptions_Test(AssumptionRunner<?> assumptionRunner) {
     super(assumptionRunner);
   }
 
@@ -50,6 +51,11 @@ public static Object[][] provideAssumptionsRunners() {
             value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
                                       .contains("Frodo", 33),
             value -> assumeThat(value).extracting(TolkienCharacter::getName, TolkienCharacter::getAge)
+                                      .contains("Gandalf", 1000)),
+        run(TolkienCharacter.of("Frodo", 33, Race.HOBBIT),
+            value -> assumeThat(value).extracting("name", "age")
+                                      .contains("Frodo", 33),
+            value -> assumeThat(value).extracting("name", "age")
                                       .contains("Gandalf", 1000))
     };
   };