Support streams in verifyEach

Add verifyEach overloads accepting java.util.stream.Stream (with and
without a namer), adapting the single-use stream to an Iterable that is
iterated exactly once.

Author: leonard84

docs/release_notes.adoc

@@ -9,6 +9,7 @@ include::include.adoc[]
 === Enhancements
 
 * Improve `verifyEach` to also accept object arrays, not only `Iterable`
+* Improve `verifyEach` to also accept a `java.util.stream.Stream`
 * Improve `verifyEach` to accept a `Map`, iterating its entries with Groovy's key/value destructuring
 * Add support for `final` local variables in `where:` blocks, declared at their beginning and evaluated once per feature, scoped to the where-block spockIssue:138[]
 * Improve `TooManyInvocationsError` now reports unsatisfied interactions with argument mismatch details, making it easier to diagnose why invocations didn't match expected interactions spockPull:2315[]

spock-core/src/main/java/spock/lang/Specification.java

@@ -28,6 +28,7 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.function.Function;
+import java.util.stream.Stream;
 
 import org.spockframework.lang.ISpecificationContext;
 import org.spockframework.lang.Wildcard;
@@ -424,6 +425,60 @@ public <U> void verifyEach(
     verifyEach(Arrays.asList(things), namer, closure);
   }
 
+  /**
+   * Performs assertions on each element of a stream, collecting up failures instead of stopping at first.
+   * <p>
+   * Exception messages will contain a toString() of the element to identify it.
+   * <p>
+   * The closure can either use one or two parameters.
+   * The first parameter will always be the element.
+   * The second optional parameter will be the iteration index of the element.
+   *
+   * @param things the stream to inspect
+   * @param closure a code block containing top-level conditions
+   * @param <U> type of elements in things
+   * @since 2.5
+   */
+  @Beta
+  public <U> void verifyEach(
+    Stream<U> things,
+    @ClosureParams(value = FromString.class, options = {"U", "U, int"})
+    @DelegatesTo(type = "U", strategy = Closure.DELEGATE_FIRST)
+    Closure<?> closure
+  ) {
+    verifyEach(things, Objects::toString, closure);
+  }
+
+  /**
+   * Performs assertions on each element of a stream, collecting up failures instead of stopping at first.
+   * <p>
+   * Exception messages will contain the result of calling the namer for an element to identify it.
+   * <p>
+   * The closure can either use one or two parameters.
+   * The first parameter will always be the element.
+   * The second optional parameter will be the iteration index of the element.
+   *
+   * @param things the stream to inspect
+   * @param namer the namer function to use when rendering the exception
+   * @param closure a code block containing top-level conditions
+   * @param <U> type of elements in things
+   * @since 2.5
+   */
+  @Beta
+  public <U> void verifyEach(
+    Stream<U> things,
+    Function<? super U, ?> namer,
+    @ClosureParams(value = FromString.class, options = {"U", "U, int"})
+    @DelegatesTo(type = "U", strategy = Closure.DELEGATE_FIRST)
+    Closure<?> closure
+  ) {
+    if (things == null) {
+      throw new SpockAssertionError("Target of 'verifyEach' block must not be null");
+    }
+    // a Stream is single-use, so adapt it to an Iterable that iterates it exactly once
+    verifyEach((Iterable<U>) things::iterator, namer, closure);
+  }
+
   /**
    * Performs assertions on each entry of a map, collecting up failures instead of stopping at first.
    * <p>

spock-specs/src/test/groovy/org/spockframework/smoke/VerifyEachBlocks.groovy

@@ -210,6 +210,65 @@ class VerifyEachBlocks extends EmbeddedSpecification {
     e.message == "Target of 'verifyEach' block must not be null"
   }
 
+  def "verifyEach supports streams"() {
+    given:
+    def stream = [1, 2, 3].stream()
+
+    expect:
+    verifyEach(stream) {
+      it > 0
+    }
+  }
+
+  def "verifyEach on a stream handles a failed element verification"() {
+    given:
+    def stream = [1, 2, 3].stream()
+
+    when:
+    verifyEach(stream) {
+      it < 3
+    }
+
+    then:
+    SpockAssertionError e = thrown()
+    e.message.contains('item[2] 3')
+  }
+
+  def "verifyEach on a stream supports the namer"() {
+    given:
+    def stream = [1, 2, 3].stream()
+
+    when:
+    verifyEach(stream, { "int($it)" }) {
+      it < 3
+    }
+
+    then:
+    SpockAssertionError e = thrown()
+    e.message.contains('int(3)')
+  }
+
+  def "verifyEach on a stream can have an optional index parameter"() {
+    given:
+    def stream = [1, 2, 3].stream()
+
+    expect:
+    verifyEach(stream) { it, index ->
+      it == index + 1
+    }
+  }
+
+  def "verifyEach on a null stream fails with a clear message"() {
+    when:
+    verifyEach((java.util.stream.Stream) null) {
+      it > 0
+    }
+
+    then:
+    SpockAssertionError e = thrown()
+    e.message == "Target of 'verifyEach' block must not be null"
+  }
+
   def "verifyEach supports maps with a key and value parameter"() {
     given:
     def map = [a: 1, b: 2, c: 3]