plugins {
    java
}

// tag::task-type[]
abstract class SomeTask : DefaultTask() {

    @get:Input lateinit var sourceSet: SourceSet // <1>

    @TaskAction
    fun action() {
        val classpathFiles = sourceSet.compileClasspath.files
        // ...
    }
}
// end::task-type[]

tasks.register<SomeTask>("someTaskType") {
    sourceSet = sourceSets.main.get()
}

// tag::ad-hoc-task[]

        .takeIf { it.isNotEmpty() }
        ?: listOf("")
    productFlavors.forEach { productFlavorName ->
        buildTypes.forEach { buildTypeName ->
            lateinit var sourceName: String
            lateinit var sourcePath: String
            if (productFlavorName.isNotEmpty()) {
                sourceName = buildTypeName
                sourcePath = sourceName
            } else {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build !386 && !amd64 && !amd64p32 && !arm64

package cpu

func archInit() {
	if err := readHWCAP(); err != nil {
		return
	}
	doinit()
	Initialized = true

  // We should test MockWebServer later.
  @Container
  val mockServer: MockServerContainer = MockServerContainer(MOCKSERVER_IMAGE)

  val capturedOut = ByteArrayOutputStream()

  private lateinit var executor: ExecutorService

  private lateinit var client: OkHttpClient

  @BeforeEach
  fun setUp() {
    platform.assumeLoom()
    assertThat(System.getProperty("jdk.tracePinnedThreads")).isNotEmpty()

    client =

import org.junit.jupiter.params.provider.ValueSource

class ExtensionLifecycleTest(
  server: MockWebServer,
) {
  init {
    assertThat(server).isSameInstanceAs(staticServer)
  }

  private lateinit var instanceServer: MockWebServer

  @RegisterExtension
  val clientTestRule: OkHttpClientTestRule = OkHttpClientTestRule()

  @BeforeEach
  fun beforeEach(server: MockWebServer) {
    instanceServer = server

package org.gradle.smoketest.kotlin.android

import org.junit.Before
import org.junit.Test

class StringPrinterTest {

    lateinit private var stringPrinter: StringPrinterFragment

    @Before fun setUp() {
        stringPrinter = StringPrinterFragment()
    }

    @Test fun shouldPrintStringLength() {
        stringPrinter.printStringLength("Hello world!")
    }

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

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private lateinit var server: MockWebServer
  private lateinit var client: OkHttpClient

  @BeforeEach
  fun setUp() {
    // Sockets on some platforms can have large buffers that mean writes do not block when

import org.junit.Test
import org.junit.rules.TemporaryFolder

import java.io.File

class BuildLogicFunctionalTest {

    @Rule
    @JvmField
    val testProjectDir: TemporaryFolder = TemporaryFolder()

    lateinit var buildFile: File

    @Before
    fun setup() {
        testProjectDir.newFile("settings.gradle").writeText("")
        buildFile = testProjectDir.newFile("build.gradle")
    }

// WITH_FIR_TEST_COMPILER_PLUGIN
// DUMP_IR

// FILE: data/PodcastWithExtraInfo.kt
package data

class PodcastWithExtraInfo {
    lateinit var url: String
    var lastEpisodeDate: kotlin.time.TimeSource? = null
    operator fun component1() = url
    operator fun component2() = lastEpisodeDate
}

// FILE: main.kt
package home

import data.PodcastWithExtraInfo

fun preview(featuredPodcast: PodcastWithExtraInfo) {

        directDependsOnDependencies.add(module)
    }

    public fun addFriendDependency(module: KtModule) {
        directFriendDependencies.add(module)
    }

    public lateinit var platform: TargetPlatform

    public abstract fun build(): KtModule