jdk8-mips64-public/langtools: comparison test/tools/javac/file/zip/T6836682.java

-:5b29f2a85085
+:f2f04935ef3f
 * questions.
 */
 /*
 * @test
-* @ignore
 * @bug 6836682 7025988
-* @summary JavacFileManager handles zip64 archives (64K+ entries and large file support)
+* @summary JavacFileManager handling of zip64 archives (Scenario A and B)
 * @compile  -XDignore.symbol.file T6836682.java Utils.java
 * @run main T6836682
 */
+/*
+* This test consists of two scenarios:
+*
+* Scenario A: create a jar with entries exceeding 64K, and see if the javac
+* can handle this large jar on the classpath. Generally this test completes
+* within a minute
+*
+* Scenario B: create a jar with a large enough file exceeding 4GB, and
+* similarly test javac. This test is known to be slow and problematic on
+* certain operating systems, thus this test can be selected by passing a
+* property through jtreg as follows:
+* -javaoptions=-DT6836682.testScenarioB=true.
+* Note this test will only run iff all the disk requirements are met at runtime.
+*/
+import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.jar.JarOutputStream;
+import java.util.zip.CRC32;
 import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
 public class T6836682 {
 private static final long GIGA = 1024 * 1024 * 1024;
+private static final int BUFFER_LEN = Short.MAX_VALUE * 2;
-static void createLargeFile(File outFile, long minlength) throws IOException {
-FileOutputStream fos = null;
+static long getCount(long minlength) {
-BufferedOutputStream bos = null;
+return (minlength / BUFFER_LEN) + 1;
-byte[] buffer = new byte[Short.MAX_VALUE * 2];
+}
-try {
-fos = new FileOutputStream(outFile);
+static long computeCRC(long minlength) {
-bos = new BufferedOutputStream(fos);
+CRC32 crc = new CRC32();
-long count = minlength / ( Short.MAX_VALUE * 2)  + 1;
+byte[] buffer = new byte[BUFFER_LEN];
-for (long i = 0 ; i < count ; i++) {
+long count = getCount(minlength);
-bos.write(buffer);
+for (long i = 0; i < count; i++) {
-}
+crc.update(buffer);
-} finally {
+}
-Utils.close(bos);
+return crc.getValue();
-Utils.close(fos);
+}
-}
-if (outFile.length() < minlength) {
+static long computeCRC(File inFile) throws IOException {
-throw new RuntimeException("could not create large file " + outFile.getAbsolutePath());
+byte[] buffer = new byte[8192];
-}
+CRC32 crc = new CRC32();
+FileInputStream fis = null;
+BufferedInputStream bis = null;
+try {
+fis = new FileInputStream(inFile);
+bis = new BufferedInputStream(fis);
+int n = bis.read(buffer);
+while (n > 0) {
+crc.update(buffer, 0, n);
+n = bis.read(buffer);
+}
+} finally {
+Utils.close(bis);
+Utils.close(fis);
+}
+return crc.getValue();
+}
+static void createLargeFile(OutputStream os, long minlength) throws IOException {
+byte[] buffer = new byte[BUFFER_LEN];
+long count = getCount(minlength);
+for (long i = 0; i < count; i++) {
+os.write(buffer);
+}
+os.flush();
 }
 static void createJarWithLargeFile(File jarFile, File javaFile,
 long minlength) throws IOException {
 Utils.createClassFile(javaFile, null, true);
-File largeFile = new File("large.data");
+File classFile = new File(Utils.getClassFileName(javaFile));
-createLargeFile(largeFile, minlength);
+ZipOutputStream zos = null;
-String[] jarArgs = {
+BufferedOutputStream bos = null;
-"0cvf",
+FileInputStream fis = null;
-jarFile.getAbsolutePath(),
+try {
-largeFile.getName(),
+zos = new ZipOutputStream(new FileOutputStream(jarFile));
-Utils.getClassFileName(javaFile)
+zos.setLevel(ZipOutputStream.STORED);
-};
+zos.setMethod(0);
-Utils.jarTool.run(jarArgs);
+bos = new BufferedOutputStream(zos);
+ZipEntry ze = new ZipEntry("large.data");
+ze.setCompressedSize(getCount(minlength) * BUFFER_LEN);
+ze.setSize(getCount(minlength) * BUFFER_LEN);
+ze.setCrc(computeCRC(minlength));
+ze.setMethod(ZipEntry.STORED);
+zos.putNextEntry(ze);
+createLargeFile(bos, minlength);
+ze = new ZipEntry(classFile.getName());
+ze.setCompressedSize(classFile.length());
+ze.setSize(classFile.length());
+ze.setCrc(computeCRC(classFile));
+ze.setMethod(ZipEntry.STORED);
+zos.putNextEntry(ze);
+fis = new FileInputStream(classFile);
+Utils.copyStream(fis, bos);
+bos.flush();
+zos.closeEntry();
+} finally {
+Utils.close(bos);
+Utils.close(zos);
+Utils.close(fis);
+}
 // deleted to prevent accidental linkage
 new File(Utils.getClassFileName(javaFile)).delete();
 }
 static void createLargeJar(File jarFile, File javaFile) throws IOException {
 File classFile = new File(Utils.getClassFileName(javaFile));
 Utils.createClassFile(javaFile, null, true);
-JarOutputStream jos = null;
+ZipOutputStream zos = null;
 FileInputStream fis = null;
-try {
+final int MAX = Short.MAX_VALUE * 2 + 10;
-jos = new JarOutputStream(new FileOutputStream(jarFile));
+ZipEntry ze = null;
+try {
-for (int i = 0; i < Short.MAX_VALUE * 2 + 10; i++) {
+zos = new ZipOutputStream(new FileOutputStream(jarFile));
-jos.putNextEntry(new ZipEntry("X" + i + ".txt"));
+zos.setLevel(ZipOutputStream.STORED);
-}
+zos.setMethod(ZipOutputStream.STORED);
-jos.putNextEntry(new ZipEntry(classFile.getName()));
+for (int i = 0; i < MAX ; i++) {
+ze = new ZipEntry("X" + i + ".txt");
+ze.setSize(0);
+ze.setCompressedSize(0);
+ze.setCrc(0);
+zos.putNextEntry(ze);
+}
+// add a class file
+ze = new ZipEntry(classFile.getName());
+ze.setCompressedSize(classFile.length());
+ze.setSize(classFile.length());
+ze.setCrc(computeCRC(classFile));
+zos.putNextEntry(ze);
 fis = new FileInputStream(classFile);
-Utils.copyStream(fis, jos);
+Utils.copyStream(fis, zos);
 } finally {
-Utils.close(jos);
+Utils.close(zos);
 Utils.close(fis);
-}
 // deleted to prevent accidental linkage
 new File(Utils.getClassFileName(javaFile)).delete();
 }
+}
 // a jar with entries exceeding 64k + a class file for the existential test
-public static void testLargeJar(String... args) throws IOException {
+public static void testScenarioA(String... args) throws IOException {
 File largeJar = new File("large.jar");
 File javaFile = new File("Foo.java");
 createLargeJar(largeJar, javaFile);
 File testFile = new File("Bar.java");
 Utils.deleteFile(largeJar);
 }
 }
 // a jar with an enormous file + a class file for the existential test
-public static void testHugeJar(String... args) throws IOException {
+public static void testScenarioB(String... args) throws IOException {
 final File largeJar = new File("huge.jar");
 final File javaFile = new File("Foo.java");
 final Path path = largeJar.getAbsoluteFile().getParentFile().toPath();
 final long available = Files.getFileStore(path).getUsableSpace();
 final long MAX_VALUE = 0xFFFF_FFFFL;
 final long absolute  = MAX_VALUE + 1L;
 final long required  = (long)(absolute * 1.1); // pad for sundries
 System.out.println("\tavailable: " + available / GIGA + " GB");
-System.out.println("\required: " + required / GIGA + " GB");
+System.out.println("\trequired: " + required / GIGA + " GB");
 if (available > required) {
 createJarWithLargeFile(largeJar, javaFile, absolute);
 File testFile = new File("Bar.java");
 Utils.createJavaFile(testFile, javaFile);
 }
 } finally {
 Utils.deleteFile(largeJar);
 }
 } else {
-System.out.println("Warning: test passes vacuously, requirements exceeds available space");
+System.out.println("Warning: testScenarioB passes vacuously," +
+" requirements exceeds available space");
 }
 }
 public static void main(String... args) throws IOException {
-testLargeJar();
+testScenarioA();
-testHugeJar();
+System.out.println("testScenarioA: PASS");
+if (Boolean.getBoolean("T6836682.testScenarioB")) {
+testScenarioB();
+System.out.println("testScenarioB: PASS");
+} else {
+System.out.println("Warning: testScenarioB, large file test skipped");
+}
 }
 }

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/file/zip/T6836682.java

test/tools/javac/file/zip/T6836682.java