1 /* 2 * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 25 import java.util.*; 26 import java.io.*; 27 import java.lang.management.ManagementFactory; 28 import java.lang.management.MemoryMXBean; 29 import java.util.jar.*; 30 31 /* 32 * @test 33 * @bug 6521334 6712743 8007902 34 * @summary check for memory leaks, test general packer/unpacker functionality\ 35 * using native and java unpackers 36 * @compile -XDignore.symbol.file Utils.java Pack200Test.java 37 * @run main/othervm/timeout=1200 -Xmx512m Pack200Test 38 * @author ksrini 39 */ 40 41 /** 42 * Tests the packing/unpacking via the APIs. 43 */ 44 public class Pack200Test { 45 46 private static ArrayList <File> jarList = new ArrayList<File>(); 47 static final MemoryMXBean mmxbean = ManagementFactory.getMemoryMXBean(); 48 static final long m0 = getUsedMemory(); 49 static final int LEAK_TOLERANCE = 21000; // OS and GC related variations. 50 51 /** Creates a new instance of Pack200Test */ 52 private Pack200Test() {} 53 54 static long getUsedMemory() { 55 mmxbean.gc(); 56 mmxbean.gc(); 57 mmxbean.gc(); 58 return mmxbean.getHeapMemoryUsage().getUsed()/1024; 59 } 60 61 private static void leakCheck() throws Exception { 62 long diff = getUsedMemory() - m0; 63 System.out.println(" Info: memory diff = " + diff + "K"); 64 if ( diff > LEAK_TOLERANCE) { 65 throw new Exception("memory leak detected " + diff); 66 } 67 } 68 69 private static void doPackUnpack() throws IOException { 70 for (File in : jarList) { 71 JarOutputStream javaUnpackerStream = null; 72 JarOutputStream nativeUnpackerStream = null; 73 JarFile jarFile = null; 74 try { 75 jarFile = new JarFile(in); 76 77 // Write out to a jtreg scratch area 78 File packFile = new File(in.getName() + Utils.PACK_FILE_EXT); 79 80 System.out.println("Packing [" + in.toString() + "]"); 81 // Call the packer 82 Utils.pack(jarFile, packFile); 83 jarFile.close(); 84 leakCheck(); 85 86 System.out.println(" Unpacking using java unpacker"); 87 File javaUnpackedJar = new File("java-" + in.getName()); 88 // Write out to current directory, jtreg will setup a scratch area 89 javaUnpackerStream = new JarOutputStream( 90 new FileOutputStream(javaUnpackedJar)); 91 Utils.unpackj(packFile, javaUnpackerStream); 92 javaUnpackerStream.close(); 93 System.out.println(" Testing...java unpacker"); 94 leakCheck(); 95 // Ok we have unpacked the file, lets test it. 96 Utils.doCompareVerify(in.getAbsoluteFile(), javaUnpackedJar); 97 98 System.out.println(" Unpacking using native unpacker"); 99 // Write out to current directory 100 File nativeUnpackedJar = new File("native-" + in.getName()); 101 nativeUnpackerStream = new JarOutputStream( 102 new FileOutputStream(nativeUnpackedJar)); 103 Utils.unpackn(packFile, nativeUnpackerStream); 104 nativeUnpackerStream.close(); 105 System.out.println(" Testing...native unpacker"); 106 leakCheck(); 107 // the unpackers (native and java) should produce identical bits 108 // so we use use bit wise compare, the verification compare is 109 // very expensive wrt. time. 110 Utils.doCompareBitWise(javaUnpackedJar, nativeUnpackedJar); 111 System.out.println("Done."); 112 } catch (Exception e) { 113 throw new RuntimeException(e); 114 } finally { 115 Utils.close(nativeUnpackerStream); 116 Utils.close(javaUnpackerStream); 117 Utils.close((Closeable) jarFile); 118 } 119 } 120 Utils.cleanup(); // cleanup artifacts, if successful run 121 } 122 123 /** 124 * @param args the command line arguments 125 */ 126 public static void main(String[] args) throws IOException { 127 // select the jars carefully, adding more jars will increase the 128 // testing time, especially for jprt. 129 jarList.add(Utils.createRtJar()); 130 jarList.add(Utils.locateJar("golden.jar")); 131 System.out.println(jarList); 132 doPackUnpack(); 133 } 134 }