Method <org.gradle.nativeplatform.test.cunit.tasks.GenerateCUnitLauncher.getHeaderDir()> does not have raw return type assignable to org.gradle.api.provider.Property in (GenerateCUnitLauncher.java:0)

Method <org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.getComponent()> does not have raw return type assignable to org.gradle.api.provider.Provider in (CUnitTestSuiteBinarySpec.java:0)
Method <org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.getTestSuite()> does not have raw return type assignable to org.gradle.api.provider.Provider in (CUnitTestSuiteBinarySpec.java:0)

                }
            """
            file("application/src/test/java/application/AdderTest.java").java """
                package application;

                import org.junit.Assert;
                import org.junit.Test;

                public class AdderTest {
                    @Test
                    public void testAdd() {
                        Adder adder = new Adder();

        // 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:

* `gradle init --type java-application --test-framework junit-jupiter`: Uses https://junit.org[JUnit Jupiter] for testing instead of JUnit 4
* `gradle init --type java-application --test-framework spock`: Uses https://spockframework.org[Spock] for testing instead of JUnit 4
* `gradle init --type java-application --test-framework testng`: Uses https://testng.org/doc/index.html[TestNG] for testing instead of JUnit 4


[[sec:java_version_option]]

    internal
    fun checkBinaryCompatible(v1: File.() -> Unit = {}, v2: File.() -> Unit = {}, block: CheckResult.() -> Unit = {}): CheckResult =
        runBinaryCompatibilityCheck(v1, v2) {
            assertBinaryCompatible()
            block()
        }

    internal
    fun checkNotBinaryCompatible(v1: File.() -> Unit = {}, v2: File.() -> Unit = {}, block: CheckResult.() -> Unit = {}): CheckResult =
        runBinaryCompatibilityCheck(v1, v2) {

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")) {