int len = string.length();
    long longSize = (long) len * (long) count;
    int size = (int) longSize;
    if (size != longSize) {
      throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
    }

    char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {
      System.arraycopy(array, 0, array, n, n);
    }

	}

	// Fetch buffer for I/O, returns from the pool if not allocates a new one and returns.
	var buffer []byte
	switch size := data.Size(); {
	case size == 0:
		buffer = make([]byte, 1) // Allocate at least a byte to reach EOF
	case size >= fi.Erasure.BlockSize || size == -1:
		if int64(globalBytePoolCap.Load().Width()) < fi.Erasure.BlockSize {
			buffer = make([]byte, fi.Erasure.BlockSize, 2*fi.Erasure.BlockSize)

        return true;
      }
      if (object instanceof ShortArrayAsList) {
        ShortArrayAsList that = (ShortArrayAsList) object;
        int size = size();
        if (that.size() != size) {
          return false;
        }
        for (int i = 0; i < size; i++) {
          if (array[start + i] != that.array[that.start + i]) {
            return false;
          }
        }
        return true;
      }

    /**
     * Gets the maximum buffer size for IO operations
     *
     * @return the maximum size of IO buffers, limits the maximum message size
     */
    int getMaximumBufferSize();

    /**
     *
     * Property {@code jcifs.smb.client.transaction_buf_size} (int, default 65535)
     *
     * @return maximum data size for SMB transactions
     */
    int getTransactionBufferSize();

     * Uses the default buffer size and no output callback.
     *
     * @param process the system process to wrap
     */
    public JobProcess(final Process process) {
        this(process, InputStreamThread.MAX_BUFFER_SIZE, null);
    }

    /**
     * Constructs a new JobProcess with the specified process, buffer size, and output callback.
     *

        .testEquals();
  }

  /** Returns a {@link Set} with a {@link Set#size()} of {@code size}. */
  private static ContiguousSet<Integer> setSize(int size) {
    checkArgument(size >= 0);
    ContiguousSet<Integer> set = ContiguousSet.closedOpen(0, size);
    checkState(set.size() == size);
    return set;
  }

  /**

    public void setExistNextPage(final boolean existNextPage) {
        this.existNextPage = existNextPage;
    }

    /**
     * Gets the number of items per page.
     * If the page size is not set or is zero or negative, returns the default page size.
     *
     * @return the number of items per page
     */
    public int getPageSize() {
        if (pageSize <= 0) {
            pageSize = getDefaultPageSize();
        }

  private static final int ENDPOINT = -2;

  /**
   * Contains the link pointers corresponding with the entries, in the range of [0, size()). The
   * high 32 bits of each long is the "prev" pointer, whereas the low 32 bits is the "succ" pointer
   * (pointing to the next entry in the linked list). The pointers in [size(), entries.length) are
   * all "null" (UNSET).
   *

        @Test
        @DisplayName("Should decode error response with correct structure size")
        void testReadErrorResponseValid() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[256];
            int bufferIndex = 0;

            // Write error response structure
            SMBUtil.writeInt2(9, buffer, bufferIndex); // structure size
            buffer[bufferIndex + 2] = 2; // error context count

  }

  /**
   * Returns the number of bytes currently being used to store the values in this cache. This may be
   * greater than the max size if a background deletion is pending.
   */
  @Synchronized
  @Throws(IOException::class)
  fun size(): Long {
    initialize()
    return size
  }

  @Synchronized
  @Throws(IOException::class)
  internal fun completeEdit(
    editor: Editor,
    success: Boolean,