/*
* 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;
}
};
}