*
   * MurmurHash3 was written by Austin Appleby, and is placed in the public domain. The author
   * hereby disclaims copyright to this source code.
   */
  static int smear(int hashCode) {
    return (int) (C2 * Integer.rotateLeft((int) (hashCode * C1), 15));
  }

  static int smearedHash(@Nullable Object o) {
    return smear((o == null) ? 0 : o.hashCode());
  }

  private static final int MAX_TABLE_SIZE = Ints.MAX_POWER_OF_TWO;

    @Test
    @DisplayName("Should get integer property with default value")
    void testGetIntWithDefault() {
        assertEquals(123, Config.getInt(testProperties, "test.int", 0));
        assertEquals(456, Config.getInt(testProperties, "nonexistent.int", 456));
        assertEquals(789, Config.getInt(testProperties, "test.invalid.int", 789));
    }

    @Test
    @DisplayName("Should get integer property")
    void testGetInt() {

     *
     * @return the list of page numbers
     */
    public List<Integer> getPageNumberList() {
        return pageNumberList;
    }

    /**
     * Sets the list of page numbers for pagination navigation.
     *
     * @param pageNumberList the list of page numbers to set
     */
    public void setPageNumberList(final List<Integer> pageNumberList) {
        this.pageNumberList = pageNumberList;
    }

            request.setPadding((byte) 0xFF);
            request.setReadFlags((byte) 0xFF);
            request.setReadLength(Integer.MAX_VALUE);
            request.setOffset(Long.MAX_VALUE);
            request.setMinimumCount(Integer.MAX_VALUE);
            request.setRemainingBytes(Integer.MAX_VALUE);

            byte[] buffer = new byte[256];
            int bytesWritten = request.writeBytesWireFormat(buffer, 0);

    @ValidateTypeFailure
    public Integer start;

    /** The offset for pagination. */
    @ValidateTypeFailure
    public Integer offset;

    /** The page number. */
    @ValidateTypeFailure
    public Integer pn;

    /** The number of results to display. */
    @ValidateTypeFailure
    public Integer num;

    /** The languages. */
    public String[] lang;

    }

    private int min = 0;
    private int max = Integer.MAX_VALUE;
    private String message;

    @Override
    public void initialize(final CustomSize constraintAnnotation) {
        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        final String minKey = constraintAnnotation.minKey();
        if (StringUtil.isNotBlank(minKey)) {
            min = Integer.parseInt(fessConfig.get(minKey));
        }

    public void setCreatedTime(Long value) {
        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public Integer getMaxSize() {
        checkSpecifiedProperty("maxSize");
        return maxSize;
    }

    public void setMaxSize(Integer value) {
        registerModifiedProperty("maxSize");
        this.maxSize = value;
    }

    public String getQuery() {

  protected volatile boolean throwException = false;

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
              runLatch.countDown();
              taskLatch.await();
              if (throwException) {

	sum64 := siphash.Hash(k0, k1, []byte(key))
	return int(sum64 % uint64(cardinality))
}

// hashOrder - hashes input key to return consistent
// hashed integer slice. Returned integer order is salted
// with an input key. This results in consistent order.
// NOTE: collisions are fine, we are not looking for uniqueness
// in the slices returned.
func hashOrder(key string, cardinality int) []int {

    @Test
    @DisplayName("Test safe integer addition")
    void testSafeAddition() {
        assertEquals(100, InputValidator.safeAdd(50, 50));
        assertEquals(0, InputValidator.safeAdd(-50, 50));

        assertThrows(ArithmeticException.class, () -> InputValidator.safeAdd(Integer.MAX_VALUE, 1));
        assertThrows(ArithmeticException.class, () -> InputValidator.safeAdd(Integer.MIN_VALUE, -1));
    }

    @Test