259 lines
9.2 KiB
Java
259 lines
9.2 KiB
Java
/*
|
|
* Copyright (c) 2015, 2016, 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.
|
|
*/
|
|
import java.io.File;
|
|
import java.io.IOException;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 8066272
|
|
* @summary tests a simple multi-versioned jar file
|
|
* @compile -XDignore.symbol.file Utils.java MultiRelease.java
|
|
* @run main MultiRelease
|
|
* @author ksrini
|
|
*/
|
|
|
|
public class MultiRelease {
|
|
private static final File cwd = new File(".");
|
|
private static int pass = 0;
|
|
private static int fail = 0;
|
|
// specify alternate name via arguments to verify
|
|
// if permanent fix works
|
|
|
|
private static final String PropKey = "pack200.MultiRelease.META-INF";
|
|
private static final String MetaInfName = System.getProperty(PropKey, "META-INF");
|
|
|
|
public static void main(String... args) throws Exception {
|
|
new MultiRelease().run();
|
|
}
|
|
|
|
void run() throws Exception {
|
|
List<TestCase> testCases = new ArrayList<>();
|
|
testCases.add(new TestCase1());
|
|
testCases.add(new TestCase2());
|
|
for (TestCase tc : testCases) {
|
|
tc.run();
|
|
}
|
|
if (fail > 0) {
|
|
throw new Exception(fail + "/" + testCases.size() + " tests fails");
|
|
} else {
|
|
System.out.println("All tests(" + pass + ") passes");
|
|
}
|
|
Utils.cleanup();
|
|
}
|
|
|
|
/*
|
|
* An abstract class to eliminate test boiler plating.
|
|
*/
|
|
static abstract class TestCase {
|
|
final File tcwd;
|
|
final File metaInfDir;
|
|
final File versionsDir;
|
|
final File manifestFile;
|
|
|
|
TestCase(String directory) throws IOException {
|
|
System.out.println("initializing directories");
|
|
tcwd = new File(cwd, directory);
|
|
metaInfDir = mkdir(new File(tcwd, MetaInfName));
|
|
versionsDir = mkdir(new File(metaInfDir, "versions"));
|
|
manifestFile = new File(tcwd, "manifest.tmp");
|
|
List<String> scratch = new ArrayList<>();
|
|
scratch.add("Multi-Release: true");
|
|
Utils.createFile(manifestFile, scratch);
|
|
}
|
|
|
|
File mkdir(File f) throws IOException {
|
|
if (f.exists() && f.isDirectory() && f.canRead() && f.canWrite()) {
|
|
return f;
|
|
}
|
|
if (!f.mkdirs()) {
|
|
throw new IOException("mkdirs failed: " + f.getAbsolutePath());
|
|
}
|
|
return f;
|
|
}
|
|
|
|
abstract void emitClassFiles() throws Exception;
|
|
|
|
void run() {
|
|
try {
|
|
emitClassFiles();
|
|
// jar the file up
|
|
File testFile = new File(tcwd, "test" + Utils.JAR_FILE_EXT);
|
|
Utils.jar("cvfm",
|
|
testFile.getAbsolutePath(),
|
|
manifestFile.getAbsolutePath(),
|
|
"-C",
|
|
tcwd.getAbsolutePath(),
|
|
".");
|
|
File outFile = new File(tcwd, "test-repacked" + Utils.JAR_FILE_EXT);
|
|
List<String> cmdsList = new ArrayList<>();
|
|
|
|
cmdsList.add(Utils.getPack200Cmd());
|
|
cmdsList.add("-J-ea");
|
|
cmdsList.add("-J-esa");
|
|
cmdsList.add("-v");
|
|
cmdsList.add("--repack");
|
|
cmdsList.add(outFile.getAbsolutePath());
|
|
cmdsList.add(testFile.getAbsolutePath());
|
|
List<String> output = Utils.runExec(cmdsList);
|
|
Utils.doCompareVerify(testFile.getAbsoluteFile(), outFile.getAbsoluteFile());
|
|
pass++;
|
|
} catch (Exception e) {
|
|
e.printStackTrace(System.err);
|
|
fail++;
|
|
}
|
|
}
|
|
}
|
|
|
|
static class TestCase1 extends TestCase {
|
|
private TestCase1(String directory) throws IOException {
|
|
super(directory);
|
|
}
|
|
|
|
public TestCase1() throws Exception {
|
|
this("case1");
|
|
}
|
|
|
|
@Override
|
|
void emitClassFiles() throws Exception {
|
|
emitClassFile("");
|
|
emitClassFile("7");
|
|
emitClassFile("8");
|
|
emitClassFile("9");
|
|
}
|
|
|
|
/*
|
|
* Adds different variants of types
|
|
*/
|
|
void emitClassFile(String version) throws IOException {
|
|
final File outDir = mkdir(version.isEmpty()
|
|
? tcwd
|
|
: new File(versionsDir, version));
|
|
|
|
final File srcDir = mkdir(version.isEmpty()
|
|
? new File(tcwd, "src")
|
|
: new File(new File(versionsDir, version), "src"));
|
|
|
|
final String fname = "Foo";
|
|
final File srcFile = new File(srcDir, fname + Utils.JAVA_FILE_EXT);
|
|
List<String> scratch = new ArrayList<>();
|
|
|
|
scratch.add("package pkg;");
|
|
switch (version) {
|
|
case "7":
|
|
scratch.add("public class Foo {");
|
|
scratch.add("public static final class Bar {}");
|
|
break;
|
|
case "8":
|
|
scratch.add("public abstract class Foo {");
|
|
scratch.add("public final class Bar {}");
|
|
break;
|
|
case "9":
|
|
scratch.add("public interface Foo {");
|
|
scratch.add("public final class Bar {}");
|
|
break;
|
|
default:
|
|
scratch.add("public class Foo {");
|
|
scratch.add("public final class Bar {}");
|
|
break;
|
|
}
|
|
scratch.add("}");
|
|
|
|
Utils.createFile(srcFile, scratch);
|
|
Utils.compiler("-d",
|
|
outDir.getAbsolutePath(),
|
|
srcFile.getAbsolutePath());
|
|
}
|
|
}
|
|
|
|
static class TestCase2 extends TestCase {
|
|
private TestCase2(String directory) throws IOException {
|
|
super(directory);
|
|
}
|
|
|
|
TestCase2() throws Exception {
|
|
this("case2");
|
|
}
|
|
|
|
@Override
|
|
void emitClassFiles() throws Exception {
|
|
emitClassFile("");
|
|
emitClassFile("8");
|
|
}
|
|
|
|
/*
|
|
* Adds different variants of types and tries to invoke an
|
|
* interface or concrete method defined by them.
|
|
*/
|
|
void emitClassFile(String version) throws IOException {
|
|
|
|
final File outDir = mkdir(version.isEmpty()
|
|
? tcwd
|
|
: new File(versionsDir, version));
|
|
|
|
final File srcDir = mkdir(version.isEmpty()
|
|
? new File(tcwd, "src")
|
|
: new File(new File(versionsDir, version), "src"));
|
|
|
|
List<String> scratch = new ArrayList<>();
|
|
final String fname1 = "Ab";
|
|
final File srcFile1 = new File(srcDir, fname1 + Utils.JAVA_FILE_EXT);
|
|
|
|
final String fname2 = "AbNormal";
|
|
final File srcFile2 = new File(srcDir, fname2 + Utils.JAVA_FILE_EXT);
|
|
switch (version) {
|
|
case "8":
|
|
scratch.clear();
|
|
scratch.add("import java.io.IOException;");
|
|
scratch.add("public interface " + fname1 + "{");
|
|
scratch.add(" public abstract void close() throws IOException ;");
|
|
scratch.add("}");
|
|
Utils.createFile(srcFile1, scratch);
|
|
break;
|
|
default:
|
|
scratch.clear();
|
|
scratch.add("import java.io.IOException;");
|
|
scratch.add("public abstract class " + fname1 + "{");
|
|
scratch.add(" public abstract void close() throws IOException ;");
|
|
scratch.add("}");
|
|
Utils.createFile(srcFile1, scratch);
|
|
}
|
|
|
|
scratch.clear();
|
|
scratch.add("import java.io.IOException;");
|
|
scratch.add("public class " + fname2 + "{");
|
|
scratch.add(" public void doSomething(Ab ab) throws IOException {");
|
|
scratch.add(" ab.close();");
|
|
scratch.add(" }");
|
|
scratch.add("}");
|
|
|
|
Utils.createFile(srcFile2, scratch);
|
|
Utils.compiler("-d",
|
|
outDir.getAbsolutePath(),
|
|
srcFile1.getAbsolutePath(),
|
|
srcFile2.getAbsolutePath());
|
|
}
|
|
}
|
|
}
|