};
    }

    /**
     * Encodes a String as UTF-8 bytes.
     *
     * @param str the String to encode
     * @param dst the destination byte array
     * @param di the starting index in the destination array
     * @param dlim the maximum index in the destination array
     * @return the number of bytes written
     */
    public static int enc_utf8(final String str, final byte[] dst, int di, final int dlim) {

    )
    assertThat(callbacks).isEmpty()
  }

  private fun consumeEvents(source: String) {
    val callback: ServerSentEventReader.Callback =
      object : ServerSentEventReader.Callback {
        override fun onEvent(
          id: String?,
          type: String?,
          data: String,
        ) {
          callbacks.add(Event(id, type, data))
        }

    private static class TestThumbnailGenerator extends BaseThumbnailGenerator {
        private boolean generateCalled = false;
        private boolean destroyCalled = false;

        @Override
        public boolean generate(String thumbnailId, File outputFile) {
            generateCalled = true;
            return true;
        }

        @Override
        public void destroy() {
            destroyCalled = true;
        }

      InterruptibleTask<?> localTask = task;
      if (localTask != null) {
        localTask.interruptTask();
      }
    }

    this.task = null;
  }

  @Override
  protected @Nullable String pendingToString() {
    InterruptibleTask<?> localTask = task;
    if (localTask != null) {
      return "task=[" + localTask + "]";
    }
    return super.pendingToString();
  }

  @WeakOuter

  @Deprecated
  protected UncheckedExecutionException(@Nullable String message) {
    super(message);
  }

  /**
   * Creates a new instance with the given detail message and cause. Prefer to provide a
   * non-nullable {@code cause}, as many users expect to find one.
   */
  public UncheckedExecutionException(@Nullable String message, @Nullable Throwable cause) {
    super(message, cause);
  }

  /**

    }

    /** Dictionary identifier */
    @Required
    public String dictId;

    /** CRUD operation mode (CREATE, EDIT, etc.) */
    @ValidateTypeFailure
    public Integer crudMode;

    /** Input terms (comma-separated) that will be mapped to the output term */
    @Required
    @Size(max = 1000)
    public String inputs;

    /** Output term that input terms will be mapped to */

    /** The dictionary ID to which this synonym entry belongs */
    @Required
    public String dictId;

    /** The CRUD operation mode for form processing */
    @ValidateTypeFailure
    public Integer crudMode;

    /** The input terms that should be considered synonymous */
    @Required
    @Size(max = 1000)
    public String inputs;

    /** The output synonyms that should be matched for the input terms */
    @Required

     */
    SmbRandomAccess openRandomAccess(String mode, int sharing) throws CIFSException;

    /**
     * Opens the file for random access
     *
     * @param mode
     *            access mode (r|rw)
     * @return random access file, needs to be closed when finished
     * @throws CIFSException if an error occurs accessing the resource
     */
    SmbRandomAccess openRandomAccess(String mode) throws CIFSException;

    /**

     */
    public static final String ROLE = "admin-accesstoken";

    /**
     * The token parameter.
     */
    public static final String TOKEN = "token";

    /**
     * The expires parameter.
     */
    public static final String EXPIRES = "expires";

    /**
     * The expired time parameter.
     */
    public static final String EXPIRED_TIME = "expiredTime";

import okio.IOException

/** An HTTP response status line like "HTTP/1.1 200 OK". */
class StatusLine(
  @JvmField val protocol: Protocol,
  @JvmField val code: Int,
  @JvmField val message: String,
) {
  override fun toString(): String =
    buildString {
      if (protocol == Protocol.HTTP_1_0) {
        append("HTTP/1.0")
      } else {
        append("HTTP/1.1")
      }
      append(' ').append(code)