val elapsedNanos = System.nanoTime() - startNanos
    org.junit.jupiter.api.Assertions.assertTrue(
      elapsedNanos < TimeUnit.SECONDS.toNanos(5),
      "Timeout should have taken ~100ms but was " + elapsedNanos / 1e6 + " ms",
    )
  }

  @Test
  fun chainWithReadTimeout() {
    val interceptor1 =
      Interceptor { chainA: Interceptor.Chain ->
        assertThat(chainA.readTimeoutMillis()).isEqualTo(5000)

     */
    public void setRateLimit(long windowMs, int maxEvents) {
        this.rateLimitWindow = windowMs;
        this.maxEventsPerWindow = maxEvents;
        log.info("Rate limiting set to {} events per {} ms", maxEvents, windowMs);
    }

    /**
     * Internal audit entry class
     */
    private static class AuditEntry {
        Instant timestamp;
        EventType eventType;
        Severity severity;

            len += pad8(bufferIndex);
        } else if (compound && this.nextCommand == 0 && this.readSize > 0) {
            // Apply compound response handling as per MS-SMB2 3.2.5.1.9 - correct for both compound and single responses
            // 3.2.5.1.9 Handling Compounded Responses
            // The final response in the compounded response chain will have NextCommand equal to 0,

     * @param failureThreshold number of failures before opening
     * @param successThreshold number of successes in half-open before closing
     * @param resetTimeoutMillis time to wait before attempting reset (ms)
     * @param halfOpenMaxAttempts max attempts in half-open state
     */
    public SmbCircuitBreaker(String name, int failureThreshold, int successThreshold, long resetTimeoutMillis, long halfOpenMaxAttempts) {

        // Check if key rotation is needed (including the current message)
        if (needsKeyRotation(message.length)) {
            log.warn("Encryption keys need rotation - will exceed usage limits (bytes: {} + {}, time: {} ms)", bytesEncrypted.get(),
                    message.length, System.currentTimeMillis() - encryptionStartTime);

            // Perform automatic key rotation if session key is available
            if (sessionKey != null) {

    }

    if (failedPing != -1) {
      failWebSocket(
        e =
          SocketTimeoutException(
            "sent ping but didn't receive pong within " +
              "${pingIntervalMillis}ms (after ${failedPing - 1} successful ping/pongs)",
          ),
        isWriter = true,
      )
      return
    }

    try {
      writer.writePing(ByteString.EMPTY)
    } catch (e: IOException) {

                    java.util.concurrent.TimeUnit.MILLISECONDS);
            log.info("Key rotation configured with interval: {} ms", intervalMillis);
        }
    }

    /**
     * Rotate a specific session key
     *
     * @param sessionId the session ID
     * @return the new key version number

Por exemplo, se você definir uma função:

```Python
@lru_cache
def say_hi(name: str, salutation: str = "Ms."):
    return f"Hello {salutation} {name}"
```

Seu programa poderia executar dessa forma:

```mermaid
sequenceDiagram

participant code as Código
participant function as say_hi()

     * @since 2.2
     */
    int getLeaseVersion();

    /**
     * Property {@code jcifs.smb.client.leaseBreakTimeout} (int, default 60)
     *
     * @return lease break timeout in seconds (per MS-SMB2 spec)
     * @since 2.2
     */
    int getLeaseBreakTimeout();

    /**
     *
     *
     * Property {@code jcifs.netbios.lmhosts} (string)
     *
     * @return lmhosts file to use

                    ((SmbComTransactionResponse) resp).nextElement();
                }
            }

            /* Verification fails (w/ W2K3 server at least) if status is not 0. This
             * suggests MS doesn't compute the signature (correctly) for error responses
             * (perhaps for DOS reasons).
             */
            if (digest != null && resp.errorCode == 0) {
                digest.verify(BUF, 4, resp);