/*

 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* @test

 * @bug 4770745 6234507 6303183 8048990

 * @summary test a variety of zip file entries

 * @author Martin Buchholz

 * @key randomness

 */

import java.util.*;

import java.util.zip.*;

import java.util.jar.*;

import java.io.*;

public class Assortment {

    static int passed = 0, failed = 0;

    static void fail(String msg) {

        failed++;

        new Exception(msg).printStackTrace();

    }

    static void unexpected(Throwable t) {

        failed++;

        t.printStackTrace();

    }

    static void check(boolean condition, String msg) {

        if (! condition)

            fail(msg);

    }

    static void check(boolean condition) {

        check(condition, "Something's wrong");

    }

    static final int get16(byte b[], int off) {

        return Byte.toUnsignedInt(b[off]) | (Byte.toUnsignedInt(b[off+1]) << 8);

    }

    // check if all "expected" extra fields equal to their

    // corresponding fields in "extra". The "extra" might have

    // timestamp fields added by ZOS.

    static boolean equalsExtraData(byte[] expected, byte[] extra) {

        if (expected == null)

            return true;

        int off = 0;

        int len = expected.length;

        while (off + 4 < len) {

            int tag = get16(expected, off);

            int sz = get16(expected, off + 2);

            int off0 = 0;

            int len0 = extra.length;

            boolean matched = false;

            while (off0 + 4 < len0) {

                int tag0 = get16(extra, off0);

                int sz0 = get16(extra, off0 + 2);

                if (tag == tag0 && sz == sz0) {

                    matched = true;

                    for (int i = 0; i < sz; i++) {

                        if (expected[off + i] != extra[off0 +i])

                            matched = false;

                    }

                    break;

                }

                off0 += (4 + sz0);

            }

            if (!matched)

                return false;

            off += (4 + sz);

        }

        return true;

    }

    private static class Entry {

        private String name;

        private int    method;

        private byte[] data;

        private byte[] extra;

        private String comment;

        Entry(String name,

              int    method,

              byte[] data,

              byte[] extra,

              String comment) {

            this.name    = name;

            this.method  = method;

            this.data    = data;

            this.extra   = extra;

            this.comment = comment;

        }

        void write(ZipOutputStream s) throws Exception {

            ZipEntry e = new ZipEntry(name);

            CRC32 crc32 = new CRC32();

            e.setMethod(method);

            if (method == ZipEntry.STORED) {

                e.setSize(data == null ? 0 : data.length);

                crc32.reset();

                if (data != null) crc32.update(data);

                e.setCrc(crc32.getValue());

            } else {

                e.setSize(0);

                e.setCrc(0);

            }

            if (comment != null) e.setComment(comment);

            if (extra   != null) e.setExtra(extra);

            s.putNextEntry(e);

            if (data != null) s.write(data);

        }

        byte[] getData(ZipFile f, ZipEntry e) throws Exception {

            byte[] fdata = new byte[(int)e.getSize()];

            InputStream is = f.getInputStream(e);

            is.read(fdata);

            return fdata;

        }

        void verify(ZipFile f, ZipEntry e) throws Exception {

            verify(e, getData(f, e));

        }

        void verify(ZipEntry e, byte[] eData) throws Exception {

            byte[] data  = (this.data == null) ? new byte[]{} : this.data;

            byte[] extra = (this.extra != null && this.extra.length == 0) ?

                null : this.extra;

            check(name.equals(e.getName()));

            check(method == e.getMethod());

            check((((comment == null) || comment.equals(""))

                   && (e.getComment() == null))

                  || comment.equals(e.getComment()));

            check(equalsExtraData(extra, e.getExtra()));

            check(Arrays.equals(data, eData));

            check(e.getSize() == data.length);

            check((method == ZipEntry.DEFLATED) ||

                  (e.getCompressedSize() == data.length));

        }

        void verify(ZipFile f) throws Exception {

            ZipEntry e = f.getEntry(name);

            verify(e, getData(f, e));

        }

        void verifyZipInputStream(ZipInputStream s) throws Exception {

            ZipEntry e = s.getNextEntry();

            byte[] data = (this.data == null) ? new byte[]{} : this.data;

            byte[] otherData = new byte[data.length];

            s.read(otherData);

            check(Arrays.equals(data, otherData));

            byte[] extra = (this.extra != null && this.extra.length == 0) ?

                null : this.extra;

            check(equalsExtraData(extra, e.getExtra()));

            check(name.equals(e.getName()));

            check(method == e.getMethod());

            check(e.getSize() == -1 || e.getSize() == data.length);

            check((method == ZipEntry.DEFLATED) ||

                  (e.getCompressedSize() == data.length));

        }

        void verifyJarInputStream(JarInputStream s) throws Exception {

            // JarInputStream "automatically" reads the manifest

            if (name.equals("meta-iNf/ManIfEst.Mf"))

                return;

            verifyZipInputStream(s);

        }

    }

    private static int uniquifier = 86;

    private static String uniquify(String name) {

        return name + (uniquifier++);

    }

    private static byte[] toBytes(String s) throws Exception {

        return s.getBytes("UTF-8");

    }

    private static byte[] toExtra(byte[] bytes) throws Exception {

        if (bytes == null) return null;

        // Construct a fake extra field with valid header length

        byte[] v = new byte[bytes.length + 4];

        v[0] = (byte) 0x47;

        v[1] = (byte) 0xff;

        v[2] = (byte) bytes.length;

        v[3] = (byte) (bytes.length << 8);

        System.arraycopy(bytes, 0, v, 4, bytes.length);

        return v;

    }

    private static Random random = new Random();

    private static String makeName(int length) {

        StringBuilder sb = new StringBuilder(length);

        for (int i = 0; i < length; i++)

            sb.append((char)(random.nextInt(10000)+1));

        return sb.toString();

    }

    public static void main(String[] args) throws Exception {

        File zipName = new File("x.zip");

        int[]    methods  = {ZipEntry.STORED, ZipEntry.DEFLATED};

        String[] names    = {makeName(1), makeName(160), makeName(9000)};

        byte[][] datas    = {null, new byte[]{}, new byte[]{'d'}};

        byte[][] extras   = {null, new byte[]{}, new byte[]{'e'}};

        String[] comments = {null, "", "c"};

        List<Entry> entries = new ArrayList<Entry>();

        // Highly unusual manifest

        entries.add(new Entry("meta-iNf/ManIfEst.Mf",

                              ZipEntry.STORED,

                              toBytes("maNiFest-VeRsIon: 1.0\n"),

                              toExtra(toBytes("Can manifests have extra??")),

                              "Can manifests have comments??"));

        // The emptiest possible entry

        entries.add(new Entry("", ZipEntry.STORED, null, null, ""));

        for (String name : names)

            for (int method : methods)

                for (byte[] data : datas) // datae??

                    for (byte[] extra : extras)

                        for (String comment : comments)

                            entries.add(new Entry(uniquify(name), method, data,

                                                  toExtra(extra), comment));

        //----------------------------------------------------------------

        // Write zip file using ZipOutputStream

        //----------------------------------------------------------------

        try (FileOutputStream fos = new FileOutputStream(zipName);

             ZipOutputStream zos = new ZipOutputStream(fos))

        {

            for (Entry e : entries)

                e.write(zos);

        }

        //----------------------------------------------------------------

        // Verify zip file contents using ZipFile.getEntry()

        //----------------------------------------------------------------

        try (ZipFile f = new ZipFile(zipName)) {

            for (Entry e : entries)

                e.verify(f);

        }

        //----------------------------------------------------------------

        // Verify zip file contents using JarFile.getEntry()

        //----------------------------------------------------------------

        try (JarFile f = new JarFile(zipName)) {

            check(f.getManifest() != null);

            for (Entry e : entries)

                e.verify(f);

        }

        //----------------------------------------------------------------

        // Verify zip file contents using ZipFile.entries()

        //----------------------------------------------------------------

        try (ZipFile f = new ZipFile(zipName)) {

            Enumeration<? extends ZipEntry> en = f.entries();

            for (Entry e : entries)

                e.verify(f, en.nextElement());

            check(!en.hasMoreElements());

        }

        //----------------------------------------------------------------

        // Verify zip file contents using JarFile.entries()

        //----------------------------------------------------------------

        try (JarFile f = new JarFile(zipName)) {

            Enumeration<? extends ZipEntry> en = f.entries();

            for (Entry e : entries)

                e.verify(f, en.nextElement());

            check(!en.hasMoreElements());

        }

        //----------------------------------------------------------------

        // Verify zip file contents using ZipInputStream class

        //----------------------------------------------------------------

        try (FileInputStream fis = new FileInputStream(zipName);

             ZipInputStream s = new ZipInputStream(fis)) {

            for (Entry e : entries)

                e.verifyZipInputStream(s);

        }

        //----------------------------------------------------------------

        // Verify zip file contents using JarInputStream class

        //----------------------------------------------------------------

        try (FileInputStream fis = new FileInputStream(zipName);

             JarInputStream s = new JarInputStream(fis)) {

            // JarInputStream "automatically" reads the manifest

            check(s.getManifest() != null);

            for (Entry e : entries)

                e.verifyJarInputStream(s);

        }

//      String cmd = "unzip -t " + zipName.getPath() + " >/dev/tty";

//      new ProcessBuilder(new String[]{"/bin/sh", "-c", cmd}).start().waitFor();

        zipName.deleteOnExit();

        System.out.printf("passed = %d, failed = %d%n", passed, failed);

        if (failed > 0) throw new Exception("Some tests failed");

    }

}