/*

 * Copyright (c) 2015, 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 8132734

 * @summary Test the extended API and the aliasing additions in JarFile that

 *          support multi-release jar files

 * @library /lib/testlibrary/java/util/jar

 * @build Compiler JarBuilder CreateMultiReleaseTestJars

 * @run testng MultiReleaseJarAPI

 */

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.nio.file.Files;

import java.util.Arrays;

import java.util.jar.JarFile;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import static java.util.jar.JarFile.Release;

import static sun.misc.Version.jdkMajorVersion;  // fixme JEP 223 Version

import org.testng.Assert;

import org.testng.annotations.AfterClass;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.Test;

public class MultiReleaseJarAPI {

    String userdir = System.getProperty("user.dir",".");

    File unversioned = new File(userdir, "unversioned.jar");

    File multirelease = new File(userdir, "multi-release.jar");

    File signedmultirelease = new File(userdir, "signed-multi-release.jar");

    Release[] values = JarFile.Release.values();

    @BeforeClass

    public void initialize() throws Exception {

        CreateMultiReleaseTestJars creator =  new CreateMultiReleaseTestJars();

        creator.compileEntries();

        creator.buildUnversionedJar();

        creator.buildMultiReleaseJar();

        creator.buildSignedMultiReleaseJar();

    }

    @AfterClass

    public void close() throws IOException {

        Files.delete(unversioned.toPath());

        Files.delete(multirelease.toPath());

        Files.delete(signedmultirelease.toPath());

    }

    @Test

    public void isMultiReleaseJar() throws Exception {

        try (JarFile jf = new JarFile(unversioned)) {

            Assert.assertFalse(jf.isMultiRelease());

        }

        try (JarFile jf = new JarFile(multirelease)) {

            Assert.assertTrue(jf.isMultiRelease());

        }

    }

    @Test

    public void testVersioning() throws Exception {

        // multi-release jar

        JarFile jar = new JarFile(multirelease);

        Assert.assertEquals(Release.BASE, jar.getVersion());

        jar.close();

        for (Release value : values) {

            System.err.println("test versioning for Release " + value);

            try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, value)) {

                Assert.assertEquals(value, jf.getVersion());

            }

        }

        // regular, unversioned, jar

        for (Release value : values) {

            try (JarFile jf = new JarFile(unversioned, true, ZipFile.OPEN_READ, value)) {

                Assert.assertEquals(Release.BASE, jf.getVersion());

            }

        }

        // assure that we have a Release object corresponding to the actual runtime version

        String version = "VERSION_" + jdkMajorVersion();

        boolean runtimeVersionExists = false;

        for (Release value : values) {

            if (version.equals(value.name())) runtimeVersionExists = true;

        }

        Assert.assertTrue(runtimeVersionExists);

    }

    @Test

    public void testAliasing() throws Exception {

        for (Release value : values) {

            System.err.println("test aliasing for Release " + value);

            String name = value.name();

            String prefix;

            if (name.equals("BASE")) {

                prefix = "";

            } else if (name.equals("RUNTIME")) {

                prefix = "META-INF/versions/" + jdkMajorVersion() + "/";

            } else {

                prefix = "META-INF/versions/" + name.substring(8) + "/";

            }

            // test both multi-release jars

            readAndCompare(multirelease, value, "README", prefix + "README");

            readAndCompare(multirelease, value, "version/Version.class", prefix + "version/Version.class");

            // and signed multi-release jars

            readAndCompare(signedmultirelease, value, "README", prefix + "README");

            readAndCompare(signedmultirelease, value, "version/Version.class", prefix + "version/Version.class");

        }

    }

    private void readAndCompare(File jar, Release version, String name, String realName) throws Exception {

        byte[] baseBytes;

        byte[] versionedBytes;

        try (JarFile jf = new JarFile(jar, true, ZipFile.OPEN_READ, Release.BASE)) {

            ZipEntry ze = jf.getEntry(realName);

            try (InputStream is = jf.getInputStream(ze)) {

                baseBytes = is.readAllBytes();

            }

        }

        assert baseBytes.length > 0;

        try (JarFile jf = new JarFile(jar, true, ZipFile.OPEN_READ, version)) {

            ZipEntry ze = jf.getEntry(name);

            try (InputStream is = jf.getInputStream(ze)) {

                versionedBytes = is.readAllBytes();

            }

        }

        assert versionedBytes.length > 0;

        Assert.assertTrue(Arrays.equals(baseBytes, versionedBytes));

    }

    @Test

    public void testNames() throws Exception {

        String rname = "version/Version.class";

        String vname = "META-INF/versions/9/version/Version.class";

        ZipEntry ze1;

        ZipEntry ze2;

        try (JarFile jf = new JarFile(multirelease)) {

            ze1 = jf.getEntry(vname);

        }

        Assert.assertEquals(ze1.getName(), vname);

        try (JarFile jf = new JarFile(multirelease, true, ZipFile.OPEN_READ, Release.VERSION_9)) {

            ze2 = jf.getEntry(rname);

        }

        Assert.assertEquals(ze2.getName(), rname);

        Assert.assertNotEquals(ze1.getName(), ze2.getName());

    }

}