spliterator simulacro de ejecución Iterable cuando se le llama varias veces?

ppasler:

Tengo un problema burlarse de una Iterableclase combinado con una llamada de spliterator(). Todo funciona bien cuando se llama a spliteratorla vez, pero la segunda llamada no devuelve ningún valor.

A medida que el simulacro siempre devuelve la misma Spliteratorinstancia, supongo que el Estado no se restablece. ¿Hay alguna forma de hacer esto?

Este es el ejemplo más pequeño que podría dar

La llamada mapStringToHashes un Lib en la vida real y no se puede cambiar. MyIterableTambién es ningún objeto bajo mi control.

package net.test;

import static org.hamcrest.CoreMatchers.is;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static java.util.stream.Collectors.toList;
import static org.hamcrest.MatcherAssert.assertThat;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Spliterator;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;

@RunWith(MockitoJUnitRunner.class)
public class SpliteratorTest {

    class MyIterable<T> implements Iterable<T> {

        private List<T> list;

        MyIterable(List<T> list) {
            this.list = new ArrayList<>(list);
        }

        @Override
        public Iterator<T> iterator() {
            return list.iterator();
        }

        @Override
        public Spliterator<T> spliterator() {
            return list.spliterator();
        }
    }

    // this a library method
    private Stream<Integer> mapStringToHash(final MyIterable<String> myIterable) {
        return StreamSupport.stream(myIterable.spliterator(), false).map(String::hashCode);
    }

    @Test
    public void testSeveralSpliteratorCalls() {
        MyIterable myIterable = givenMyIterableMock("a", "b", "c");

        Stream<Integer> myIterableHash1 = mapStringToHash(myIterable);
        assertThat(myIterableHash1.count(), is(3L));


        Stream<Integer> myIterableHash2 = mapStringToHash(myIterable);
        assertThat(myIterableHash2.count(), is(3L));
    }

    private MyIterable givenMyIterableMock(String... values) {
        MyIterable myIterable = mock(MyIterable.class);

        Spliterator myIterableSpliterator = Arrays.stream(values)
                .collect(toList())
                .spliterator();
        doReturn(myIterableSpliterator).when(myIterable).spliterator();
        return myIterable;
    }
}

Tomasz Linkowski:

Resulta que no es tan eludir como pensaba. Se puede hacer uso de una costumbre Answeraplicación, pero ya que Answeres una interfaz funcional, los siguientes basta:

Mockito.when(myIterable.spliterator()).then(invocation -> Arrays.spliterator(values));