given:
        useTestDirectoryThatIsNotEmbeddedInAnotherBuild()
        executer.beforeExecute {
            requireOwnGradleUserHomeDir()
        }

        when:
        succeeds('init', '--type', 'java-application', '--dsl', 'groovy')

        and:
        executer.withArgument("-Porg.gradle.java.installations.auto-detect=false")
        executer.withArgument("-Porg.gradle.java.installations.auto-download=true")

            plugins {
                id("java")
                id("idea")
            }
        """

        //given
        executer.withTasks('idea').run()
        def projectContent = getFile([:], 'master.ipr').text
        def moduleContent = getFile([:], 'master.iml').text

        executer.withTasks('idea').run()
        def projectContentAfterMerge = getFile([:], 'master.ipr').text

import com.google.common.collect.ImmutableSet
import com.gradle.develocity.testing.annotations.LocalOnly
import org.apache.commons.io.FileUtils
import org.gradle.cache.GlobalCacheLocations
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.internal.os.OperatingSystem
import org.gradle.internal.service.scopes.VirtualFileSystemServices
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider

    @Rule Sample sample = new Sample(temporaryFolder, 'java/application')

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "can run the application using run task with #dsl dsl"() {
        when:
        executer.inDirectory(sample.dir.file(dsl))
        succeeds('run')

        then:
        outputContains('Greetings from the sample application.')

    @Rule
    final TestResources resources = new TestResources(testDirectoryProvider)

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emitsBuildOperationsForJUnitTests"() {
        given:
        executer.withRepositoryMirrors()

        when:
        run "test"

        then: "test build operations are emitted in expected hierarchy"

                        classpath = sourceSets.main.runtimeClasspath
                        mainClass = 'Main'
                    }
                }
            }
        """

        when:
        executer.withConsole(consoleType)
        succeeds("run")

        then:
        def output = result.groupedOutput.task(':run').output
        output.contains(EXPECTED_OUTPUT)

        module.pom.sha1.expectGet()
        module.pom.expectGet()
        module.artifact.expectHead()
        module.artifact.sha1.expectGet()
        module.artifact.expectGet()

        and:
        executer.withArguments(arg)
        succeeds 'retrieve'

        then:
        file('libs/projectA-1.2.jar').assertIsCopyOf(module.artifactFile).assertHasChangedSince(snapshot)

        where:

    @Rule
    public final ScopeIdsFixture scopeIds = new ScopeIdsFixture(executer, temporaryFolder)

    @Rule
    public final OriginFixture outputOrigin = new OriginFixture(executer, temporaryFolder)

    @Delegate
    @Rule
    public final BuildCacheKeyFixture buildCacheKeyFixture = new BuildCacheKeyFixture(executer, temporaryFolder)

    String getBuildInvocationId() {

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    VerboseVfsLogAccessor vfsLogs

    def setup() {
        executer.requireDaemon()
        executer.beforeExecute {
            vfsLogs = enableVerboseVfsLogs()
        }
        server.start()
        settingsFile  << """
            import org.gradle.internal.file.FileType
            import org.gradle.internal.snapshot.*

        proxyServer.configureProxy(executer)
        fails('listJars') // Don't have to succeed here, just record the attempt in the fake proxy and verify it
        then:
        result.assertTaskExecuted(":listJars")
        recordingServer.madeAnyConnection()

        when:
        proxyServer.stop()
        proxyServer.configureProxy(executer)
        fails('listJars', '--refresh-dependencies')
        then: