import okhttp3.internal.connection.Exchange
import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache {
  return Cache(fileSystem, file, maxSize)
}

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

  @BeforeEach
  fun setUp() {
    testResourceDir = "./build/resources/test/okhttp3/osgi".toPath()
    workspaceDir = testResourceDir / "workspace"

    // Ensure we start from scratch.
    fileSystem.deleteRecursively(workspaceDir)
    fileSystem.createDirectories(workspaceDir)
  }

  /**
   * Resolve the OSGi metadata of the all okhttp3 modules. If required modules do not have OSGi
   * metadata this will fail with an exception.
   */

 *
 *
 * The resulting file is used by [PublicSuffixDatabase].
 */
class PublicSuffixListGenerator(
  projectRoot: Path = ".".toPath(),
  val fileSystem: FileSystem = FileSystem.SYSTEM,
  val client: OkHttpClient = OkHttpClient(),
) {
  private val resources = projectRoot / "okhttp/src/main/resources/okhttp3/internal/publicsuffix"

class PostPath {
  private val client = OkHttpClient()
  private val fileSystem = FakeFileSystem()
  val path = "test.json".toPath()

  fun run() {
    fileSystem.write(path) {
      writeUtf8("{}")
    }

    val request =
      Request.Builder()
        .url("https://httpbin.org/anything")
        .put(path.asRequestBody(fileSystem, MEDIA_TYPE_JSON))
        .build()

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

import okio.FileSystem
import okio.ForwardingFileSystem
import okio.Path
import okio.Sink
import okio.Source

class LoggingFilesystem(fileSystem: FileSystem) : ForwardingFileSystem(fileSystem) {
  fun log(line: String) {
    println(line)
  }

  override fun appendingSink(
    file: Path,

      .build()
  private val STORY_JSON_ADAPTER = MOSHI.adapter(Story::class.java)

  private val fileSystem = FileSystem.SYSTEM

  private fun readStory(source: BufferedSource): Story {
    return STORY_JSON_ADAPTER.fromJson(source)!!
  }

  private fun readStory(file: Path): Story {
    fileSystem.read(file) {
      return readStory(this)
    }
  }

	"ef51":     "EXT2OLD",
	"ef53":     "EXT4",
	"f15f":     "ecryptfs",
	"794c7630": "overlayfs",
	"2fc12fc1": "zfs",
	"ff534d42": "cifs",
	"53464846": "wslfs",
}

// getFSType returns the filesystem type of the underlying mounted filesystem
func getFSType(ftype int64) string {
	fsTypeHex := strconv.FormatInt(ftype, 16)
	fsTypeString, ok := fsType2StringMap[fsTypeHex]
	if !ok {
		return "UNKNOWN"
	}
	return fsTypeString

  }

  private fun corruptMetadata(corruptor: (String) -> String) {
    val metadataFile =
      fileSystem.allPaths.find {
        it.name.endsWith(".0")
      }

    if (metadataFile != null) {
      val contents =
        fileSystem.read(metadataFile) {
          readUtf8()
        }

      fileSystem.write(metadataFile) {
        writeUtf8(corruptor(contents))
      }
    }
  }

import assertk.assertions.isEqualTo
import assertk.assertions.isGreaterThan
import okhttp3.HttpUrl.Companion.toHttpUrl
import okhttp3.internal.publicsuffix.PublicSuffixDatabase
import okhttp3.testing.PlatformRule
import okio.FileSystem
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension

class PublicSuffixDatabaseTest {
  @RegisterExtension
  @JvmField
  val platform = PlatformRule()

  @Test

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import okhttp3.ConnectionSpec
import okhttp3.OkHttp
import okhttp3.survey.types.Client
import okhttp3.survey.types.SuiteId
import okio.FileSystem
import okio.Path.Companion.toPath
import org.conscrypt.Conscrypt

fun currentOkHttp(ianaSuites: IanaSuites): Client {
  return Client(
    userAgent = "OkHttp",
    version = OkHttp.VERSION,
    enabled =