assertNotNull(ignored);
        assertEquals(testRequest, ignored);
    }

    /**
     * Test implementation of Request interface
     */
    private static class TestRequest implements Request<TestResponse> {
        private TestResponse response;
        private boolean ignoreDisconnect = false;
        private int tid = 0;
        private SMBSigningDigest digest;
        private long mid = 0;

    static final GetCheckedTypeValidator BEST_VALIDATOR = getBestValidator();

    @J2ObjCIncompatible // ClassValue
    enum ClassValueValidator implements GetCheckedTypeValidator {
      INSTANCE;

      /*
       * Static final fields are presumed to be fastest, based on our experience with
       * UnsignedBytesBenchmark. TODO(cpovirk): benchmark this
       */

Caching
=======

OkHttp implements an optional, off by default, Cache. OkHttp aims for RFC correct and
pragmatic caching behaviour, following common real-world browser like Firefox/Chrome and 
server behaviour when ambiguous.

# Basic Usage

```kotlin
  private val client: OkHttpClient = OkHttpClient.Builder()
      .cache(Cache(
          directory = File(application.cacheDir, "http_cache"),
          // $0.05 worth of phone storage in 2020

import java.util.Collection;
import java.util.Iterator;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A simplistic collection which implements only the bare minimum allowed by the spec, and throws
 * exceptions whenever it can.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked

    assertEquals(2, copy.size());
    assertSame(copy, copy.iterator().next());
  }

  @J2ktIncompatible
  @GwtIncompatible // Only used by @GwtIncompatible code
  private static class MultisetHolder implements Serializable {
    private final Multiset<?> member;

    MultisetHolder(Multiset<?> multiset) {
      this.member = multiset;
    }

package jcifs.internal.smb1.trans;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Configuration;

/**
 * SMB1 transaction subcommand for calling a named pipe.
 *
 * This class implements the TRANS_CALL_NAMED_PIPE transaction which allows
 * writing data to and reading data from a named pipe in a single operation.
 */
public class TransCallNamedPipe extends SmbComTransaction {

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import jcifs.Configuration;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 transaction subcommand for transacting with a named pipe.
 *
 * This class implements the TRANS_TRANSACT_NAMED_PIPE transaction which
 * combines writing data to a pipe and reading the response in a single operation.
 * This is more efficient than separate write and read operations.
 */

 *
 * @author Chris Povirk
 * @author Jared Levy
 * @author George van den Driessche
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public abstract class TestStringBiMapGenerator implements TestBiMapGenerator<String, String> {

  @Override
  public SampleElements<Entry<String, String>> samples() {
    return new SampleElements<>(
        mapEntry("one", "January"),
        mapEntry("two", "February"),

    NullPointerTester tester = new NullPointerTester();
    tester.testAllPublicInstanceMethods(new MapMaker());
  }

  @GwtIncompatible // threads
  static final class DelayingIdentityLoader<T> implements Function<T, T> {
    private final CountDownLatch delayLatch;

    DelayingIdentityLoader(CountDownLatch delayLatch) {
      this.delayLatch = delayLatch;
    }

    @CanIgnoreReturnValue // Sure, why not?

 *
 * @author Louis Wasserman
 */
final class UnmodifiableSortedMultiset<E extends @Nullable Object> extends UnmodifiableMultiset<E>
    implements SortedMultiset<E> {
  UnmodifiableSortedMultiset(SortedMultiset<E> delegate) {
    super(delegate);
  }

  @Override
  protected SortedMultiset<E> delegate() {
    return (SortedMultiset<E>) super.delegate();