GeneralSpliterator<E> spliterator, Consumer<? super E> consumer) {
        spliterator.forEachRemaining(consumer);
      }
    },
    NO_SPLIT_TRY_ADVANCE {
      @Override
      <E extends @Nullable Object> void forEach(
          GeneralSpliterator<E> spliterator, Consumer<? super E> consumer) {
        while (spliterator.tryAdvance(consumer)) {
          // do nothing
        }
      }
    },

    }

    /**
     * Processes thumbnail generation with a consumer function.
     * @param id The document ID.
     * @param consumer The consumer function to process thumbnail and config ID.
     * @return True if processing was successful, false otherwise.
     */
    protected boolean process(final String id, final BiPredicate<String, String> consumer) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();

        // Arrange: pick a value and a mocked consumer
        RequestParam rp = RequestParam.NO_RETRY;

        // Act: pass to the collaborator
        consumer.accept(rp);

        // Assert: interaction happened exactly once with correct argument; no other calls
        verify(consumer, times(1)).accept(RequestParam.NO_RETRY);
        verifyNoMoreInteractions(consumer);
    }

    /**
     * Sets an attribute value from search results using a Consumer.
     *
     * @param result the list of search results
     * @param name the attribute name
     * @param consumer the Consumer to process the attribute value
     */
    protected void setAttributeValue(final List<SearchResult> result, final String name, final Consumer<Object> consumer) {
        final List<Object> attrList = getAttributeValueList(result, name);

    private static class StreamGobbler implements Runnable {
        private final InputStream inputStream;
        private final Consumer<String> consumer;

        private StreamGobbler(InputStream inputStream, Consumer<String> consumer) {
            this.inputStream = inputStream;
            this.consumer = consumer;
        }

        @Override
        public void run() {

     * @param initializer the initializer consumer for the component
     * @param destroyer the destroyer consumer for the component
     * @return this container instance for method chaining
     */
    public <T> StandardCrawlerContainer singleton(final String name, final Class<T> cls, final Consumer<T> initializer,
            final Consumer<T> destroyer) {

        DeployRequest result = transformer.remapDeployArtifacts(session, request);

        // Should have both consumer POM (no classifier) and build POM (with "build" classifier)
        Collection<Artifact> artifacts = result.getArtifacts();
        assertEquals(3, artifacts.size()); // original jar + consumer pom + build pom

        }
    }

    /**
     * Processes all thread information and sends it to the provided consumer.
     *
     * @param writer the consumer that will handle each line of thread dump output
     */
    public static void processThreadDump(final Consumer<String> writer) {
        for (final Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {

        if (logger.isDebugEnabled()) {
            writePlan(logger::debug, plan, project);
        }
    }

    public void writePlan(Consumer<String> writer, BuildPlan plan) {
        plan.projects().forEach(project -> writePlan(writer, plan, project));
    }

    public void writePlan(Consumer<String> writer, BuildPlan plan, MavenProject project) {
        writer.accept("=== PROJECT BUILD PLAN ================================================");

    class MockCurlRequest extends CurlRequest {

        MockCurlRequest(Curl.Method method, String url) {
            super(method, url);
        }

        @Override
        public void connect(Consumer<HttpURLConnection> actionListener, Consumer<Exception> exceptionListener) {
            try {
                actionListener.accept(new MockHttpURLConnection(new URL(url)));
            } catch (MalformedURLException e) {