// given:
        val buildOperationRunner = mock<BuildOperationRunner> {
            on { call<Unit>(any()) } doReturn Unit
        }
        val stateFile = testDirectoryProvider.file("stateFile")

        // when:
        buildOperationRunner.withLoadOperation {
            LoadResult(stateFile, UUID.randomUUID().toString()) to Unit
        }

        // then:

import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test
import spock.lang.Issue


class UnitCodecTest : AbstractUserTypeCodecTest() {

    @Test
    @Issue("https://github.com/gradle/gradle/issues/25560")
    fun `same Unit instance is used upon restore`() {
        configurationCacheRoundtripOf(Unit).run {
            assertThat(this, sameInstance(Unit))
        }
    }

    fun `adding function may not have a configuring lambda if it returns Unit`() {
        val exception = assertThrows<IllegalStateException> {
            schemaFromTypes(ReceiverTwo::class, listOf(ReceiverTwo::class))
        }
        assertTrue { exception.message!!.contains("@Adding") }
    }

    @Test
    fun `adding function with no lambda is accepted if it returns Unit`() {

        get() = TODO()

    @Configuring
    fun n1(fn: NestedForAnalysisFilterTest.() -> Unit): Unit = TODO()

    @Configuring
    fun n2(fn: NestedForAnalysisFilterTest.() -> Unit): Unit = TODO()
}


private
class NestedForAnalysisFilterTest {
    @get:Restricted
    var x = 1
}


class AnalysisFilterTest {

    }
    pluginsRuntimeOnly(project(":configuration-cache")) {
        because("We always need a BuildLogicTransformStrategy service implementation.")
    }
    pluginsRuntimeOnly(project(":testing-junit-platform")) {
        because("All test workers have JUnit platform on their classpath (see ForkingTestClassProcessor.getTestWorkerImplementationClasspath).")
    }
    pluginsRuntimeOnly(project(":kotlin-dsl-provider-plugins")) {

    printResolvedAssignments(result)
}


class Tests {
    @Test
    fun `unit assigned to val is reported as an error`() {
        val result = schema.resolve("val x = plugins { }")
        assertTrue { result.errors.single().errorReason == ErrorReason.UnitAssignment }
    }

    @Test
    fun `unit assigned to property is reported as an error`() {
        val result = schema.resolve("plugins = plugins { }")

    api(project(":stdlib-java-extensions"))
    api(project(":native"))

    api(libs.groovy)
    api(libs.groovyXml)
    api(libs.hamcrest)
    api(libs.hamcrestCore)
    api(libs.junit)
    api(libs.junit5JupiterApi)
    api(libs.spock)
    api(libs.spockJUnit4)

    implementation(project(":build-operations"))
    implementation(project(":functional"))
    implementation(project(":serialization"))

    implementation(libs.ant)

import model.CIBuildModel
import model.JsonBasedGradleSubprojectProvider
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.ExtendWith
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.CsvSource
import java.io.File

/*

import org.gradle.internal.metaobject.DynamicObject
import org.junit.Test


class TrackingDynamicLookupRoutineTest {
    @Test
    fun `tracks context in all implementations`() {
        val receiver = mock<DynamicObject> {
            on { tryGetProperty(any()) }.thenReturn(DynamicInvokeResult.found())
        }

        fun shouldTrackContext(action: DynamicLookupRoutine.() -> Unit) {
            val tracker = mock<DynamicCallContextTracker>()

import okhttp3.Request
import okhttp3.Response
import okhttp3.ResponseBody
import okio.Buffer
import okio.ForwardingSource
import okio.buffer
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.api.fail

class ExecuteAsyncTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()