MultipleJRERemoved.java

/*
 * Copyright (c) 2014, 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 8067437
 * @summary Verify Multiple JRE version support has been removed.
 * @modules jdk.compiler
 *          jdk.zipfs
 * @build TestHelper
 * @run main MultipleJRERemoved
 */

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.file.Files;
import java.util.*;
import java.util.jar.Attributes;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import java.util.zip.ZipEntry;

public class MultipleJRERemoved extends TestHelper {

    public static final String VERSION_JAR = "version.jar";
    public static final String PRINT_VERSION_CLASS = "PrintVersion";
    private final File javaFile = new File(PRINT_VERSION_CLASS + ".java");
    private final File clsFile = new File(PRINT_VERSION_CLASS + ".class");

    private MultipleJRERemoved() {
    }

    /**
     * @param args the command line arguments
     * @throws java.io.FileNotFoundException
     */
    public static void main(String[] args) throws Exception {
        MultipleJRERemoved a = new MultipleJRERemoved();
        a.run(args);
    }

    /**
     * Check all combinations of flags: "-version:", "-jre-restrict-search", "-jre-no-restrict-search". Test expects to see errors.
     */
    @Test
    public void allFlagCombinations() throws IOException {
        final Pattern newLine = Pattern.compile("\n");
        createJar(Collections.emptyMap());

        for (Flag flag1 : Flag.values()) {
            for (Flag flag2 : Flag.values()) {
                for (Flag flag3 : Flag.values()) {
                    List<Flag> flags = Stream.of(flag1, flag2, flag3)
                            .filter(f -> !Flag.EMPTY.equals(f))
                            .collect(Collectors.toList());

                    if (flags.size() == 0) continue;

                    List<String> flagValues = flags.stream()
                            .map(Flag::value)
                            .collect(Collectors.toList());

                    List<String> errorMessages = flags.stream()
                            .map(Flag::errorMessage)
                            .flatMap(newLine::splitAsStream)
                            .collect(Collectors.toList());

                    List<String> jarCmd = new ArrayList<>();
                    jarCmd.add(javaCmd);
                    jarCmd.addAll(flagValues);
                    jarCmd.add("-jar");
                    jarCmd.add("version.jar");

                    check(jarCmd, errorMessages);

                    List<String> cmd = new ArrayList<>();
                    cmd.add(javaCmd);
                    cmd.addAll(flagValues);
                    cmd.add(PRINT_VERSION_CLASS);

                    check(cmd, errorMessages);
                }
            }
        }
    }

    private void check(List<String> cmd, List<String> errorMessages) {
        TestResult tr = doExec(cmd.toArray(new String[cmd.size()]));
        tr.checkNegative();
        tr.isNotZeroOutput();
        errorMessages.forEach(tr::contains);

        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("test case: failed\n" + cmd);
        }
    }

    /**
     * Verifies that java -help output doesn't contain information about "mJRE" flags.
     */
    @Test
    public void javaHelp() {
        TestResult tr = doExec(javaCmd, "-help");
        tr.checkPositive();
        tr.isNotZeroOutput();
        tr.notContains("-version:<value>");
        tr.notContains("-jre-restrict-search");
        tr.notContains("-jre-no-restrict-search");
        tr.notContains("-no-jre-restrict-search");  //it's not a typo in flag name.
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("Failed. java -help output contains obsolete flags.\n");
        }
    }

    /**
     * Verifies that java -jar version.jar output ignores "mJRE" manifest directives.
     */
    @Test
    public void manifestDirectives() throws IOException {
        Map<String, String> manifest = new TreeMap<>();
        manifest.put("JRE-Version", "1.8");
        manifest.put("JRE-Restrict-Search", "1.8");
        createJar(manifest);

        TestResult tr = doExec(javaCmd, "-jar", VERSION_JAR);
        tr.checkPositive();
        tr.contains(System.getProperty("java.version"));
        if (!tr.testStatus) {
            System.out.println(tr);
            throw new RuntimeException("Failed.\n");
        }
    }

    private void emitFile() throws IOException {
        List<String> scr = new ArrayList<>();
        scr.add("public class PrintVersion {");
        scr.add("    public static void main(String... args) {");
        scr.add("       System.out.println(System.getProperty(\"java.version\"));");
        scr.add("    }");
        scr.add("}");
        createFile(javaFile, scr);
        compile(javaFile.getName());
    }

    private void createJar(Map<String, String> manifestAttributes) throws IOException {
        emitFile();

        Manifest manifest = new Manifest();
        final Attributes mainAttributes = manifest.getMainAttributes();
        mainAttributes.putValue("Manifest-Version", "1.0");
        mainAttributes.putValue("Main-Class", PRINT_VERSION_CLASS);
        manifestAttributes.forEach(mainAttributes::putValue);

        try (JarOutputStream jar = new JarOutputStream(new FileOutputStream(VERSION_JAR), manifest)) {
            jar.putNextEntry(new ZipEntry(PRINT_VERSION_CLASS + ".class"));
            jar.write(Files.readAllBytes(clsFile.toPath()));
            jar.closeEntry();
        } finally {
            javaFile.delete();
        }
    }

    private enum Flag {
        EMPTY("", ""),
        VERSION("-version:1.9", "Error: Specifying an alternate JDK/JRE version is no longer supported.\n" +
                "The use of the flag '-version:' is no longer valid.\n" +
                "Please download and execute the appropriate version."),
        JRE_RESTRICT_SEARCH("-jre-restrict-search", "Error: Specifying an alternate JDK/JRE is no longer supported.\n" +
                "The related flags -jre-restrict-search | -jre-no-restrict-search are also no longer valid."),
        JRE_NO_RESTRICT_SEARCH("-jre-no-restrict-search", "Error: Specifying an alternate JDK/JRE is no longer supported.\n" +
                "The related flags -jre-restrict-search | -jre-no-restrict-search are also no longer valid.");
        private final String flag;
        private final String errorMessage;

        Flag(String flag, String errorMessage) {
            this.flag = flag;
            this.errorMessage = errorMessage;
        }

        String value() {
            return flag;
        }

        String errorMessage() {
            return errorMessage;
        }
    }
}