1 /* 2 * Copyright (c) 2007, 2016, 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 * @key intermittent 35 * @summary check for memory leaks, test general packer/unpacker functionality\ 36 * using native and java unpackers 37 * @compile -XDignore.symbol.file Utils.java Pack200Test.java 38 * @run main/othervm/timeout=1200 -Xmx1280m -Xshare:off Pack200Test 39 * @author ksrini 40 */ 41 42 /** 43 * Tests the packing/unpacking via the APIs. 44 */ 45 public class Pack200Test { 46 47 private static ArrayList <File> jarList = new ArrayList<File>(); 48 static final MemoryMXBean mmxbean = ManagementFactory.getMemoryMXBean(); 49 static final long m0 = getUsedMemory(); 50 static final int LEAK_TOLERANCE = 21000; // OS and GC related variations. 51 52 /** Creates a new instance of Pack200Test */ 53 private Pack200Test() {} 54 55 static long getUsedMemory() { 56 mmxbean.gc(); 57 mmxbean.gc(); 58 mmxbean.gc(); 59 return mmxbean.getHeapMemoryUsage().getUsed()/1024; 60 } 61 62 private static void leakCheck() throws Exception { 63 long diff = getUsedMemory() - m0; 64 System.out.println(" Info: memory diff = " + diff + "K"); 65 if ( diff > LEAK_TOLERANCE) { 66 throw new Exception("memory leak detected " + diff); 67 } 68 } 69 70 private static void doPackUnpack() throws IOException { 71 for (File in : jarList) { 72 JarOutputStream javaUnpackerStream = null; 73 JarOutputStream nativeUnpackerStream = null; 74 JarFile jarFile = null; 75 try { 76 jarFile = new JarFile(in); 77 78 // Write out to a jtreg scratch area 79 File packFile = new File(in.getName() + Utils.PACK_FILE_EXT); 80 81 System.out.println("Packing [" + in.toString() + "]"); 82 // Call the packer 83 Utils.pack(jarFile, packFile); 84 jarFile.close(); 85 leakCheck(); 86 87 System.out.println(" Unpacking using java unpacker"); 88 File javaUnpackedJar = new File("java-" + in.getName()); 89 // Write out to current directory, jtreg will setup a scratch area 90 javaUnpackerStream = new JarOutputStream( 91 new FileOutputStream(javaUnpackedJar)); 92 Utils.unpackj(packFile, javaUnpackerStream); 93 javaUnpackerStream.close(); 94 System.out.println(" Testing...java unpacker"); 95 leakCheck(); 96 // Ok we have unpacked the file, lets test it. 97 Utils.doCompareVerify(in.getAbsoluteFile(), javaUnpackedJar); 98 99 System.out.println(" Unpacking using native unpacker"); 100 // Write out to current directory 101 File nativeUnpackedJar = new File("native-" + in.getName()); 102 nativeUnpackerStream = new JarOutputStream( 103 new FileOutputStream(nativeUnpackedJar)); 104 Utils.unpackn(packFile, nativeUnpackerStream); 105 nativeUnpackerStream.close(); 106 System.out.println(" Testing...native unpacker"); 107 leakCheck(); 108 // the unpackers (native and java) should produce identical bits 109 // so we use use bit wise compare, the verification compare is 110 // very expensive wrt. time. 111 Utils.doCompareBitWise(javaUnpackedJar, nativeUnpackedJar); 112 System.out.println("Done."); 113 } catch (Exception e) { 114 throw new RuntimeException(e); 115 } finally { 116 Utils.close(nativeUnpackerStream); 117 Utils.close(javaUnpackerStream); 118 Utils.close((Closeable) jarFile); 119 } 120 } 121 Utils.cleanup(); // cleanup artifacts, if successful run 122 } 123 124 /** 125 * @param args the command line arguments 126 */ 127 public static void main(String[] args) throws IOException { 128 // select the jars carefully, adding more jars will increase the 129 // testing time, especially for jprt. 130 jarList.add(Utils.createRtJar()); 131 jarList.add(Utils.getGoldenJar()); 132 System.out.println(jarList); 133 doPackUnpack(); 134 } 135 }