package org.gradle.internal.declarativedsl.analysis

import org.gradle.declarative.dsl.model.annotations.Adding
import org.gradle.declarative.dsl.model.annotations.Restricted


class MyClass {
    @get:Restricted
    lateinit var my: MyClass
}


class TopLevel {
    @Adding
    fun my1(): MyClass = MyClass()

    @Adding
    fun my2(): MyClass = MyClass()

    @Adding

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!")
    }

  val clientTestRule = OkHttpClientTestRule()
  private lateinit var server: MockWebServer
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private val logRecorder =
    HttpLoggingInterceptorTest.LogRecorder(
      prefix = Regex("""\[\d+ ms] """),
    )
  private val loggingEventListenerFactory = LoggingEventListener.Factory(logRecorder)
  private lateinit var client: OkHttpClient
  private lateinit var url: HttpUrl

@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")
    }