* {@code null}; it may either return a non-null value or throw an exception.
   *
   * <p>No observable state associated with this cache is modified until loading completes.
   *
   * @throws ExecutionException if a checked exception was thrown while loading the value
   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value

     */
    void recordMisses(int count);

    /**
     * Records the successful load of a new entry. This should be called when a cache request causes
     * an entry to be loaded, and the loading completes successfully. In contrast to {@link
     * #recordMisses}, this method should only be called by the loading thread.
     *
     * @param loadTime the number of nanoseconds the cache spent computing or retrieving the new

              errorMessage.set("Set call exited before future was complete.");
            }
          });
      executor.execute(
          () -> {
            future.setException(new IllegalArgumentException("failure"));
            if (!future.isDone()) {
              errorMessage.set("SetException call exited before future was complete.");
            }
          });
      executor.execute(
          () -> {

            assertEquals(4, bytesRead, "Iteration " + i + " should read 4 bytes");
        }
    }

    @Test
    @DisplayName("Should verify complete response structure parsing")
    void testCompleteResponseParsing() throws SMBProtocolDecodingException {
        // Given - complete SMB2 TREE_DISCONNECT response
        byte[] completeResponse = new byte[] { 0x04, 0x00, // StructureSize = 4
                0x00, 0x00 // Reserved = 0

      )
    serverIpv4.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE)
    serverIpv6.protocols = listOf(Protocol.H2_PRIOR_KNOWLEDGE)

    // Yield the first IP address so the second IP address completes first.
    val firstConnectLatch = CountDownLatch(1)
    val socketFactory =
      object : DelegatingSocketFactory(SocketFactory.getDefault()) {
        var first = true

        assertEquals(newState, entry.getLeaseState());
        assertEquals(initialEpoch + 1, entry.getEpoch());
        assertFalse(entry.isBreaking()); // Should be false after break handling completes
    }

    @Test
    @DisplayName("Should release lease")
    void testReleaseLease() {
        String path = "/share/file.txt";
        int requestedState = Smb2LeaseState.SMB2_LEASE_READ_HANDLE;

   * {@code null}; it may either return a non-null value or throw an exception.
   *
   * <p>No observable state associated with this cache is modified until loading completes.
   *
   * @throws ExecutionException if a checked exception was thrown while loading the value
   * @throws UncheckedExecutionException if an unchecked exception was thrown while loading the
   *     value

internal fun BufferedSource.skipAll() {
  while (!exhausted()) {
    skip(buffer.size)
  }
}

/**
 * Attempts to exhaust this, returning true if successful. This is useful when reading a complete
 * source is helpful, such as when doing so completes a cache body or frees a socket connection for
 * reuse.
 */
internal fun Source.discard(
  timeout: Int,
  timeUnit: TimeUnit,
): Boolean =
  try {

        }
        // buffer remaining input
        if (i < len) {
            System.arraycopy(input, offset + i, buffer, bufferNdx, len - i);
        }
    }

    /**
     * Completes the hash computation by performing final operations such
     * as padding. At the return of this engineDigest, the MD engine is
     * reset.
     *
     * @return the array of bytes for the resulting hash value.

  /**
   * Adds each member of {@code elements} as a candidate for the top {@code k} elements. This
   * operation takes amortized linear time in the length of {@code elements}. The iterator is
   * consumed after this operation completes.
   *
   * <p>If all input data to this {@code TopKSelector} is in a single {@code Iterator}, prefer
   * {@link Ordering#leastOf(Iterator, int)}, which provides a simpler API for that use case.
   */