* accessed by the connection closer task.
     */
    var concurrentCallCapacity: Int = 0
  }

  companion object {
    fun get(connectionPool: ConnectionPool): RealConnectionPool = connectionPool.delegate

    private var addressStatesUpdater =
      AtomicReferenceFieldUpdater.newUpdater(
        RealConnectionPool::class.java,
        Map::class.java,
        "addressStates",
      )
  }

    ImmutableSet<?> deserialized = (ImmutableSet<?>) in.readObject();
    EnumSet<?> delegate = (EnumSet<?>) in.readObject();

    assertEquals(original, deserialized);
    assertTrue(delegate.remove(SomeEnum.A));
    assertTrue(deserialized.contains(SomeEnum.A));
  }

  @J2ktIncompatible
  @GwtIncompatible // java serialization not supported in GWT.

  val originalRequest: Request,
  val forWebSocket: Boolean,
) : Call, Cloneable {
  internal val lock: ReentrantLock = ReentrantLock()

  private val connectionPool: RealConnectionPool = client.connectionPool.delegate

  internal val eventListener: EventListener = client.eventListenerFactory.create(this)

  private val timeout =
    object : AsyncTimeout() {
      override fun timedOut() {
        ******@****.***()

              public List<String> create(final String[] elements) {
                final List<String> delegate = newArrayList(elements);
                return new ForwardingList<String>() {
                  @Override
                  protected List<String> delegate() {
                    return delegate;
                  }

                  @Override

      vspace, target_tensor_ids, source_tensor_ids, sources_that_are_targets,
      output_gradients, result, /*build_default_zeros_grads*/ false));
  return absl::OkStatus();
}

// Helper functions which delegate to `AbstractOperation`, update
// the state of the ForwardOperation and call the tape as appropriate.
// These APIs are mainly to facilitate testing and are subject to change.
namespace internal {

                        throws Throwable {
                      throw new UnsupportedOperationException();
                    }
                  });
    }

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

    @Override
    public boolean put(K key, V value) {
      map.put(key, value);
      return true;
    }

    SetMultimap<K, V> build() {

  public final <S extends @Nullable T> Wrapper<S> wrap(@ParametricNullness S reference) {
    return new Wrapper<>(this, reference);
  }

  /**
   * Wraps an object so that {@link #equals(Object)} and {@link #hashCode()} delegate to an {@link
   * Equivalence}.
   *
   * <p>For example, given an {@link Equivalence} for {@link String strings} named {@code equiv}
   * that tests equivalence using their lengths:
   *
   * <pre>{@code

    *   Add a compiler flag to enable building a TFLite library that applies
        `XNNPACK` delegate automatically when the model has a `fp32` operation.
*   GPU
    *   Allow GPU acceleration starting with internal graph nodes
    *   Experimental support for quantized models with the Android GPU delegate
    *   Add GPU delegate whitelist.
    *   Rename GPU whitelist -> compatibility (list).

    public boolean equals(@CheckForNull Object object) {
      if (object instanceof AsList) {
        AsList that = (AsList) object;
        return this.parent.equals(that.parent);
      }
      // We could delegate to super now but it would still box too much
      if (!(object instanceof List)) {
        return false;
      }
      List<?> that = (List<?>) object;
      if (this.size() != that.size()) {
        return false;

    public boolean equals(@CheckForNull Object object) {
      if (object instanceof AsList) {
        AsList that = (AsList) object;
        return this.parent.equals(that.parent);
      }
      // We could delegate to super now but it would still box too much
      if (!(object instanceof List)) {
        return false;
      }
      List<?> that = (List<?>) object;
      if (this.size() != that.size()) {
        return false;