Add files using upload-large-folder tool

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_winrar/file_to_compare_1

@@ -0,0 +1,1297 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.commons.compress.archivers.zip;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.zip.CRC32;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipException;
+
+import org.apache.commons.compress.archivers.ArchiveEntry;
+import org.apache.commons.compress.archivers.ArchiveInputStream;
+import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
+import org.apache.commons.compress.compressors.deflate64.Deflate64CompressorInputStream;
+import org.apache.commons.compress.utils.ArchiveUtils;
+import org.apache.commons.compress.utils.IOUtils;
+import org.apache.commons.compress.utils.InputStreamStatistics;
+
+import static org.apache.commons.compress.archivers.zip.ZipConstants.DWORD;
+import static org.apache.commons.compress.archivers.zip.ZipConstants.SHORT;
+import static org.apache.commons.compress.archivers.zip.ZipConstants.WORD;
+import static org.apache.commons.compress.archivers.zip.ZipConstants.ZIP64_MAGIC;
+
+/**
+ * Implements an input stream that can read Zip archives.
+ *
+ * <p>As of Apache Commons Compress it transparently supports Zip64
+ * extensions and thus individual entries and archives larger than 4
+ * GB or with more than 65536 entries.</p>
+ *
+ * <p>The {@link ZipFile} class is preferred when reading from files
+ * as {@link ZipArchiveInputStream} is limited by not being able to
+ * read the central directory header before returning entries.  In
+ * particular {@link ZipArchiveInputStream}</p>
+ *
+ * <ul>
+ *
+ *  <li>may return entries that are not part of the central directory
+ *  at all and shouldn't be considered part of the archive.</li>
+ *
+ *  <li>may return several entries with the same name.</li>
+ *
+ *  <li>will not return internal or external attributes.</li>
+ *
+ *  <li>may return incomplete extra field data.</li>
+ *
+ *  <li>may return unknown sizes and CRC values for entries until the
+ *  next entry has been reached if the archive uses the data
+ *  descriptor feature.</li>
+ *
+ * </ul>
+ *
+ * @see ZipFile
+ * @NotThreadSafe
+ */
+public class ZipArchiveInputStream extends ArchiveInputStream implements InputStreamStatistics {
+
+    /** The zip encoding to use for file names and the file comment. */
+    private final ZipEncoding zipEncoding;
+
+    // the provided encoding (for unit tests)
+    final String encoding;
+
+    /** Whether to look for and use Unicode extra fields. */
+    private final boolean useUnicodeExtraFields;
+
+    /** Wrapped stream, will always be a PushbackInputStream. */
+    private final InputStream in;
+
+    /** Inflater used for all deflated entries. */
+    private final Inflater inf = new Inflater(true);
+
+    /** Buffer used to read from the wrapped stream. */
+    private final ByteBuffer buf = ByteBuffer.allocate(ZipArchiveOutputStream.BUFFER_SIZE);
+
+    /** The entry that is currently being read. */
+    private CurrentEntry current = null;
+
+    /** Whether the stream has been closed. */
+    private boolean closed = false;
+
+    /** Whether the stream has reached the central directory - and thus found all entries. */
+    private boolean hitCentralDirectory = false;
+
+    /**
+     * When reading a stored entry that uses the data descriptor this
+     * stream has to read the full entry and caches it.  This is the
+     * cache.
+     */
+    private ByteArrayInputStream lastStoredEntry = null;
+
+    /** Whether the stream will try to read STORED entries that use a data descriptor. */
+    private boolean allowStoredEntriesWithDataDescriptor = false;
+
+    /** Count decompressed bytes for current entry */
+    private long uncompressedCount = 0;
+
+    private static final int LFH_LEN = 30;
+    /*
+      local file header signature     WORD
+      version needed to extract       SHORT
+      general purpose bit flag        SHORT
+      compression method              SHORT
+      last mod file time              SHORT
+      last mod file date              SHORT
+      crc-32                          WORD
+      compressed size                 WORD
+      uncompressed size               WORD
+      file name length                SHORT
+      extra field length              SHORT
+    */
+
+    private static final int CFH_LEN = 46;
+    /*
+        central file header signature   WORD
+        version made by                 SHORT
+        version needed to extract       SHORT
+        general purpose bit flag        SHORT
+        compression method              SHORT
+        last mod file time              SHORT
+        last mod file date              SHORT
+        crc-32                          WORD
+        compressed size                 WORD
+        uncompressed size               WORD
+        file name length                SHORT
+        extra field length              SHORT
+        file comment length             SHORT
+        disk number start               SHORT
+        internal file attributes        SHORT
+        external file attributes        WORD
+        relative offset of local header WORD
+    */
+
+    private static final long TWO_EXP_32 = ZIP64_MAGIC + 1;
+
+    // cached buffers - must only be used locally in the class (COMPRESS-172 - reduce garbage collection)
+    private final byte[] lfhBuf = new byte[LFH_LEN];
+    private final byte[] skipBuf = new byte[1024];
+    private final byte[] shortBuf = new byte[SHORT];
+    private final byte[] wordBuf = new byte[WORD];
+    private final byte[] twoDwordBuf = new byte[2 * DWORD];
+
+    private int entriesRead = 0;
+
+    /**
+     * Create an instance using UTF-8 encoding
+     * @param inputStream the stream to wrap
+     */
+    public ZipArchiveInputStream(final InputStream inputStream) {
+        this(inputStream, ZipEncodingHelper.UTF8);
+    }
+
+    /**
+     * Create an instance using the specified encoding
+     * @param inputStream the stream to wrap
+     * @param encoding the encoding to use for file names, use null
+     * for the platform's default encoding
+     * @since 1.5
+     */
+    public ZipArchiveInputStream(final InputStream inputStream, final String encoding) {
+        this(inputStream, encoding, true);
+    }
+
+    /**
+     * Create an instance using the specified encoding
+     * @param inputStream the stream to wrap
+     * @param encoding the encoding to use for file names, use null
+     * for the platform's default encoding
+     * @param useUnicodeExtraFields whether to use InfoZIP Unicode
+     * Extra Fields (if present) to set the file names.
+     */
+    public ZipArchiveInputStream(final InputStream inputStream, final String encoding, final boolean useUnicodeExtraFields) {
+        this(inputStream, encoding, useUnicodeExtraFields, false);
+    }
+
+    /**
+     * Create an instance using the specified encoding
+     * @param inputStream the stream to wrap
+     * @param encoding the encoding to use for file names, use null
+     * for the platform's default encoding
+     * @param useUnicodeExtraFields whether to use InfoZIP Unicode
+     * Extra Fields (if present) to set the file names.
+     * @param allowStoredEntriesWithDataDescriptor whether the stream
+     * will try to read STORED entries that use a data descriptor
+     * @since 1.1
+     */
+    public ZipArchiveInputStream(final InputStream inputStream,
+                                 final String encoding,
+                                 final boolean useUnicodeExtraFields,
+                                 final boolean allowStoredEntriesWithDataDescriptor) {
+        this.encoding = encoding;
+        zipEncoding = ZipEncodingHelper.getZipEncoding(encoding);
+        this.useUnicodeExtraFields = useUnicodeExtraFields;
+        in = new PushbackInputStream(inputStream, buf.capacity());
+        this.allowStoredEntriesWithDataDescriptor =
+            allowStoredEntriesWithDataDescriptor;
+        // haven't read anything so far
+        buf.limit(0);
+    }
+
+    public ZipArchiveEntry getNextZipEntry() throws IOException {
+        uncompressedCount = 0;
+
+        boolean firstEntry = true;
+        if (closed || hitCentralDirectory) {
+            return null;
+        }
+        if (current != null) {
+            closeEntry();
+            firstEntry = false;
+        }
+
+        long currentHeaderOffset = getBytesRead();
+        try {
+            if (firstEntry) {
+                // split archives have a special signature before the
+                // first local file header - look for it and fail with
+                // the appropriate error message if this is a split
+                // archive.
+                readFirstLocalFileHeader(lfhBuf);
+            } else {
+                readFully(lfhBuf);
+            }
+        } catch (final EOFException e) { //NOSONAR
+            return null;
+        }
+
+        final ZipLong sig = new ZipLong(lfhBuf);
+        if (!sig.equals(ZipLong.LFH_SIG)) {
+            if (sig.equals(ZipLong.CFH_SIG) || sig.equals(ZipLong.AED_SIG) || isApkSigningBlock(lfhBuf)) {
+                hitCentralDirectory = true;
+                skipRemainderOfArchive();
+                return null;
+            }
+            throw new ZipException(String.format("Unexpected record signature: 0X%X", sig.getValue()));
+        }
+
+        int off = WORD;
+        current = new CurrentEntry();
+
+        final int versionMadeBy = ZipShort.getValue(lfhBuf, off);
+        off += SHORT;
+        current.entry.setPlatform((versionMadeBy >> ZipFile.BYTE_SHIFT) & ZipFile.NIBLET_MASK);
+
+        final GeneralPurposeBit gpFlag = GeneralPurposeBit.parse(lfhBuf, off);
+        final boolean hasUTF8Flag = gpFlag.usesUTF8ForNames();
+        final ZipEncoding entryEncoding = hasUTF8Flag ? ZipEncodingHelper.UTF8_ZIP_ENCODING : zipEncoding;
+        current.hasDataDescriptor = gpFlag.usesDataDescriptor();
+        current.entry.setGeneralPurposeBit(gpFlag);
+
+        off += SHORT;
+
+        current.entry.setMethod(ZipShort.getValue(lfhBuf, off));
+        off += SHORT;
+
+        final long time = ZipUtil.dosToJavaTime(ZipLong.getValue(lfhBuf, off));
+        current.entry.setTime(time);
+        off += WORD;
+
+        ZipLong size = null, cSize = null;
+        if (!current.hasDataDescriptor) {
+            current.entry.setCrc(ZipLong.getValue(lfhBuf, off));
+            off += WORD;
+
+            cSize = new ZipLong(lfhBuf, off);
+            off += WORD;
+
+            size = new ZipLong(lfhBuf, off);
+            off += WORD;
+        } else {
+            off += 3 * WORD;
+        }
+
+        final int fileNameLen = ZipShort.getValue(lfhBuf, off);
+
+        off += SHORT;
+
+        final int extraLen = ZipShort.getValue(lfhBuf, off);
+        off += SHORT; // NOSONAR - assignment as documentation
+
+        final byte[] fileName = new byte[fileNameLen];
+        readFully(fileName);
+        current.entry.setName(entryEncoding.decode(fileName), fileName);
+        if (hasUTF8Flag) {
+            current.entry.setNameSource(ZipArchiveEntry.NameSource.NAME_WITH_EFS_FLAG);
+        }
+
+        final byte[] extraData = new byte[extraLen];
+        readFully(extraData);
+        current.entry.setExtra(extraData);
+
+        if (!hasUTF8Flag && useUnicodeExtraFields) {
+            ZipUtil.setNameAndCommentFromExtraFields(current.entry, fileName, null);
+        }
+
+        processZip64Extra(size, cSize);
+
+        current.entry.setLocalHeaderOffset(currentHeaderOffset);
+        current.entry.setDataOffset(getBytesRead());
+        current.entry.setStreamContiguous(true);
+
+        ZipMethod m = ZipMethod.getMethodByCode(current.entry.getMethod());
+        if (current.entry.getCompressedSize() != ArchiveEntry.SIZE_UNKNOWN) {
+            if (ZipUtil.canHandleEntryData(current.entry) && m != ZipMethod.STORED && m != ZipMethod.DEFLATED) {
+                InputStream bis = new BoundedInputStream(in, current.entry.getCompressedSize());
+                switch (m) {
+                case UNSHRINKING:
+                    current.in = new UnshrinkingInputStream(bis);
+                    break;
+                case IMPLODING:
+                    current.in = new ExplodingInputStream(
+                        current.entry.getGeneralPurposeBit().getSlidingDictionarySize(),
+                        current.entry.getGeneralPurposeBit().getNumberOfShannonFanoTrees(),
+                        bis);
+                    break;
+                case BZIP2:
+                    current.in = new BZip2CompressorInputStream(bis);
+                    break;
+                case ENHANCED_DEFLATED:
+                    current.in = new Deflate64CompressorInputStream(bis);
+                    break;
+                default:
+                    // we should never get here as all supported methods have been covered
+                    // will cause an error when read is invoked, don't throw an exception here so people can
+                    // skip unsupported entries
+                    break;
+                }
+            }
+        } else if (m == ZipMethod.ENHANCED_DEFLATED) {
+            current.in = new Deflate64CompressorInputStream(in);
+        }
+
+        entriesRead++;
+        return current.entry;
+    }
+
+    /**
+     * Fills the given array with the first local file header and
+     * deals with splitting/spanning markers that may prefix the first
+     * LFH.
+     */
+    private void readFirstLocalFileHeader(final byte[] lfh) throws IOException {
+        readFully(lfh);
+        final ZipLong sig = new ZipLong(lfh);
+        if (sig.equals(ZipLong.DD_SIG)) {
+            throw new UnsupportedZipFeatureException(UnsupportedZipFeatureException.Feature.SPLITTING);
+        }
+
+        if (sig.equals(ZipLong.SINGLE_SEGMENT_SPLIT_MARKER)) {
+            // The archive is not really split as only one segment was
+            // needed in the end.  Just skip over the marker.
+            final byte[] missedLfhBytes = new byte[4];
+            readFully(missedLfhBytes);
+            System.arraycopy(lfh, 4, lfh, 0, LFH_LEN - 4);
+            System.arraycopy(missedLfhBytes, 0, lfh, LFH_LEN - 4, 4);
+        }
+    }
+
+    /**
+     * Records whether a Zip64 extra is present and sets the size
+     * information from it if sizes are 0xFFFFFFFF and the entry
+     * doesn't use a data descriptor.
+     */
+    private void processZip64Extra(final ZipLong size, final ZipLong cSize) {
+        final Zip64ExtendedInformationExtraField z64 =
+            (Zip64ExtendedInformationExtraField)
+            current.entry.getExtraField(Zip64ExtendedInformationExtraField.HEADER_ID);
+        current.usesZip64 = z64 != null;
+        if (!current.hasDataDescriptor) {
+            if (z64 != null // same as current.usesZip64 but avoids NPE warning
+                    && (ZipLong.ZIP64_MAGIC.equals(cSize) || ZipLong.ZIP64_MAGIC.equals(size)) ) {
+                current.entry.setCompressedSize(z64.getCompressedSize().getLongValue());
+                current.entry.setSize(z64.getSize().getLongValue());
+            } else if (cSize != null && size != null) {
+                current.entry.setCompressedSize(cSize.getValue());
+                current.entry.setSize(size.getValue());
+            }
+        }
+    }
+
+    @Override
+    public ArchiveEntry getNextEntry() throws IOException {
+        return getNextZipEntry();
+    }
+
+    /**
+     * Whether this class is able to read the given entry.
+     *
+     * <p>May return false if it is set up to use encryption or a
+     * compression method that hasn't been implemented yet.</p>
+     * @since 1.1
+     */
+    @Override
+    public boolean canReadEntryData(final ArchiveEntry ae) {
+        if (ae instanceof ZipArchiveEntry) {
+            final ZipArchiveEntry ze = (ZipArchiveEntry) ae;
+            return ZipUtil.canHandleEntryData(ze)
+                && supportsDataDescriptorFor(ze)
+                && supportsCompressedSizeFor(ze);
+        }
+        return false;
+    }
+
+    @Override
+    public int read(final byte[] buffer, final int offset, final int length) throws IOException {
+        if (length == 0) {
+            return 0;
+        }
+        if (closed) {
+            throw new IOException("The stream is closed");
+        }
+
+        if (current == null) {
+            return -1;
+        }
+
+        // avoid int overflow, check null buffer
+        if (offset > buffer.length || length < 0 || offset < 0 || buffer.length - offset < length) {
+            throw new ArrayIndexOutOfBoundsException();
+        }
+
+        ZipUtil.checkRequestedFeatures(current.entry);
+        if (!supportsDataDescriptorFor(current.entry)) {
+            throw new UnsupportedZipFeatureException(UnsupportedZipFeatureException.Feature.DATA_DESCRIPTOR,
+                    current.entry);
+        }
+        if (!supportsCompressedSizeFor(current.entry)) {
+            throw new UnsupportedZipFeatureException(UnsupportedZipFeatureException.Feature.UNKNOWN_COMPRESSED_SIZE,
+                    current.entry);
+        }
+
+        int read;
+        if (current.entry.getMethod() == ZipArchiveOutputStream.STORED) {
+            read = readStored(buffer, offset, length);
+        } else if (current.entry.getMethod() == ZipArchiveOutputStream.DEFLATED) {
+            read = readDeflated(buffer, offset, length);
+        } else if (current.entry.getMethod() == ZipMethod.UNSHRINKING.getCode()
+                || current.entry.getMethod() == ZipMethod.IMPLODING.getCode()
+                || current.entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode()
+                || current.entry.getMethod() == ZipMethod.BZIP2.getCode()) {
+            read = current.in.read(buffer, offset, length);
+        } else {
+            throw new UnsupportedZipFeatureException(ZipMethod.getMethodByCode(current.entry.getMethod()),
+                    current.entry);
+        }
+
+        if (read >= 0) {
+            current.crc.update(buffer, offset, read);
+            uncompressedCount += read;
+        }
+
+        return read;
+    }
+
+    /**
+     * @since 1.17
+     */
+    @Override
+    public long getCompressedCount() {
+        if (current.entry.getMethod() == ZipArchiveOutputStream.STORED) {
+            return current.bytesRead;
+        } else if (current.entry.getMethod() == ZipArchiveOutputStream.DEFLATED) {
+            return getBytesInflated();
+        } else if (current.entry.getMethod() == ZipMethod.UNSHRINKING.getCode()) {
+            return ((UnshrinkingInputStream) current.in).getCompressedCount();
+        } else if (current.entry.getMethod() == ZipMethod.IMPLODING.getCode()) {
+            return ((ExplodingInputStream) current.in).getCompressedCount();
+        } else if (current.entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode()) {
+            return ((Deflate64CompressorInputStream) current.in).getCompressedCount();
+        } else if (current.entry.getMethod() == ZipMethod.BZIP2.getCode()) {
+            return ((BZip2CompressorInputStream) current.in).getCompressedCount();
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * @since 1.17
+     */
+    @Override
+    public long getUncompressedCount() {
+        return uncompressedCount;
+    }
+
+    /**
+     * Implementation of read for STORED entries.
+     */
+    private int readStored(final byte[] buffer, final int offset, final int length) throws IOException {
+
+        if (current.hasDataDescriptor) {
+            if (lastStoredEntry == null) {
+                readStoredEntry();
+            }
+            return lastStoredEntry.read(buffer, offset, length);
+        }
+
+        final long csize = current.entry.getSize();
+        if (current.bytesRead >= csize) {
+            return -1;
+        }
+
+        if (buf.position() >= buf.limit()) {
+            buf.position(0);
+            final int l = in.read(buf.array());
+            if (l == -1) {
+                buf.limit(0);
+                throw new IOException("Truncated ZIP file");
+            }
+            buf.limit(l);
+
+            count(l);
+            current.bytesReadFromStream += l;
+        }
+
+        int toRead = Math.min(buf.remaining(), length);
+        if ((csize - current.bytesRead) < toRead) {
+            // if it is smaller than toRead then it fits into an int
+            toRead = (int) (csize - current.bytesRead);
+        }
+        buf.get(buffer, offset, toRead);
+        current.bytesRead += toRead;
+        return toRead;
+    }
+
+    /**
+     * Implementation of read for DEFLATED entries.
+     */
+    private int readDeflated(final byte[] buffer, final int offset, final int length) throws IOException {
+        final int read = readFromInflater(buffer, offset, length);
+        if (read <= 0) {
+            if (inf.finished()) {
+                return -1;
+            } else if (inf.needsDictionary()) {
+                throw new ZipException("This archive needs a preset dictionary"
+                                       + " which is not supported by Commons"
+                                       + " Compress.");
+            } else if (read == -1) {
+                throw new IOException("Truncated ZIP file");
+            }
+        }
+        return read;
+    }
+
+    /**
+     * Potentially reads more bytes to fill the inflater's buffer and
+     * reads from it.
+     */
+    private int readFromInflater(final byte[] buffer, final int offset, final int length) throws IOException {
+        int read = 0;
+        do {
+            if (inf.needsInput()) {
+                final int l = fill();
+                if (l > 0) {
+                    current.bytesReadFromStream += buf.limit();
+                } else if (l == -1) {
+                    return -1;
+                } else {
+                    break;
+                }
+            }
+            try {
+                read = inf.inflate(buffer, offset, length);
+            } catch (final DataFormatException e) {
+                throw (IOException) new ZipException(e.getMessage()).initCause(e);
+            }
+        } while (read == 0 && inf.needsInput());
+        return read;
+    }
+
+    @Override
+    public void close() throws IOException {
+        if (!closed) {
+            closed = true;
+            try {
+                in.close();
+            } finally {
+                inf.end();
+            }
+        }
+    }
+
+    /**
+     * Skips over and discards value bytes of data from this input
+     * stream.
+     *
+     * <p>This implementation may end up skipping over some smaller
+     * number of bytes, possibly 0, if and only if it reaches the end
+     * of the underlying stream.</p>
+     *
+     * <p>The actual number of bytes skipped is returned.</p>
+     *
+     * @param value the number of bytes to be skipped.
+     * @return the actual number of bytes skipped.
+     * @throws IOException - if an I/O error occurs.
+     * @throws IllegalArgumentException - if value is negative.
+     */
+    @Override
+    public long skip(final long value) throws IOException {
+        if (value >= 0) {
+            long skipped = 0;
+            while (skipped < value) {
+                final long rem = value - skipped;
+                final int x = read(skipBuf, 0, (int) (skipBuf.length > rem ? rem : skipBuf.length));
+                if (x == -1) {
+                    return skipped;
+                }
+                skipped += x;
+            }
+            return skipped;
+        }
+        throw new IllegalArgumentException();
+    }
+
+    /**
+     * Checks if the signature matches what is expected for a zip file.
+     * Does not currently handle self-extracting zips which may have arbitrary
+     * leading content.
+     *
+     * @param signature the bytes to check
+     * @param length    the number of bytes to check
+     * @return true, if this stream is a zip archive stream, false otherwise
+     */
+    public static boolean matches(final byte[] signature, final int length) {
+        if (length < ZipArchiveOutputStream.LFH_SIG.length) {
+            return false;
+        }
+
+        return checksig(signature, ZipArchiveOutputStream.LFH_SIG) // normal file
+            || checksig(signature, ZipArchiveOutputStream.EOCD_SIG) // empty zip
+            || checksig(signature, ZipArchiveOutputStream.DD_SIG) // split zip
+            || checksig(signature, ZipLong.SINGLE_SEGMENT_SPLIT_MARKER.getBytes());
+    }
+
+    private static boolean checksig(final byte[] signature, final byte[] expected) {
+        for (int i = 0; i < expected.length; i++) {
+            if (signature[i] != expected[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Closes the current ZIP archive entry and positions the underlying
+     * stream to the beginning of the next entry. All per-entry variables
+     * and data structures are cleared.
+     * <p>
+     * If the compressed size of this entry is included in the entry header,
+     * then any outstanding bytes are simply skipped from the underlying
+     * stream without uncompressing them. This allows an entry to be safely
+     * closed even if the compression method is unsupported.
+     * <p>
+     * In case we don't know the compressed size of this entry or have
+     * already buffered too much data from the underlying stream to support
+     * uncompression, then the uncompression process is completed and the
+     * end position of the stream is adjusted based on the result of that
+     * process.
+     *
+     * @throws IOException if an error occurs
+     */
+    private void closeEntry() throws IOException {
+        if (closed) {
+            throw new IOException("The stream is closed");
+        }
+        if (current == null) {
+            return;
+        }
+
+        // Ensure all entry bytes are read
+        if (currentEntryHasOutstandingBytes()) {
+            drainCurrentEntryData();
+        } else {
+            // this is guaranteed to exhaust the stream
+            skip(Long.MAX_VALUE); //NOSONAR
+
+            final long inB = current.entry.getMethod() == ZipArchiveOutputStream.DEFLATED
+                       ? getBytesInflated() : current.bytesRead;
+
+            // this is at most a single read() operation and can't
+            // exceed the range of int
+            final int diff = (int) (current.bytesReadFromStream - inB);
+
+            // Pushback any required bytes
+            if (diff > 0) {
+                pushback(buf.array(), buf.limit() - diff, diff);
+                current.bytesReadFromStream -= diff;
+            }
+
+            // Drain remainder of entry if not all data bytes were required
+            if (currentEntryHasOutstandingBytes()) {
+                drainCurrentEntryData();
+            }
+        }
+
+        if (lastStoredEntry == null && current.hasDataDescriptor) {
+            readDataDescriptor();
+        }
+
+        inf.reset();
+        buf.clear().flip();
+        current = null;
+        lastStoredEntry = null;
+    }
+
+    /**
+     * If the compressed size of the current entry is included in the entry header
+     * and there are any outstanding bytes in the underlying stream, then
+     * this returns true.
+     *
+     * @return true, if current entry is determined to have outstanding bytes, false otherwise
+     */
+    private boolean currentEntryHasOutstandingBytes() {
+        return current.bytesReadFromStream <= current.entry.getCompressedSize()
+                && !current.hasDataDescriptor;
+    }
+
+    /**
+     * Read all data of the current entry from the underlying stream
+     * that hasn't been read, yet.
+     */
+    private void drainCurrentEntryData() throws IOException {
+        long remaining = current.entry.getCompressedSize() - current.bytesReadFromStream;
+        while (remaining > 0) {
+            final long n = in.read(buf.array(), 0, (int) Math.min(buf.capacity(), remaining));
+            if (n < 0) {
+                throw new EOFException("Truncated ZIP entry: "
+                                       + ArchiveUtils.sanitize(current.entry.getName()));
+            }
+            count(n);
+            remaining -= n;
+        }
+    }
+
+    /**
+     * Get the number of bytes Inflater has actually processed.
+     *
+     * <p>for Java &lt; Java7 the getBytes* methods in
+     * Inflater/Deflater seem to return unsigned ints rather than
+     * longs that start over with 0 at 2^32.</p>
+     *
+     * <p>The stream knows how many bytes it has read, but not how
+     * many the Inflater actually consumed - it should be between the
+     * total number of bytes read for the entry and the total number
+     * minus the last read operation.  Here we just try to make the
+     * value close enough to the bytes we've read by assuming the
+     * number of bytes consumed must be smaller than (or equal to) the
+     * number of bytes read but not smaller by more than 2^32.</p>
+     */
+    private long getBytesInflated() {
+        long inB = inf.getBytesRead();
+        if (current.bytesReadFromStream >= TWO_EXP_32) {
+            while (inB + TWO_EXP_32 <= current.bytesReadFromStream) {
+                inB += TWO_EXP_32;
+            }
+        }
+        return inB;
+    }
+
+    private int fill() throws IOException {
+        if (closed) {
+            throw new IOException("The stream is closed");
+        }
+        final int length = in.read(buf.array());
+        if (length > 0) {
+            buf.limit(length);
+            count(buf.limit());
+            inf.setInput(buf.array(), 0, buf.limit());
+        }
+        return length;
+    }
+
+    private void readFully(final byte[] b) throws IOException {
+        readFully(b, 0);
+    }
+
+    private void readFully(final byte[] b, final int off) throws IOException {
+        final int len = b.length - off;
+        final int count = IOUtils.readFully(in, b, off, len);
+        count(count);
+        if (count < len) {
+            throw new EOFException();
+        }
+    }
+
+    private void readDataDescriptor() throws IOException {
+        readFully(wordBuf);
+        ZipLong val = new ZipLong(wordBuf);
+        if (ZipLong.DD_SIG.equals(val)) {
+            // data descriptor with signature, skip sig
+            readFully(wordBuf);
+            val = new ZipLong(wordBuf);
+        }
+        current.entry.setCrc(val.getValue());
+
+        // if there is a ZIP64 extra field, sizes are eight bytes
+        // each, otherwise four bytes each.  Unfortunately some
+        // implementations - namely Java7 - use eight bytes without
+        // using a ZIP64 extra field -
+        // https://bugs.sun.com/bugdatabase/view_bug.do?bug_id=7073588
+
+        // just read 16 bytes and check whether bytes nine to twelve
+        // look like one of the signatures of what could follow a data
+        // descriptor (ignoring archive decryption headers for now).
+        // If so, push back eight bytes and assume sizes are four
+        // bytes, otherwise sizes are eight bytes each.
+        readFully(twoDwordBuf);
+        final ZipLong potentialSig = new ZipLong(twoDwordBuf, DWORD);
+        if (potentialSig.equals(ZipLong.CFH_SIG) || potentialSig.equals(ZipLong.LFH_SIG)) {
+            pushback(twoDwordBuf, DWORD, DWORD);
+            current.entry.setCompressedSize(ZipLong.getValue(twoDwordBuf));
+            current.entry.setSize(ZipLong.getValue(twoDwordBuf, WORD));
+        } else {
+            current.entry.setCompressedSize(ZipEightByteInteger.getLongValue(twoDwordBuf));
+            current.entry.setSize(ZipEightByteInteger.getLongValue(twoDwordBuf, DWORD));
+        }
+    }
+
+    /**
+     * Whether this entry requires a data descriptor this library can work with.
+     *
+     * @return true if allowStoredEntriesWithDataDescriptor is true,
+     * the entry doesn't require any data descriptor or the method is
+     * DEFLATED or ENHANCED_DEFLATED.
+     */
+    private boolean supportsDataDescriptorFor(final ZipArchiveEntry entry) {
+        return !entry.getGeneralPurposeBit().usesDataDescriptor()
+
+                || (allowStoredEntriesWithDataDescriptor && entry.getMethod() == ZipEntry.STORED)
+                || entry.getMethod() == ZipEntry.DEFLATED
+                || entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode();
+    }
+
+    /**
+     * Whether the compressed size for the entry is either known or
+     * not required by the compression method being used.
+     */
+    private boolean supportsCompressedSizeFor(final ZipArchiveEntry entry) {
+        return entry.getCompressedSize() != ArchiveEntry.SIZE_UNKNOWN
+            || entry.getMethod() == ZipEntry.DEFLATED
+            || entry.getMethod() == ZipMethod.ENHANCED_DEFLATED.getCode()
+            || (entry.getGeneralPurposeBit().usesDataDescriptor()
+                && allowStoredEntriesWithDataDescriptor
+                && entry.getMethod() == ZipEntry.STORED);
+    }
+
+    private static final String USE_ZIPFILE_INSTEAD_OF_STREAM_DISCLAIMER =
+        " while reading a stored entry using data descriptor. Either the archive is broken"
+        + " or it can not be read using ZipArchiveInputStream and you must use ZipFile."
+        + " A common cause for this is a ZIP archive containing a ZIP archive."
+        + " See http://commons.apache.org/proper/commons-compress/zip.html#ZipArchiveInputStream_vs_ZipFile";
+
+    /**
+     * Caches a stored entry that uses the data descriptor.
+     *
+     * <ul>
+     *   <li>Reads a stored entry until the signature of a local file
+     *     header, central directory header or data descriptor has been
+     *     found.</li>
+     *   <li>Stores all entry data in lastStoredEntry.</p>
+     *   <li>Rewinds the stream to position at the data
+     *     descriptor.</li>
+     *   <li>reads the data descriptor</li>
+     * </ul>
+     *
+     * <p>After calling this method the entry should know its size,
+     * the entry's data is cached and the stream is positioned at the
+     * next local file or central directory header.</p>
+     */
+    private void readStoredEntry() throws IOException {
+        final ByteArrayOutputStream bos = new ByteArrayOutputStream();
+        int off = 0;
+        boolean done = false;
+
+        // length of DD without signature
+        final int ddLen = current.usesZip64 ? WORD + 2 * DWORD : 3 * WORD;
+
+        while (!done) {
+            final int r = in.read(buf.array(), off, ZipArchiveOutputStream.BUFFER_SIZE - off);
+            if (r <= 0) {
+                // read the whole archive without ever finding a
+                // central directory
+                throw new IOException("Truncated ZIP file");
+            }
+            if (r + off < 4) {
+                // buffer too small to check for a signature, loop
+                off += r;
+                continue;
+            }
+
+            done = bufferContainsSignature(bos, off, r, ddLen);
+            if (!done) {
+                off = cacheBytesRead(bos, off, r, ddLen);
+            }
+        }
+        if (current.entry.getCompressedSize() != current.entry.getSize()) {
+            throw new ZipException("compressed and uncompressed size don't match"
+                                   + USE_ZIPFILE_INSTEAD_OF_STREAM_DISCLAIMER);
+        }
+        final byte[] b = bos.toByteArray();
+        if (b.length != current.entry.getSize()) {
+            throw new ZipException("actual and claimed size don't match"
+                                   + USE_ZIPFILE_INSTEAD_OF_STREAM_DISCLAIMER);
+        }
+        lastStoredEntry = new ByteArrayInputStream(b);
+    }
+
+    private static final byte[] LFH = ZipLong.LFH_SIG.getBytes();
+    private static final byte[] CFH = ZipLong.CFH_SIG.getBytes();
+    private static final byte[] DD = ZipLong.DD_SIG.getBytes();
+
+    /**
+     * Checks whether the current buffer contains the signature of a
+     * &quot;data descriptor&quot;, &quot;local file header&quot; or
+     * &quot;central directory entry&quot;.
+     *
+     * <p>If it contains such a signature, reads the data descriptor
+     * and positions the stream right after the data descriptor.</p>
+     */
+    private boolean bufferContainsSignature(final ByteArrayOutputStream bos, final int offset, final int lastRead, final int expectedDDLen)
+            throws IOException {
+
+        boolean done = false;
+        for (int i = 0; !done && i < offset + lastRead - 4; i++) {
+            if (buf.array()[i] == LFH[0] && buf.array()[i + 1] == LFH[1]) {
+                int expectDDPos = i;
+                if (i >= expectedDDLen &&
+                    (buf.array()[i + 2] == LFH[2] && buf.array()[i + 3] == LFH[3])
+                    || (buf.array()[i] == CFH[2] && buf.array()[i + 3] == CFH[3])) {
+                    // found a LFH or CFH:
+                    expectDDPos = i - expectedDDLen;
+                    done = true;
+                }
+                else if (buf.array()[i + 2] == DD[2] && buf.array()[i + 3] == DD[3]) {
+                    // found DD:
+                    done = true;
+                }
+                if (done) {
+                    // * push back bytes read in excess as well as the data
+                    //   descriptor
+                    // * copy the remaining bytes to cache
+                    // * read data descriptor
+                    pushback(buf.array(), expectDDPos, offset + lastRead - expectDDPos);
+                    bos.write(buf.array(), 0, expectDDPos);
+                    readDataDescriptor();
+                }
+            }
+        }
+        return done;
+    }
+
+    /**
+     * If the last read bytes could hold a data descriptor and an
+     * incomplete signature then save the last bytes to the front of
+     * the buffer and cache everything in front of the potential data
+     * descriptor into the given ByteArrayOutputStream.
+     *
+     * <p>Data descriptor plus incomplete signature (3 bytes in the
+     * worst case) can be 20 bytes max.</p>
+     */
+    private int cacheBytesRead(final ByteArrayOutputStream bos, int offset, final int lastRead, final int expecteDDLen) {
+        final int cacheable = offset + lastRead - expecteDDLen - 3;
+        if (cacheable > 0) {
+            bos.write(buf.array(), 0, cacheable);
+            System.arraycopy(buf.array(), cacheable, buf.array(), 0, expecteDDLen + 3);
+            offset = expecteDDLen + 3;
+        } else {
+            offset += lastRead;
+        }
+        return offset;
+    }
+
+    private void pushback(final byte[] buf, final int offset, final int length) throws IOException {
+        ((PushbackInputStream) in).unread(buf, offset, length);
+        pushedBackBytes(length);
+    }
+
+    // End of Central Directory Record
+    //   end of central dir signature    WORD
+    //   number of this disk             SHORT
+    //   number of the disk with the
+    //   start of the central directory  SHORT
+    //   total number of entries in the
+    //   central directory on this disk  SHORT
+    //   total number of entries in
+    //   the central directory           SHORT
+    //   size of the central directory   WORD
+    //   offset of start of central
+    //   directory with respect to
+    //   the starting disk number        WORD
+    //   .ZIP file comment length        SHORT
+    //   .ZIP file comment               up to 64KB
+    //
+
+    /**
+     * Reads the stream until it find the "End of central directory
+     * record" and consumes it as well.
+     */
+    private void skipRemainderOfArchive() throws IOException {
+        // skip over central directory. One LFH has been read too much
+        // already.  The calculation discounts file names and extra
+        // data so it will be too short.
+        realSkip((long) entriesRead * CFH_LEN - LFH_LEN);
+        findEocdRecord();
+        realSkip((long) ZipFile.MIN_EOCD_SIZE - WORD /* signature */ - SHORT /* comment len */);
+        readFully(shortBuf);
+        // file comment
+        realSkip(ZipShort.getValue(shortBuf));
+    }
+
+    /**
+     * Reads forward until the signature of the &quot;End of central
+     * directory&quot; record is found.
+     */
+    private void findEocdRecord() throws IOException {
+        int currentByte = -1;
+        boolean skipReadCall = false;
+        while (skipReadCall || (currentByte = readOneByte()) > -1) {
+            skipReadCall = false;
+            if (!isFirstByteOfEocdSig(currentByte)) {
+                continue;
+            }
+            currentByte = readOneByte();
+            if (currentByte != ZipArchiveOutputStream.EOCD_SIG[1]) {
+                if (currentByte == -1) {
+                    break;
+                }
+                skipReadCall = isFirstByteOfEocdSig(currentByte);
+                continue;
+            }
+            currentByte = readOneByte();
+            if (currentByte != ZipArchiveOutputStream.EOCD_SIG[2]) {
+                if (currentByte == -1) {
+                    break;
+                }
+                skipReadCall = isFirstByteOfEocdSig(currentByte);
+                continue;
+            }
+            currentByte = readOneByte();
+            if (currentByte == -1
+                || currentByte == ZipArchiveOutputStream.EOCD_SIG[3]) {
+                break;
+            }
+            skipReadCall = isFirstByteOfEocdSig(currentByte);
+        }
+    }
+
+    /**
+     * Skips bytes by reading from the underlying stream rather than
+     * the (potentially inflating) archive stream - which {@link
+     * #skip} would do.
+     *
+     * Also updates bytes-read counter.
+     */
+    private void realSkip(final long value) throws IOException {
+        if (value >= 0) {
+            long skipped = 0;
+            while (skipped < value) {
+                final long rem = value - skipped;
+                final int x = in.read(skipBuf, 0, (int) (skipBuf.length > rem ? rem : skipBuf.length));
+                if (x == -1) {
+                    return;
+                }
+                count(x);
+                skipped += x;
+            }
+            return;
+        }
+        throw new IllegalArgumentException();
+    }
+
+    /**
+     * Reads bytes by reading from the underlying stream rather than
+     * the (potentially inflating) archive stream - which {@link #read} would do.
+     *
+     * Also updates bytes-read counter.
+     */
+    private int readOneByte() throws IOException {
+        final int b = in.read();
+        if (b != -1) {
+            count(1);
+        }
+        return b;
+    }
+
+    private boolean isFirstByteOfEocdSig(final int b) {
+        return b == ZipArchiveOutputStream.EOCD_SIG[0];
+    }
+
+    private static final byte[] APK_SIGNING_BLOCK_MAGIC = new byte[] {
+        'A', 'P', 'K', ' ', 'S', 'i', 'g', ' ', 'B', 'l', 'o', 'c', 'k', ' ', '4', '2',
+    };
+    private static final BigInteger LONG_MAX = BigInteger.valueOf(Long.MAX_VALUE);
+
+    /**
+     * Checks whether this might be an APK Signing Block.
+     *
+     * <p>Unfortunately the APK signing block does not start with some kind of signature, it rather ends with one. It
+     * starts with a length, so what we do is parse the suspect length, skip ahead far enough, look for the signature
+     * and if we've found it, return true.</p>
+     *
+     * @param suspectLocalFileHeader the bytes read from the underlying stream in the expectation that they would hold
+     * the local file header of the next entry.
+     *
+     * @return true if this looks like a APK signing block
+     *
+     * @see <a href="https://source.android.com/security/apksigning/v2">https://source.android.com/security/apksigning/v2</a>
+     */
+    private boolean isApkSigningBlock(byte[] suspectLocalFileHeader) throws IOException {
+        // length of block excluding the size field itself
+        BigInteger len = ZipEightByteInteger.getValue(suspectLocalFileHeader);
+        // LFH has already been read and all but the first eight bytes contain (part of) the APK signing block,
+        // also subtract 16 bytes in order to position us at the magic string
+        BigInteger toSkip = len.add(BigInteger.valueOf(DWORD - suspectLocalFileHeader.length
+            - (long) APK_SIGNING_BLOCK_MAGIC.length));
+        byte[] magic = new byte[APK_SIGNING_BLOCK_MAGIC.length];
+
+        try {
+            if (toSkip.signum() < 0) {
+                // suspectLocalFileHeader contains the start of suspect magic string
+                int off = suspectLocalFileHeader.length + toSkip.intValue();
+                // length was shorter than magic length
+                if (off < DWORD) {
+                    return false;
+                }
+                int bytesInBuffer = Math.abs(toSkip.intValue());
+                System.arraycopy(suspectLocalFileHeader, off, magic, 0, Math.min(bytesInBuffer, magic.length));
+                if (bytesInBuffer < magic.length) {
+                    readFully(magic, bytesInBuffer);
+                }
+            } else {
+                while (toSkip.compareTo(LONG_MAX) > 0) {
+                    realSkip(Long.MAX_VALUE);
+                    toSkip = toSkip.add(LONG_MAX.negate());
+                }
+                realSkip(toSkip.longValue());
+                readFully(magic);
+            }
+        } catch (EOFException ex) { //NOSONAR
+            // length was invalid
+            return false;
+        }
+        return Arrays.equals(magic, APK_SIGNING_BLOCK_MAGIC);
+    }
+
+    /**
+     * Structure collecting information for the entry that is
+     * currently being read.
+     */
+    private static final class CurrentEntry {
+
+        /**
+         * Current ZIP entry.
+         */
+        private final ZipArchiveEntry entry = new ZipArchiveEntry();
+
+        /**
+         * Does the entry use a data descriptor?
+         */
+        private boolean hasDataDescriptor;
+
+        /**
+         * Does the entry have a ZIP64 extended information extra field.
+         */
+        private boolean usesZip64;
+
+        /**
+         * Number of bytes of entry content read by the client if the
+         * entry is STORED.
+         */
+        private long bytesRead;
+
+        /**
+         * Number of bytes of entry content read from the stream.
+         *
+         * <p>This may be more than the actual entry's length as some
+         * stuff gets buffered up and needs to be pushed back when the
+         * end of the entry has been reached.</p>
+         */
+        private long bytesReadFromStream;
+
+        /**
+         * The checksum calculated as the current entry is read.
+         */
+        private final CRC32 crc = new CRC32();
+
+        /**
+         * The input stream decompressing the data for shrunk and imploded entries.
+         */
+        private InputStream in;
+    }
+
+    /**
+     * Bounded input stream adapted from commons-io
+     */
+    private class BoundedInputStream extends InputStream {
+
+        /** the wrapped input stream */
+        private final InputStream in;
+
+        /** the max length to provide */
+        private final long max;
+
+        /** the number of bytes already returned */
+        private long pos = 0;
+
+        /**
+         * Creates a new <code>BoundedInputStream</code> that wraps the given input
+         * stream and limits it to a certain size.
+         *
+         * @param in The wrapped input stream
+         * @param size The maximum number of bytes to return
+         */
+        public BoundedInputStream(final InputStream in, final long size) {
+            this.max = size;
+            this.in = in;
+        }
+
+        @Override
+        public int read() throws IOException {
+            if (max >= 0 && pos >= max) {
+                return -1;
+            }
+            final int result = in.read();
+            pos++;
+            count(1);
+            current.bytesReadFromStream++;
+            return result;
+        }
+
+        @Override
+        public int read(final byte[] b) throws IOException {
+            return this.read(b, 0, b.length);
+        }
+
+        @Override
+        public int read(final byte[] b, final int off, final int len) throws IOException {
+            if (len == 0) {
+                return 0;
+            }
+            if (max >= 0 && pos >= max) {
+                return -1;
+            }
+            final long maxRead = max >= 0 ? Math.min(len, max - pos) : len;
+            final int bytesRead = in.read(b, off, (int) maxRead);
+
+            if (bytesRead == -1) {
+                return -1;
+            }
+
+            pos += bytesRead;
+            count(bytesRead);
+            current.bytesReadFromStream += bytesRead;
+            return bytesRead;
+        }
+
+        @Override
+        public long skip(final long n) throws IOException {
+            final long toSkip = max >= 0 ? Math.min(n, max - pos) : n;
+            final long skippedBytes = IOUtils.skip(in, toSkip);
+            pos += skippedBytes;
+            return skippedBytes;
+        }
+
+        @Override
+        public int available() throws IOException {
+            if (max >= 0 && pos >= max) {
+                return 0;
+            }
+            return in.available();
+        }
+    }
+}

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_zip/file_to_compare_1

@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.commons.compress.archivers.dump;
+
+
+/**
+ * Unsupported compression algorithm. The dump archive uses an unsupported
+ * compression algorithm (BZLIB2 or LZO).
+ */
+public class UnsupportedCompressionAlgorithmException
+    extends DumpArchiveException {
+    private static final long serialVersionUID = 1L;
+
+    public UnsupportedCompressionAlgorithmException() {
+        super("this file uses an unsupported compression algorithm.");
+    }
+
+    public UnsupportedCompressionAlgorithmException(final String alg) {
+        super("this file uses an unsupported compression algorithm: " + alg +
+            ".");
+    }
+}

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/COMPRESS-477/split_zip_created_by_zip/file_to_compare_2

@@ -0,0 +1,79 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.commons.compress.compressors.deflate;
+
+import java.util.zip.Deflater;
+
+/**
+ * Parameters for the Deflate compressor.
+ * @since 1.9
+ */
+public class DeflateParameters {
+
+    private boolean zlibHeader = true;
+    private int compressionLevel = Deflater.DEFAULT_COMPRESSION;
+
+    /**
+     * Whether or not the zlib header shall be written (when
+     * compressing) or expected (when decompressing).
+     * @return true if zlib header shall be written
+     */
+    public boolean withZlibHeader() {
+        return zlibHeader;
+    }
+
+    /**
+     * Sets the zlib header presence parameter.
+     *
+     * <p>This affects whether or not the zlib header will be written
+     * (when compressing) or expected (when decompressing).</p>
+     *
+     * @param zlibHeader true if zlib header shall be written
+     */
+    public void setWithZlibHeader(final boolean zlibHeader) {
+        this.zlibHeader = zlibHeader;
+    }
+
+    /**
+     * The compression level.
+     * @see #setCompressionLevel
+     * @return the compression level
+     */
+    public int getCompressionLevel() {
+        return compressionLevel;
+    }
+
+    /**
+     * Sets the compression level.
+     *
+     * @param compressionLevel the compression level (between 0 and 9)
+     * @see Deflater#NO_COMPRESSION
+     * @see Deflater#BEST_SPEED
+     * @see Deflater#DEFAULT_COMPRESSION
+     * @see Deflater#BEST_COMPRESSION
+     */
+    public void setCompressionLevel(final int compressionLevel) {
+        if (compressionLevel < -1 || compressionLevel > 9) {
+            throw new IllegalArgumentException("Invalid Deflate compression level: " + compressionLevel);
+        }
+        this.compressionLevel = compressionLevel;
+    }
+
+}

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/META-INF/services/org.apache.commons.compress.compressors.CompressorStreamProvider

@@ -0,0 +1 @@
+org.apache.commons.compress.compressors.TestCompressorStreamProvider

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/COMPRESS-661/testARofText.ar

@@ -0,0 +1,5 @@
+!<arch>
+testTXT.txt/    1262968202  500   500   100644  47        `
+Test d'indexation de Txt
+http://www.apache.org
+

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_group-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              1454693980  1000  1.23  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_length-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              1454693980  1000  1000  100664  1.23      `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_long_namelen_bsd-fail.ar

@@ -0,0 +1,5 @@
+!<arch>
+#1/123456789012 1311256511  1000  1000  100644  42        `
+this_is_a_long_file_name.txtHello, world!
+#1/36           1454694016  1000  1000  100664  40        `
+this_is_a_long_file_name_as_well.txtBye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_long_namelen_gnu1-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/9999999999     1454693980  1000  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_long_namelen_gnu2-fail.ar

@@ -0,0 +1,6 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/29             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_modified-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              9e99999999  1000  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_table_length_gnu-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              1.23      `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              1454693980  1000  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/afc-commons-compress/src/test/resources/org/apache/commons/compress/ar/number_parsing/bad_user-fail.ar

@@ -0,0 +1,8 @@
+!<arch>
+//                                              68        `
+this_is_a_long_file_name.txt/
+this_is_a_long_file_name_as_well.txt/
+/0              1454693980  9e99  1000  100664  14        `
+Hello, world!
+/30             1454694016  1000  1000  100664  4         `
+Bye

local-test-commons-compress-delta-03/fuzz-tooling/docs/assets/css/just-the-docs-wider.scss

@@ -0,0 +1,3 @@
+---
+---
+{% include css/just-the-docs.scss.liquid color_scheme="wider" %}

local-test-commons-compress-delta-03/fuzz-tooling/docs/getting-started/new-project-guide/swift_lang.md

@@ -0,0 +1,78 @@
+---
+layout: default
+title: Integrating a Swift project
+parent: Setting up a new project
+grand_parent: Getting started
+nav_order: 1
+permalink: /getting-started/new-project-guide/swift-lang/
+---
+
+# Integrating a Swift project
+{: .no_toc}
+
+- TOC
+{:toc}
+---
+
+The process of integrating a project written in Swift with OSS-Fuzz is very similar
+to the general
+[Setting up a new project]({{ site.baseurl }}/getting-started/new-project-guide/)
+process. The key specifics of integrating a Swift project are outlined below.
+
+## Project files
+
+First, you need to write a Swift fuzz target that accepts a stream of bytes and
+calls the program API with that. This fuzz target should reside in your project
+repository.
+
+The structure of the project directory in OSS-Fuzz repository doesn't differ for
+projects written in Swift. The project files have the following Swift specific
+aspects.
+
+### project.yaml
+
+The `language` attribute must be specified.
+
+```yaml
+language: swift
+```
+
+The only supported fuzzing engine is `libfuzzer`
+
+The supported sanitizers are and `address`, `thread`
+
+[Example](https://github.com/google/oss-fuzz/blob/2a15c3c88b21f4f1be2a7ff115f72bd7a08e34ac/projects/swift-nio/project.yaml#L9):
+
+```yaml
+fuzzing_engines:
+  - libfuzzer
+sanitizers:
+  - address
+  - thread
+```
+
+### Dockerfile
+
+The Dockerfile should start by `FROM gcr.io/oss-fuzz-base/base-builder-swift`
+instead of using the simple base-builder
+
+### build.sh
+
+A `precompile_swift` generates an environment variable `SWIFTFLAGS`
+This can then be used in the building command such as `swift build -c release $SWIFTFLAGS`
+
+
+A usage example from swift-protobuf project is
+
+```sh
+. precompile_swift
+# build project
+cd FuzzTesting
+swift build -c debug $SWIFTFLAGS
+
+(
+cd .build/debug/
+find . -maxdepth 1 -type f -name "*Fuzzer" -executable | while read i; do cp $i $OUT/"$i"-debug; done
+)
+
+```

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/.vscodeignore

@@ -0,0 +1,10 @@
+.vscode/**
+.vscode-test/**
+src/**
+.gitignore
+.yarnrc
+vsc-extension-quickstart.md
+**/tsconfig.json
+**/.eslintrc.json
+**/*.map
+**/*.ts

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/README.md

@@ -0,0 +1,17 @@
+# OSS-Fuzz VSCode extension
+
+[OSS-Fuzz](https://github.com/google/oss-fuzz) is a fuzzing toolkit and service for fuzzing open source projects. This VSCode extension provides features and capabilities for interacting with the OSS-Fuzz toolkit and also to compare local changes to the OSS-Fuzz cloud database by way of [Open source fuzz introspection](https://introspector.oss-fuzz.com).
+
+## Features
+
+The VSCode extension is largely driven by commands at this point. The featues of these commands includes:
+
+- Easily setting up OSS-Fuzz
+- Templates for easily setting up a new OSS-Fuzz project
+- Building arbitrary projects from OSS-Fuzz
+- Modify a project from VSCode and test changes in OSS-Fuzz
+- Easily extract code coverage of fuzzers, including local-only fuzzers
+- Compare local code coverage to what is currently achieved by OSS-Fuzz
+- Auto-generation of fuzzer templates
+
+For a full list of commands and their features, please check the commands page.

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commandUtils.ts

@@ -0,0 +1,17 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+export const commandHistory: any[] = [];

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdBuildFuzzerFromWorkspace.ts

@@ -0,0 +1,80 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {commandHistory} from '../commandUtils';
+import {
+  hasOssFuzzInWorkspace,
+  getOssFuzzWorkspaceProjectName,
+  setStatusText,
+} from '../utils';
+import {buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+
+export async function cmdInputCollectorBuildFuzzersFromWorkspace() {
+  let ossFuzzProjectName = '';
+  // First determine if we have a name in the workspace
+  if (await hasOssFuzzInWorkspace()) {
+    /**
+     * The fuzzers are in the workspace, as opposed to e.g. the oss-fuzz dirctory.
+     */
+    ossFuzzProjectName = await getOssFuzzWorkspaceProjectName();
+  } else {
+    // If we did not have that, ask the user.
+
+    const ossFuzzProjectNameInput = await vscode.window.showInputBox({
+      value: '',
+      placeHolder: 'The OSS-Fuzz project name',
+    });
+    if (!ossFuzzProjectNameInput) {
+      println('Did not get a ossFuzzTargetProject');
+      return false;
+    }
+    ossFuzzProjectName = ossFuzzProjectNameInput.toString();
+  }
+
+  // Create an history object
+  const args = new Object({
+    projectName: ossFuzzProjectName,
+    sanitizer: '',
+    toClean: false,
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.WSBuildFuzzers',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchBuildFuzzersFromWorkspace,
+  });
+  console.log('L1: ' + commandHistory.length);
+  commandHistory.push(commandObject);
+
+  await cmdDispatchBuildFuzzersFromWorkspace(args);
+  return true;
+}
+
+async function cmdDispatchBuildFuzzersFromWorkspace(args: any) {
+  await setStatusText('Building fuzzers: starting');
+  const res = await buildFuzzersFromWorkspace(
+    args.projectName,
+    args.sanitizer,
+    args.toClean
+  );
+  if (res) {
+    await setStatusText('Building fuzzers: finished');
+  } else {
+    await setStatusText('Building fuzzers: failed');
+  }
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdCreateOSSFuzzSetup.ts

@@ -0,0 +1,28 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {setupProjectInitialFiles} from '../projectIntegrationHelper';
+import {setStatusText} from '../utils';
+
+export async function createOssFuzzSetup() {
+  await setStatusText('Creating OSS-Fuzz setup: starting');
+  const res = await setupProjectInitialFiles(false);
+  if (res) {
+    await setStatusText('Creating OSS-Fuzz setup: finished');
+  } else {
+    await setStatusText('Creating OSS-Fuzz setup: failed');
+  }
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdFIGetOptimalTargets.ts

@@ -0,0 +1,21 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {getOptimalTargetsFromIntrospector} from '../fuzzIntrospectorHelper';
+
+export async function runGetOptimalTargetsHandler() {
+  getOptimalTargetsFromIntrospector();
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdReproduceTestcase.ts

@@ -0,0 +1,167 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+const fs = require('fs');
+import {println} from '../logger';
+import {commandHistory} from '../commandUtils';
+import {systemSyncLogIfFailure} from '../utils';
+import {buildFuzzersFromWorkspace} from '../ossfuzzWrappers';
+import {extensionConfig} from '../config';
+const readline = require('readline');
+
+export async function cmdInputCollectorReproduceTestcase() {
+  // Runs a fuzzer from a given project.
+  const crashFileInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'The ID of the testcase.',
+  });
+  if (!crashFileInput) {
+    return;
+  }
+  // Create an history object and append it to the command history.
+  const args = new Object({
+    crashFile: crashFileInput.toString(),
+  });
+
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.ReproduceFuzzer',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchReproduceTestcase,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchReproduceTestcase(args);
+  return true;
+}
+
+async function cmdDispatchReproduceTestcase(args: any) {
+  await reproduceTestcase(args.crashFile);
+}
+
+export async function reproduceTestcase(crashInfoFileInput: string) {
+  println('Reproducing testcase for ' + crashInfoFileInput);
+  println('Checking directory: ' + extensionConfig.crashesDirectory);
+
+  const crashInfoFile =
+    extensionConfig.crashesDirectory + '/' + crashInfoFileInput + '.info';
+  println(crashInfoFile);
+  try {
+    if (fs.existsSync(crashInfoFile)) {
+      println('File exists');
+    } else {
+      println('Crash file does not exist');
+      return;
+    }
+  } catch (err) {
+    console.error(err);
+    return;
+  }
+
+  // At this point the file exists
+  const r = readline.createInterface({
+    input: fs.createReadStream(crashInfoFile),
+  });
+
+  let targetProject = 'N/A';
+  let targetFuzzer = 'N/A';
+  // Logic for passing the file. This is based off of clusterfuzz monorail reports,
+  // and the intention is the file needs to be a copy of:
+  //
+  // Project: project-name
+  // Fuzzing Engine: libFuzzer
+  // Fuzz Target: fuzzer-name
+  //
+  // Example:
+  // The following URL: https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=59747
+  // has the bug information:
+  // """
+  // Project: my-fuzzing-project
+  // Fuzzing Engine: libFuzzer
+  // Fuzz Target: the-fuzzer-name-fuzz-parseXX
+  // Job Type: libfuzzer_asan_my-fuzzing-project
+  // Platform Id: linux
+  // """
+  // and a link to a reproducer test case:
+  // https://oss-fuzz.com/download?testcase_id=5009071179431936
+  // which, when accessed will download the file
+  // clusterfuzz-testcase-minimized-flb-it-fuzz-config_map_fuzzer_OSSFUZZ-5009071179431936
+  //
+  // To enable reproducing of this issue we need to:
+  // - 1) Download the crash file and place it in the directory given in config.ts
+  //      and "crashesDirectory" variable.
+  // - 2) create a file "5009071179431936.info" and paste the information above
+  //      (Project:... Fuzz Target: ...) into the file. This information is
+  //      needed because we need to know project name and fuzzer name in order
+  //      to reproduce the crash.
+  // - 3) the reproducer can now be reproduced using the reproduce command
+  //      with argument "5009071179431936" as argument.
+  r.on('line', (text: string) => {
+    println(text);
+    if (text.startsWith('Project: ')) {
+      println('Starts with project');
+      println(text.split('Project: ').toString());
+      targetProject = text.split('Project: ')[1];
+    } else if (text.startsWith('Fuzzing Engine: ')) {
+      println('Starts with fuzzing engine');
+    } else if (text.startsWith('Fuzz Target:')) {
+      println('Starts with Fuzz Target');
+      targetFuzzer = text.split('Fuzz Target: ')[1];
+    } else if (text.startsWith('Job Type:')) {
+      println('Starts with Job Type');
+    }
+  });
+
+  r.on('close', async () => {
+    println('Target project: ' + targetProject);
+    println('Target fuzzer: ' + targetFuzzer);
+
+    // Build a fresh version of the project.
+    const buildResult: boolean = await buildFuzzersFromWorkspace(
+      targetProject,
+      '',
+      true
+    );
+    if (!buildResult) {
+      println('Failed to build fuzzers');
+      return false;
+    }
+
+    // We have a fresh build of the project, proceed to reproduce the testcase.
+    const crashInputTestCase =
+      extensionConfig.crashesDirectory +
+      '/' +
+      'clusterfuzz-testcase-minimized-' +
+      targetFuzzer +
+      '-' +
+      crashInfoFileInput;
+    // Run reproduce command against the target file
+    // Build the fuzzers using OSS-Fuzz infrastructure.
+    const cmdToExec = 'python3';
+    const args = [
+      extensionConfig.ossFuzzPepositoryWorkPath + '/infra/helper.py',
+      'reproduce',
+      targetProject,
+      targetFuzzer,
+      crashInputTestCase,
+    ];
+    if (!(await systemSyncLogIfFailure(cmdToExec, args))) {
+      println('Failed to reproduce testcase');
+    }
+
+    return true;
+  });
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdSetupOSSFuzz.ts

@@ -0,0 +1,53 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import {println} from '../logger';
+import {extensionConfig} from '../config';
+import {isPathValidOssFuzzPath} from '../ossfuzzWrappers';
+import {systemSync} from '../utils';
+
+/**
+ * Function for setting up oss-fuzz. This clones the relevant directory
+ * and sets the oss-fuzz variable accordingly.
+ */
+export async function setUpOssFuzzHandler() {
+  println('Setting up oss-fuzz in /tmp/');
+
+  // First check if we already have an OSS-Fuzz path
+  const tmpOssFuzzRepositoryPath = '/tmp/oss-fuzz';
+
+  if ((await isPathValidOssFuzzPath(tmpOssFuzzRepositoryPath)) === true) {
+    println('OSS-Fuzz already exists in /tmp/oss-fuzz');
+    extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+    return;
+  }
+
+  const cmdToExec = 'git';
+  const args: Array<string> = [
+    'clone',
+    'https://github.com/google/oss-fuzz',
+    tmpOssFuzzRepositoryPath,
+  ];
+  const [res, output] = await systemSync(cmdToExec, args);
+  if (res === false) {
+    println('Failed to clone oss-fuzz');
+    println(output);
+    return;
+  }
+  println('Finished cloning oss-fuzz');
+
+  extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/commands/cmdTestFuzzerCFLite.ts

@@ -0,0 +1,89 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import path = require('path');
+import * as vscode from 'vscode';
+import {println} from '../logger';
+import {
+  runFuzzerHandlerCFLite,
+  buildFuzzersFromWorkspaceClusterfuzzLite,
+} from '../ossfuzzWrappers';
+import {setStatusText} from '../utils';
+import {commandHistory} from '../commandUtils';
+import {extensionConfig} from '../config';
+
+/**
+ * Does an end-to-end test of a project/fuzzer. This is done by
+ * first building the project and then running the fuzzer.
+ * @param context
+ * @returns
+ */
+
+export async function cmdInputCollectorTestFuzzerCFLite() {
+  setStatusText('Testing specific fuzzer: getting input');
+  // Get the fuzzer to run
+  const fuzzerNameInput = await vscode.window.showInputBox({
+    value: '',
+    placeHolder: 'Type a fuzzer name',
+  });
+  if (!fuzzerNameInput) {
+    println('Failed to get fuzzer name');
+    return;
+  }
+
+  // Create the args object for the dispatcher
+  const args = new Object({
+    fuzzerName: fuzzerNameInput.toString(),
+  });
+
+  // Create a dispatcher object.
+  const commandObject = new Object({
+    commandType: 'oss-fuzz.TestFuzzerCFLite',
+    Arguments: args,
+    dispatcherFunc: cmdDispatchTestFuzzerHandlerCFLite,
+  });
+  commandHistory.push(commandObject);
+
+  await cmdDispatchTestFuzzerHandlerCFLite(args);
+}
+
+async function cmdDispatchTestFuzzerHandlerCFLite(args: any) {
+  // Build the project
+  setStatusText('Test specific fuzzer: building fuzzers in workspace');
+  if (!(await buildFuzzersFromWorkspaceClusterfuzzLite())) {
+    println('Build projects');
+    return;
+  }
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+
+  const pathOfLocal = workspaceFolder[0].uri.path;
+  println('path of local: ' + pathOfLocal);
+
+  // Run the fuzzer for 10 seconds
+  println('Running fuzzer');
+  setStatusText('Test specific fuzzer: running fuzzer ' + args.fuzzerName);
+  await runFuzzerHandlerCFLite(
+    pathOfLocal,
+    args.fuzzerName,
+    extensionConfig.numberOfSecondsForTestRuns.toString()
+  );
+  setStatusText('Test specific fuzzer: test completed of ' + args.fuzzerName);
+  return;
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/coverageHelper.ts

@@ -0,0 +1,300 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+import {Uri} from 'vscode';
+import {println} from './logger';
+import {
+  getOSSFuzzCloudURL,
+  getLocalOutBuildDir,
+  downloadRemoteURL,
+} from './utils';
+
+const path = require('path');
+let isCodeCoverageEnabled = false;
+
+// create a decorator type that we use to decorate small numbers
+const codeCoveredLineDecorationType =
+  vscode.window.createTextEditorDecorationType({
+    backgroundColor: '#184916',
+    overviewRulerColor: 'blue',
+    overviewRulerLane: vscode.OverviewRulerLane.Right,
+    light: {
+      // this color will be used in light color themes
+      borderColor: 'darkblue',
+    },
+    dark: {
+      // this color will be used in dark color themes
+      borderColor: 'lightblue',
+    },
+  });
+
+const missingLineDecorationType = vscode.window.createTextEditorDecorationType({
+  backgroundColor: '#6C2B34',
+  overviewRulerColor: 'blue',
+  overviewRulerLane: vscode.OverviewRulerLane.Right,
+  light: {
+    // this color will be used in light color themes
+    borderColor: 'darkblue',
+  },
+  dark: {
+    // this color will be used in dark color themes
+    borderColor: 'lightblue',
+  },
+});
+
+export async function loadSummaryJsonCoverage(
+  context: vscode.ExtensionContext,
+  codeCoverageFile: Uri
+) {
+  const coverageSummaryRawJson = await vscode.workspace.openTextDocument(
+    codeCoverageFile
+  );
+  const jsonCodeCoverage = JSON.parse(coverageSummaryRawJson.getText());
+  return jsonCodeCoverage;
+}
+
+export async function compareLocalToRemoteCoverage(
+  context: vscode.ExtensionContext,
+  projectName: string
+) {
+  println('Checking the file matching');
+  /* Get the coverage from the remote server */
+  const urlString =
+    (await getOSSFuzzCloudURL(projectName)) + '/linux/summary.json';
+
+  println('URL: ' + urlString);
+  const codeCoverageFile: false | vscode.Uri = await downloadRemoteURL(
+    urlString,
+    'summary.json',
+    context
+  );
+  if (!codeCoverageFile) {
+    println('Could not get the coverage summary file');
+    return;
+  }
+  const remoteCoverage = await loadSummaryJsonCoverage(
+    context,
+    codeCoverageFile
+  );
+
+  /* Get the local coverage report */
+  // Compare the local coverage to the upstream coverage
+  const localSummaryCovPath =
+    (await getLocalOutBuildDir(projectName)) + '/report/linux/summary.json';
+  const localCodeCoverage = await loadSummaryJsonCoverage(
+    context,
+    vscode.Uri.file(localSummaryCovPath)
+  );
+
+  for (let i = 0; i < localCodeCoverage.data[0].files.length; i++) {
+    for (let j = 0; j < remoteCoverage.data[0].files.length; j++) {
+      // Get the file dictionary
+      const localFileData = localCodeCoverage.data[0].files[i];
+      const remoteFileData = remoteCoverage.data[0].files[j];
+
+      // If the filepaths are the same, then we match coverage data
+      if (localFileData.filename === remoteFileData.filename) {
+        const remoteFuncCount = remoteFileData.summary.functions.count;
+        const localFuncCount = localFileData.summary.functions.count;
+
+        if (localFuncCount > remoteFuncCount) {
+          println(
+            'Coverage improved in :' +
+              localFileData.filename +
+              ' [' +
+              localFuncCount +
+              ' : ' +
+              remoteFuncCount +
+              ']'
+          );
+        }
+      }
+    }
+  }
+}
+
+/**
+ *
+ * @param context Adds visualisation to the editor based on reading a code coverage file.
+ * @param codeCoverageFile
+ */
+export async function loadCoverageIntoWorkspace(
+  context: vscode.ExtensionContext,
+  codeCoverageFile: Uri
+) {
+  isCodeCoverageEnabled = true;
+
+  const doc3 = await vscode.workspace.openTextDocument(codeCoverageFile);
+  const jsonCodeCoverageObj3 = JSON.parse(doc3.getText());
+
+  const codeCoverageMappingWithCoverage = new Map();
+  const codeCoverageMapMissingCoverage = new Map();
+
+  Object.entries(jsonCodeCoverageObj3['files']).forEach(entry => {
+    const [key, value] = entry;
+    println(key);
+    const filename = path.parse(key).base;
+    println('Filename base: ' + filename);
+    const objectDictionary: any = value as any;
+    const linesWithCodeCoverage: unknown[] = [];
+    println(objectDictionary['executed_lines']);
+    Object.entries(objectDictionary['executed_lines']).forEach(entryInner => {
+      const lineNumber = entryInner[1];
+      //println("executed line: " + lineNumber);
+      linesWithCodeCoverage.push(lineNumber);
+    });
+    codeCoverageMappingWithCoverage.set(filename, linesWithCodeCoverage);
+
+    const linesMissingCodeCoverage: unknown[] = [];
+    Object.entries(objectDictionary['missing_lines']).forEach(entryInner => {
+      const lineNumber = entryInner[1];
+      //println("executed line: " + line_numb);
+      linesMissingCodeCoverage.push(lineNumber);
+    });
+    codeCoverageMapMissingCoverage.set(filename, linesMissingCodeCoverage);
+  });
+  println('=========>');
+
+  println('Enabling code coverage decorator');
+  println('decorator sample is activated');
+
+  let timeout: NodeJS.Timer | undefined = undefined;
+
+  // create a decorator type that we use to decorate large numbers
+
+  let activeEditor = vscode.window.activeTextEditor;
+
+  function updateDecorations(
+    linesWithCodeCoverage: any,
+    linesWithoNoCodeCoverage: any
+  ) {
+    if (!isCodeCoverageEnabled) {
+      return;
+    }
+    if (!activeEditor) {
+      return;
+    }
+    println('Filename');
+    println(activeEditor.document.fileName);
+
+    // Current file opened in the editor.
+    const nameOfCurrentFile = path.parse(activeEditor.document.fileName).base;
+
+    println('Base filename: ' + nameOfCurrentFile);
+    println('Done filename');
+    const lineNumbersWithCoverage: vscode.DecorationOptions[] = [];
+    const missingLineNumbers: vscode.DecorationOptions[] = [];
+
+    if (linesWithCodeCoverage.has(nameOfCurrentFile)) {
+      println('Has this file');
+      const elemWithCov = linesWithCodeCoverage.get(nameOfCurrentFile);
+      for (let idx = 0; idx < elemWithCov.length; idx++) {
+        const lineNo = elemWithCov[idx];
+        println('Setting up: ' + lineNo);
+        lineNumbersWithCoverage.push({
+          range: new vscode.Range(lineNo - 1, 0, lineNo, 0),
+        });
+      }
+
+      const elemNoCov = linesWithoNoCodeCoverage.get(nameOfCurrentFile);
+      for (let idx = 0; idx < elemNoCov.length; idx++) {
+        const lineNo = elemNoCov[idx];
+        println('Setting up: ' + lineNo);
+        missingLineNumbers.push({
+          range: new vscode.Range(lineNo - 1, 0, lineNo, 0),
+        });
+      }
+    } else {
+      println('Does not have this file');
+    }
+
+    activeEditor.setDecorations(
+      codeCoveredLineDecorationType,
+      lineNumbersWithCoverage
+    );
+    activeEditor.setDecorations(missingLineDecorationType, missingLineNumbers);
+    //activeEditor.setDecorations(largeNumberDecorationType, largeNumbers);
+  }
+
+  function triggerUpdateDecorations(
+    throttle = false,
+    covMap: any,
+    covMisMap: any
+  ) {
+    if (timeout) {
+      clearTimeout(timeout);
+      timeout = undefined;
+    }
+    if (throttle) {
+      //timeout = setTimeout(updateDecorations, 500);
+      updateDecorations(covMap, covMisMap);
+    } else {
+      updateDecorations(covMap, covMisMap);
+    }
+  }
+
+  if (activeEditor) {
+    triggerUpdateDecorations(
+      false,
+      codeCoverageMappingWithCoverage,
+      codeCoverageMapMissingCoverage
+    );
+  }
+
+  vscode.window.onDidChangeActiveTextEditor(
+    editor => {
+      activeEditor = editor;
+      if (editor) {
+        triggerUpdateDecorations(
+          false,
+          codeCoverageMappingWithCoverage,
+          codeCoverageMapMissingCoverage
+        );
+      }
+    },
+    null,
+    context.subscriptions
+  );
+
+  vscode.workspace.onDidChangeTextDocument(
+    event => {
+      if (activeEditor && event.document === activeEditor.document) {
+        triggerUpdateDecorations(
+          true,
+          codeCoverageMappingWithCoverage,
+          codeCoverageMapMissingCoverage
+        );
+      }
+    },
+    null,
+    context.subscriptions
+  );
+}
+
+/**
+ * Removes the values from the mappings used to track code coverage. As a
+ * result, the visualisation disappears.
+ */
+export async function clearCoverage() {
+  // Set global indicator.
+  const activeEditor = vscode.window.activeTextEditor;
+  isCodeCoverageEnabled = false;
+  if (activeEditor) {
+    activeEditor.setDecorations(codeCoveredLineDecorationType, []);
+    activeEditor.setDecorations(missingLineDecorationType, []);
+  }
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/extension.ts

@@ -0,0 +1,227 @@
+// Copyright 2023 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+
+import {clearCoverage} from './coverageHelper';
+import {println} from './logger';
+
+// Import the command dispatcher functions
+import {cmdInputCollectorRunSpecificFuzzer} from './commands/cmdRunFuzzer';
+import {cmdInputCollectorBuildFuzzersFromWorkspace} from './commands/cmdBuildFuzzerFromWorkspace';
+import {cmdInputCollectorBuildFuzzersFromWorkspaceCFLite} from './commands/cmdBuildFuzzerFromWorkspaceCFLite';
+import {cmdInputCollectorTestFuzzerCFLite} from './commands/cmdTestFuzzerCFLite';
+import {cmdDispatcherRe} from './commands/cmdRedo';
+import {setupCIFuzzHandler} from './commands/cmdSetupCIFuzz';
+import {cmdInputCollectorTestFuzzer} from './commands/cmdTestFuzzer';
+import {displayCodeCoverageFromOssFuzz} from './commands/cmdDisplayCoverage';
+import {createOssFuzzSetup} from './commands/cmdCreateOSSFuzzSetup';
+import {runEndToEndAndGetCoverage} from './commands/cmdEndToEndCoverage';
+import {listFuzzersHandler} from './commands/cmdListFuzzers';
+import {cmdInputCollectorReproduceTestcase} from './commands/cmdReproduceTestcase';
+import {cmdDispatcherTemplate} from './commands/cmdTemplate';
+import {runGetOptimalTargetsHandler} from './commands/cmdFIGetOptimalTargets';
+import {setUpFuzzIntrospectorHandler} from './commands/cmdSetupFI';
+import {runFuzzIntrospectorHandler} from './commands/cmdRunFI';
+import {cmdDispatcherGenerateClusterfuzzLite} from './commands/cmdDispatcherGenerateClusterfuzzLite';
+import {setUpOssFuzzHandler} from './commands/cmdSetupOSSFuzz';
+import {setOssFuzzPath} from './commands/cmdSetOSSFuzzPath';
+import {extensionConfig} from './config';
+
+/**
+ * Extension entrypoint. Activate the extension and register the commands.
+ */
+export function activate(context: vscode.ExtensionContext) {
+  console.log('Activating extension)');
+  extensionConfig.printConfig();
+  println('OSS-Fuzz extension is now active!');
+
+  // Command registration
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.SetUp', async () => {
+      println('CMD start: SetUp');
+      await setUpOssFuzzHandler();
+      println('CMD end: SetUp');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.RunFuzzer', async () => {
+      println('CMD start: Run Fuzzer');
+      //await runFuzzerHandler('', '', '', '');
+      cmdInputCollectorRunSpecificFuzzer();
+      println('CMD end: Run Fuzzer');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.ListFuzzers', async () => {
+      println('CMD start: ListFuzzers');
+      await listFuzzersHandler();
+      println('CMD end: ListFuzzers');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.SetOSSFuzzPath', async () => {
+      println('CMD start: SetOSSFuzzPath');
+      await setOssFuzzPath();
+      println('CMD end: SetOSSFuzzPath');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.GetCodeCoverage', async () => {
+      println('CMD start: GetCodeCoverage');
+      await displayCodeCoverageFromOssFuzz(context);
+      println('CMD end: GetCodeCoverage');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.ClearCodeCoverage', async () => {
+      println('CMD start: ClearCodeCoverage');
+      await clearCoverage();
+      println('CMD end: ClearCodeCoverage');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.CreateOSSFuzzSetup', async () => {
+      println('CMD start: CreateOSSFuzzSetup');
+      await createOssFuzzSetup();
+      println('CMD end: CreateOSSFuzzSetup');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.WSBuildFuzzers', async () => {
+      println('CMD start: WSBuildFuzzers3');
+      await cmdInputCollectorBuildFuzzersFromWorkspace();
+      println('CMD end: WSBuildFuzzers4');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.SetupCIFuzz', async () => {
+      println('CMD start: SetupCIFuzz');
+      await setupCIFuzzHandler();
+      println('CMD end: SetupCIFuzz');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.testFuzzer', async () => {
+      println('CMD start: testFuzzer');
+      await cmdInputCollectorTestFuzzer();
+      println('CMD end: testFuzzer');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.testCodeCoverage', async () => {
+      println('CMD start: testCodeCoverage');
+      await runEndToEndAndGetCoverage(context);
+      println('CMD end: testCodeCoverage');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.Reproduce', async () => {
+      println('CMD start: Reproduce');
+      await cmdInputCollectorReproduceTestcase();
+      println('CMD end: Reproduce');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.Redo', async () => {
+      println('CMD start: Re');
+      await cmdDispatcherRe();
+      println('CMD end: Re');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.Template', async () => {
+      println('CMD start: remplate');
+      await cmdDispatcherTemplate(context);
+      println('CMD end: template');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.GenerateClusterfuzzLite',
+      async () => {
+        println('CMD start: GenerateClusterfuzzLite');
+        await cmdDispatcherGenerateClusterfuzzLite(context);
+        println('CMD end: GenerateClusterfuzzLite');
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.WSBuildFuzzersCFLite',
+      async () => {
+        println('CMD start: WSBuildFuzzersCFLite');
+        await cmdInputCollectorBuildFuzzersFromWorkspaceCFLite();
+        println('CMD end: WSBuildFuzzersCFLite');
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.testFuzzerCFLite', async () => {
+      println('CMD start: testFuzzerCFLite');
+      await cmdInputCollectorTestFuzzerCFLite();
+      println('CMD end: testFuzzerCFLite');
+    })
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.setupFuzzIntrospector',
+      async () => {
+        println('CMD start: setup FI');
+        await setUpFuzzIntrospectorHandler();
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand(
+      'oss-fuzz.runFuzzIntrospector',
+      async () => {
+        println('CMD start: run Fuzz Introspector');
+        await runFuzzIntrospectorHandler();
+      }
+    )
+  );
+
+  context.subscriptions.push(
+    vscode.commands.registerCommand('oss-fuzz.GetOptimalTargets', async () => {
+      println('CMD start: run GetOptimalTargets');
+      await runGetOptimalTargetsHandler();
+    })
+  );
+}
+
+// This method is called when your extension is deactivated
+export function deactivate() {
+  println('Deactivating the extension');
+}

local-test-commons-compress-delta-03/fuzz-tooling/tools/vscode-extension/src/fuzzIntrospectorHelper.ts

@@ -0,0 +1,117 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+////////////////////////////////////////////////////////////////////////////////
+
+import * as vscode from 'vscode';
+
+import {println} from './logger';
+import {extensionConfig} from './config';
+import {isPathValidOssFuzzPath} from './ossfuzzWrappers';
+import {systemSync} from './utils';
+
+const fs = require('fs');
+
+export async function setUpFuzzIntrospector() {
+  println('Setting up oss-fuzz in /tmp/');
+
+  // First check if we already have Fuzz Introspector installed.
+  const tmpOssFuzzRepositoryPath = '/tmp/fi-tmp-env';
+
+  if ((await isPathValidOssFuzzPath(tmpOssFuzzRepositoryPath)) === true) {
+    println('Fuzz Introspector virtual env already exists in /tmp/fi-tmp-env');
+    extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+    return;
+  }
+
+  const cmdToExec = 'python3.11';
+  const args: Array<string> = ['-m', 'virtualenv', tmpOssFuzzRepositoryPath];
+  const [res, output] = await systemSync(cmdToExec, args);
+  if (res === false) {
+    println('Failed to create virtual environment');
+    println(output);
+    return;
+  }
+
+  const cmdToExec2 = '/tmp/fi-tmp-env/bin/python3.11';
+  const args2: Array<string> = [
+    '-m',
+    'pip',
+    'install',
+    'fuzz-introspector==0.1.6',
+  ];
+  const [res2, output2] = await systemSync(cmdToExec2, args2);
+  if (res2 === false) {
+    println('Failed to create virtual environment');
+    println(output2);
+    return;
+  }
+}
+
+export async function runFuzzIntrospector() {
+  println('Setting up oss-fuzz in /tmp/');
+
+  const workspaceFolder = vscode.workspace.workspaceFolders;
+  if (!workspaceFolder) {
+    return;
+  }
+  const pathOfLocal = workspaceFolder[0].uri.fsPath;
+  println('path of local: ' + pathOfLocal);
+
+  // First check if we already have Fuzz Introspector installed.
+  const tmpOssFuzzRepositoryPath = '/tmp/fi-tmp-env';
+
+  if ((await isPathValidOssFuzzPath(tmpOssFuzzRepositoryPath)) === true) {
+    println('Fuzz Introspector virtual env already exists in /tmp/fi-tmp-env');
+    extensionConfig.ossFuzzPepositoryWorkPath = tmpOssFuzzRepositoryPath;
+    return;
+  }
+
+  await systemSync('mkdir', ['-p', '/tmp/out-fi/']);
+
+  const cmdToExec = '/tmp/fi-tmp-env/bin/fuzz-introspector';
+  const args: Array<string> = [
+    'full',
+    '--target_dir=' + pathOfLocal,
+    '--out-dir=/tmp/out-fi',
+  ];
+  const [res, output] = await systemSync(cmdToExec, args);
+  if (res === false) {
+    println('Failed run FI');
+    println(output);
+    return;
+  }
+}
+
+export async function getOptimalTargetsFromIntrospector() {
+  if (!fs.existsSync('/tmp/out-fi/summary.json')) {
+    println('There are no introspector reports. Please run introspector first');
+  }
+  const json_data = fs.readFileSync('/tmp/out-fi/summary.json');
+  // println(json_data);
+
+  const jsonCodeCoverage = JSON.parse(json_data);
+
+  println('Optimal targets');
+  Object.entries(jsonCodeCoverage['analyses']['OptimalTargets']).forEach(
+    entry => {
+      const [key, value] = entry;
+      const objectDictionary: any = value as any;
+      println(JSON.stringify(objectDictionary, null, 2));
+    }
+  );
+  println('--------------------------');
+
+  return;
+}