lockRankGlobalAlloc:     "globalAlloc",
	lockRankTrace:           "trace",
	lockRankTraceStackTab:   "traceStackTab",
	lockRankPanic:           "panic",
	lockRankDeadlock:        "deadlock",
	lockRankRaceFini:        "raceFini",
	lockRankAllocmRInternal: "allocmRInternal",
	lockRankExecRInternal:   "execRInternal",
	lockRankTestRInternal:   "testRInternal",
}

func (rank lockRank) String() string {
	if rank == 0 {

import org.junit.jupiter.api.extension.RegisterExtension

/** Derived from Android's CookiesTest.  */
@Timeout(30)
class CookiesTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private lateinit var server: MockWebServer
  private var client = clientTestRule.newClient()

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
  }

  @Test
  fun testNetscapeResponse() {

class OkHttpClientTestRule : BeforeEachCallback, AfterEachCallback {
  private val clientEventsList = mutableListOf<String>()
  private var testClient: OkHttpClient? = null
  private var uncaughtException: Throwable? = null
  private lateinit var testName: String
  private var defaultUncaughtExceptionHandler: Thread.UncaughtExceptionHandler? = null
  private var taskQueuesWereIdle: Boolean = false
  val connectionListener = RecordingConnectionListener()

    )
}

@Timeout(60)
@Tag("Slow")
class DiskLruCacheTest {
  private lateinit var filesystem: FaultyFileSystem
  private var windows: Boolean = false

  @TempDir lateinit var cacheDirFile: File
  lateinit var cacheDir: Path
  private val appVersion = 100
  private lateinit var journalFile: Path
  private lateinit var journalBkpFile: Path
  private val taskFaker = TaskFaker()

        }
    }

    public val application: Application = kotlinCoreProjectEnvironment.environment.application

    public val project: Project = kotlinCoreProjectEnvironment.project

    private lateinit var projectStructureProvider: KtStaticProjectStructureProvider

    public fun buildKtModuleProvider(init: KtModuleProviderBuilder.() -> Unit) {

    private
    var reusedProjects = 0

    private
    var updatedProjects = 0

    private
    var incompatibleTasks = newConcurrentHashSet<String>()

    private
    lateinit var cacheAction: ConfigurationCacheAction

    val shouldDiscardEntry: Boolean
        get() {
            if (cacheAction == LOAD) {
                return false
            }

@Tag("Slowish")
class ConnectionReuseTest {
  @RegisterExtension
  val platform: PlatformRule = PlatformRule()

  @RegisterExtension
  val clientTestRule: OkHttpClientTestRule = OkHttpClientTestRule()

  private lateinit var server: MockWebServer
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client: OkHttpClient = clientTestRule.newClient()

  @BeforeEach
  fun setUp(server: MockWebServer) {

        parse(code).assert(expected)
    }

    @Test
    fun `rejects mutable vars`() {
        val code = """
            var x = 0
            var x: Int = 0
            var x: Int
            lateinit var x: Int""".trimIndent()
        val expected = """
            ErroneousStatement (
                UnsupportedConstruct(
                    languageFeature = LocalVarNotSupported,

		types.CalcSize(n.Type())
	}
}

// walkRecv walks an ORECV node.
func walkRecv(n *ir.UnaryExpr) ir.Node {
	if n.Typecheck() == 0 {
		base.Fatalf("missing typecheck: %+v", n)
	}
	init := ir.TakeInit(n)

	n.X = walkExpr(n.X, &init)
	call := walkExpr(mkcall1(chanfn("chanrecv1", 2, n.X.Type()), nil, &init, n.X, typecheck.NodNil()), &init)
	return ir.InitExpr(init, call)
}

    }
  }

  @Test fun secondReadFailsSameAsFirst() {
    val badPublicSuffixDatabase =
      PublicSuffixDatabase(
        path = "/xxx.gz".toPath(),
      )
    lateinit var firstFailure: Exception
    assertFailsWith<Exception> {
      badPublicSuffixDatabase.getEffectiveTldPlusOne("squareup.com")
    }.also { e ->
      firstFailure = e
    }
    assertFailsWith<Exception> {