},
        "dutch_keywords": {
          "type":       "keyword_marker",
          "keywords": ["hallo", "wereld", "zoeken"]
        },
        "dutch_stemmer": {
          "type":       "stemmer",

  Chat chat = new Chat(baseUrl);

  chat.loadMore();
  assertEquals("hello, world!", chat.messages());

  chat.loadMore();
  chat.loadMore();
  assertEquals(""
      + "hello, world!\n"
      + "sup, bra?\n"
      + "yo dog", chat.messages());

  // Optional: confirm that your app made the HTTP requests you were expecting.
  RecordedRequest request1 = server.takeRequest();

        .addEqualityGroup(Equivalence.identity().equivalentTo("1"))
        .testEquals();
  }

  /*
   * We use large numbers to avoid the integer cache. Normally, we'd accomplish that merely by using
   * `new Integer` (as we do) instead of `Integer.valueOf`. However, under J2KT, `new Integer`
   * gets translated back to `Integer.valueOf` because that is the only thing J2KT can support. And

        .addEqualityGroup(Equivalence.identity().equivalentTo("1"))
        .testEquals();
  }

  /*
   * We use large numbers to avoid the integer cache. Normally, we'd accomplish that merely by using
   * `new Integer` (as we do) instead of `Integer.valueOf`. However, under J2KT, `new Integer`
   * gets translated back to `Integer.valueOf` because that is the only thing J2KT can support. And

            // Read remaining bytes
            byte[] remaining = new byte[20];
            int remainingBytes = stream.read(remaining);
            assertEquals(8, remainingBytes); // ", World!"
            assertEquals(", World!", new String(remaining, 0, remainingBytes, "UTF-8"));
        }
    }

        Did you *actually* encounter the need for this enhancement in a real-world scenario, or does
        it just seem like a sensible behavior for the feature to have?


        Before we make significant changes to existing features in Guava, we really want to be sure
        that it's for a use case that actually comes up in the real world. We want to hear the
        real-world use case so the community can discuss and debate whether this feature is actually

    val responseString = decompressed.body.string()
    assertThat(responseString).isEqualTo("hello zstd world")
  }

  @Test
  fun testDecompressGzip() {
    val s = "hello gzip world".encodeUtf8().gzipCompress()

    val response =
      response("https://example.com/", s) {
        header("Content-Encoding", "gzip")
      }

    }
  }

  @Test
  fun singlePart() {
    val expected =
      """
      |--123
      |
      |Hello, World!
      |--123--
      |
      """.trimMargin().replace("\n", "\r\n")
    val body =
      MultipartBody
        .Builder("123")
        .addPart("Hello, World!".toRequestBody(null))
        .build()
    assertThat(body.boundary).isEqualTo("123")

        }
    }

    public void test_startProcess_withBufferSizeAndCallback() {
        String sessionId = "test_session_buffer";
        List<String> cmdList = Arrays.asList("echo", "hello world");
        Consumer<ProcessBuilder> pbCall = pb -> {
            pb.redirectErrorStream(true);
        };

        List<String> outputs = new ArrayList<>();

        assertEquals("hello", DocumentUtil.encodeUrl("hello"));
        assertEquals("hello-world", DocumentUtil.encodeUrl("hello-world"));
        assertEquals("hello_world", DocumentUtil.encodeUrl("hello_world"));
        assertEquals("hello.world", DocumentUtil.encodeUrl("hello.world"));
    }

    public void test_encodeUrl_empty_and_null() {
        assertEquals("", DocumentUtil.encodeUrl(""));