return charset;
    }

    /**
     * Gets the character encoding used for FTP operations.
     *
     * @return The character encoding
     */
    public String getCharset() {
        return charset;
    }

    /**
     * Sets the character encoding used for FTP operations.
     *
     * @param charset The character encoding to set
     */
    public void setCharset(final String charset) {

  /** Public suffix that is backed by an ICANN-style domain name registry */
  REGISTRY('!', '?');

  /** The character used for an inner node in the trie encoding */
  private final char innerNodeCode;

  /** The character used for a leaf node in the trie encoding */
  private final char leafNodeCode;

  PublicSuffixType(char innerNodeCode, char leafNodeCode) {
    this.innerNodeCode = innerNodeCode;

        // Verify size
        assertEquals(3, encodable.size(), "Size should be equal to the specified length");
    }

    @Test
    void testEncodeBasic() {
        // Test basic encoding
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };
        ByteEncodable encodable = new ByteEncodable(data, 1, 3);
        byte[] dest = new byte[5];

        int encodedLen = encodable.encode(dest, 0);

    /**
     * Field name for data.
     */
    public static final String DATA = "data";

    /**
     * Field name for encoding.
     */
    public static final String ENCODING = "encoding";

    /**
     * Creates a new instance of OpenSearchAccessResultData.
     */
    public OpenSearchAccessResultData() {
    }

    /**

    responseBody.close()
    networkLogs
      .assertLogEqual("--> POST $url http/1.1")
      .assertLogEqual("Content-Encoding: gzip")
      .assertLogEqual("Transfer-Encoding: chunked")
      .assertLogEqual("Host: $host")
      .assertLogEqual("Connection: Keep-Alive")
      .assertLogEqual("Accept-Encoding: gzip")
      .assertLogMatch(Regex("""User-Agent: okhttp/.+"""))
      .assertLogEqual("")

        if (data == null) {
            return null;
        }
        final String encoding = accessResultData.getEncoding();
        String filePath;
        try {
            filePath = new String(data, encoding == null ? Constants.UTF_8 : encoding);
        } catch (final UnsupportedEncodingException e) {
            filePath = new String(data, Constants.UTF_8_CHARSET);
        }

        DurableHandleRequest request = new DurableHandleRequest();

        assertEquals("DHnQ", new String(request.getName()));
        assertTrue(request.size() > 0);

        // Test encoding
        byte[] buffer = new byte[request.size()];
        int encoded = request.encode(buffer, 0);
        assertEquals(request.size(), encoded);
    }

    @Test
    public void testDurableHandleV2Request() {

    }

    // If we add an "Accept-Encoding: gzip" header field we're responsible for also decompressing
    // the transfer stream.
    var transparentGzip = false
    if (userRequest.header("Accept-Encoding") == null && userRequest.header("Range") == null) {
      transparentGzip = true
      requestBuilder.header("Accept-Encoding", "gzip")
    }

    val cookies = cookieJar.loadForRequest(userRequest.url)

        .addInterceptor { chain ->
          assertThat(chain.request().header("Accept-Encoding")).isNull()
          Response
            .Builder()
            .request(chain.request())
            .protocol(Protocol.HTTP_1_1)
            .code(200)
            .message("OK")
            .body("Hello".toResponseBody())
            .header("Content-Encoding", "piedpiper")
            .build()
        }.build()

		},
		{
			name:    "unknown key Content-Encoding is error as it does not appear in policy",
			fv:      defaultFormVals.Clone().Set(http.CanonicalHeaderKey(xhttp.ContentEncoding), "encoding-val"),
			wantErr: `Each form field that you specify in a form must appear in the list of policy conditions. "Content-Encoding" not specified in the policy.`,
		},
		{
			name:    "many bucket values",