try (ZipInput entries = FileZipInput.create(source)) {
                for (ZipEntry entry : entries) {
                    String entryName = entry.getName();
                    if (isJarSignatureFile(entryName)) {
                        // TODO(mlopatkin) Manifest of the signed JAR contains signature information and must be the first entry in the JAR.

        resourceFile.text = "bar"
        testResources.zipTo(file("libs/bar.jar"))
        resourceFile.text = "foo"
        testResources.zipTo(file("libs/foo.jar"))
        buildFile << """
            dependencies {
                implementation files("libs/bar.jar")
                implementation files("libs/foo.jar")
            }
        """

        when:
        run 'installDist'

        file("jars/first").mkdirs()
        file("jars/second").mkdirs()
        def jar = file("jars/first/test-plugin-0.2.jar").with {
            it.createFile()
        }
        GFileUtils.copyFile(jar, file("jars/second/test-plugin-0.2.jar"))

        when:
        buildFile.text = """
            buildscript {

    //
    // or we can show it graphically as:
    //
    // p1 ---> p0 --> super model
    //
    // p1 has a depMgmt section that specifies versions 1.0 of jars "a" & "b"
    // jar "a" has a transitive dependency on 2.0 of jar "b", but maven should
    // prefer to use version 1.0.
    //
    // ----------------------------------------------------------------------

    @Test

        getM1Pom.release()
        getM2Pom.release()
        jars.waitForAllPendingCalls()

        then:
        ConcurrentTestUtil.poll {
            outputContainsProgress(build,
                "> :resolve > Resolve files of configuration ':compile'",
                "> one-1.2.jar", "> two-1.2.jar"
            )
        }

        when:
        jars.releaseAll()
        getM1Jar.waitUntilBlocked()

 */

package org.gradle.internal.classloader;

import org.gradle.api.JavaVersion;

import java.io.Closeable;
import java.io.File;
import java.io.IOException;
import java.util.jar.JarFile;

/**
 * Compatibility wrapper for multi-release JARs that can be used on Java 8 too.
 */
abstract class JarCompat implements Closeable {
    public static final boolean JAVA_9_COMPATIBLE = JavaVersion.current().isJava9Compatible();

        withBuildSrc()
        def someJar = withEmptyJar("classes_some.jar")
        def settingsJar = withEmptyJar("classes_settings.jar")
        def rootJar = withEmptyJar("classes_root.jar")
        def aJar = withEmptyJar("classes_a.jar")
        def bJar = withEmptyJar("classes_b.jar")
        def precompiledJar = withEmptyJar("classes_b_precompiled.jar")

        def some = withFile("some.gradle.kts", getBuildScriptDependency(someJar))

                    assert files.size() == 5
                    assert files == ['a-1.0.jar', 'd-1.0.jar', 'e-1.0.jar', 'b-2.0.jar', 'f-1.0.jar']

                    files = compile.getFiles { true }.collect { it.name }

                    assert files == ['a-1.0.jar', 'f-1.0.jar', 'd-1.0.jar', 'b-2.0.jar', 'e-1.0.jar']

                    def artifacts = compile.artifacts.collect { it.file.name }

            if (sourceSnapshot.getType() == FileType.Directory) {
                // Prior to 8.7 we were combining instrumented classes from both directories and JARs into JARs.
                // Now we store instrumented directories as directories, so we invalidate these.
                // However, transformed JARs should be left intact.
                hasher.putBoolean(true);
            }
            return hasher.hash();
        };
    }

                String attributeValue = attributes.getAttribute(USAGE_STRING_ATTRIBUTE);
                if (attributeValue.endsWith("-jars")) {
                    updatedAttributes = attributesFactory.concat(updatedAttributes, USAGE_STRING_ATTRIBUTE, new CoercingStringValueSnapshot(attributeValue.replace("-jars", ""), instantiator));
                }
            }