Extend dead-chain pattern to Matcher group/groups and Iterator.toIterable

`AbstractMatcherAssert#group(int)`, `group(String)`, and `groups()` called
`matches()` (which wraps its own `isNotNull()` in `executeAssertion`) and
then dereferenced `actual.group(...)` / `actual.groupCount()`; on a null
matcher in soft mode the null-guard was collected but the subsequent
dereference leaked an NPE.

`AbstractIteratorAssert#toIterable()` had no guard at all and NPE'd on
a null iterator.

Add `if (actual == null) return markAsDeadChain(new StringAssert(null))`
(or `ListAssert`/`IterableAssert` for the other return types) after the
existing guard. Also propagate `withAssertionState(myself)` on the
normal-mode return for Matcher navigations so downstream chained
assertions inherit the soft handler.

Author: filiphr

assertj-core/src/main/java/org/assertj/core/api/AbstractIteratorAssert.java

@@ -93,7 +93,9 @@ public SELF isExhausted() {
    * @since 3.12.0
    */
   public IterableAssert<ELEMENT> toIterable() {
-    return new IterableAssert<>(IterableAssert.toIterable(actual));
+    isNotNull();
+    if (actual == null) return markAsDeadChain(new IterableAssert<ELEMENT>((Iterable<? extends ELEMENT>) null));
+    return new IterableAssert<ELEMENT>(IterableAssert.toIterable(actual)).withAssertionState(myself);
   }
 
   /**

assertj-core/src/main/java/org/assertj/core/api/AbstractMatcherAssert.java

@@ -20,6 +20,7 @@
 import static org.assertj.core.error.MatcherShouldHaveGroup.shouldHaveGroup;
 import static org.assertj.core.error.MatcherShouldMatch.shouldMatch;
 
+import java.util.List;
 import java.util.function.Supplier;
 import java.util.regex.Matcher;
 
@@ -84,9 +85,9 @@ public SELF matches() {
    * @since 4.0.0
    */
   public AbstractStringAssert<?> group(int groupIndex) {
-    isNotNull();
     matches();
-    return assertThat(extractGroup(() -> actual.group(groupIndex), groupIndex));
+    if (actual == null) return markAsDeadChain(new StringAssert(null));
+    return assertThat(extractGroup(() -> actual.group(groupIndex), groupIndex)).withAssertionState(myself);
   }
 
   /**
@@ -108,9 +109,9 @@ public AbstractStringAssert<?> group(int groupIndex) {
    * @since 4.0.0
    */
   public AbstractStringAssert<?> group(String groupName) {
-    isNotNull();
     matches();
-    return assertThat(extractGroup(() -> actual.group(groupName), groupName));
+    if (actual == null) return markAsDeadChain(new StringAssert(null));
+    return assertThat(extractGroup(() -> actual.group(groupName), groupName)).withAssertionState(myself);
   }
 
   /**
@@ -130,9 +131,9 @@ public AbstractStringAssert<?> group(String groupName) {
    * @since 4.0.0
    */
   public ListAssert<String> groups() {
-    isNotNull();
     matches();
-    return assertThat(rangeClosed(1, actual.groupCount()).mapToObj(actual::group).toList());
+    if (actual == null) return markAsDeadChain(new ListAssert<>((List<String>) null));
+    return assertThat(rangeClosed(1, actual.groupCount()).mapToObj(actual::group).toList()).withAssertionState(myself);
   }
 
   private String extractGroup(Supplier<String> groupExtractor, Object groupIdentifier) {

assertj-core/src/test/java/org/assertj/core/api/SoftAssertions_navigations_on_null_actual_Test.java

@@ -843,6 +843,51 @@ void should_not_throw_when_calling_asString_with_charset_on_null_input_stream()
 
   }
 
+  @Nested
+  class MatcherAndIterator {
+
+    @Test
+    void should_not_throw_when_calling_group_by_index_on_null_matcher() {
+      // GIVEN / WHEN
+      softly.assertThat((java.util.regex.Matcher) null).group(1).isEqualTo("foo");
+      // THEN
+      List<Throwable> errors = softly.errorsCollected();
+      then(errors).hasSize(1);
+      then(errors.get(0)).hasMessageContaining("Expecting actual not to be null");
+    }
+
+    @Test
+    void should_not_throw_when_calling_group_by_name_on_null_matcher() {
+      // GIVEN / WHEN
+      softly.assertThat((java.util.regex.Matcher) null).group("g1").isEqualTo("foo");
+      // THEN
+      List<Throwable> errors = softly.errorsCollected();
+      then(errors).hasSize(1);
+      then(errors.get(0)).hasMessageContaining("Expecting actual not to be null");
+    }
+
+    @Test
+    void should_not_throw_when_calling_groups_on_null_matcher() {
+      // GIVEN / WHEN
+      softly.assertThat((java.util.regex.Matcher) null).groups().contains("foo");
+      // THEN
+      List<Throwable> errors = softly.errorsCollected();
+      then(errors).hasSize(1);
+      then(errors.get(0)).hasMessageContaining("Expecting actual not to be null");
+    }
+
+    @Test
+    void should_not_throw_when_calling_toIterable_on_null_iterator() {
+      // GIVEN / WHEN
+      softly.assertThat((java.util.Iterator<String>) null).toIterable().contains("foo");
+      // THEN
+      List<Throwable> errors = softly.errorsCollected();
+      then(errors).hasSize(1);
+      then(errors.get(0)).hasMessageContaining("Expecting actual not to be null");
+    }
+
+  }
+
   @Nested
   class StringNavigations {