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);
    }

        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;
      }

     * 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();
        }

            assertEquals(24, ServerMessageBlock2.size8(17));
        }

        @Test
        @DisplayName("Should calculate size8 with alignment")
        void testSize8WithAlignment() {
            assertEquals(8, ServerMessageBlock2.size8(8, 0));
            // size8(10, 2): rem = 10%8 - 2 = 2 - 2 = 0, returns 10
            assertEquals(10, ServerMessageBlock2.size8(10, 2));

    val rule = findMatchingRule(domainLabels)
    if (domainLabels.size == rule.size && rule[0][0] != EXCEPTION_MARKER) {
      return null // The domain is a public suffix.
    }

    val firstLabelOffset =
      if (rule[0][0] == EXCEPTION_MARKER) {
        // Exception rules hold the effective TLD plus one.
        domainLabels.size - rule.size
      } else {

  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).
   *

  }

  /**
   * 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,

import jakarta.validation.constraints.Size;

/**
 * The edit form for Search Log.
 * This form handles the editing of search log entries in the administration interface.
 */
public class EditForm {

    /** CRUD operation mode indicator */
    @ValidateTypeFailure
    public int crudMode;

    /** Type of the search log entry */
    @Required
    @Size(max = 10)
    public String logType;