exclude("gradle-*-classpath.properties")
    exclude("gradle-*-parameter-names.properties")
}

// Using Gr8 plugin with ProGuard to minify the wrapper JAR.
// This minified JAR is added to the project root when the wrapper task is used.
// It is embedded in the main JAR as a resource called `/gradle-wrapper.jar.`
gr8 {
    create("gr8") {

        URL[] jars = [
            jar(NativeServices),
            jar(ServiceRegistration),
            jar(ServiceRegistry),
            jar(Native),
            jar(LoggerFactory),
            jar(Chmod),
            jar(TemporaryFileProvider),
            jar(Cast),
            jar(Inject),
            jar(Stoppable)
        ]

        run "verify"

        then:
        outputContains("files: [lib.jar]")
        outputContains("resolve: [lib.jar]")
        outputContains("resolve-not-transitive: [lib.jar]")
        outputContains("resolve-transitive: [lib.jar]")
    }

    // This test documents existing behaviour rather than desired behaviour

                        attribute(Usage.USAGE_ATTRIBUTE, project.objects.named(Usage, 'java-api'))
                        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, project.objects.named(LibraryElements, 'jar'))
                        attribute(Bundling.BUNDLING_ATTRIBUTE, project.objects.named(Bundling, Bundling.EXTERNAL))

        addVariantToExistingComponent(project, outgoingConfiguration)
    }

    private void attachArtifact(Project project) {
        def instrumentedJar = project.tasks.register("instrumentedJar", Jar) { Jar jar ->
            jar.archiveClassifier.set("instrumented")
        }
        project.artifacts.add("instrumentedJars", instrumentedJar)
    }

    private Configuration createOutgoingConfiguration(Project project) {

        def options = inferJvmOptions(Mock(FileCollectionFactory), ['-Xmx1g', '-javaagent:foo.jar', '-javaagent:' + AgentUtils.AGENT_MODULE_NAME + '.jar'])
        expect:
        options.allJvmArgs.containsAll('-Xmx1g', '-javaagent:foo.jar')
        !options.allJvmArgs.contains('-javaagent:' + AgentUtils.AGENT_MODULE_NAME + '.jar')
    }

        then:
        cl instanceof VisitableURLClassLoader
        cl.URLs == [url1, url2] as URL[]
    }

    def "creates ClassLoader for jar classpath"() {
        def jarFile = tmpDir.createFile("file1.jar")
        def cachedJar = tmpDir.createFile("cached/file1.jar")
        def url1 = jarFile.toURI().toURL()
        def cached = cachedJar.toURI().toURL()
        def url2 = tmpDir.createDir("classes-dir").toURI().toURL()

plugins {
    id("gradlebuild.distribution.api-java")
    id("gradlebuild.publish-public-libraries")
    id("gradlebuild.shaded-jar")
}

description = "Gradle Tooling API - the programmatic API to invoke Gradle"

gradlebuildJava.usedInToolingApi()

tasks.named<Jar>("sourcesJar") {
    // duplicate package-info.java because of split packages
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

shadedJar {

                    return null;
                }
            }
        """
        def jar = temporaryFolder.file("work folder", "action-impl.jar")
        builder.buildJar(jar)

        when:
        def classloader = new URLClassLoader([jar.toURL()] as URL[], getClass().classLoader)
        def action = classloader.loadClass("ActionImpl").getConstructor().newInstance()

        _ * distribution1.getToolingImplementationClasspath(loggerFactory, progressListener, params, cancellationToken) >> DefaultClassPath.of(new File('a.jar'))
        _ * distribution2.getToolingImplementationClasspath(loggerFactory, progressListener, params, cancellationToken) >> DefaultClassPath.of(new File('b.jar'))
        0 * _._
    }

    def "close connections when closed"() {
        def connection1 = Mock(ConsumerConnection)