*/
package okhttp3.internal.connection

import java.io.IOException

/** Attempt routes one at a time until one connects. */
internal class SequentialExchangeFinder(
  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {

 * @author Isaac Shum
 */
@GwtCompatible
@NullMarked
public class MapsTransformValuesTest extends AbstractMapsTransformValuesTest {
  @Override
  protected Map<String, String> makeEmptyMap() {
    return transformValues(new HashMap<String, String>(), Functions.<String>identity());
  }

  @Override
  protected Map<String, String> makePopulatedMap() {
    Map<String, Integer> underlying = new HashMap<>();
    underlying.put("a", 1);

  public UnmodifiableRowSortedTableRowTest() {
    super(false, false, false, false, false);
  }

  @Override
  Table<Character, String, Integer> makeTable() {
    RowSortedTable<Character, String, Integer> table = TreeBasedTable.create();
    return unmodifiableRowSortedTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {

  public UnmodifiableTableColumnMapTest() {
    super(false, false, false, false);
  }

  @Override
  Table<Integer, String, Character> makeTable() {
    Table<Integer, String, Character> original = HashBasedTable.create();
    return unmodifiableTable(original);
  }

  @Override
  protected Map<String, Map<Integer, Character>> makePopulatedMap() {

 */
@GwtCompatible
@NullMarked
public class MapsSortedTransformValuesTest extends AbstractMapsTransformValuesTest {
  @Override
  protected SortedMap<String, String> makeEmptyMap() {
    return transformValues(Maps.<String, String>newTreeMap(), Functions.<String>identity());
  }

  @Override
  protected SortedMap<String, String> makePopulatedMap() {
    SortedMap<String, Integer> underlying = Maps.newTreeMap();

     * use token-based authentication instead of traditional session-based login.
     *
     * @return empty OptionalThing indicating no login manager is used
     */
    @Override
    protected OptionalThing<LoginManager> myLoginManager() {
        return OptionalThing.empty();
    }

    /**
     * Pre-processes API requests by checking access authorization before executing the action.

It will be generated only once, and then the same cached schema will be used for the next requests.

{* ../../docs_src/extending_openapi/tutorial001.py hl[13:14,25:26] *}

### Override the method { #override-the-method }

Now you can replace the `.openapi()` method with your new function.

{* ../../docs_src/extending_openapi/tutorial001.py hl[29] *}

### Check it { #check-it }

     * Implementations must ensure that if two requests are equal according to
     * {@link #equals(Object)}, they have the same hashcode.
     *
     * @return a hash code value for this request
     */
    @Override
    int hashCode();

    /**
     * Returns {@code true} if the specified object is equal to this request.
     * Two requests are considered equal if they have the same type and all
     * significant fields are equal.

    delay: Long,
    timeUnit: TimeUnit,
  ) : RequestBody() {
    private val delayMillis = timeUnit.toMillis(delay)

    override fun contentType() = delegate.contentType()

    override fun isDuplex() = true

    override fun writeTo(sink: BufferedSink) {
      executorService.schedule({
        try {
          delegate.writeTo(sink)
          sink.close()

    AtomicBoolean shouldWait = new AtomicBoolean(false);
    CountDownLatch computingLatch = new CountDownLatch(1);
    CacheLoader<String, String> computingFunction =
        new CacheLoader<String, String>() {
          @Override
          public String load(String key) throws InterruptedException {
            if (shouldWait.get()) {
              computingLatch.await();
            }
            return key;
          }
        };