_ * cache.getBaseDir() >> cacheDir
        1 * cache.close()
        0 * cache._
        classpath.asFiles == [jarFile]
        jarFile.file
    }

    def reusesTheCachedClasspath() {
        def cacheDir = tmpDir.testDirectory
        def jarFile = cacheDir.file('gradle-worker.jar')
        CacheBuilder cacheBuilder = Mock()
        PersistentCache cache = Mock()

        when:

            assert firstEntryName.equalsIgnoreCase(JarFile.MANIFEST_NAME)
        } finally {
            zipFile.close()
        }
    }

    @Override
    def hasDescendants(String... relativePaths) {
        String[] allDescendants = relativePaths + JarFile.MANIFEST_NAME
        return super.hasDescendants(allDescendants)
    }

    JavaVersion getJavaVersion() {
        JarFile jarFile = new JarFile(file)
        try {

            IoActions.closeQuietly(jarFile);
        }

        private JarFile getJarFileLocked() throws IOException {
            ensureOpened();
            if (jarFile == null) {
                jarFile = JarCompat.open(transformedJarPath);
                if (jarFile.isMultiRelease() && !isTransformed(jarFile.getJarFile())) {
                    throw new GradleException(String.format(

    File jarFile = File.createTempFile("with_circular_class_path", ".jar");
    try {
      writeSelfReferencingJarFile(jarFile, "test.txt");
      assertThat(
              new ClassPath.LocationInfo(jarFile, ClassPathTest.class.getClassLoader())
                  .scanResources())
          .hasSize(1);
    } finally {
      jarFile.delete();
    }
  }

        when:
        module.ivy.expectGet()
        module.jar.expectGet()

        run 'retrieve'

        then:
        def jarFile = file('build/projectA-1.1.jar')
        jarFile.assertIsCopyOf(module.jarFile)
        def snapshot = jarFile.snapshot()

        when:
        module.publishWithChangedContent()

        server.resetExpectations()

        file('libs/projectA-1.1.jar').assertIsCopyOf(projectA1.jarFile)
        file('libs/projectB-1.0.jar').assertIsCopyOf(projectB1.jarFile)
        def jarC = file('libs/projectC-1.0.jar')
        jarC.assertIsCopyOf(projectC1.jarFile)
        def jarCsnapshot = jarC.snapshot()

        when:
        def projectA2 = repo.module("group", "projectA", "1.2")

        final File jarFile = jarFile(identifier);
        cache.useCache(new Runnable() {
            @Override
            public void run() {
                if (!jarFile.exists()) {
                    creator.execute(jarFile);
                }
            }
        });
        return jarFile;
    }

    @Override
    public void close() {
        cache.close();

        JarRelocator(primaryInput.get().asFile, output, relocations).run()
    }
// end::artifact-transform-relocate[]

    private fun File.readPackages(): Set<String> {
        return JarFile(this).use { jarFile ->
            return jarFile.stream()
                .filter { !it.isDirectory }
                .filter { it.name.endsWith(".class") }
                .map { entry ->

        }
    }

    private void buildJar(File jarFile, Action action) throws IOException {
        File parentDir = jarFile.getParentFile();
        File tmpFile = temporaryFileProvider.createTemporaryFile(jarFile.getName(), ".tmp");
        try {
            Files.createDirectories(parentDir.toPath());
            inPlaceBuilder.jar(tmpFile, action);
            Files.move(tmpFile.toPath(), jarFile.toPath(), StandardCopyOption.REPLACE_EXISTING);

import java.io.IOException
import java.util.Properties
import java.util.jar.JarEntry
import java.util.jar.JarFile


data class PluginEntry(val pluginId: String, val implementationClass: String)


fun pluginEntriesFrom(jar: File): List<PluginEntry> = try {
    JarFile(jar, false).use { jarFile ->
        jarFile.entries().asSequence().filter {
            isGradlePluginPropertiesFile(it)
        }.map { pluginEntry ->