assert configurations._compileFree.collect { it.name } == ['b-transitive.jar', 'c-foo.jar']
                    }
                }
                task checkPaid(dependsOn: configurations._compilePaid) {
                    doLast {
                       assert configurations._compilePaid.collect { it.name } == ['b-transitive.jar', 'c-bar.jar']
                    }
                }
            }

        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) {

                        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))

        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')
    }

import java.util.Map;
import java.util.jar.Attributes;
import java.util.jar.JarFile;
import java.util.jar.Manifest;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;

import org.apache.maven.api.JavaPathType;
import org.apache.maven.api.annotations.Nonnull;

/**
 * Information about the modules contained in a path element.

	queries     []query  // Queries to test the Jar.Cookies method
}

// query contains one test of the cookies returned from Jar.Cookies.
type query struct {
	toURL string // the URL in the Cookies call
	want  string // the expected list of cookies (order matters)
}

// run runs the jarTest.
func (test jarTest) run(t *testing.T, jar *Jar) {
	now := tNow

        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()

                    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()

        when:
        run "compile"
        then:
        executedAndNotSkipped ":compile"

        when:
        run "compile"
        then:
        skipped ":compile"

        when:
        file("lib1.jar").renameTo(file("lib1-renamed.jar"))
        buildFile.text = buildScriptWithClasspath("lib1-renamed.jar", "lib2.jar")

        run "compile"

        _ * 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)