*     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in
   * @throws IllegalArgumentException if {@code duration} is not positive
   * @since 2.0
   */
  @SuppressWarnings("GoodTime") // Prefer the Duration overload
  public static <T extends @Nullable Object> Supplier<T> memoizeWithExpiration(
      Supplier<T> delegate, long duration, TimeUnit unit) {
    checkNotNull(delegate);

   *     by subsequent {@code get()} calls
   * @param unit the unit that {@code duration} is expressed in
   * @throws IllegalArgumentException if {@code duration} is not positive
   * @since 2.0
   */
  @SuppressWarnings("GoodTime") // Prefer the Duration overload
  public static <T extends @Nullable Object> Supplier<T> memoizeWithExpiration(
      Supplier<T> delegate, long duration, TimeUnit unit) {
    checkNotNull(delegate);

  fun takeRequest(): RecordedRequest = delegate.takeRequest().unwrap()

  @Throws(InterruptedException::class)
  fun takeRequest(
    timeout: Long,
    unit: TimeUnit,
  ): RecordedRequest? = delegate.takeRequest(timeout, unit)?.unwrap()

  @JvmName("-deprecated_requestCount")
  fun getRequestCount(): Int = delegate.requestCount

  fun enqueue(response: MockResponse) {

  @Override
  @ParametricNullness
  public V get() {
    return value;
  }

  @Override
  @ParametricNullness
  public V get(long timeout, TimeUnit unit) throws ExecutionException {
    checkNotNull(unit);
    return get();
  }

  @Override
  public boolean isCancelled() {
    return false;
  }

  @Override
  public boolean isDone() {
    return true;
  }

   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up, in units of {@code unit}
   * @param unit a {@code TimeUnit} determining how to interpret the timeout parameter
   * @return the number of elements transferred
   * @throws InterruptedException if interrupted while waiting
   */

    }
  }

  fun exhaustResponse() =
    apply {
      actions += { stream -> stream.sink.close() }
    }

  fun sleep(
    duration: Long,
    unit: TimeUnit,
  ) = apply {
    actions += { Thread.sleep(unit.toMillis(duration)) }
  }

  override fun handle(socket: Socket) {
    val task = serviceSocketTask(socket.asBufferedSocket())
    results.add(task)
    task.run()
  }

package jcifs.smb1.smb1;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.lang.reflect.Field;
import java.util.Arrays;

import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;

import jcifs.smb1.util.Hexdump;

/**
 * Unit test for {@link Trans2QueryFSInformation}. The class contains mostly

                .let(transform)
        }

    override fun close() {
        val errors = mutableListOf<Exception>()
        openKotlinCompilationUnitsByRoot.values.forEach { unit ->
            try {
                unit.close()
            } catch (ex: Exception) {
                errors.add(ex)
            }
        }
        openJavaCompilationUnitsByFile.clear()

import org.apache.maven.impl.DefaultMessageBuilder;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

    <dependency>
      <groupId>com.google.errorprone</groupId>
      <artifactId>error_prone_annotations</artifactId>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-core</artifactId>