/** Delay in milliseconds after processing a URL */
    protected long delayMillisAfterProcessing = 0L;

    /** Delay in milliseconds when no URL is in the queue */
    protected long delayMillisAtNoUrlInQueue = 500L;

    /** Delay in milliseconds before processing a URL */
    protected long delayMillisBeforeProcessing = 0L;

    /** Delay in milliseconds for waiting for new URLs */

    override val isReady: Boolean
      get() = connectState == ConnectState.TLS_CONNECTED

    var tcpConnectDelayNanos = 0L
    var tcpConnectThrowable: Throwable? = null
    var yieldBeforeTcpConnectReturns = false
    var connectTcpNextPlan: FakePlan? = null
    var tlsConnectDelayNanos = 0L
    var tlsConnectThrowable: Throwable? = null
    var connectTlsNextPlan: FakePlan? = null

    fun createRetry(): FakePlan {

        // Test various long values
        assertEquals("0000000000000000", Hexdump.toHexString(0L, 16));
        assertEquals("00000000000000FF", Hexdump.toHexString(255L, 16));
        assertEquals("FFFFFFFFFFFFFFFF", Hexdump.toHexString(-1L, 16));

        // Test different sizes
        assertEquals("00000000", Hexdump.toHexString(0L, 8));
        assertEquals("12345678", Hexdump.toHexString(0x12345678L, 8));
    }

    @Test

        result.setContentLength(2048L);
        assertEquals(Long.valueOf(2048L), result.getContentLength());

        result.setContentLength(0L);
        assertEquals(Long.valueOf(0L), result.getContentLength());
    }

    public void test_lastModifiedGetterSetter() {
        // Test last modified getter/setter
        AccessResultImpl<Long> result = new AccessResultImpl<>();

    Random rng = new Random(0L);
    byte[] bytes = new byte[rng.nextInt(256) + 1];
    rng.nextBytes(bytes);
    assertEquals(hashFunction.hashBytes(bytes), hashFunction.hashBytes(ByteBuffer.wrap(bytes)));
  }

  static void assertHashByteBufferExhaustsBuffer(HashFunction hashFunction) {
    Random rng = new Random(0L);
    byte[] bytes = new byte[rng.nextInt(256) + 1];

      }
    }

    if (isClient) {
      random.nextBytes(maskKey!!)
      sinkBuffer.write(maskKey)

      if (dataSize > 0L) {
        messageBuffer.readAndWriteUnsafe(maskCursor!!)
        maskCursor.seek(0L)
        toggleMask(maskCursor, maskKey)
        maskCursor.close()
      }
    }

    sinkBuffer.write(messageBuffer, dataSize)
    sink.flush()
  }

  }

  public void testCheckPositive_zeroLong() {
    assertThrows(IllegalArgumentException.class, () -> MathPreconditions.checkPositive("long", 0L));
  }

  public void testCheckPositive_maxLong() {
    MathPreconditions.checkPositive("long", Long.MAX_VALUE);
  }

  public void testCheckPositive_minLong() {
    assertThrows(

            // When
            int bytesWritten = chunk.encode(buffer, startIndex);

            // Then
            assertEquals(EXPECTED_SIZE, bytesWritten);
            assertEquals(0L, SMBUtil.readInt8(buffer, startIndex));
            assertEquals(0L, SMBUtil.readInt8(buffer, startIndex + 8));
            assertEquals(0, SMBUtil.readInt4(buffer, startIndex + 16));
        }

        @Test

      this.throttlePeriodNanos = 0L
      this.failHandshake = false
      this.onRequestStart = null
      this.doNotReadRequestBody = false
      this.onRequestBody = null
      this.onResponseStart = null
      this.onResponseBody = null
      this.onResponseEnd = null
      this.shutdownServer = false
      this.headersDelayNanos = 0L
      this.bodyDelayNanos = 0L
      this.trailersDelayNanos = 0L

            assertEquals(chunkCount, SMBUtil.readInt4(buffer, SOURCE_KEY_SIZE));

            // Verify some chunks
            int offset = HEADER_SIZE;
            assertEquals(0L, SMBUtil.readInt8(buffer, offset));
            assertEquals(0L, SMBUtil.readInt8(buffer, offset + 8));
            assertEquals(0, SMBUtil.readInt4(buffer, offset + 16));

            offset = HEADER_SIZE + ((chunkCount - 1) * CHUNK_SIZE);