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 System.out.println("Done Packing [" + in.toString() + "]"); 85 jarFile.close(); 86 System.out.println("Start leak check"); 87 leakCheck(); 88 89 System.out.println(" Unpacking using java unpacker"); 90 File javaUnpackedJar = new File("java-" + in.getName()); 91 // Write out to current directory, jtreg will setup a scratch area 92 javaUnpackerStream = new JarOutputStream( 93 new FileOutputStream(javaUnpackedJar)); 94 Utils.unpackj(packFile, javaUnpackerStream); 95 javaUnpackerStream.close(); 96 System.out.println(" Testing...java unpacker"); 97 leakCheck(); 98 // Ok we have unpacked the file, lets test it. 99 Utils.doCompareVerify(in.getAbsoluteFile(), javaUnpackedJar); 100 101 System.out.println(" Unpacking using native unpacker"); 102 // Write out to current directory 103 File nativeUnpackedJar = new File("native-" + in.getName()); 104 nativeUnpackerStream = new JarOutputStream( 105 new FileOutputStream(nativeUnpackedJar)); 106 Utils.unpackn(packFile, nativeUnpackerStream); 107 nativeUnpackerStream.close(); 108 System.out.println(" Testing...native unpacker"); 109 leakCheck(); 110 // the unpackers (native and java) should produce identical bits 111 // so we use use bit wise compare, the verification compare is 112 // very expensive wrt. time. 113 Utils.doCompareBitWise(javaUnpackedJar, nativeUnpackedJar); 114 System.out.println("Done."); 115 } catch (Exception e) { 116 throw new RuntimeException(e); 117 } finally { 118 Utils.close(nativeUnpackerStream); 119 Utils.close(javaUnpackerStream); 120 Utils.close((Closeable) jarFile); 121 } 122 } 123 Utils.cleanup(); // cleanup artifacts, if successful run 124 } 125 126 /** 127 * @param args the command line arguments 128 */ 129 public static void main(String[] args) throws IOException { 130 // select the jars carefully, adding more jars will increase the 131 // testing time, especially for jprt. 132 jarList.add(Utils.createRtJar()); 133 jarList.add(Utils.getGoldenJar()); 134 System.out.println(jarList); 135 doPackUnpack(); 136 } 137 }