import java.util.concurrent.atomic.AtomicBoolean
import okio.ByteString
import okio.Source
import okio.buffer

internal abstract class BasePublicSuffixList : PublicSuffixList {
  /** True after we've attempted to read the list for the first time. */
  private val listRead = AtomicBoolean(false)

  /** Used for concurrent threads reading the list for the first time. */
  private val readCompleteLatch = CountDownLatch(1)

 * or to force a specific known IP address.
 *
 * Implementations of this interface must be safe for concurrent use.
 */
fun interface Dns {
  /**
   * Returns the IP addresses of `hostname`, in the order they will be attempted by OkHttp. If a
   * connection to an address fails, OkHttp will retry the connection with the next address until
   * either a connection is made, the set of IP addresses is exhausted, or a limit is exceeded.
   */

 *
 * Unfortunately, older HTTPS servers refuse to connect when such options are presented. Rather than
 * avoiding these options entirely, this class allows a connection to be attempted with modern
 * options and then retried without them should the attempt fail.
 *
 * ## Connection Reuse
 *
 * Each connection can carry a varying number of streams, depending on the underlying protocol being

        assertTrue(ex.getMessage().contains("Server does not support kerberos authentication"));
        // No fallback attempted; config should not be queried in this path
        verify(tc, never()).getConfig();
        verifyNoInteractions(config);
    }

    @Test

        }

        /**
         * Get retry count
         *
         * @return number of retry attempts
         */
        public int getRetryCount() {
            return retryCount;
        }

        /**
         * Get next retry time
         *
         * @return time of next retry attempt
         */
        public long getNextRetryTime() {
            return nextRetryTime;
        }

    ```kotlin
    if (credential == response.request.header("Authorization")) {
      return null // If we already failed with these credentials, don't retry.
     }
    ```

    You may also skip the retry when you’ve hit an application-defined attempt limit:

    ```kotlin
    if (response.responseCount >= 3) {

	if !client.IsOnlineWS() {
		// make sure to check if the disk is offline, since the underlying
		// value is cached we should attempt to invalidate it if such calls
		// were attempted. This can lead to false success under certain conditions
		// - this change attempts to avoid stale information if the underlying
		// transport is already down.
		return "", errDiskNotFound
	}

   * proxy server can issue an auth challenge and then close the connection.
   *
   * @return the next plan to attempt, or null if no further attempt should be made either because
   *     we've successfully connected or because no further attempts should be made.
   */
  @Throws(IOException::class)
  internal fun connectTunnel(): ConnectResult {
    val nextTunnelRequest =
      createTunnel()

	}

	defer l.getMutex()()

	for _, resource := range args.Resources {
		lri, ok := l.lockMap[resource]
		if ok && !isWriteLock(lri) {
			// Unless it is a write lock reject it.
			err = fmt.Errorf("unlock attempted on a read locked entity: %s", resource)
			continue
		}
		if ok {
			reply = l.removeEntry(resource, args, &lri) || reply
		}
	}
	return
}

    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->
      assertThat(expected).hasMessage("timeout")
    }
  }

  /**
   * This test reproduces a crash where OkHttp attempted to use a deferred connection when the call
   * already had a healthy connection. It sets up a deferred connection by stalling the IPv6
   * connect, and it sets up a same-connection retry with [ErrorCode.REFUSED_STREAM].
   *