when:
        relocatedJarCreator.create(outputJar, [jarFile1, jarFile2, jarFile3, jarFile4, jarFile5, jarFile6, inputDirectory])

        then:

        TestFile[] contents = tmpDir.testDirectory.listFiles().findAll { it.isFile() }
        contents.length == 1
        contents[0] == outputJar
        handleAsJarFile(outputJar) { JarFile file ->
            List<JarEntry> entries = file.entries() as List

        then:
        noExceptionThrown()
        jarFile1 && jarFile2
        jarFile1.exists() && jarFile2.exists()
        jarFile1 == jarFile2
    }

    def "only generates single JAR in cache when invoked by concurrent threads"() {
        given:
        def jarGenerationInvocations = 10
        def triggeredJarFileGeneration = new AtomicInteger()
        def jarFiles = Collections.synchronizedList(new ArrayList<File>())

        def fingerprints = collectFingerprints(strategy)
        expect:
        fingerprints[jarFile1]                      == jarFile1.name
        fingerprints[jarFile2]                      == jarFile2.name
        fingerprints[resources]                     == null
        fingerprints[resources.file(fileInRoot)]    == fileInRoot

    private Module loadOptionalModule(final String moduleName) {
        File jarFile = findJar(moduleName, jarFile1 -> hasModuleProperties(moduleName, jarFile1));
        if (jarFile != null) {
            Set<File> implementationClasspath = new LinkedHashSet<>();
            implementationClasspath.add(jarFile);
            Properties properties = loadModuleProperties(moduleName, jarFile);

        given:
        def jarfile = tmpDir.file("test.jar")
        createJarWithAttributes(jarfile, ["Implementation-Version": "1.0.0"])

        def jarfile2 = tmpDir.file("test2.jar")
        createJarWithAttributes(jarfile2, ["Implementation-Version": "1.0.1"])

        def hash1 = zipHasher.hash(snapshotContext(jarfile))
        def hash2 = zipHasher.hash(snapshotContext(jarfile2))

        expect:

            public void receivePackage(String packageName) {
                Set<File> jarFiles = packageJarFilesMappings.get(packageName);
                if (jarFiles == null) {
                    jarFiles = new TreeSet<File>();
                    packageJarFilesMappings.put(packageName, jarFiles);
                }
                jarFiles.add(libraryJar);
            }
        });
    }

    /**

            List<File> jarFiles = listFiles(new File(distributionHomeDir, "lib"), new RegexFileFilter(entry.getValue()));
            if (!jarFiles.isEmpty()) {
                Preconditions.checkArgument(jarFiles.size() == 1, "A Gradle distribution must contain at most one %s-*.jar: %s", entry.getKey(), jarFiles);
                File jarFile = single(jarFiles);

    protected List<String> loadDataStoreNameList() {
        final Set<String> nameSet = new HashSet<>();
        final File[] jarFiles = ResourceUtil.getPluginJarFiles(PluginHelper.ArtifactType.DATA_STORE.getId());
        for (final File jarFile : jarFiles) {
            try (FileSystem fs = FileSystems.newFileSystem(jarFile.toPath(), ClassLoader.getSystemClassLoader())) {
                final Path xmlPath = fs.getPath("fess_ds++.xml");

            }

            verifyTestKitJars {
                doLast {
                    def jarFiles = libsDir.listFiles()
                    def testKitFunctionalJar = jarFiles.find { it.name.startsWith('$GRADLE_TEST_KIT_JAR_BASE_NAME') }
                    assert testKitFunctionalJar

                    def jar = new java.util.jar.JarFile(testKitFunctionalJar)
                    def classFiles
                    try {

            return null;
        }
        JarFile jarFile;
        try {
            jarFile = new JarFile(possibleJarFile);
        } catch (ZipException e) {
            // Not a zip file
            return null;
        }
        try {
            return jarFile.getManifest();
        } finally {
            jarFile.close();
        }
    }