// Initial value
        assertEquals(0L, item.getId());

        // First modification
        item.id = 50L;
        assertEquals(50L, item.getId());

        // Second modification
        item.id = 100L;
        assertEquals(100L, item.getId());

        // Third modification back to 0
        item.id = 0L;
        assertEquals(0L, item.getId());
    }

    /**

    assertThat(max(8L, 6L, 7L, 5L, 3L, 0L, 9L)).isEqualTo(9L);
  }

  public void testMin_noArgs() {
    assertThrows(IllegalArgumentException.class, () -> min());
  }

  public void testMin() {
    assertThat(min(MIN_VALUE)).isEqualTo(MIN_VALUE);
    assertThat(min(MAX_VALUE)).isEqualTo(MAX_VALUE);
    assertThat(min(8L, 6L, 7L, 5L, 3L, 0L, 9L)).isEqualTo(0L);
  }

  public void testConstrainToRange() {

        }
    }

    private static class SimpleSearcher extends RankFusionSearcher {
        @Override
        protected SearchResult search(String query, SearchRequestParams params, OptionalThing<FessUserBean> userBean) {

        val servedMillis = servedDate?.time ?: sentRequestMillis
        val delta = servedMillis - lastModified!!.time
        return if (delta > 0L) delta / 10 else 0L
      }

      return 0L
    }

    /**
     * Returns the current age of the response, in milliseconds. The calculation is specified by RFC
     * 7234, 4.2.3 Calculating Age.
     */

        assertEquals("0", mockConfig.getTimeAdjustTimeMillis());
        assertEquals(Long.valueOf(0L), mockConfig.getTimeAdjustTimeMillisAsLong());

        // Test multiple calls return same values
        for (int i = 0; i < 10; i++) {
            assertEquals("0", mockConfig.getTimeAdjustTimeMillis());
            assertEquals(Long.valueOf(0L), mockConfig.getTimeAdjustTimeMillisAsLong());
        }
    }

        assertEquals(0, freshData.getCurrentPageNumber());
        assertEquals(0L, freshData.getAllRecordCount());
        assertEquals(0, freshData.getAllPageCount());
        assertFalse(freshData.isExistNextPage());
        assertFalse(freshData.isExistPrevPage());
        assertEquals(0L, freshData.getCurrentStartRecordNumber());
        assertEquals(0L, freshData.getCurrentEndRecordNumber());
        assertFalse(freshData.isPartialResults());

    builder = builder.callTimeout(0L, TimeUnit.SECONDS)
    builder = builder.callTimeout(Duration.ofSeconds(0L))
    builder = builder.connectTimeout(0L, TimeUnit.SECONDS)
    builder = builder.connectTimeout(Duration.ofSeconds(0L))
    builder = builder.readTimeout(0L, TimeUnit.SECONDS)
    builder = builder.readTimeout(Duration.ofSeconds(0L))
    builder = builder.writeTimeout(0L, TimeUnit.SECONDS)

        // Test with null values
        SearchResult result = new SearchResult(null, 0L, null, 0L, true, null);

        assertNull(result.getDocumentList());
        assertEquals(0L, result.getAllRecordCount());
        assertNull(result.getAllRecordCountRelation());
        assertEquals(0L, result.getQueryTime());
        assertTrue(result.isPartialResults());
        assertNull(result.getFacetResponse());

            throw ProtocolException("length encoded with more than 8 bytes is not supported")
          }

          var lengthBits = source.readByte().toLong() and 0xff
          if (lengthBits == 0L || lengthBytes == 1 && lengthBits and 0b1000_0000 == 0L) {
            throw ProtocolException("invalid encoding for length")
          }

          for (i in 1 until lengthBytes) {
            lengthBits = lengthBits shl 8

  }

  public void testOf1() {
    assertThat(ImmutableLongArray.of(0).asList()).containsExactly(0L);
  }

  public void testOf2() {
    assertThat(ImmutableLongArray.of(0, 1).asList()).containsExactly(0L, 1L).inOrder();
  }

  public void testOf3() {
    assertThat(ImmutableLongArray.of(0, 1, 3).asList()).containsExactly(0L, 1L, 3L).inOrder();
  }

  public void testOf4() {