return new Builder<B>().putAll(map).build();
  }

  private final ImmutableMap<Class<? extends B>, B> delegate;

  private ImmutableClassToInstanceMap(ImmutableMap<Class<? extends B>, B> delegate) {
    this.delegate = delegate;
  }

  @Override
  protected Map<Class<? extends B>, B> delegate() {
    return delegate;
  }

  @Override
  @SuppressWarnings("unchecked") // value could not get in if not a T

  private static class SimpleForwardingSortedMap<K, V> extends ForwardingSortedMap<K, V> {
    final SortedMap<K, V> delegate;

    SimpleForwardingSortedMap(SortedMap<K, V> delegate) {
      this.delegate = delegate;
    }

    @Override
    protected SortedMap<K, V> delegate() {
      return delegate;
    }
  }

  public ForwardingSortedMapImplementsMapTest() {
    super(true, true, true, true, true);
  }

  @Synchronized private fun getDelegate(sslSocket: SSLSocket): SocketAdapter? {
    if (this.delegate == null && socketAdapterFactory.matchesSocket(sslSocket)) {
      this.delegate = socketAdapterFactory.create(sslSocket)
    }

    return delegate
  }

  interface Factory {
    fun matchesSocket(sslSocket: SSLSocket): Boolean

    fun create(sslSocket: SSLSocket): SocketAdapter

 * (API level 24).
 */
@IgnoreJRERequirement
internal class InsecureExtendedTrustManager(
  private val delegate: X509ExtendedTrustManager,
  private val insecureHosts: List<String>,
) : X509ExtendedTrustManager() {
  override fun getAcceptedIssuers(): Array<X509Certificate> = delegate.acceptedIssuers

  override fun checkServerTrusted(
    chain: Array<out X509Certificate>,
    authType: String,

  @Override
  protected abstract Iterator<T> delegate();

  @Override
  public boolean hasNext() {
    return delegate().hasNext();
  }

  @CanIgnoreReturnValue
  @Override
  @ParametricNullness
  public T next() {
    return delegate().next();
  }

  @Override
  public void remove() {
    delegate().remove();
  }

  @Override
  protected abstract SortedSet<E> delegate();

  @Override
  public @Nullable Comparator<? super E> comparator() {
    return delegate().comparator();
  }

  @Override
  @ParametricNullness
  public E first() {
    return delegate().first();
  }

  @Override
  public SortedSet<E> headSet(@ParametricNullness E toElement) {
    return delegate().headSet(toElement);
  }

  @Override

        .addEqualityGroup(map2, wrap(map2))
        .testEquals();
  }

  private static <K, V> SortedMap<K, V> wrap(SortedMap<K, V> delegate) {
    return new ForwardingSortedMap<K, V>() {
      @Override
      protected SortedMap<K, V> delegate() {
        return delegate;
      }
    };
  }

    public final Object mutex;
    private final Map<K, V> delegate;

    public TestMap(Map<K, V> delegate, Object mutex) {
      checkNotNull(mutex);
      this.delegate = delegate;
      this.mutex = mutex;
    }

    @Override
    protected Map<K, V> delegate() {
      return delegate;
    }

    @Override
    public int size() {
      assertTrue(Thread.holdsLock(mutex));

                // release
                old.release(true);
            }
            if (this.delegate != null && this.delegateAcquired) {
                log.debug("Releasing delegate");
                this.delegateAcquired = false;
                this.delegate.release();
            }
        }
    }

    /**
     * @return tree connection with increased usage count
     */

        super(original);
        this.in = new Reader() {
            Reader delegate = null;

            @Override
            public int read(char[] cbuf, int off, int len) throws IOException {
                if (delegate == null) {
                    delegate = transform(original);
                }
                return delegate.read(cbuf, off, len);
            }

            @Override