#
##############################################################################

# Attempt to set APP_HOME

# Resolve links: $0 may be a link
app_path=$0

# Need this for daisy-chained symlinks.
while
    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
    [ -h "$app_path" ]
do
    ls=$( ls -ld "$app_path" )
    link=${ls#*' -> '}

    assertThat(cookie!!.domain).isEqualTo("::1")
  }

  /**
   * These public suffixes were selected by inspecting the publicsuffix.org list. It's possible they
   * may change in the future. If this test begins to fail, please double check they are still
   * present in the public suffix list.
   */
  @Test fun domainIsPublicSuffix() {

    cache.evictAll()

    // Create a new value in its place.
    set("k1", "bb", "bb")
    assertThat(cache.size()).isEqualTo(4)

    // Committing the detached editor should not change the cache's size.
    editor.commit()
    assertThat(cache.size()).isEqualTo(4)
    assertValue("k1", "bb", "bb")
  }

  @ParameterizedTest
  @ArgumentsSource(FileSystemParamProvider::class)

    assertNotSame(
      client.routeDatabase,
      OkHttpClient.Builder()
        .build()
        .routeDatabase,
    )

    // same client with no change affecting route db
    assertSame(
      client.routeDatabase,
      client.newBuilder()
        .build()
        .routeDatabase,
    )
    assertSame(
      client.routeDatabase,

    assertThat(taskFaker.executeCallCount).isEqualTo(1)
  }

  @Test fun noMoreThanOneWorkerThreadWaitingToStartAtATime() {
    // Enqueueing the red task starts a thread because the head of the queue changed.
    redQueue.execute("red task") {
      log += "red:starting@${taskFaker.nanoTime}"
      taskFaker.sleep(100.µs)
      log += "red:finishing@${taskFaker.nanoTime}"
    }

            listOf(Channel, Standard).flatMap { socketMode ->
              listOf(DISABLED, STANDARD).map { tlsExtensionMode ->
                TlsInstance(provider, protocol, tlsVersion, socketMode, tlsExtensionMode)
              }
            }
          }
        }
      } + Channel + Standard
  }
}

sealed class SocketMode

object Channel : SocketMode() {

      private val useCompression: Boolean = true,
      private val out: Buffer,
    ) {
      /**
       * In the scenario where the dynamic table size changes multiple times between transmission of
       * header blocks, we need to keep track of the smallest value in that interval.
       */
      private var smallestHeaderTableSizeSetting = Integer.MAX_VALUE

 *
 * The configuration of each spec changes with each OkHttp release. This is annoying: upgrading
 * your OkHttp library can break connectivity to certain web servers! But it’s a necessary annoyance
 * because the TLS ecosystem is dynamic and staying up to date is necessary to stay secure. See
 * [OkHttp's TLS Configuration History][tls_history] to track these changes.
 *

 * limitations under the License.
 */
package mockwebserver3

import okhttp3.ExperimentalOkHttpApi
import okio.BufferedSink
import okio.BufferedSource

/**
 * A bidirectional sequence of data frames exchanged between client and server.
 */
@ExperimentalOkHttpApi
interface Stream {
  val requestBody: BufferedSource
  val responseBody: BufferedSink

  /**

 * this class offers:
 *
 *  * **Read/write:** read and write using the same operator.
 *  * **Random access:** access any position within the file.
 *  * **Shared channels:** read and write a file channel that's shared between
 * multiple operators. Note that although the underlying [FileChannel] may be shared,
 * each [FileOperator] should not be.
 */
internal class FileOperator(
  private val fileChannel: FileChannel,