import java.util.jar.Manifest
import java.util.zip.ZipEntry

class JarUtils {
    static def jarWithContents(Map<String, String> contents) {
        def out = new ByteArrayOutputStream()
        def jarOut = new JarOutputStream(out)
        try {
            contents.each { file, fileContents ->
                def zipEntry = new ZipEntry(file)
                zipEntry.setTime(0)
                jarOut.putNextEntry(zipEntry)

        return zipEntry(path, bos.toByteArray())
    }

    static ZipEntryContext zipEntry(String path, byte[] bytes, boolean unsafe = false, boolean directory = false) {
        def zipEntry = new ZipEntry() {
            @Override
            boolean isDirectory() {
                return directory
            }

        ZipEntry zipEntry = zipEntryContext.getEntry();

        if (isNotClassFile(zipEntry.getName())) {
            return null;
        }

        // A failure to read the zip entry content is a failure to read from the zip stream and should
        // be handled as a failure at the file level rather than at the entry level
        byte[] content = zipEntry.getContent();

        def zipInput = new StreamZipInput(makeZip("foo.zip").newInputStream())

        when:
        def zipEntry = zipInput.iterator().next()
        def content = zipEntry.withInputStream { readAllBytes(it) }

        then:
        content == ZIP_ENTRY_CONTENT.bytes
        noExceptionThrown()

        when:
        zipEntry.withInputStream { readAllBytes(it) }

        then:
        thrown(IllegalStateException)

        def zipEntryContext = Mock(ZipEntryContext)
        def zipEntry = Mock(ZipEntry)
        def classContent = bytesOf(String.class)

        when:
        def hash = resourceHasher.hash(zipEntryContext)

        then:
        1 * zipEntryContext.getEntry() >> zipEntry
        2 * zipEntry.getName() >> 'String.class'
        1 * zipEntry.getContent() >> classContent

        def file = makeZip("foo.zip")
        def zipInput = FileZipInput.create(file)

        when:
        def zipEntry = zipInput.iterator().next()
        def content = zipEntry.withInputStream { readAllBytes(it) }

        then:
        content == ZIP_ENTRY_CONTENT.bytes

        when:
        content = zipEntry.withInputStream { readAllBytes(it) }

        then:
        noExceptionThrown()

        def file = temporaryFolder.file("foo.txt")
        file.text = ZIP_ENTRY_CONTENT
        def zipStream = new ZipOutputStream(zipFile.newOutputStream())
        def zipEntry = new ZipEntry(file.name)
        zipEntry.setSize(file.size())
        zipStream.putNextEntry(zipEntry)
        zipStream.write(file.bytes)
        zipStream.close()
        return zipFile
    }

    abstract TestNameTestDirectoryProvider getTemporaryFolder()

        File dependencies = outputs.dir("gradle-dependencies")
        try (ZipInputStream zin = new ZipInputStream(artifact.get().asFile.newInputStream())) {
            ZipEntry zipEntry
            while (zipEntry = zin.nextEntry) {
                String shortName = zipEntry.name
                if (shortName.contains('/')) {
                    shortName = shortName.substring(shortName.lastIndexOf('/') + 1)
                }

        // Add archive entry
        ZipEntry entry = normalizedZipEntry(name)
        out.putNextEntry(entry)

        // Write file to archive
        def contentBytes = content.getBytes("utf-8")
        out.write(contentBytes, 0, contentBytes.length)
    }

    private void addGeneratedUncompressedZipEntry(ZipOutputStream out, String name, int sizeInBytes) {
        ZipEntry entry = normalizedZipEntry(name)

    private final Enumeration<? extends java.util.zip.ZipEntry> entries;

    private FileZipInput(File file) {
        try {
            this.file = new ZipFile(file);
        } catch (IOException e) {
            throw new FileException(e);
        }
        this.entries = this.file.entries();
    }

    @Override
    public Iterator<ZipEntry> iterator() {
        return new AbstractIterator<ZipEntry>() {