server.enqueue(
      MockResponse
        .Builder()
        .body(
          """
          |data: hey
          |
          |
          """.trimMargin(),
        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val request = Request.Builder().url(server.url("/")).build()
    val response = client.newCall(request).execute()
    response.processEventSource(listener)
    listener.assertOpen()

                    } else {
                        ignoreFields = new String[] { Constants.INDEXING_TARGET, Constants.SESSION_ID };
                    }
                    stream(ignoreFields).of(stream -> stream.map(String::trim).forEach(s -> dataMap.remove(s)));

                    indexUpdateCallback.store(paramMap, dataMap);
                    crawlerStatsHelper.record(keyObj, StatsAction.PROCESSED);

         *
         * @param value the configuration value string to parse
         */
        public Config(final String value) {
            values = StreamUtil.split(value, Pattern.quote("|")).get(stream -> stream.map(String::trim).toArray(n -> new String[n]));
        }

        /**
         * Checks if the cache option is enabled in the configuration.

        // or throw an exception. Test the actual behavior.
        queryFieldConfig.highlightedFields(stream -> {
            // If it doesn't throw NPE, it should provide an empty stream
            assertEquals(0, stream.count());
        });
    }

    public void test_init_withInvalidDefaultFields() {
        // Test with invalid default field formats

   * corresponding response body stream. This is necessary if we want servers to be able to stop
   * inbound data and send an early 400 before the request body completes.
   *
   * This test sends a slow request that is canceled by the server. It expects the response to still
   * be readable after the request stream is canceled.
   */
  @Disabled
  @Test

        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 {
            this.stream.close();
            this.collector.close();

    assertThat(count.get()).isEqualTo(4);
  }

  public void testStream() {
    ImmutableLongArray.of().stream().forEach(i -> fail());
    ImmutableLongArray.of(0, 1, 3).subArray(1, 1).stream().forEach(i -> fail());
    assertThat(ImmutableLongArray.of(0, 1, 3).stream().toArray()).isEqualTo(new long[] {0, 1, 3});
  }

  public void testSubArray() {
    ImmutableLongArray iia0 = ImmutableLongArray.of();

    /**
     * Creates a new MsWordExtractor instance.
     */
    public MsWordExtractor() {
        super();
    }

    /**
     * Extracts text from the Word input stream.
     * @param in The input stream.
     * @param params The parameters.
     * @return The extracted data.
     */
    @Override
    public ExtractData getText(final InputStream in, final Map<String, String> params) {

    }

    /**
     * Wraps exception handling for {@link Properties#load(InputStream)}.
     * <p>
     * The input stream is not closed.
     * </p>
     *
     * @param props the property set (must not be {@literal null})
     * @param in the input stream (must not be {@literal null})
     */
    public static void load(final Properties props, final InputStream in) {

        this.body = body;
        return this;
    }

    /**
     * Sets the input stream for the request body.
     *
     * @param stream the input stream
     * @return this CurlRequest instance
     * @throws CurlException if the body method is already called
     */
    public CurlRequest body(final InputStream stream) {
        if (body != null) {
            throw new CurlException("body method is already called.");