if (!errors.isEmpty()) {
                            logger.warn("{}", errors.stream().collect(Collectors.joining(", ")));
                            if (auth.isDebugActive() && StringUtil.isNotBlank(auth.getLastErrorReason())) {
                                logger.warn("Authentication Failure: {} - Reason: {}", errors.stream().collect(Collectors.joining(", ")),
                                        auth.getLastErrorReason());

        private final OutputStream stream;

        private final OutputStream collector;

        public CacheStream(final OutputStream stream, final OutputStream collector) {
            this.stream = stream;
            this.collector = collector;
        }

        @Override
        public void close() throws IOException {
            stream.close();
            collector.close();
        }

import java.util.TreeMap;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.stream.Collector;
import java.util.stream.Stream;
import org.jspecify.annotations.Nullable;

/** Collectors utilities for {@code common.collect} internals. */
@GwtCompatible
@IgnoreJRERequirement // used only from APIs with Java 8 types in them

import java.util.TreeMap;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.stream.Collector;
import java.util.stream.Stream;
import org.jspecify.annotations.Nullable;

/** Collectors utilities for {@code common.collect} internals. */
@GwtCompatible
final class CollectCollectors {

  override fun finishRequest() {
    stream!!.sink.close()
  }

  override fun readResponseHeaders(expectContinue: Boolean): Response.Builder? {
    val stream = stream ?: throw IOException("stream wasn't created")
    val headers = stream.takeHeaders(callerIsIdle = expectContinue)
    val responseBuilder = readHttp2HeadersList(headers, protocol)
    return if (expectContinue && responseBuilder.code == HTTP_CONTINUE) {
      null
    } else {

 */
package org.codelibs.fess.app.web.api.admin.labeltype;

import static org.codelibs.core.stream.StreamUtil.stream;
import static org.codelibs.fess.app.web.admin.labeltype.AdminLabeltypeAction.getLabelType;

import java.util.List;
import java.util.stream.Collectors;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.codelibs.core.lang.StringUtil;

            }
        }

        if (code >= 400 && stream != null) {
            when(conn.getErrorStream()).thenReturn(stream);
        } else if (stream != null) {
            when(conn.getInputStream()).thenReturn(stream);
        }
    }

    /**
     * Test helper class for mocking URL.openConnection() behavior
     */

            ioe = new InterruptedIOException(root.getMessage());
            ioe.initCause(root);
        }
        return ioe;
    }

    /**
     * Closes this input stream and releases any system resources associated with the stream.
     *
     * @throws IOException
     *             if a network error occurs
     */

    @Override
    public void close() throws IOException {
        try {

 *
 * <p>All other methods delegate to the wrapped input stream.</p>
 *
 */
public class IgnoreCloseInputStream extends InputStream {

    /** The wrapped input stream. */
    private transient InputStream inputStream;

    /**
     * Constructs a new IgnoreCloseInputStream that wraps the specified input stream.
     *

        return chains().get(stream -> stream.allMatch(c -> c.changePassword(username, password)));
    }

    /**
     * Deletes a user from all authentication chains.
     * @param user The user to delete.
     */
    public void delete(final User user) {
        chains().of(stream -> stream.forEach(c -> c.delete(user)));
    }

    /**