then: "Version 1.1 is used"
        file('libs').assertHasDescendants('projectA-1.1.jar', 'projectB-1.1.jar')
        file('libs/projectA-1.1.jar').assertIsCopyOf(projectA1.jarFile)
        file('libs/projectB-1.1.jar').assertIsCopyOf(projectB1.jarFile)

        when: "New versions are published"
        server.resetExpectations()
        def projectA2 = ivySftpRepo.module("group", "projectA", "1.2")
        projectA2.publish()

        }
    }

    def "files are requested once only when dependency is resolved"() {
        buildFile << '''
            def jarFile = file("jar-1.jar")
            jarFile << 'content'
            def libFiles = {
                println "FILES REQUESTED"
                [jarFile]
            }

            configurations { compile }
            dependencies {
                compile files(libFiles)

                    .progressDisplayName("Generating " + file.getName());
            }
        }));
        LOGGER.debug("Using Gradle runtime shaded JAR file: {}", jarFile);
        return jarFile;
    }

     *
     * @param conn
     *            {@link JarURLConnection}。{@literal null}であってはいけません
     * @return {@link JarFile}
     */
    public static JarFile getJarFile(final JarURLConnection conn) {
        assertArgumentNotNull("conn", conn);

        try {
            return conn.getJarFile();
        } catch (final IOException e) {
            throw new IORuntimeException(e);
        }

        result.assertTestClassesExecuted('org.gradle.PersonTest')
        // Check jar exists
        def jarFile = javaprojectDir.file("build/libs/quickstart-1.0.jar")
        jarFile.assertIsFile()
        // Check contents of Jar
        TestFile jarContents = file('jar')
        jarFile.unzipTo(jarContents)
        jarContents.assertHasDescendants(
            'META-INF/MANIFEST.MF',

        // copy the jar to the project location
        fs.copy {
            from jarFile
            into projectDirectory
        }

        // create the .project and .classpath files
        new File(projectDirectory, '.project').text = getDotProjectText()
        new File(projectDirectory, '.classpath').text = getDotClasspathText(jarFile.name)
    }

                if (form.jarFile == null) {
                    throwValidationError(messages -> messages.addErrorsPluginFileIsNotFound(GLOBAL, form.id), this::asListHtml);
                }
                if (!form.jarFile.getFileName().endsWith(".jar")) {
                    throwValidationError(messages -> messages.addErrorsFileIsNotSupported(GLOBAL, form.jarFile.getFileName()),
                            this::asListHtml);

    public static boolean extractZipEntry(File jarFile, String entryName, File extractToFile) throws IOException {
        boolean entryExtracted = false;

        ZipInputStream zipStream = null;
        BufferedOutputStream extractTargetStream = null;
        try {
            zipStream = new ZipInputStream(new FileInputStream(jarFile));

    private val unshadedPackages: Set<String>,
    private val ignorePackages: Set<String>
) {

    fun analyze(jarFile: File, classesDir: File, manifestFile: File, buildReceipt: File): ClassGraph {
        val classGraph = classGraph()

        val jarUri = URI.create("jar:${jarFile.toPath().toUri()}")
        FileSystems.newFileSystem(jarUri, emptyMap<String, Any>()).use { jarFileSystem ->

            }
        }

        JarOutputStream(BufferedOutputStream(FileOutputStream(jarFile.get().asFile))).use { jarOutputStream ->
            if (!manifests.isEmpty) {
                jarOutputStream.addJarEntry(JarFile.MANIFEST_NAME, manifests.first())
            }
            if (!buildReceiptFile.isEmpty) {