)
      request.isChunked -> newChunkedSink() // Stream a request body of unknown length.
      contentLength != -1L -> newKnownLengthSink() // Stream a request body of a known length.
      else -> // Stream a request body of a known length.
        throw IllegalStateException(
          "Cannot stream a request body without chunked encoding or a known content length!",
        )
    }

import com.google.common.collect.Table.Cell;
import com.google.common.testing.CollectorTester;
import java.util.function.BiPredicate;
import java.util.function.BinaryOperator;
import java.util.stream.Collector;
import java.util.stream.Stream;
import junit.framework.TestCase;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/** Unit tests for {@link TableCollectors}. */
@GwtCompatible
@NullMarked

    /**
     * Gets the input stream for reading from this pipe.
     *
     * @return this pipe's input stream
     * @throws CIFSException if an error occurs getting the input stream
     */
    InputStream getInput() throws CIFSException;

    /**
     * Gets the output stream for writing to this pipe.
     *
     * @return this pipe's output stream

          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    newEventSource()
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
    assertThat(server.takeRequest().headers["Accept"])
      .isEqualTo("text/event-stream")
  }

  @Test
  fun eventListenerEvents() {
    server.enqueue(

 * is deleted when the stream is closed.
 */
public class TemporaryFileInputStream extends InputStream {
    private static final Logger logger = LogManager.getLogger(TemporaryFileInputStream.class);

    private final File tempFile;

    private final FileInputStream fileInputStream;

    /**
     * A class that provides an input stream for reading from a temporary file.

  /*
   * We're not really testing the implementation of Stream, only that we're getting a Stream
   * that corresponds to the expected elements.
   */

  @CollectionFeature.Require(absent = KNOWN_ORDER)
  public void testStreamToArrayUnknownOrder() {
    Helpers.assertEqualIgnoringOrder(getSampleElements(), asList(collection.stream().toArray()));
  }

  @CollectionFeature.Require(KNOWN_ORDER)

 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.app.web.admin.labeltype;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.stream.Collectors;
import java.util.stream.Stream;

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

@J2ktIncompatible
@GwtIncompatible
public final class LittleEndianDataInputStream extends FilterInputStream implements DataInput {

  /**
   * Creates a {@code LittleEndianDataInputStream} that wraps the given stream.
   *
   * @param in the stream to delegate to
   */
  public LittleEndianDataInputStream(InputStream in) {
    super(Preconditions.checkNotNull(in));
  }

  /** This method will throw an {@link UnsupportedOperationException}. */

        }

        byte[] content;
        try (ASN1InputStream stream = new ASN1InputStream(token)) {
            content = ASN1Util.readUnparsedTagged(0, 0x8000, stream);
        } catch (IOException e) {
            throw new PACDecodingException("Malformed kerberos token", e);
        }

        try (ASN1InputStream stream = new ASN1InputStream(content)) {

                            }
                        });
                        final List<String> newGroupList = stream(user.getGroupNames()).get(stream -> stream.collect(Collectors.toList()));
                        stream(user.getGroupNames()).of(stream -> stream.forEach(name -> {
                            if (oldGroupList.contains(name)) {
                                oldGroupList.remove(name);