def operations = new BuildOperationsFixture(executer, temporaryFolder)

    @SuppressWarnings("GroovyUnusedDeclaration")
    def operationNotificationsFixture = new BuildOperationNotificationsFixture(executer, temporaryFolder)

    def "repositories used when resolving project configurations are exposed via build operation (repo: #repo)"() {
        setup:
        executer.beforeExecute { executer.withPluginRepositoryMirrorDisabled() }

import org.gradle.integtests.fixtures.StaleOutputJavaProject
import org.gradle.integtests.fixtures.UnsupportedWithConfigurationCache
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.integtests.fixtures.timeout.IntegrationTestTimeout
import org.gradle.integtests.fixtures.versions.ReleasedVersionDistributions
import org.gradle.internal.jvm.Jvm

        def java11Home = AvailableJavaHomes.getJdk11().javaHome

        when:
        executer.withJavaHome(java8Home).withArguments("-Porg.gradle.java.installations.paths=$java8Home,$java11Home")
        succeeds("printFoo")

        then:
        outputContains("JAR = DEFAULT")

        when:
        executer.withJavaHome(java11Home).withArguments("-Porg.gradle.java.installations.paths=$java8Home,$java11Home")

            'LOGGER: evaluated project :',
            'LOGGER: evaluated project :project1',
            'LOGGER: evaluated project :project2',
            'LOGGER: executed task :project1:log',
            'LOGGER: executed task :project1:logInfo',
            'LOGGER: executed task :project1:logLifecycle',
            'LOGGER: task :project1:log starting work',
            'LOGGER: task :project1:log completed work',
        )
        forbidden(

    GarbageCollectorUnderTest garbageCollector

    def setup() {
        garbageCollector = version
        executer.withBuildJvmOpts(garbageCollector.configuration.jvmArgs.split(" "))
        executer.withEnvironmentVars(JAVA_TOOL_OPTIONS: "-D${DefaultGarbageCollectionMonitor.DISABLE_POLLING_SYSTEM_PROPERTY}=true")
    }

 */
package org.gradle.api.tasks.diagnostics

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class DependencyReportTaskIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        executer.requireOwnGradleUserHomeDir()
    }

    def "omits repeated dependencies in case of circular dependencies"() {
        given:
        createDirs("client", "a", "b", "c")

        when:
        consumer.file("build.gradle") << """
            dependencies {
                install 'some.group:test:1.2'
            }
        """
        executer.inDirectory(consumer)
        run("install")

        then:
        def installation = installation("consumer/install")
        installation.exec().out == app.expectedOutput
    }

                doLast {
                    println files.files
                }
            }
        """

        expect:

    String remoteCacheClass = "RemoteBuildCache"

    def operations = new BuildOperationsFixture(executer, testDirectoryProvider)
    def cacheOperations = new BuildCacheOperationFixtures(operations)

    void remote(String loadBody, String storeBody) {
        register(remoteCacheClass, loadBody, storeBody)
    }

    def setup() {
        executer.beforeExecute { it.withBuildCacheEnabled() }
    }

 */

package org.gradle.integtests.resolve.ivy

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache
import org.gradle.integtests.fixtures.executer.ProgressLoggingFixture
import org.gradle.test.fixtures.file.LeaksFileHandles
import org.gradle.test.fixtures.server.RepositoryServer
import org.junit.Rule

@LeaksFileHandles