@Override
        public long createTime() {
            return 0L;
        }

        @Override
        public long lastModified() {
            return 0L;
        }

        @Override
        public long lastAccess() {
            return 0L;
        }

        @Override
        public long length() {
            return 0L;
        }

        @Override
        public String toString() {

  private val delegate: Sink,
  private val triggerByteCount: Long,
  private val trigger: () -> Unit,
) : Sink by delegate {
  private var bytesWritten = 0L

  override fun write(
    source: Buffer,
    byteCount: Long,
  ) {
    if (byteCount == 0L) return // Avoid double-triggering.

    if (bytesWritten == triggerByteCount) {
      source.skip(byteCount)
      return
    }

  }

  public void testLongsOffset() {
    assertEquals(1, DiscreteDomain.longs().offset(0L, 1).longValue());
    assertEquals(Long.MAX_VALUE, DiscreteDomain.longs().offset(0L, Long.MAX_VALUE).longValue());
  }

  public void testLongsOffsetExceptions() {
    assertThrows(IllegalArgumentException.class, () -> DiscreteDomain.longs().offset(0L, -1));
    assertThrows(

        void shouldHandleZeroValues() {
            // Given
            TestAllocInfo allocInfo = new TestAllocInfo(0L, 0L);

            // When & Then
            assertEquals(0L, allocInfo.getCapacity());
            assertEquals(0L, allocInfo.getFree());
        }

        @Test
        @DisplayName("Should handle maximum long values")
        void shouldHandleMaximumLongValues() {

        @Override
        public int getAttributes() {
            return 0;
        }

        @Override
        public long getCreateTime() {
            return 0L;
        }

        @Override
        public long getLastWriteTime() {
            return 0L;
        }

        @Override
        public long getSize() {
            return endOfFile;
        }

        @Override
        public String toString() {

    return Longs.constrainToRange(timeoutNanos, 0L, (Long.MAX_VALUE / 4) * 3);
  }

  /**
   * Returns System.nanoTime() unless the timeout has already elapsed. Returns 0L if and only if the
   * timeout has already elapsed.
   */
  private static long initNanoTime(long timeoutNanos) {
    if (timeoutNanos <= 0L) {
      return 0L;
    } else {
      long startTime = System.nanoTime();

        TestSearchLogEvent event = new TestSearchLogEvent("id", 0L, "type");

        // Test minimum value
        event.setVersionNo(Long.MIN_VALUE);
        assertEquals(Long.valueOf(Long.MIN_VALUE), event.getVersionNo());

        // Test zero
        event.setVersionNo(0L);
        assertEquals(Long.valueOf(0L), event.getVersionNo());

        // Test maximum value

        sink: Buffer,
        byteCount: Long,
      ): Long {
        require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
        check(currentPart == this) { "closed" }

        return source.timeout().intersectWith(timeout) {
          when (val limit = currentPartBytesRemaining(maxByteCount = byteCount)) {
            0L -> -1L

            // No more bytes in this part.
            else -> source.read(sink, limit)

) : Closeable {
  private var closed = false
  private var receivedCloseFrame = false

  // Stateful data about the current frame.
  private var opcode = 0
  private var frameLength = 0L
  private var isFinalFrame = false
  private var isControlFrame = false
  private var readingCompressedMessage = false

  private val controlFrameBuffer = Buffer()
  private val messageFrameBuffer = Buffer()

    assertThat(min(LEAST)).isEqualTo(LEAST);
    assertThat(min(GREATEST)).isEqualTo(GREATEST);
    assertThat(min(0x5a4316b8c153ac4dL, 8L, 100L, 0L, 0x6cf78a4b139a4e2aL, 0xff1a618b7f65ea12L))
        .isEqualTo(0L);
  }

  public void testLexicographicalComparator() {
    List<long[]> ordered =
        Arrays.asList(
            new long[] {},
            new long[] {LEAST},
            new long[] {LEAST, LEAST},