repositories {
    mavenCentral()
}

// tag::toolchain[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
    }
}
// end::toolchain[]

tasks.withType<Test>().configureEach {
    useJUnitPlatform()
}

dependencies {
    testImplementation("org.junit.jupiter:junit-jupiter:5.7.1")
    testRuntimeOnly("org.junit.platform:junit-platform-launcher")

    def "fails when working directory is invalid"() {
        buildWithApplicationAndDependencies()
        buildFile << """
            project(':app') {
                tasks.withType(XCTest).configureEach {
                    doFirst {
                        workingDirectory = project.layout.projectDirectory.dir("does-not-exist")
                    }
                }
            }
        """
        expect:

    }

    @Override
    public void all(Closure action) {
        all(ConfigureUtil.configureUsing(action));
    }

    @Override
    public void configureEach(Action<? super T> action) {
        delegate.configureEach(action);
    }

    @Override
    public Action<? super T> whenObjectAdded(Action<? super T> action) {
        return delegate.whenObjectAdded(action);
    }

    @Override

    dependsOn(":dist")
    workingDir = rootDir
    useJUnitPlatform()
}.also { confugureFirPluginAnnotationsDependency(it) }

testsJar()

allprojects {
    tasks.withType<KotlinJvmCompile>().configureEach {
        compilerOptions.optIn.addAll(
            listOf(
                "org.jetbrains.kotlin.fir.symbols.SymbolInternals",

            c.defaultDependencies(d -> d.add(project.getDependencies().create("org.myorg:data:1.4.6")));
        });

        project.getTasks().withType(DataProcessing.class).configureEach(
            dataProcessing -> dataProcessing.getDataFiles().from(dataFiles));
    }
}

tasks.withType(PublishToMavenRepository).configureEach {
    notCompatibleWithConfigurationCache("Configures repository at execution time")
    doFirst {
        def address = com.example.MavenRepositoryStub.start()
        getRepository().setUrl(address)
    }
    doLast {
        com.example.MavenRepositoryStub.stop()
    }

            c.defaultDependencies(d -> d.add(project.getDependencies().create("org.myorg:data:1.4.6")));
        });

        project.getTasks().withType(DataProcessing.class).configureEach(
            dataProcessing -> dataProcessing.getDataFiles().from(dataFiles));
    }
}

}

// tag::java-cross-compilation[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(7)
    }
}
// end::java-cross-compilation[]

tasks.withType<Test>().configureEach {
    project.findProperty("targetJavaVersion")?.let { systemProperty("targetJavaVersion", it) }
}

tasks.register("checkJavadocOutput") {
    dependsOn(tasks.javadoc)
    val docsDir = java.docsDir
    doLast {

plugins {
    id("myproject.java-conventions")
    `java-library`
}

// tag::customToolchain[]
tasks.withType<JavaCompile>().configureEach {
    javaCompiler = javaToolchains.compilerFor {
        languageVersion = JavaLanguageVersion.of(8)
    }
}

tasks.register<Test>("testsOn17") {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(17)
    }
}

// tag::test-report[]
plugins {
    id("xctest")
}

extensions.configure<SwiftXCTestSuite>() {
    binaries.configureEach {
        // Disable the test report for the individual test task
        runTask.get().reports.html.required = false
    }
}

configurations.create("binaryTestResultsElements") {
    isCanBeResolved = false
    isCanBeConsumed = true
    attributes {