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

class OkHttpClientTestRuleTest {
  lateinit var extensionContext: ExtensionContext

  @RegisterExtension @JvmField
  val beforeEachCallback =
    BeforeEachCallback { context ->
      ******@****.***ionContext = context
    }

import org.gradle.testkit.runner.GradleRunner
import org.junit.jupiter.api.io.TempDir

/**
 * A simple functional test for the '${pluginId.value}' plugin.
 */
class ${className.javaIdentifier} {

    @field:TempDir
    lateinit var projectDir: File

    private val buildFile by lazy { projectDir.resolve("build.gradle") }
    private val settingsFile by lazy { projectDir.resolve("settings.gradle") }

    @Test fun `can run task`() {

class BouncyCastleTest {
  @JvmField @RegisterExtension
  var platform = PlatformRule()

  @JvmField @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  var client = clientTestRule.newClient()
  private lateinit var server: MockWebServer

  @BeforeEach
  fun setUp(server: MockWebServer) {
    this.server = server
    OkHttpDebugLogging.enable("org.bouncycastle.jsse")
    platform.assumeBouncyCastle()
  }

  @Test

import org.junit.jupiter.api.Test

@OptIn(KaAnalysisApiInternals::class)
class NativeStandaloneSessionBuilderTest {
    @Test
    fun testResolveAgainstCommonKlib() {
        lateinit var sourceModule: KtSourceModule
        val currentArchitectureTarget = HostManager.host
        val nativePlatform = NativePlatforms.nativePlatformByTargets(listOf(currentArchitectureTarget))

import kotlin.contracts.contract

@KtModuleBuilderDsl
public class KtLibraryModuleBuilder(
    private val kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment
) : KtBinaryModuleBuilder() {
    public lateinit var libraryName: String
    public var librarySources: KtLibrarySourceModule? = null

    override fun build(): KtLibraryModule {
        val binaryRoots = getBinaryRoots()

	"cmd/internal/src"
)

func walkSelect(sel *ir.SelectStmt) {
	lno := ir.SetPos(sel)
	if sel.Walked() {
		base.Fatalf("double walkSelect")
	}
	sel.SetWalked(true)

	init := ir.TakeInit(sel)

	init = append(init, walkSelectCases(sel.Cases)...)
	sel.Cases = nil

	sel.Compiled = init
	walkStmtList(sel.Compiled)

	base.Pos = lno
}

import java.util.concurrent.atomic.AtomicInteger
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout

@Timeout(30)
class CustomDispatcherTest {
  private lateinit var mockWebServer: MockWebServer

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

  @Test
  fun simpleDispatch() {

import kotlin.contracts.contract

@KtModuleBuilderDsl
public class KtSdkModuleBuilder(
    private val kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment
) : KtBinaryModuleBuilder() {
    public lateinit var sdkName: String

    public fun addBinaryRootsFromJdkHome(jdkHome: Path, isJre: Boolean) {
        val jdkRoots = LibraryUtils.findClassesFromJdkHome(jdkHome, isJre)
        addBinaryRoots(jdkRoots)
    }

    protected fun doTestKotlinStdLibResolve(
        targetPlatform: TargetPlatform, platformStdlibPath: Path,
        additionalStdlibRoots: List<Path> = emptyList(),
    ) {
        lateinit var sourceModule: KtSourceModule
        val session = buildStandaloneAnalysisAPISession(disposable) {
            buildKtModuleProvider {
                platform = targetPlatform
                val stdlib = addModule(

    private
    val implicitImports: ImplicitImports

) : DefaultTask(), SharedAccessorsPackageAware {

    @get:Internal
    abstract val metadataDir: DirectoryProperty

    private
    lateinit var onConfigure: (Provider<String>) -> Unit

    fun onConfigure(action: (Provider<String>) -> Unit) {
        onConfigure = action
    }

    @TaskAction
    fun configureImports() {