342 lines
11 KiB
Java
342 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2010, 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.
|
|
*/
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.Closeable;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.jar.JarFile;
|
|
import java.util.jar.JarInputStream;
|
|
import java.util.jar.JarOutputStream;
|
|
import java.util.jar.Pack200;
|
|
|
|
/*
|
|
* @test
|
|
* @bug 6985763
|
|
* @summary verify that proper exceptions are thrown
|
|
* @compile -XDignore.symbol.file Utils.java TestExceptions.java
|
|
* @run main TestExceptions
|
|
* @author ksrini
|
|
*/
|
|
|
|
public class TestExceptions {
|
|
|
|
static final File testJar = new File("test.jar");
|
|
static final File testPackFile = new File("test.pack");
|
|
|
|
static void init() {
|
|
Utils.jar("cvf", testJar.getAbsolutePath(), ".");
|
|
JarFile jf = null;
|
|
try {
|
|
jf = new JarFile(testJar);
|
|
Utils.pack(jf, testPackFile);
|
|
} catch (IOException ioe) {
|
|
throw new Error("Initialization error", ioe);
|
|
} finally {
|
|
Utils.close(jf);
|
|
}
|
|
}
|
|
|
|
// a test that closes the input jarFile.
|
|
static void pack200Test1() {
|
|
PackTestInput ti = null;
|
|
// setup the scenario
|
|
try {
|
|
ti = new PackTestInput(new JarFile(testJar), new ByteArrayOutputStream());
|
|
} catch (Exception e) {
|
|
throw new Error("Initialization error", e);
|
|
} finally {
|
|
Utils.close(ti.getJarFile());
|
|
}
|
|
// test the scenario
|
|
try {
|
|
System.out.println(ti);
|
|
Pack200.Packer p = Pack200.newPacker();
|
|
p.pack(ti.getJarFile(), ti.getOutputStream());
|
|
} catch (Exception e) {
|
|
ti.checkException(e);
|
|
} finally {
|
|
if (ti != null) {
|
|
ti.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
// test the Pack200.pack(JarFile, OutputStream);
|
|
static void pack200Test2() {
|
|
List<PackTestInput> tlist = new ArrayList<PackTestInput>();
|
|
try {
|
|
// setup the test scenarios
|
|
try {
|
|
tlist.add(new PackTestInput((JarFile)null, null));
|
|
tlist.add(new PackTestInput(new JarFile(testJar), null));
|
|
tlist.add(new PackTestInput((JarFile)null, new ByteArrayOutputStream()));
|
|
} catch (Exception e) {
|
|
throw new Error("Initialization error", e);
|
|
}
|
|
|
|
// test the scenarios
|
|
for (PackTestInput ti : tlist) {
|
|
System.out.println(ti);
|
|
try {
|
|
Pack200.Packer p = Pack200.newPacker();
|
|
p.pack(ti.getJarFile(), ti.getOutputStream());
|
|
} catch (Exception e) {
|
|
ti.checkException(e);
|
|
}
|
|
}
|
|
} finally { // keep jprt happy
|
|
for (TestInput ti : tlist) {
|
|
if (ti != null) {
|
|
ti.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// test the Pack200.pack(JarInputStream, OutputStream);
|
|
static void pack200Test3() {
|
|
List<PackTestJarInputStream> tlist = new ArrayList<PackTestJarInputStream>();
|
|
try {
|
|
// setup the test scenarios
|
|
try {
|
|
tlist.add(new PackTestJarInputStream((JarInputStream)null, null));
|
|
tlist.add(new PackTestJarInputStream((JarInputStream)null,
|
|
new ByteArrayOutputStream()));
|
|
tlist.add(new PackTestJarInputStream(
|
|
new JarInputStream(new FileInputStream(testJar)), null));
|
|
|
|
} catch (Exception e) {
|
|
throw new Error("Initialization error", e);
|
|
}
|
|
for (PackTestJarInputStream ti : tlist) {
|
|
System.out.println(ti);
|
|
try {
|
|
Pack200.Packer p = Pack200.newPacker();
|
|
p.pack(ti.getJarInputStream(), ti.getOutputStream());
|
|
} catch (Exception e) {
|
|
ti.checkException(e);
|
|
}
|
|
}
|
|
} finally { // keep jprt happy
|
|
for (PackTestJarInputStream ti : tlist) {
|
|
if (ti != null) {
|
|
ti.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// test the Pack200.unpack(InputStream, OutputStream);
|
|
static void unpack200Test1() {
|
|
List<UnpackTestInput> tlist = new ArrayList<UnpackTestInput>();
|
|
try {
|
|
// setup the test scenarios
|
|
try {
|
|
tlist.add(new UnpackTestInput((InputStream)null, null));
|
|
tlist.add(new UnpackTestInput(new FileInputStream(testPackFile),
|
|
null));
|
|
tlist.add(new UnpackTestInput((InputStream) null,
|
|
new JarOutputStream(new ByteArrayOutputStream())));
|
|
} catch (Exception e) {
|
|
throw new Error("Initialization error", e);
|
|
}
|
|
|
|
// test the scenarios
|
|
for (UnpackTestInput ti : tlist) {
|
|
System.out.println(ti);
|
|
try {
|
|
Pack200.Unpacker unpacker = Pack200.newUnpacker();
|
|
unpacker.unpack(ti.getInputStream(), ti.getJarOutputStream());
|
|
} catch (Exception e) {
|
|
ti.checkException(e);
|
|
}
|
|
}
|
|
} finally { // keep jprt happy
|
|
for (TestInput ti : tlist) {
|
|
if (ti != null) {
|
|
ti.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// test the Pack200.unpack(File, OutputStream);
|
|
static void unpack200Test2() {
|
|
List<UnpackTestFileInput> tlist = new ArrayList<UnpackTestFileInput>();
|
|
try {
|
|
// setup the test scenarios
|
|
try {
|
|
tlist.add(new UnpackTestFileInput((File)null, null));
|
|
tlist.add(new UnpackTestFileInput(testPackFile, null));
|
|
tlist.add(new UnpackTestFileInput((File)null,
|
|
new JarOutputStream(new ByteArrayOutputStream())));
|
|
} catch (Exception e) {
|
|
throw new Error("Initialization error", e);
|
|
}
|
|
|
|
// test the scenarios
|
|
for (UnpackTestFileInput ti : tlist) {
|
|
System.out.println(ti);
|
|
try {
|
|
Pack200.Unpacker unpacker = Pack200.newUnpacker();
|
|
unpacker.unpack(ti.getInputFile(), ti.getJarOutputStream());
|
|
} catch (Exception e) {
|
|
ti.checkException(e);
|
|
}
|
|
}
|
|
} finally { // keep jprt happy
|
|
for (TestInput ti : tlist) {
|
|
if (ti != null) {
|
|
ti.close();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void main(String... args) throws IOException {
|
|
init();
|
|
pack200Test1();
|
|
pack200Test2();
|
|
pack200Test3();
|
|
unpack200Test1();
|
|
Utils.cleanup();
|
|
}
|
|
|
|
// containers for test inputs and management
|
|
static abstract class TestInput {
|
|
|
|
private final Object in;
|
|
private final Object out;
|
|
final boolean shouldNPE;
|
|
final String testname;
|
|
|
|
public TestInput(String name, Object in, Object out) {
|
|
this.testname = name;
|
|
this.in = in;
|
|
this.out = out;
|
|
shouldNPE = (in == null || out == null);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
StringBuilder outStr = new StringBuilder(testname);
|
|
outStr.append(", input:").append(in);
|
|
outStr.append(", output:").append(this.out);
|
|
outStr.append(", should NPE:").append(shouldNPE);
|
|
return outStr.toString();
|
|
}
|
|
|
|
void close() {
|
|
if (in != null && (in instanceof Closeable)) {
|
|
Utils.close((Closeable) in);
|
|
}
|
|
if (out != null && (out instanceof Closeable)) {
|
|
Utils.close((Closeable) out);
|
|
}
|
|
}
|
|
|
|
void checkException(Throwable t) {
|
|
if (shouldNPE) {
|
|
if (t instanceof NullPointerException) {
|
|
System.out.println("Got expected exception");
|
|
return;
|
|
} else {
|
|
throw new RuntimeException("Expected NPE, but got ", t);
|
|
}
|
|
}
|
|
if (t instanceof IOException) {
|
|
System.out.println("Got expected exception");
|
|
return;
|
|
} else {
|
|
throw new RuntimeException("Expected IOException but got ", t);
|
|
}
|
|
}
|
|
}
|
|
|
|
static class PackTestInput extends TestInput {
|
|
|
|
public PackTestInput(JarFile jf, OutputStream out) {
|
|
super("PackTestInput", jf, out);
|
|
}
|
|
|
|
JarFile getJarFile() {
|
|
return (JarFile) super.in;
|
|
}
|
|
|
|
OutputStream getOutputStream() {
|
|
return (OutputStream) super.out;
|
|
}
|
|
};
|
|
|
|
static class PackTestJarInputStream extends TestInput {
|
|
|
|
public PackTestJarInputStream(JarInputStream in, OutputStream out) {
|
|
super("PackTestJarInputStream", in, out);
|
|
}
|
|
|
|
JarInputStream getJarInputStream() {
|
|
return (JarInputStream) super.in;
|
|
}
|
|
|
|
OutputStream getOutputStream() {
|
|
return (OutputStream) super.out;
|
|
}
|
|
};
|
|
|
|
static class UnpackTestInput extends TestInput {
|
|
|
|
public UnpackTestInput(InputStream in, JarOutputStream out) {
|
|
super("UnpackTestInput", in, out);
|
|
}
|
|
|
|
InputStream getInputStream() {
|
|
return (InputStream) super.in;
|
|
}
|
|
|
|
JarOutputStream getJarOutputStream() {
|
|
return (JarOutputStream) super.out;
|
|
}
|
|
};
|
|
|
|
static class UnpackTestFileInput extends TestInput {
|
|
|
|
public UnpackTestFileInput(File in, JarOutputStream out) {
|
|
super("UnpackTestInput", in, out);
|
|
}
|
|
|
|
File getInputFile() {
|
|
return (File) super.in;
|
|
}
|
|
|
|
JarOutputStream getJarOutputStream() {
|
|
return (JarOutputStream) super.out;
|
|
}
|
|
};
|
|
}
|