}
                this.passwordLength = this.password.length;
            } else if (this.ctx.getConfig().isDisablePlainTextPasswords()) {
                throw new RuntimeCIFSException("Plain text passwords are disabled");
            } else {
                // plain text
                this.password = new byte[(pwAuth.getPassword().length() + 1) * 2];

        AppConfigurationEntry[] a2 = cfg.getAppConfigurationEntry("y");

        // Assert
        assertNotSame(a1, a2, "Arrays should be different instances");
        assertEquals(1, a1.length);
        assertEquals(1, a2.length);

        AppConfigurationEntry e1 = a1[0];
        AppConfigurationEntry e2 = a2[0];

        assertNotSame(e1, e2, "Entries should be different instances");

        if (version != null) {
            if (version.regionMatches(
                    true,
                    version.length() - Artifact.SNAPSHOT_VERSION.length(),
                    Artifact.SNAPSHOT_VERSION,
                    0,
                    Artifact.SNAPSHOT_VERSION.length())) {
                return true;
            } else {
                return Artifact.VERSION_FILE_PATTERN.matcher(version).matches();

    private SuggestUtil() {
    }

    /**
     * Creates a unique identifier for the given text by encoding it to a Base64 string.
     * If the encoded string exceeds the maximum allowed length, it truncates the string
     * to the specified maximum length.
     *
     * @param text the input text to be encoded
     * @return the encoded string, truncated if necessary
     */
    public static String createSuggestTextId(final String text) {

// the type:
//
//   - Slice: The size specifies the length. The capacity of the slice is
//     equal to its length. A second integer argument may be provided to
//     specify a different capacity; it must be no smaller than the
//     length. For example, make([]int, 0, 10) allocates an underlying array
//     of size 10 and returns a slice of length 0 and capacity 10 that is
//     backed by this underlying array.

  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method do
   * double-duty to make sure the counting and content are consistent, particularly when it comes
   * to awkward operations like measuring the encoded length of header strings, or the
   * length-in-digits of an encoded integer.
   */
  @Throws(IOException::class)
  private fun writeOrCountBytes(

    assertThat(map.segments).hasLength(4);
    assertThat(map.segments[0].table.length()).isEqualTo(2);
    assertThat(map.segments[1].table.length()).isEqualTo(2);
    assertThat(map.segments[2].table.length()).isEqualTo(2);
    assertThat(map.segments[3].table.length()).isEqualTo(2);
  }

  @GwtIncompatible // CacheTesting
  public void testInitialCapacity_smallest() {

          && method.getParameterTypes().length == 1
          && method.getParameterTypes()[0] == Object.class) {
        continue;
      }
      if (method.getName().equals("hashCode") && method.getParameterTypes().length == 0) {
        continue;
      }
      if (method.getName().equals("toString") && method.getParameterTypes().length == 0) {
        continue;
      }

    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)
    assertThat(buffer.readUtf8()).isEqualTo(expected)
  }

  @Test
  fun buildEmptyForm() {
    val body = FormBody.Builder().build()
    val expected = ""
    assertThat(body.contentLength()).isEqualTo(expected.length.toLong())
    val buffer = Buffer()
    body.writeTo(buffer)

     */
    public RC4(final byte[] key) {
        init(key, 0, key.length);
    }

    /**
     * Initializes the RC4 cipher with a key.
     * This method sets up the RC4 state array using the key scheduling algorithm.
     *
     * @param key the key array
     * @param ki the starting offset in the key array
     * @param klen the length of the key to use
     */