/*
 *  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 static org.apache.commons.compress.AbstractTestCase.getFile;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.Assume.assumeTrue;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.RandomAccessFile;
import java.nio.file.Files;
import java.util.Enumeration;
import java.util.Random;
import java.util.zip.ZipEntry;

import org.apache.commons.compress.AbstractTestCase;
import org.junit.Test;

public class Zip64SupportIT {

    private static final long FIVE_BILLION = 5000000000l;
    private static final int ONE_MILLION = 1000000;
    private static final int ONE_HUNDRED_THOUSAND = 100000;

    @Test public void read5GBOfZerosUsingInputStream() throws Throwable {
        read5GBOfZerosImpl(get5GBZerosFile(), "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedBy7ZIPUsingInputStream()
        throws Throwable {
        read5GBOfZerosImpl(get5GBZerosFileGeneratedBy7ZIP(), "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedByJava7JarUsingInputStream()
        throws Throwable {
        read5GBOfZerosImpl(get5GBZerosFileGeneratedByJava7Jar(), "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedByWinZIPUsingInputStream()
        throws Throwable {
        read5GBOfZerosImpl(get5GBZerosFileGeneratedByWinZIP(), "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedByPKZipUsingInputStream()
        throws Throwable {
        read5GBOfZerosImpl(get5GBZerosFileGeneratedByPKZip(),
                           "zip6/5GB_of_Zeros");
    }

    @Test public void read100KFilesUsingInputStream() throws Throwable {
        read100KFilesImpl(get100KFileFile());
    }

    @Test public void read100KFilesGeneratedBy7ZIPUsingInputStream()
        throws Throwable {
        read100KFilesImpl(get100KFileFileGeneratedBy7ZIP());
    }

    @Test public void read100KFilesGeneratedByWinCFUsingInputStream()
        throws Throwable {
        read100KFilesImpl(get100KFileFileGeneratedByWinCF());
    }

    @Test public void read100KFilesGeneratedByJava7JarUsingInputStream()
        throws Throwable {
        read100KFilesImpl(get100KFileFileGeneratedByJava7Jar());
    }

    @Test public void read100KFilesGeneratedByWinZIPUsingInputStream()
        throws Throwable {
        read100KFilesImpl(get100KFileFileGeneratedByWinZIP());
    }

    @Test public void read100KFilesGeneratedByPKZipUsingInputStream()
        throws Throwable {
        read100KFilesImpl(get100KFileFileGeneratedByPKZip());
    }

    @Test public void read5GBOfZerosUsingZipFile() throws Throwable {
        read5GBOfZerosUsingZipFileImpl(get5GBZerosFile(), "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedBy7ZIPUsingZipFile()
        throws Throwable {
        read5GBOfZerosUsingZipFileImpl(get5GBZerosFileGeneratedBy7ZIP(),
                                       "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedByJava7JarUsingZipFile()
        throws Throwable {
        read5GBOfZerosUsingZipFileImpl(get5GBZerosFileGeneratedByJava7Jar(),
                                       "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedByWinZIPUsingZipFile()
        throws Throwable {
        read5GBOfZerosUsingZipFileImpl(get5GBZerosFileGeneratedByWinZIP(),
                                       "5GB_of_Zeros");
    }

    @Test public void read5GBOfZerosGeneratedByPKZipUsingZipFile()
        throws Throwable {
        read5GBOfZerosUsingZipFileImpl(get5GBZerosFileGeneratedByPKZip(),
                                       "zip6/5GB_of_Zeros");
    }

    @Test public void writeAndRead5GBOfZerosUsingZipFile() throws Throwable {
        File f = null;
        try {
            f = write5GBZerosFile("writeAndRead5GBOfZerosUsingZipFile");
            read5GBOfZerosUsingZipFileImpl(f, "5GB_of_Zeros");
        } finally {
            if (f != null) {
                AbstractTestCase.tryHardToDelete(f);
            }
        }
    }

    private static File write5GBZerosFile(final String testName) throws Throwable {
        final File f = getTempFile(testName);
        final ZipArchiveOutputStream zos = new ZipArchiveOutputStream(f);
        try {
            zos.setUseZip64(Zip64Mode.Always);
            final byte[] buf = new byte[ONE_MILLION];
            final ZipArchiveEntry zae = new ZipArchiveEntry("5GB_of_Zeros");
            zae.setSize(FIVE_BILLION);
            zae.setMethod(ZipEntry.DEFLATED);
            zae.setCrc(0x8a408f16L);
            zos.putArchiveEntry(zae);
            for (int j = 0; j < FIVE_BILLION / 1000 / 1000; j++) {
                zos.write(buf);
            }
            zos.closeArchiveEntry();
            zos.close();
        } catch (final IOException ex) {
            System.err.println("Failed to write archive because of: "
                               + ex.getMessage()
                               + " - likely not enough disk space.");
            assumeTrue(false);
        } finally {
            zos.destroy();
        }
        return f;
    }

    @Test public void read100KFilesUsingZipFile() throws Throwable {
        read100KFilesUsingZipFileImpl(get100KFileFile());
    }

    @Test public void read100KFilesGeneratedBy7ZIPUsingZipFile()
        throws Throwable {
        read100KFilesUsingZipFileImpl(get100KFileFileGeneratedBy7ZIP());
    }

    @Test public void read100KFilesGeneratedByWinCFUsingZipFile()
        throws Throwable {
        read100KFilesUsingZipFileImpl(get100KFileFileGeneratedByWinCF());
    }

    @Test public void read100KFilesGeneratedByJava7JarUsingZipFile()
        throws Throwable {
        read100KFilesUsingZipFileImpl(get100KFileFileGeneratedByJava7Jar());
    }

    @Test public void read100KFilesGeneratedByWinZIPUsingZipFile()
        throws Throwable {
        read100KFilesUsingZipFileImpl(get100KFileFileGeneratedByWinZIP());
    }

    @Test public void read100KFilesGeneratedByPKZipUsingZipFile()
        throws Throwable {
        read100KFilesUsingZipFileImpl(get100KFileFileGeneratedByPKZip());
    }

    private static ZipOutputTest write100KFiles() {
        return write100KFiles(Zip64Mode.AsNeeded);
    }

    private static ZipOutputTest write100KFiles(final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                write100KFilesToStream(zos);
                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    final long end = a.length();

                    // validate "end of central directory" is at
                    // the end of the file and contains the magic
                    // value 0xFFFF as "number of entries".
                    a.seek(end
                            - 22 /* length of EOCD without file comment */);
                    final byte[] eocd = new byte[12];
                    a.readFully(eocd);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 5, 6,
                            // disk numbers
                            0, 0, 0, 0,
                            // entries
                            (byte) 0xff, (byte) 0xff,
                            (byte) 0xff, (byte) 0xff,
                    }, eocd);

                    // validate "Zip64 end of central directory
                    // locator" is right in front of the EOCD and
                    // the location of the "Zip64 end of central
                    // directory record" seems correct
                    final long expectedZ64EocdOffset = end - 22 /* eocd.length */
                            - 20 /* z64 eocd locator.length */
                            - 56 /* z64 eocd without extensible data sector */;
                    final byte[] loc =
                            ZipEightByteInteger.getBytes(expectedZ64EocdOffset);
                    a.seek(end - 22 - 20);
                    final byte[] z64EocdLoc = new byte[20];
                    a.readFully(z64EocdLoc);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 6, 7,
                            // disk numbers
                            0, 0, 0, 0,
                            // location of Zip64 EOCD,
                            loc[0], loc[1], loc[2], loc[3],
                            loc[4], loc[5], loc[6], loc[7],
                            // total number of disks
                            1, 0, 0, 0,
                    }, z64EocdLoc);

                    // validate "Zip64 end of central directory
                    // record" is where it is supposed to be, the
                    // known values are fine and read the location
                    // of the central directory from it
                    a.seek(expectedZ64EocdOffset);
                    final byte[] z64EocdStart = new byte[40];
                    a.readFully(z64EocdStart);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 6, 6,
                            // size of z64 EOCD
                            44, 0, 0, 0,
                            0, 0, 0, 0,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // disk numbers
                            0, 0, 0, 0,
                            0, 0, 0, 0,
                            // number of entries 100k = 0x186A0
                            (byte) 0xA0, (byte) 0x86, 1, 0,
                            0, 0, 0, 0,
                            (byte) 0xA0, (byte) 0x86, 1, 0,
                            0, 0, 0, 0,
                    }, z64EocdStart);
                    a.seek(expectedZ64EocdOffset + 48 /* skip size */);
                    final byte[] cdOffset = new byte[8];
                    a.readFully(cdOffset);
                    final long cdLoc = ZipEightByteInteger.getLongValue(cdOffset);

                    // finally verify there really is a central
                    // directory entry where the Zip64 EOCD claims
                    a.seek(cdLoc);
                    final byte[] sig = new byte[4];
                    a.readFully(sig);
                    assertArrayEquals(new byte[] {
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                    }, sig);
                }
            }
        };
    }

    @Test public void write100KFilesFile() throws Throwable {
        withTemporaryArchive("write100KFilesFile", write100KFiles(), true);
    }

    @Test public void write100KFilesStream() throws Throwable {
        withTemporaryArchive("write100KFilesStream", write100KFiles(), false);
    }

    @Test public void write100KFilesFileModeAlways() throws Throwable {
        withTemporaryArchive("write100KFilesFileModeAlways",
                             write100KFiles(Zip64Mode.Always), true);
    }

    @Test public void write100KFilesStreamModeAlways() throws Throwable {
        withTemporaryArchive("write100KFilesStreamModeAlways",
                             write100KFiles(Zip64Mode.Always), false);
    }

    private static final ZipOutputTest write100KFilesModeNever =
        new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Never);
                try {
                    write100KFilesToStream(zos);
                    fail("expected a Zip64RequiredException");
                } catch (final Zip64RequiredException ex) {
                    assertEquals(Zip64RequiredException.TOO_MANY_ENTRIES_MESSAGE,
                                 ex.getMessage());
                }
            }
        };

    @Test public void write100KFilesFileModeNever() throws Throwable {
        withTemporaryArchive("write100KFilesFileModeNever",
                             write100KFilesModeNever, true);
    }

    @Test public void write100KFilesStreamModeNever() throws Throwable {
        withTemporaryArchive("write100KFilesStreamModeNever",
                             write100KFilesModeNever, false);
    }

    @Test public void readSelfGenerated100KFilesUsingZipFile()
        throws Throwable {
        withTemporaryArchive("readSelfGenerated100KFilesUsingZipFile()",
                             new ZipOutputTest() {
                                 @Override
                                public void test(final File f,
                                                  final ZipArchiveOutputStream zos)
                                     throws IOException {
                                     write100KFilesToStream(zos);
                                     read100KFilesUsingZipFileImpl(f);
                                 }
                             },
                             true);
    }

    private static ZipOutputTest write3EntriesCreatingBigArchive() {
        return write3EntriesCreatingBigArchive(Zip64Mode.AsNeeded);
    }

    private static ZipOutputTest write3EntriesCreatingBigArchive(final Zip64Mode mode) {
        return write3EntriesCreatingBigArchive(mode, false);
    }

    /*
     * Individual sizes don't require ZIP64 but the offset of the
     * third entry is bigger than 0xFFFFFFFF so a ZIP64 extended
     * information is needed inside the central directory.
     *
     * Creates a temporary archive of approx 5GB in size
     */
    private static ZipOutputTest
        write3EntriesCreatingBigArchive(final Zip64Mode mode, final boolean isSplitArchive) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                write3EntriesCreatingBigArchiveToStream(zos);

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);
                    // skip first two entries
                    a.skipBytes(2 * 47 /* CD entry of file with
                                          file name length 1 and no
                                          extra data */
                                    + 2 * (mode == Zip64Mode.Always ? 32 : 0)
                                /* ZIP64 extra fields if mode is Always */
                    );

                    // grab third entry, verify offset is
                    // 0xFFFFFFFF and it has a ZIP64 extended
                    // information extra field
                    final byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp, CRC, compressed size
                    a.skipBytes(12);
                    // Original Size
                    final byte[] originalSize = new byte[4];
                    a.readFully(originalSize);
                    if (mode == Zip64Mode.Always) {
                        assertArrayEquals("CDH original size", new byte[] {
                                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            }, originalSize);
                    } else {
                        assertArrayEquals("CDH original size", new byte[] {
                                1, 0, 0, 0
                            }, originalSize);
                    }
                    final byte[] rest = new byte[19];
                    a.readFully(rest);
                    assertArrayEquals("CDH rest", new byte[] {
                            // file name length
                            1, 0,
                            // extra field length
                            (byte) (mode == Zip64Mode.Always? 32 : 12), 0,
                            // comment length
                            0, 0,
                            // disk number
                            (byte) (isSplitArchive? 0xFF : 0), (byte) (isSplitArchive? 0xFF : 0),
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            (byte) 0xFF, (byte) 0xFF,
                            (byte) 0xFF, (byte) 0xFF,
                            // file name
                            (byte) '2'
                    }, rest);
                    if (mode == Zip64Mode.Always) {
                        final byte[] extra = new byte[12];
                        a.readFully(extra);
                        assertArrayEquals("CDH extra", new byte[] {
                                // Header-ID
                                1, 0,
                                // size
                                28, 0,
                                // Original Size
                                1, 0, 0, 0, 0, 0, 0, 0,
                            }, extra);
                        // skip compressed size
                        a.skipBytes(8);
                    } else {
                        final byte[] extra = new byte[4];
                        a.readFully(extra);
                        assertArrayEquals("CDH extra", new byte[] {
                                // Header-ID
                                1, 0,
                                // size
                                8, 0,
                            }, extra);
                    }

                    // read offset of LFH
                    final byte[] offset = new byte[8];
                    a.readFully(offset);
                    // verify there is a LFH where the CD claims it
                    a.seek(ZipEightByteInteger.getLongValue(offset));
                    final byte[] sig = new byte[4];
                    a.readFully(sig);
                    assertArrayEquals("LFH signature", new byte[] {
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                    }, sig);
                }
            }
        };
    }

    @Test public void write3EntriesCreatingBigArchiveFile() throws Throwable {
        withTemporaryArchive("write3EntriesCreatingBigArchiveFile",
                             write3EntriesCreatingBigArchive(),
                             true);
    }

    @Test public void write3EntriesCreatingBigArchiveStream() throws Throwable {
        withTemporaryArchive("write3EntriesCreatingBigArchiveStream",
                             write3EntriesCreatingBigArchive(),
                             false);
    }

    @Test public void write3EntriesCreatingBigArchiveFileModeAlways()
        throws Throwable {
        withTemporaryArchive("write3EntriesCreatingBigArchiveFileModeAlways",
                             write3EntriesCreatingBigArchive(Zip64Mode.Always),
                             true);
    }

    @Test public void write3EntriesCreatingBigArchiveStreamModeAlways()
        throws Throwable {
        withTemporaryArchive("write3EntriesCreatingBigArchiveStreamModeAlways",
                             write3EntriesCreatingBigArchive(Zip64Mode.Always),
                             false);
    }

    private static final ZipOutputTest write3EntriesCreatingBigArchiveModeNever =
        new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Never);
                try {
                    write3EntriesCreatingBigArchiveToStream(zos);
                    fail("expected a Zip64RequiredException");
                } catch (final Zip64RequiredException ex) {
                    assertEquals(Zip64RequiredException.ARCHIVE_TOO_BIG_MESSAGE,
                                 ex.getMessage());
                }
            }
        };

    @Test public void write3EntriesCreatingBigArchiveFileModeNever()
        throws Throwable {
        withTemporaryArchive("write3EntriesCreatingBigArchiveFileModeNever",
                             write3EntriesCreatingBigArchiveModeNever,
                             true);
    }

    @Test public void write3EntriesCreatingBigArchiveStreamModeNever()
        throws Throwable {
        withTemporaryArchive("write3EntriesCreatingBigArchiveStreamModeNever",
                             write3EntriesCreatingBigArchiveModeNever,
                             false);
    }

    @Test public void read3EntriesCreatingBigArchiveFileUsingZipFile()
        throws Throwable {
        withTemporaryArchive("read3EntriesCreatingBigArchiveFileUsingZipFile",
                             new ZipOutputTest() {
                                 @Override
                                public void test(final File f,
                                                  final ZipArchiveOutputStream zos)
                                     throws IOException {
                                     write3EntriesCreatingBigArchiveToStream(zos);
                                     ZipFile zf = null;
                                     try {
                                         zf = new ZipFile(f);
                                         int idx = 0;
                                         for (final Enumeration<ZipArchiveEntry> e =
                                                  zf.getEntriesInPhysicalOrder();
                                              e.hasMoreElements(); ) {
                                             final ZipArchiveEntry zae = e.nextElement();
                                             assertEquals(String.valueOf(idx),
                                                          zae.getName());
                                             if (idx++ < 2) {
                                                 assertEquals(FIVE_BILLION / 2,
                                                              zae.getSize());
                                             } else {
                                                 assertEquals(1,
                                                              zae.getSize());
                                                 try (InputStream i = zf.getInputStream(zae)) {
                                                     assertNotNull(i);
                                                     assertEquals(42, i.read());
                                                 }
                                             }
                                         }
                                     } finally {
                                         ZipFile.closeQuietly(zf);
                                     }
                                 }
                             },
                             true);
    }

    private static ZipOutputTest writeBigStoredEntry(final boolean knownSize) {
        return writeBigStoredEntry(knownSize, Zip64Mode.AsNeeded);
    }

    /*
     * One entry of length 5 billion bytes, written without
     * compression.
     *
     * No Compression => sizes are stored directly inside the LFH.  No
     * Data Descriptor at all.
     *
     * Creates a temporary archive of approx 5GB in size
     */
    private static ZipOutputTest writeBigStoredEntry(final boolean knownSize,
                                                     final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(FIVE_BILLION);
                    zae.setCrc(0x5c316f50L);
                }
                zae.setMethod(ZipEntry.STORED);
                zos.putArchiveEntry(zae);
                for (int j = 0; j < FIVE_BILLION / 1000 / 1000; j++) {
                    zos.write(buf);
                }
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    // grab first entry, verify sizes are 0xFFFFFFFF
                    // and it has a ZIP64 extended information extra
                    // field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] rest = new byte[26];
                    a.readFully(rest);
                    assertArrayEquals("CDH rest", new byte[] {
                            // CRC
                            (byte) 0x50, (byte) 0x6F, (byte) 0x31, (byte) 0x5c,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            (byte) (mode == Zip64Mode.Always? 32 : 20), 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                    }, rest);
                    byte[] offset = new byte[4];
                    a.readFully(offset);
                    if (mode == Zip64Mode.Always) {
                        assertArrayEquals("offset", new byte[] {
                                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            }, offset);
                    } else {
                        assertArrayEquals("offset", new byte[] {
                                0, 0, 0, 0,
                            }, offset);
                    }
                    assertEquals('0', a.read());
                    final byte[] extra = new byte[20];
                    a.readFully(extra);
                    // 5e9 == 0x12A05F200
                    assertArrayEquals("CDH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            (byte) (mode == Zip64Mode.Always? 28 : 16), 0,
                            // original size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                            // compressed size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                    }, extra);
                    if (mode == Zip64Mode.Always) {
                        offset = new byte[8];
                        a.readFully(offset);
                        assertArrayEquals("extra offset", new byte[] {
                                0, 0, 0, 0, 0, 0, 0, 0,
                            }, offset);
                    }

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    assertArrayEquals("LFH rest", new byte[] {
                            // CRC
                            (byte) 0x50, (byte) 0x6F, (byte) 0x31, (byte) 0x5c,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            20, 0,
                            // file name
                            (byte) '0'
                    }, rest);
                    a.readFully(extra);
                    // 5e9 == 0x12A05F200
                    assertArrayEquals("LFH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            16, 0,
                            // original size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                            // compressed size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                    }, extra);
                }
            }
        };
    }

    /*
     * No Compression + Stream => sizes must be known before data is
     * written.
     */
    @Test public void writeBigStoredEntryToStream() throws Throwable {
        withTemporaryArchive("writeBigStoredEntryToStream",
                             writeBigStoredEntry(true),
                             false);
    }

    @Test public void writeBigStoredEntryKnownSizeToFile() throws Throwable {
        withTemporaryArchive("writeBigStoredEntryKnownSizeToFile",
                             writeBigStoredEntry(true),
                             true);
    }

    @Test public void writeBigStoredEntryUnnownSizeToFile() throws Throwable {
        withTemporaryArchive("writeBigStoredEntryUnknownSizeToFile",
                             writeBigStoredEntry(false),
                             true);
    }

    @Test public void writeBigStoredEntryToStreamModeAlways() throws Throwable {
        withTemporaryArchive("writeBigStoredEntryToStreamModeAlways",
                             writeBigStoredEntry(true, Zip64Mode.Always),
                             false);
    }

    @Test public void writeBigStoredEntryKnownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeBigStoredEntryKnownSizeToFileModeAlways",
                             writeBigStoredEntry(true, Zip64Mode.Always),
                             true);
    }

    @Test public void writeBigStoredEntryUnnownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeBigStoredEntryUnknownSizeToFileModeAlways",
                             writeBigStoredEntry(false, Zip64Mode.Always),
                             true);
    }

    private static ZipOutputTest
        writeBigStoredEntryModeNever(final boolean knownSize) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Never);
                try {
                    final byte[] buf = new byte[ONE_MILLION];
                    final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                    if (knownSize) {
                        zae.setSize(FIVE_BILLION);
                        zae.setCrc(0x5c316f50L);
                    }
                    zae.setMethod(ZipEntry.STORED);
                    zos.putArchiveEntry(zae);
                    for (int j = 0; j < FIVE_BILLION / 1000 / 1000; j++) {
                        zos.write(buf);
                    }
                    zos.closeArchiveEntry();
                    fail("expected a Zip64RequiredException");
                } catch (final Zip64RequiredException ex) {
                    assertTrue(ex.getMessage().startsWith("0's size"));
                }
            }
        };
    }

    @Test public void writeBigStoredEntryToStreamModeNever() throws Throwable {
        withTemporaryArchive("writeBigStoredEntryToStreamModeNever",
                             writeBigStoredEntryModeNever(true),
                             false);
    }

    @Test public void writeBigStoredEntryKnownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeBigStoredEntryKnownSizeToFileModeNever",
                             writeBigStoredEntryModeNever(true),
                             true);
    }

    @Test public void writeBigStoredEntryUnnownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeBigStoredEntryUnknownSizeToFileModeNever",
                             writeBigStoredEntryModeNever(false),
                             true);
    }

    /*
     * One entry of length 5 billion bytes, written with
     * compression to a stream.
     *
     * Compression + Stream => sizes are set to 0 in LFH and ZIP64
     * entry, real values are inside the data descriptor.
     *
     * Creates a temporary archive of approx 4MB in size
     */
    private static ZipOutputTest
        writeBigDeflatedEntryToStream(final boolean knownSize,
                                      final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f,
                             final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(FIVE_BILLION);
                }
                zae.setMethod(ZipEntry.DEFLATED);
                zos.putArchiveEntry(zae);
                for (int j = 0; j < FIVE_BILLION / 1000 / 1000; j++) {
                    zos.write(buf);
                }
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    final long cfhPos = a.getFilePointer();
                    // grab first entry, verify
                    // sizes are 0xFFFFFFFF and
                    // it has a ZIP64 extended
                    // information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS + Data Descriptor)
                            8, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] rest = new byte[26];
                    a.readFully(rest);
                    assertArrayEquals("CDH rest", new byte[] {
                            // CRC
                            (byte) 0x50, (byte) 0x6F, (byte) 0x31, (byte) 0x5c,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            (byte) (mode == Zip64Mode.Always? 32 : 20), 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                    }, rest);
                    byte[] offset = new byte[4];
                    a.readFully(offset);
                    if (mode == Zip64Mode.Always) {
                        assertArrayEquals("offset", new byte[] {
                                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            }, offset);
                    } else {
                        assertArrayEquals("offset", new byte[] {
                                0, 0, 0, 0,
                            }, offset);
                    }
                    assertEquals('0', a.read());
                    byte[] extra = new byte[12];
                    a.readFully(extra);
                    // 5e9 == 0x12A05F200
                    assertArrayEquals("CDH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            (byte) (mode == Zip64Mode.Always? 28 : 16), 0,
                            // original size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                    }, extra);
                    if (mode == Zip64Mode.Always) {
                        // skip compressed size
                        a.skipBytes(8);
                        offset = new byte[8];
                        a.readFully(offset);
                        assertArrayEquals("extra offset", new byte[] {
                                0, 0, 0, 0, 0, 0, 0, 0,
                            }, offset);
                    }

                    // validate data descriptor
                    a.seek(cfhPos - 24);
                    byte[] dd = new byte[8];
                    a.readFully(dd);
                    assertArrayEquals("DD", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 7, 8,
                            // CRC
                            (byte) 0x50, (byte) 0x6F, (byte) 0x31, (byte) 0x5c,
                    }, dd);
                    // skip compressed size
                    a.skipBytes(8);
                    dd = new byte[8];
                    a.readFully(dd);
                    assertArrayEquals("DD sizes", new byte[] {
                            // original size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                    }, dd);

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS + Data Descriptor)
                            8, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    assertArrayEquals("LFH rest", new byte[] {
                            // CRC
                            0, 0, 0, 0,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            20, 0,
                            // file name
                            (byte) '0'
                    }, rest);
                    extra = new byte[20];
                    a.readFully(extra);
                    assertArrayEquals("LFH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            16, 0,
                            // original size
                            0, 0, 0, 0,
                            0, 0, 0, 0,
                            // compressed size
                            0, 0, 0, 0,
                            0, 0, 0, 0,
                    }, extra);
                }
            }
        };
    }

    @Test public void writeBigDeflatedEntryKnownSizeToStream()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryKnownSizeToStream",
                             writeBigDeflatedEntryToStream(true,
                                                           Zip64Mode.AsNeeded),
                             false);
    }

    @Test public void writeBigDeflatedEntryKnownSizeToStreamModeAlways()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryKnownSizeToStreamModeAlways",
                             writeBigDeflatedEntryToStream(true,
                                                           Zip64Mode.Always),
                             false);
    }

    @Test public void writeBigDeflatedEntryUnknownSizeToStreamModeAlways()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryUnknownSizeToStreamModeAlways",
                             writeBigDeflatedEntryToStream(false,
                                                           Zip64Mode.Always),
                             false);
    }

    private static ZipOutputTest
        writeBigDeflatedEntryUnknownSizeToStream(final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                try {
                    if (mode != Zip64Mode.AsNeeded) {
                        zos.setUseZip64(mode);
                    }
                    final byte[] buf = new byte[ONE_MILLION];
                    final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                    zae.setMethod(ZipEntry.DEFLATED);
                    zos.putArchiveEntry(zae);
                    for (int j = 0; j < FIVE_BILLION / 1000 / 1000; j++) {
                        zos.write(buf);
                    }
                    zos.closeArchiveEntry();
                    fail("expected a Zip64RequiredException");
                } catch (final Zip64RequiredException ex) {
                    assertTrue(ex.getMessage().startsWith("0's size"));
                }
            }
        };
    }

    @Test public void writeBigDeflatedEntryUnknownSizeToStream()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryUnknownSizeToStream",
                             writeBigDeflatedEntryUnknownSizeToStream(Zip64Mode
                                                                      .AsNeeded),
                             false);
    }

    @Test public void writeBigDeflatedEntryUnknownSizeToStreamModeNever()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryUnknownSizeToStreamModeNever",
                             writeBigDeflatedEntryUnknownSizeToStream(Zip64Mode
                                                                      .Never),
                             false);
    }

    private static ZipOutputTest
        writeBigDeflatedEntryToFile(final boolean knownSize) {
        return writeBigDeflatedEntryToFile(knownSize, Zip64Mode.AsNeeded);
    }

    /*
     * One entry of length 5 billion bytes, written with
     * compression to a file.
     *
     * Writing to a file => sizes are stored directly inside the LFH.
     * No Data Descriptor at all.
     *
     * Creates a temporary archive of approx 4MB in size
     */
    private static ZipOutputTest
        writeBigDeflatedEntryToFile(final boolean knownSize,
                                    final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(FIVE_BILLION);
                }
                zae.setMethod(ZipEntry.DEFLATED);
                zos.putArchiveEntry(zae);
                for (int j = 0;
                     j < FIVE_BILLION / 1000 / 1000;
                     j++) {
                    zos.write(buf);
                }
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    // grab first entry, verify
                    // sizes are 0xFFFFFFFF and
                    // it has a ZIP64 extended
                    // information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS + *no* Data Descriptor)
                            0, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] rest = new byte[26];
                    a.readFully(rest);
                    assertArrayEquals("CDH rest", new byte[] {
                            // CRC
                            (byte) 0x50, (byte) 0x6F, (byte) 0x31, (byte) 0x5c,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            (byte) (mode == Zip64Mode.Always? 32 : 20), 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                    }, rest);
                    byte[] offset = new byte[4];
                    a.readFully(offset);
                    if (mode == Zip64Mode.Always) {
                        assertArrayEquals("offset", new byte[] {
                                (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            }, offset);
                    } else {
                        assertArrayEquals("offset", new byte[] {
                                0, 0, 0, 0,
                            }, offset);
                    }
                    assertEquals('0', a.read());
                    byte[] extra = new byte[12];
                    a.readFully(extra);
                    // 5e9 == 0x12A05F200
                    assertArrayEquals("CDH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            (byte) (mode == Zip64Mode.Always? 28 : 16), 0,
                            // original size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                    }, extra);
                    if (mode == Zip64Mode.Always) {
                        // skip compressed size
                        a.skipBytes(8);
                        offset = new byte[8];
                        a.readFully(offset);
                        assertArrayEquals("extra offset", new byte[] {
                                0, 0, 0, 0, 0, 0, 0, 0,
                            }, offset);
                    }

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit, no DD)
                            0, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    assertArrayEquals(new byte[] {
                            // CRC
                            (byte) 0x50, (byte) 0x6F, (byte) 0x31, (byte) 0x5c,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            20, 0,
                            // file name
                            (byte) '0'
                    }, rest);
                    extra = new byte[12];
                    a.readFully(extra);
                    assertArrayEquals(new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            16, 0,
                            // original size
                            0, (byte) 0xF2, 5, (byte) 0x2A,
                            1, 0, 0, 0,
                            // skip compressed size
                    }, extra);
                }
            }
        };
    }

    @Test public void writeBigDeflatedEntryKnownSizeToFile()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryKnownSizeToFile",
                             writeBigDeflatedEntryToFile(true),
                             true);
    }

    @Test public void writeBigDeflatedEntryUnknownSizeToFile()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryUnknownSizeToFile",
                             writeBigDeflatedEntryToFile(false),
                             true);
    }

    @Test public void writeBigDeflatedEntryKnownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryKnownSizeToFileModeAlways",
                             writeBigDeflatedEntryToFile(true, Zip64Mode.Always),
                             true);
    }

    @Test public void writeBigDeflatedEntryUnknownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryUnknownSizeToFileModeAlways",
                             writeBigDeflatedEntryToFile(false,
                                                         Zip64Mode.Always),
                             true);
    }

    @Test public void writeBigDeflatedEntryKnownSizeToStreamModeNever()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryKnownSizeToStreamModeNever",
                             new ZipOutputTest() {
                                 @Override
                                public void test(final File f,
                                                  final ZipArchiveOutputStream zos)
                                     throws IOException {
                                     zos.setUseZip64(Zip64Mode.Never);
                                     try {
                                         final ZipArchiveEntry zae =
                                             new ZipArchiveEntry("0");
                                         zae.setSize(FIVE_BILLION);
                                         zae.setMethod(ZipEntry.DEFLATED);
                                         zos.putArchiveEntry(zae);
                                         fail("expected a"
                                              + " Zip64RequiredException");
                                     } catch (final Zip64RequiredException ex) {
                                         assertTrue(ex.getMessage()
                                                    .startsWith("0's size"));
                                     }
                                 }
                             },
                             false);
    }

    /*
     * One entry of length 5 billion bytes, written with
     * compression to a file.
     *
     * Writing to a file => sizes are stored directly inside the LFH.
     * No Data Descriptor at all.
     *
     * Creates a temporary archive of approx 4MB in size
     */
    private static ZipOutputTest
        writeBigDeflatedEntryToFileModeNever(final boolean knownSize) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Never);
                try {
                    final byte[] buf = new byte[ONE_MILLION];
                    final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                    if (knownSize) {
                        zae.setSize(FIVE_BILLION);
                    }
                    zae.setMethod(ZipEntry.DEFLATED);
                    zos.putArchiveEntry(zae);
                    for (int j = 0;
                         j < FIVE_BILLION / 1000 / 1000;
                         j++) {
                        zos.write(buf);
                    }
                    zos.closeArchiveEntry();
                    fail("expected a Zip64RequiredException");
                } catch (final Zip64RequiredException ex) {
                    assertTrue(ex.getMessage().startsWith("0's size"));
                }
            }
        };
    }

    @Test public void writeBigDeflatedEntryKnownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryKnownSizeToFileModeNever",
                             writeBigDeflatedEntryToFileModeNever(true),
                             true);
    }

    @Test public void writeBigDeflatedEntryUnknownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeBigDeflatedEntryUnknownSizeToFileModeNever",
                             writeBigDeflatedEntryToFileModeNever(false),
                             true);
    }

    private static ZipOutputTest writeSmallStoredEntry(final boolean knownSize) {
        return writeSmallStoredEntry(knownSize, Zip64Mode.AsNeeded);
    }

    /*
     * One entry of length 1 million bytes, written without compression.
     *
     * No Compression => sizes are stored directly inside the LFH.  No
     * Data Descriptor at all.  Shouldn't contain any ZIP64 extra
     * field if size was known.
     *
     * Creates a temporary archive of approx 1MB in size
     */
    private static ZipOutputTest writeSmallStoredEntry(final boolean knownSize,
                                                       final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(ONE_MILLION);
                    zae.setCrc(0x1279CB9EL);
                }
                zae.setMethod(ZipEntry.STORED);
                zos.putArchiveEntry(zae);
                zos.write(buf);
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    // grab first CF entry, verify sizes are 1e6 and it
                    // has no ZIP64 extended information extra field
                    // at all
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            20, 0,
                            // version needed to extract
                            10, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] rest = new byte[31];
                    a.readFully(rest);
                    // 1e6 == 0xF4240
                    assertArrayEquals("CDH rest", new byte[] {
                            // CRC
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                            // Compressed Size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            // Original Size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            // file name length
                            1, 0,
                            // extra field length
                            0, 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            0, 0, 0, 0,
                            // file name
                            (byte) '0'
                    }, rest);

                    // and now validate local file header: this one
                    // has a ZIP64 extra field if and only if size was
                    // unknown and mode was not Never or the mode was
                    // Always (regardless of size)
                    final boolean hasExtra = mode == Zip64Mode.Always
                            || (mode == Zip64Mode.AsNeeded && !knownSize);
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            10, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    // 1e6 == 0xF4240
                    assertArrayEquals("LFH rest", new byte[] {
                            // CRC
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                            // Compressed Size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            // Original Size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            // file name length
                            1, 0,
                            // extra field length
                            (byte) (!hasExtra ? 0 : 20), 0,
                            // file name
                            (byte) '0'
                    }, rest);
                    if (hasExtra) {
                        final byte[] extra = new byte[20];
                        a.readFully(extra);
                        assertArrayEquals("ZIP64 extra field", new byte[] {
                                // Header-ID
                                1, 0,
                                // size of extra
                                16, 0,
                                // original size
                                (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                                0, 0, 0, 0,
                                // compressed size
                                (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                                0, 0, 0, 0,
                        }, extra);
                    }
                }
            }
        };
    }

    @Test public void writeSmallStoredEntryToStream() throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryToStream",
                             writeSmallStoredEntry(true),
                             false);
    }

    @Test public void writeSmallStoredEntryKnownSizeToFile() throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryKnownSizeToFile",
                             writeSmallStoredEntry(true),
                             true);
    }

    @Test public void writeSmallStoredEntryUnnownSizeToFile() throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryUnknownSizeToFile",
                             writeSmallStoredEntry(false),
                             true);
    }

    @Test public void writeSmallStoredEntryToStreamModeNever() throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryToStreamModeNever",
                             writeSmallStoredEntry(true, Zip64Mode.Never),
                             false);
    }

    @Test public void writeSmallStoredEntryKnownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryKnownSizeToFileModeNever",
                             writeSmallStoredEntry(true, Zip64Mode.Never),
                             true);
    }

    @Test public void writeSmallStoredEntryUnnownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryUnknownSizeToFileModeNever",
                             writeSmallStoredEntry(false, Zip64Mode.Never),
                             true);
    }

    /*
     * One entry of length 1 million bytes, written without compression.
     *
     * No Compression => sizes are stored directly inside the LFH.  No
     * Data Descriptor at all. Contains ZIP64 extra fields because
     * mode is Always
     *
     * Creates a temporary archive of approx 1MB in size
     */
    private static ZipOutputTest
        writeSmallStoredEntryModeAlways(final boolean knownSize) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Always);
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(ONE_MILLION);
                    zae.setCrc(0x1279CB9EL);
                }
                zae.setMethod(ZipEntry.STORED);
                zos.putArchiveEntry(zae);
                zos.write(buf);
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    // grab first CF entry, verify sizes are 1e6 and it
                    // has an empty ZIP64 extended information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] rest = new byte[31];
                    a.readFully(rest);
                    // 1e6 == 0xF4240
                    assertArrayEquals("CDH rest", new byte[] {
                            // CRC
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            32, 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name
                            (byte) '0'
                    }, rest);

                    byte[] extra = new byte[28];
                    a.readFully(extra);
                    assertArrayEquals("CDH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            28, 0,
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                            // compressed size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                            0, 0, 0, 0, 0, 0, 0, 0,
                    }, extra);

                    // and now validate local file header: this one
                    // has a ZIP64 extra field as the mode was
                    // Always
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit)
                            0, 8,
                            // method
                            0, 0
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    // 1e6 == 0xF4240
                    assertArrayEquals("LFH rest", new byte[] {
                            // CRC
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            20, 0,
                            // file name
                            (byte) '0'
                    }, rest);

                    extra = new byte[20];
                    a.readFully(extra);
                    assertArrayEquals("LFH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            16, 0,
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                            // compressed size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                    }, extra);
                }
            }
        };
    }

    @Test public void writeSmallStoredEntryToStreamModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryToStreamModeAlways",
                             writeSmallStoredEntryModeAlways(true),
                             false);
    }

    @Test public void writeSmallStoredEntryKnownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryKnownSizeToFileModeAlways",
                             writeSmallStoredEntryModeAlways(true),
                             true);
    }

    @Test public void writeSmallStoredEntryUnnownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallStoredEntryUnknownSizeToFileModeAlways",
                             writeSmallStoredEntryModeAlways(false),
                             true);
    }

    /*
     * One entry of length 1 million bytes, written with compression
     * to a stream.
     *
     * Compression + Stream => sizes are set to 0 in LFH, real values
     * are inside the data descriptor.  No ZIP64 extra field at all.
     */
    private static ZipOutputTest
        writeSmallDeflatedEntryToStream(final boolean knownSize,
                                        final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(ONE_MILLION);
                }
                zae.setMethod(ZipEntry.DEFLATED);
                zos.putArchiveEntry(zae);
                zos.write(buf);
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    final long cfhPos = a.getFilePointer();
                    // grab first entry, verify sizes are not
                    // 0xFFFFFFF and it has no ZIP64 extended
                    // information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            20, 0,
                            // version needed to extract
                            20, 0,
                            // GPB (EFS + Data Descriptor)
                            8, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    final byte[] crc = new byte[4];
                    a.readFully(crc);
                    assertArrayEquals(new byte[] {
                            (byte) 0x9E, (byte) 0xCB,
                            (byte) 0x79, (byte) 0x12,
                    }, crc);
                    // skip compressed size
                    a.skipBytes(4);
                    byte[] rest = new byte[23];
                    a.readFully(rest);
                    assertArrayEquals(new byte[] {
                            // Original Size
                            (byte) 0x40, (byte) 0x42,
                            (byte) 0x0F, 0,
                            // file name length
                            1, 0,
                            // extra field length
                            0, 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            0, 0, 0, 0,
                            // file name
                            (byte) '0'
                    }, rest);

                    // validate data descriptor
                    a.seek(cfhPos - 16);
                    byte[] dd = new byte[8];
                    a.readFully(dd);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 7, 8,
                            // CRC
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                    }, dd);
                    // skip uncompressed size
                    a.skipBytes(4);
                    dd = new byte[4];
                    a.readFully(dd);
                    assertArrayEquals(new byte[] {
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                    }, dd);

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            20, 0,
                            // GPB (EFS + Data Descriptor)
                            8, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    assertArrayEquals(new byte[] {
                            // CRC
                            0, 0, 0, 0,
                            // Compressed Size
                            0, 0, 0, 0,
                            // Original Size
                            0, 0, 0, 0,
                            // file name length
                            1, 0,
                            // extra field length
                            0, 0,
                            // file name
                            (byte) '0'
                    }, rest);
                }
            }
        };

    }

    @Test public void writeSmallDeflatedEntryKnownSizeToStream()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryKnownSizeToStream",
                             writeSmallDeflatedEntryToStream(true,
                                                             Zip64Mode.AsNeeded),
                             false);
    }

    @Test public void writeSmallDeflatedEntryKnownSizeToStreamModeNever()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryKnownSizeToStreamModeNever",
                             writeSmallDeflatedEntryToStream(true,
                                                             Zip64Mode.Never),
                             false);
    }

    @Test public void writeSmallDeflatedEntryUnknownSizeToStream()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryUnknownSizeToStream",
                             writeSmallDeflatedEntryToStream(false,
                                                             Zip64Mode.AsNeeded),
                             false);
    }

    @Test public void writeSmallDeflatedEntryUnknownSizeToStreamModeNever()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryUnknownSizeToStreamModeNever",
                             writeSmallDeflatedEntryToStream(false,
                                                             Zip64Mode.Never),
                             false);
    }

    /*
     * One entry of length 1 million bytes, written with compression
     * to a stream.
     *
     * Compression + Stream => sizes are set to 0 in LFH, real values
     * are inside the data descriptor.  ZIP64 extra field as mode is Always.
     */
    private static ZipOutputTest
        writeSmallDeflatedEntryToStreamModeAlways(final boolean knownSize) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Always);
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(ONE_MILLION);
                }
                zae.setMethod(ZipEntry.DEFLATED);
                zos.putArchiveEntry(zae);
                zos.write(buf);
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    final long cfhPos = a.getFilePointer();
                    // grab first entry, verify sizes are not
                    // 0xFFFFFFF and it has an empty ZIP64 extended
                    // information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS + Data Descriptor)
                            8, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    final byte[] crc = new byte[4];
                    a.readFully(crc);
                    assertArrayEquals(new byte[] {
                            (byte) 0x9E, (byte) 0xCB,
                            (byte) 0x79, (byte) 0x12,
                    }, crc);
                    // skip compressed size
                    a.skipBytes(4);
                    byte[] rest = new byte[23];
                    a.readFully(rest);
                    assertArrayEquals("CDH rest", new byte[] {
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            32, 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name
                            (byte) '0'
                    }, rest);
                    byte[] extra = new byte[12];
                    a.readFully(extra);
                    assertArrayEquals("CDH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            28, 0,
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                    }, extra);
                    // skip compressed size
                    a.skipBytes(8);
                    byte[] offset = new byte[8];
                    a.readFully(offset);
                    assertArrayEquals("extra offset", new byte[] {
                            0, 0, 0, 0, 0, 0, 0, 0,
                        }, offset);

                    // validate data descriptor
                    a.seek(cfhPos - 24);
                    byte[] dd = new byte[8];
                    a.readFully(dd);
                    assertArrayEquals("DD", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 7, 8,
                            // CRC
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                    }, dd);
                    // skip compressed size
                    a.skipBytes(8);
                    dd = new byte[8];
                    a.readFully(dd);
                    assertArrayEquals("DD size", new byte[] {
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0
                    }, dd);

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS + Data Descriptor)
                            8, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    rest = new byte[17];
                    a.readFully(rest);
                    assertArrayEquals("LFH rest", new byte[] {
                            // CRC
                            0, 0, 0, 0,
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            20, 0,
                            // file name
                            (byte) '0'
                    }, rest);

                    extra = new byte[20];
                    a.readFully(extra);
                    assertArrayEquals("LFH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            16, 0,
                            // original size
                            0, 0, 0, 0,
                            0, 0, 0, 0,
                            // compressed size
                            0, 0, 0, 0,
                            0, 0, 0, 0,
                    }, extra);
                }
            }
        };

    }

    @Test public void writeSmallDeflatedEntryKnownSizeToStreamModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryKnownSizeToStreamModeAlways",
                             writeSmallDeflatedEntryToStreamModeAlways(true),
                             false);
    }

    @Test public void writeSmallDeflatedEntryUnknownSizeToStreamModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryUnknownSizeToStreamModeAlways",
                             writeSmallDeflatedEntryToStreamModeAlways(false),
                             false);
    }

    private static ZipOutputTest writeSmallDeflatedEntryToFile(final boolean knownSize) {
        return writeSmallDeflatedEntryToFile(knownSize, Zip64Mode.AsNeeded);
    }

    /*
     * One entry of length 1 million bytes, written with compression
     * to a file.
     *
     * Writing to a file => sizes are stored directly inside the LFH.
     * No Data Descriptor at all.  Shouldn't contain any ZIP64 extra
     * field if size was known.
     */
    private static ZipOutputTest
        writeSmallDeflatedEntryToFile(final boolean knownSize,
                                      final Zip64Mode mode) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                if (mode != Zip64Mode.AsNeeded) {
                    zos.setUseZip64(mode);
                }
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(ONE_MILLION);
                }
                zae.setMethod(ZipEntry.DEFLATED);
                zos.putArchiveEntry(zae);
                zos.write(buf);
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    // grab first CD entry, verify sizes are not
                    // 0xFFFFFFFF and it has a no ZIP64 extended
                    // information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            20, 0,
                            // version needed to extract
                            20, 0,
                            // GPB (EFS + *no* Data Descriptor)
                            0, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] crc = new byte[4];
                    a.readFully(crc);
                    assertArrayEquals(new byte[] {
                            (byte) 0x9E, (byte) 0xCB,
                            (byte) 0x79, (byte) 0x12,
                    }, crc);
                    // skip compressed size
                    a.skipBytes(4);
                    byte[] rest = new byte[23];
                    a.readFully(rest);
                    assertArrayEquals(new byte[] {
                            // Original Size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            // file name length
                            1, 0,
                            // extra field length
                            0, 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            0, 0, 0, 0,
                            // file name
                            (byte) '0'
                    }, rest);

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals(new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            20, 0,
                            // GPB (EFS bit, no DD)
                            0, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    crc = new byte[4];
                    a.readFully(crc);
                    assertArrayEquals(new byte[] {
                            (byte) 0x9E, (byte) 0xCB,
                            (byte) 0x79, (byte) 0x12,
                    }, crc);
                    // skip compressed size
                    a.skipBytes(4);
                    rest = new byte[9];
                    a.readFully(rest);

                    final boolean hasExtra =
                            mode == Zip64Mode.AsNeeded && !knownSize;

                    assertArrayEquals(new byte[] {
                            // Original Size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            // file name length
                            1, 0,
                            // extra field length
                            (byte) (!hasExtra ? 0 : 20), 0,
                            // file name
                            (byte) '0'
                    }, rest);
                    if (hasExtra) {
                        final byte[] extra = new byte[12];
                        a.readFully(extra);
                        assertArrayEquals(new byte[] {
                                // Header-ID
                                1, 0,
                                // size of extra
                                16, 0,
                                // original size
                                (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                                0, 0, 0, 0,
                                // don't know the
                                // compressed size,
                                // don't want to
                                // hard-code it
                        }, extra);
                    }
                }
            }
        };
    }

    @Test public void writeSmallDeflatedEntryKnownSizeToFile()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryKnownSizeToFile",
                             writeSmallDeflatedEntryToFile(true),
                             true);
    }

    @Test public void writeSmallDeflatedEntryUnknownSizeToFile()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryUnknownSizeToFile",
                             writeSmallDeflatedEntryToFile(false),
                             true);
    }

    @Test public void writeSmallDeflatedEntryKnownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryKnownSizeToFileModeNever",
                             writeSmallDeflatedEntryToFile(true,
                                                           Zip64Mode.Never),
                             true);
    }

    @Test public void writeSmallDeflatedEntryUnknownSizeToFileModeNever()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryUnknownSizeToFileModeNever",
                             writeSmallDeflatedEntryToFile(false,
                                                           Zip64Mode.Never),
                             true);
    }

    /*
     * One entry of length 1 million bytes, written with compression
     * to a file.
     *
     * Writing to a file => sizes are stored directly inside the LFH.
     * No Data Descriptor at all.  Must contain ZIP64 extra field as
     * mode is Always.
     */
    private static ZipOutputTest
        writeSmallDeflatedEntryToFileModeAlways(final boolean knownSize) {
        return new ZipOutputTest() {
            @Override
            public void test(final File f, final ZipArchiveOutputStream zos)
                throws IOException {
                zos.setUseZip64(Zip64Mode.Always);
                final byte[] buf = new byte[ONE_MILLION];
                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                if (knownSize) {
                    zae.setSize(ONE_MILLION);
                }
                zae.setMethod(ZipEntry.DEFLATED);
                zos.putArchiveEntry(zae);
                zos.write(buf);
                zos.closeArchiveEntry();
                zos.close();

                try (RandomAccessFile a = new RandomAccessFile(f, "r")) {
                    getLengthAndPositionAtCentralDirectory(a);

                    // grab first CD entry, verify sizes are not
                    // 0xFFFFFFFF and it has a an empty ZIP64 extended
                    // information extra field
                    byte[] header = new byte[12];
                    a.readFully(header);
                    assertArrayEquals("CDH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 1, 2,
                            // version made by
                            45, 0,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS + *no* Data Descriptor)
                            0, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    byte[] crc = new byte[4];
                    a.readFully(crc);
                    assertArrayEquals("CDH CRC", new byte[] {
                            (byte) 0x9E, (byte) 0xCB, (byte) 0x79, (byte) 0x12,
                    }, crc);
                    // skip compressed size
                    a.skipBytes(4);
                    byte[] rest = new byte[23];
                    a.readFully(rest);
                    assertArrayEquals("CDH rest", new byte[] {
                            // Original Size
                            (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
                            // file name length
                            1, 0,
                            // extra field length
                            32, 0,
                            // comment length
                            0, 0,
                            // disk number
                            0, 0,
                            // attributes
                            0, 0,
                            0, 0, 0, 0,
                            // offset
                            (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
                            // file name
                            (byte) '0'
                    }, rest);
                    byte[] extra = new byte[12];
                    a.readFully(extra);
                    assertArrayEquals("CDH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            28, 0,
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                    }, extra);
                    // skip compressed size
                    a.skipBytes(8);
                    byte[] offset = new byte[8];
                    a.readFully(offset);
                    assertArrayEquals("extra offset", new byte[] {
                            0, 0, 0, 0, 0, 0, 0, 0,
                        }, offset);

                    // and now validate local file header
                    a.seek(0);
                    header = new byte[10];
                    a.readFully(header);
                    assertArrayEquals("LFH start", new byte[] {
                            // sig
                            (byte) 0x50, (byte) 0x4b, 3, 4,
                            // version needed to extract
                            45, 0,
                            // GPB (EFS bit, no DD)
                            0, 8,
                            // method
                            8, 0,
                    }, header);
                    // ignore timestamp
                    a.skipBytes(4);
                    crc = new byte[4];
                    a.readFully(crc);
                    assertArrayEquals("LFH CRC", new byte[] {
                            (byte) 0x9E, (byte) 0xCB,
                            (byte) 0x79, (byte) 0x12,
                    }, crc);
                    rest = new byte[13];
                    a.readFully(rest);

                    assertArrayEquals("LFH rest", new byte[] {
                            // Compressed Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // Original Size
                            (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
                            // file name length
                            1, 0,
                            // extra field length
                            20, 0,
                            // file name
                            (byte) '0'
                    }, rest);

                    extra = new byte[12];
                    a.readFully(extra);
                    assertArrayEquals("LFH extra", new byte[] {
                            // Header-ID
                            1, 0,
                            // size of extra
                            16, 0,
                            // original size
                            (byte) 0x40, (byte) 0x42, (byte) 0x0F, 0,
                            0, 0, 0, 0,
                            // don't know the
                            // compressed size,
                            // don't want to
                            // hard-code it
                    }, extra);
                }
            }
        };
    }

    @Test public void writeSmallDeflatedEntryKnownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryKnownSizeToFileModeAlways",
                             writeSmallDeflatedEntryToFileModeAlways(true),
                             true);
    }

    @Test public void writeSmallDeflatedEntryUnknownSizeToFileModeAlways()
        throws Throwable {
        withTemporaryArchive("writeSmallDeflatedEntryUnknownSizeToFileModeAlways",
                             writeSmallDeflatedEntryToFileModeAlways(false),
                             true);
    }

    @Test
    public void write3EntriesCreatingManySplitArchiveFileModeNever()
            throws Throwable {
        withTemporaryArchive("write3EntriesCreatingManySplitArchiveFileModeNever",
                write3EntriesCreatingBigArchiveModeNever,
                true, 65536L);
    }

    @Test
    public void write3EntriesCreatingManySplitArchiveFileModeAlways()
            throws Throwable {
        // about 76,293 zip split segments will be created
        withTemporaryArchive("write3EntriesCreatingManySplitArchiveFileModeAlways",
                write3EntriesCreatingBigArchive(Zip64Mode.Always, true),
                true, 65536L);
    }

    static interface ZipOutputTest {
        void test(File f, ZipArchiveOutputStream zos) throws IOException;
    }

    private static void withTemporaryArchive(final String testName,
                                             final ZipOutputTest test,
                                             final boolean useRandomAccessFile) throws Throwable {
        withTemporaryArchive(testName, test, useRandomAccessFile, null);
    }

    private static void withTemporaryArchive(final String testName,
                                             final ZipOutputTest test,
                                             final boolean useRandomAccessFile,
                                             final Long splitSize)
        throws Throwable {
        File f = getTempFile(testName);
        File dir = null;
        if (splitSize != null) {
            dir = Files.createTempDirectory("commons-compress-" + testName).toFile();
            dir.deleteOnExit();

            f = new File(dir, "commons-compress-" + testName + ".zip");
        }
        BufferedOutputStream os = null;
        ZipArchiveOutputStream zos = useRandomAccessFile
            ? new ZipArchiveOutputStream(f)
            : new ZipArchiveOutputStream(os = new BufferedOutputStream(new FileOutputStream(f)));
        if (splitSize != null) {
            zos = new ZipArchiveOutputStream(f, splitSize);
        }

        try {
            test.test(f, zos);
        } catch (final IOException ex) {
            System.err.println("Failed to write archive because of: "
                               + ex.getMessage()
                               + " - likely not enough disk space.");
            assumeTrue(false);
        } finally {
            try {
                zos.destroy();
            } finally {
                try {
                    if (os != null) {
                        os.close();
                    }
                    AbstractTestCase.tryHardToDelete(f);
                } finally {
                    if (dir != null) {
                        AbstractTestCase.rmdir(dir);
                    }
                }
            }
        }
    }

    private static File get5GBZerosFile() throws Throwable {
        return getFile("5GB_of_Zeros.zip");
    }

    private static File get5GBZerosFileGeneratedBy7ZIP() throws Throwable {
        return getFile("5GB_of_Zeros_7ZIP.zip");
    }

    private static File get5GBZerosFileGeneratedByJava7Jar() throws Throwable {
        return getFile("5GB_of_Zeros_jar.zip");
    }

    private static File get5GBZerosFileGeneratedByWinZIP() throws Throwable {
        return getFile("5GB_of_Zeros_WinZip.zip");
    }

    private static File get5GBZerosFileGeneratedByPKZip() throws Throwable {
        return getFile("5GB_of_Zeros_PKZip.zip");
    }

    private static File get100KFileFile() throws Throwable {
        return getFile("100k_Files.zip");
    }

    private static File get100KFileFileGeneratedBy7ZIP() throws Throwable {
        return getFile("100k_Files_7ZIP.zip");
    }

    private static File get100KFileFileGeneratedByWinCF() throws Throwable {
        return getFile("100k_Files_WindowsCompressedFolders.zip");
    }

    private static File get100KFileFileGeneratedByJava7Jar() throws Throwable {
        return getFile("100k_Files_jar.zip");
    }

    private static File get100KFileFileGeneratedByWinZIP() throws Throwable {
        return getFile("100k_Files_WinZIP.zip");
    }

    private static File get100KFileFileGeneratedByPKZip() throws Throwable {
        return getFile("100k_Files_PKZip.zip");
    }

    private static File getTempFile(final String testName) throws Throwable {
        final File f = File.createTempFile("commons-compress-" + testName, ".zip");
        f.deleteOnExit();
        return f;
    }

    private static void read5GBOfZerosImpl(final File f, final String expectedName)
        throws IOException {
        final FileInputStream fin = new FileInputStream(f);
        ZipArchiveInputStream zin = null;
        try {
            zin = new ZipArchiveInputStream(fin);
            ZipArchiveEntry zae = zin.getNextZipEntry();
            while (zae.isDirectory()) {
                zae = zin.getNextZipEntry();
            }
            assertEquals(expectedName, zae.getName());
            final byte[] buf = new byte[1024 * 1024];
            long read = 0;
            final Random r = new Random(System.currentTimeMillis());
            int readNow;
            while ((readNow = zin.read(buf, 0, buf.length)) > 0) {
                // testing all bytes for a value of 0 is going to take
                // too long, just pick a few ones randomly
                for (int i = 0; i < 1024; i++) {
                    final int idx = r.nextInt(readNow);
                    assertEquals("testing byte " + (read + idx), 0, buf[idx]);
                }
                read += readNow;
            }
            assertEquals(FIVE_BILLION, read);
            assertNull(zin.getNextZipEntry());
            assertEquals(FIVE_BILLION, zae.getSize());
        } finally {
            if (zin != null) {
                zin.close();
            }
            fin.close(); // fin cannot be null here
        }
    }

    private static void read5GBOfZerosUsingZipFileImpl(final File f,
                                                       final String expectedName)
        throws IOException {
        ZipFile zf = null;
        try {
            zf = new ZipFile(f);
            final Enumeration<ZipArchiveEntry> e = zf.getEntries();
            assertTrue(e.hasMoreElements());
            ZipArchiveEntry zae = e.nextElement();
            while (zae.isDirectory()) {
                zae = e.nextElement();
            }
            assertEquals(expectedName, zae.getName());
            assertEquals(FIVE_BILLION, zae.getSize());
            final byte[] buf = new byte[1024 * 1024];
            long read = 0;
            final Random r = new Random(System.currentTimeMillis());
            int readNow;
            try (InputStream zin = zf.getInputStream(zae)) {
                while ((readNow = zin.read(buf, 0, buf.length)) > 0) {
                    // testing all bytes for a value of 0 is going to take
                    // too long, just pick a few ones randomly
                    for (int i = 0; i < 1024; i++) {
                        final int idx = r.nextInt(readNow);
                        assertEquals("testing byte " + (read + idx), 0, buf[idx]);
                    }
                    read += readNow;
                }
            }
            assertEquals(FIVE_BILLION, read);
            assertFalse(e.hasMoreElements());
        } finally {
            ZipFile.closeQuietly(zf);
        }
    }

    private static void read100KFilesImpl(final File f) throws IOException {
        final FileInputStream fin = new FileInputStream(f);
        ZipArchiveInputStream zin = null;
        try {
            zin = new ZipArchiveInputStream(fin);
            int files = 0;
            ZipArchiveEntry zae = null;
            while ((zae = zin.getNextZipEntry()) != null) {
                if (!zae.isDirectory()) {
                    files++;
                    assertEquals(0, zae.getSize());
                }
            }
            assertEquals(ONE_HUNDRED_THOUSAND, files);
        } finally {
            if (zin != null) {
                zin.close();
            }
            fin.close();
        }
    }

    private static void read100KFilesUsingZipFileImpl(final File f)
        throws IOException {
        ZipFile zf = null;
        try {
            zf = new ZipFile(f);
            int files = 0;
            for (final Enumeration<ZipArchiveEntry> e = zf.getEntries(); e.hasMoreElements(); ) {
                final ZipArchiveEntry zae = e.nextElement();
                if (!zae.isDirectory()) {
                    files++;
                    assertEquals(0, zae.getSize());
                }
            }
            assertEquals(ONE_HUNDRED_THOUSAND, files);
        } finally {
            ZipFile.closeQuietly(zf);
        }
    }

    private static long getLengthAndPositionAtCentralDirectory(final RandomAccessFile a)
        throws IOException {
        final long end = a.length();
        a.seek(end - 22 - 20);
        final byte[] sig = new byte[4];
        a.readFully(sig);
        if (sig[0] != (byte) 0x50 || sig[1] != (byte) 0x4b
            || sig[2] != 6 || sig[3] != 7) {
            // not a ZIP64 archive
            return getLengthAndPositionAtCentralDirectory32(a, end);
        }

        final long cdOffsetLoc = end - 22 - 20 - 56 + 48;
        // seek to central directory locator
        a.seek(cdOffsetLoc);
        final byte[] cdOffset = new byte[8];
        a.readFully(cdOffset);
        a.seek(ZipEightByteInteger.getLongValue(cdOffset));
        return end;
    }

    private static long getLengthAndPositionAtCentralDirectory32(final RandomAccessFile a, final long end)
        throws IOException {
        a.seek(end - 22 + 16);
        final byte[] cdOffset = new byte[4];
        a.readFully(cdOffset);
        a.seek(ZipLong.getValue(cdOffset));
        return end;
    }

    private static void write100KFilesToStream(final ZipArchiveOutputStream zos)
        throws IOException {
        for (int i = 0; i < ONE_HUNDRED_THOUSAND; i++) {
            final ZipArchiveEntry zae = new ZipArchiveEntry(String.valueOf(i));
            zae.setSize(0);
            zos.putArchiveEntry(zae);
            zos.closeArchiveEntry();
        }
        zos.close();
    }

    private static void
        write3EntriesCreatingBigArchiveToStream(final ZipArchiveOutputStream zos)
        throws IOException {
        final byte[] buf = new byte[ONE_MILLION];
        ZipArchiveEntry zae = null;
        for (int i = 0; i < 2; i++) {
            zae = new ZipArchiveEntry(String.valueOf(i));
            zae.setSize(FIVE_BILLION / 2);
            zae.setMethod(ZipEntry.STORED);
            zae.setCrc(0x8a408f16L);
            zos.putArchiveEntry(zae);
            for (int j = 0; j < FIVE_BILLION / 2 / 1000 / 1000;
                 j++) {
                zos.write(buf);
            }
            zos.closeArchiveEntry();
        }
        zae = new ZipArchiveEntry(String.valueOf(2));
        zae.setSize(1);
        zae.setMethod(ZipEntry.STORED);
        zae.setCrc(0x9b9265bL);
        zos.putArchiveEntry(zae);
        zos.write(new byte[] { 42 });
        zos.closeArchiveEntry();
        zos.close();
    }
}
