SmbTransport transport;

    // static helper that returns the mocked transport. The real class
    // performs several other operations, but for the purpose of the test
    // we intercept the factory call.
    private MockedStatic<SmbTransport> smbtStatic;

    @BeforeEach
    void setUp() throws Exception {
        // Create a real NtlmPasswordAuthentication instance

/**
 * Internal Bootstrap DNS implementation for handling initial connection to DNS over HTTPS server.
 *
 * Returns hardcoded results for the known host.
 */
internal class BootstrapDns(
  private val dnsHostname: String,
  private val dnsServers: List<InetAddress>,
) : Dns {
  @Throws(UnknownHostException::class)
  override fun lookup(hostname: String): List<InetAddress> {
    if (this.dnsHostname != hostname) {

        getOnly = false,
      )
    runBatch(dnsProviders, names)
    val dnsCache =
      Cache(
        directory = File("./target/TestDohMain.cache.${System.currentTimeMillis()}"),
        maxSize = 10L * 1024 * 1024,
      )
    println("Bad targets\n***********\n")
    val url = "https://dns.cloudflare.com/.not-so-well-known/run-dmc-query".toHttpUrl()
    val badProviders =
      listOf(
        DnsOverHttps
          .Builder()

  block: () -> T,
): T {
  var startNs = -1L
  val loggingEnabled = isLoggable(Level.FINE)
  if (loggingEnabled) {
    startNs = queue.taskRunner.backend.nanoTime()
    log(task, queue, "starting")
  }

  var completedNormally = false
  try {
    val result = block()
    completedNormally = true
    return result
  } finally {
    if (loggingEnabled) {
      val elapsedNs = queue.taskRunner.backend.nanoTime() - startNs

package okhttp3.tls.internal.der

import okio.ByteString

/**
 * Like a [ByteString], but whose bits are not necessarily a strict multiple of 8.
 */
internal data class BitString(
  val byteString: ByteString,
  /** 0-7 unused bits in the last byte. */
  val unusedBitsCount: Int,
) {
  // Avoid Long.hashCode(long) which isn't available on Android 5.
  override fun hashCode(): Int {
    var result = 0

 * limitations under the License.
 */
package okhttp3.recipes.kt

import java.io.IOException
import okhttp3.OkHttpClient
import okhttp3.Request

class SynchronousGet {
  private val client = OkHttpClient()

  fun run() {
    val request =
      Request
        .Builder()
        .url("https://publicobject.com/helloworld.txt")
        .build()

    client.newCall(request).execute().use { response ->

            }
        }

        if (value instanceof String val) {
            // TODO without #, this could just be an evaluate call...

            int exprStartDelimiter = val.indexOf("${");

            if (exprStartDelimiter >= 0) {
                if (exprStartDelimiter > 0) {
                    value = val.substring(0, exprStartDelimiter) + evaluate(val.substring(exprStartDelimiter));
                } else {

import okhttp3.OkHttpClient
import okhttp3.Request

class ConfigureTimeouts {
  private val client: OkHttpClient =
    OkHttpClient
      .Builder()
      .connectTimeout(5, TimeUnit.SECONDS)
      .writeTimeout(5, TimeUnit.SECONDS)
      .readTimeout(5, TimeUnit.SECONDS)
      .callTimeout(10, TimeUnit.SECONDS)
      .build()

  fun run() {
    val request =
      Request
        .Builder()

 * limitations under the License.
 */
package okhttp3.zstd

import okhttp3.CompressionInterceptor
import okhttp3.OkHttpClient
import okhttp3.Request

fun main() {
  val client =
    OkHttpClient
      .Builder()
      .addInterceptor(CompressionInterceptor(Zstd))
      .build()

  sendRequest("https://developers.facebook.com/docs/", client)

  fun createFactory(client: OkHttpClient) = createFactory(client as Call.Factory)

  @JvmStatic
  fun createFactory(callFactory: Call.Factory): EventSource.Factory =
    EventSource.Factory { request, listener ->
      val actualRequest =
        if (request.header("Accept") == null) {
          request.newBuilder().addHeader("Accept", "text/event-stream").build()
        } else {
          request
        }