file("run.sh") << '''#!/bin/sh
# convert paths into absolute Unix-like paths
BUILD_FILE=$(cygpath --absolute --unix build.gradle)
SRC_DIR=$(cygpath --absolute --unix src)
# pass them to the generated start script
build/install/sample/bin/sample "$BUILD_FILE" "$SRC_DIR"
'''
        buildFile << """
task execStartScript(type: Exec) {
    commandLine 'cmd.exe', '/d', '/c', 'sh', 'run.sh'
}
"""

# Finally: Run your script of choice.
#   If you've clicked on a test result from our CI (via a dashboard or GitHub link),
#   click to "Invocation Details" and find BUILD_CONFIG, which will contain a
#   "build_file" item that indicates the script used.
ci/official/wheel.sh

# Advanced: Select specific build/test targets with "any.sh".
# TF_ANY_TARGETS=":your/target" TF_ANY_MODE="test" ci/official/any.sh

            include 'a', 'b'
        '''.stripIndent()
        def buildSrcFile = file('buildSrc/build.gradle')
        def aBuildFile = file('a/build.gradle')
        def bBuildFile = file('b/build.gradle')
        [buildSrcFile, buildFile, aBuildFile, bBuildFile].each { it << '' }

        when:
        def events = ProgressEvents.create()
        withConnection {
            ProjectConnection connection ->

        TestFile buildFile1 = testFile("similarly-named build.gradle").write("task build");
        TestFile buildFile2 = testFile("similarly_named_build_gradle").write("task 'other-build'");

        executer.expectDeprecationWarnings(1);
        usingBuildFile(buildFile1).withTasks("build").run();

        executer.expectDeprecationWarnings(1);
        usingBuildFile(buildFile2).withTasks("other-build").run();

        given:
        buildFile << """
            apply plugin: 'java'

            task expect {
                assert project.components.mainComponent.get() == components.java
            }
        """

        expect:
        succeeds "expect"
    }

    def "Java plugin adds outgoing variant for main source set"() {
        buildFile << """
            plugins {
                id 'java'

    private final Map<String, BuildFileBuilder> buildFiles = [:].withDefault { new BuildFileBuilder(it.toString()) }

    @Delegate
    private final BuildFileBuilder mainBuildFile

    PolyglotProjectBuilder(GradleDsl dsl, TestFile targetDirectory) {
        this.dsl = dsl
        this.targetDirectory = targetDirectory
        this.mainBuildFile = this.buildFiles['build']
    }

        given:
        buildFile << """
            apply plugin: 'base'

            task myTask {
                def builtFile = file('build/file')
                def builtDir = file('build/dir')
                outputs.file builtFile
                outputs.dir builtDir
                doLast {
                    assert !builtFile.exists()
                    builtFile.text = "Created"

class ComponentMetadataRulesErrorHandlingIntegrationTest extends AbstractHttpDependencyResolutionTest {
    final resolve = new ResolveFailureTestFixture(buildFile)

    def setup() {
        ivyRepo.module('org.test', 'projectA', '1.0').publish()
        buildFile << """
            repositories {
                ivy {
                    url "$ivyRepo.uri"
                }
            }

        failure.assertHasDescription("Could not compile build file '${buildFile}'.")
                .assertThatCause(containsString("build file '$buildFile': 3: unable to resolve class org.gradle.unknown.Unknown"))
                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(3)
    }

    def "produces reasonable error message when buildFile evaluation fails with exception"() {
        when:

    def setup() {
        new ResolveTestFixture(buildA.buildFile).prepare()

        buildA.buildFile << """
            task resolve(type: Copy) {
                from configurations.runtimeClasspath
                into 'libs'
            }
"""

        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java'