}

        result.listed(ImmutableSet.of());
    }

    /**
     * If the repository provides a rule to create a list of versions of a module, use it.
     * It's assumed that the result of such a call is authoritative.
     */
    private void tryListingViaRule(ModuleIdentifier module, BuildableModuleVersionListingResolveResult result) {
        if (providedVersionLister != null) {

    val mockitoKotlin2 = "com.nhaarman.mockitokotlin2:mockito-kotlin"
    val mockwebserver = "com.squareup.okhttp3:mockwebserver"
    val mySqlConnector = "mysql:mysql-connector-java"
    val netty = "io.netty:netty-all"
    val opentest4j = "org.opentest4j:opentest4j"
    val samplesCheck = "org.gradle.exemplar:samples-check"
    val samplesDiscovery = "org.gradle.exemplar:samples-discovery"
    val snappy = "org.iq80.snappy:snappy"

        then:
        ScriptDslFixture.of(BuildInitDsl.KOTLIN, targetDir, null).assertGradleFilesGenerated()
    }

    @Issue("https://github.com/gradle/gradle/issues/26598")
    def "user can provide all necessary options to generate java application non-interactively"() {
        when:
        def handle = startInteractiveExecutorWithTasks(
            "init",
            "--type", "java-application",

        }
    }

    private
    fun checkFingerprint(entryDetails: EntryDetails, layout: ConfigurationCacheRepository.Layout): CheckedFingerprint {
        // Register all included build root directories as watchable hierarchies,
        // so we can load the fingerprint for build scripts and other files from included builds
        // without violating file system invariants.

            "--add-opens",
            "java.base/java.util=ALL-UNNAMED",
            "--add-opens",
            "java.base/java.util.concurrent.atomic=ALL-UNNAMED",
            "--add-opens",
            "java.base/java.lang=ALL-UNNAMED",
            "--add-opens",
            "java.base/java.lang.invoke=ALL-UNNAMED",
            "--add-opens",
            "java.base/java.net=ALL-UNNAMED"

            }
        """
    }

    private cleanUpAll(List<RepoFixture> fixtures) {
        fixtures.forEach {
            it.cleanup?.call()
        }
    }

    def "does not invalidate configuration cache entry when changing artifact information has not expired"() {
        given:
        server.start()

      "testProject" : "largeMonolithicJavaProject",
      "coverage" : {
        "per_day" : [ "linux" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.java.JavaTasksPerformanceTest.tasks --all",
    "groups" : [ {
      "testProject" : "largeJavaMultiProject",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    }, {
      "testProject" : "largeMonolithicJavaProject",

                    val baseScope = classLoaderScopeRegistry.coreAndPluginsScope.createChild("accessors-classpath", null).apply {
                        // we export the build logic classpath to the base scope here so that all referenced plugins
                        // can be resolved in the root project scope created below.
                        export(buildLogicClassPath(gradle))
                        lock()
                    }

27347 pts/0    S      0:00 bash

            this.detectionStrategy = detectionStrategy;
        }

        @Override
        public Set<InstallationLocation> call(BuildOperationContext context) throws Exception {
            return detectionStrategy.call();
        }

        @Override
        public BuildOperationDescriptor.Builder description() {
            return BuildOperationDescriptor