jdk/test/tools/pack200/TestExceptions.java - edge/openjdk - Git at Google

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