/*
* Copyright (c) 2009, 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.
*/
/*
* @test
* @bug 6877206
* @summary JavaFileObject.toUri returns bogus URI (win)
*/
import java.io.*;
import java.net.*;
import java.util.*;
import java.util.jar.*;
import java.util.zip.*;
import javax.tools.*;
import com.sun.tools.javac.file.JavacFileManager;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.Options;
// Test URIs returned from JavacFileManager and its support classes.
// For a variety of file objects, verify the validity of FileObject.toUri()
// by verifying the URI exists and points to the same contents as the file
// object itself
public class T6877206 {
public static void main(String... args) throws Exception {
new T6877206().run();
}
Set<String> foundClasses = new TreeSet<String>();
Set<String> foundJars = new TreeSet<String>();
void run() throws Exception {
File rt_jar = findRtJar();
// names for entries to be created in directories and jar files
String[] entries = { "p/A.class", "p/resources/A-1.jpg" };
// test various combinations of directories and jar files, intended to
// cover all sources of URIs within JavacFileManager's support classes
test(createFileManager(), createDir("dir", entries), "p", entries.length);
test(createFileManager(), createDir("a b/dir", entries), "p", entries.length);
for (boolean useJavaUtilZip: new boolean[] { false, true }) {
test(createFileManager(useJavaUtilZip), createJar("jar", entries), "p", entries.length);
test(createFileManager(useJavaUtilZip), createJar("jar jar", entries), "p", entries.length);
for (boolean useSymbolFile: new boolean[] { false, true }) {
test(createFileManager(useJavaUtilZip, useSymbolFile), rt_jar, "java.lang.ref", -1);
}
}
// Verify that we hit all the impl classes we intended
checkCoverage("classes", foundClasses,
"RegularFileObject", "SymbolFileObject", "ZipFileIndexFileObject", "ZipFileObject");
// Verify that we hit the jar files we intended, specifically ct.sym as well as rt.jar
checkCoverage("jar files", foundJars,
"ct.sym", "jar", "jar jar", "rt.jar");
}
// use a new file manager for each test
void test(StandardJavaFileManager fm, File f, String pkg, int expect) throws Exception {
JarURLConnection c;
System.err.println("Test " + f);
try {
fm.setLocation(StandardLocation.CLASS_PATH, Collections.singleton(f));
int count = 0;
for (JavaFileObject fo: fm.list(StandardLocation.CLASS_PATH,
pkg, EnumSet.allOf(JavaFileObject.Kind.class), true)) {
System.err.println("checking " + fo);
// record the file object class name for coverage checks later
foundClasses.add(fo.getClass().getSimpleName());
testFileObject(fo);
count++;
}
if (expect > 0 && count != expect)
throw new Exception("wrong number of entries found: "
+ count + ", expected " + expect);
} finally {
fm.close();
}
}
void testFileObject(JavaFileObject fo) throws Exception {
// test the validity of the result of toUri() by using URLConnection
// and comparing the results of reading from the connection with the
// result of reading from the file object directly.
URI uri = fo.toUri();
System.err.println("uri: " + uri);
URLConnection urlconn = uri.toURL().openConnection();
if (urlconn instanceof JarURLConnection) {
JarURLConnection jarconn = (JarURLConnection) urlconn;
File f = new File(jarconn.getJarFile().getName());
// record access to the jar file for coverage checks later
foundJars.add(f.getName());
}
try {
byte[] uriData = read(urlconn.getInputStream());
byte[] foData = read(fo.openInputStream());
if (!Arrays.equals(uriData, foData)) {
if (uriData.length != foData.length)
throw new Exception("data size differs: uri data "
+ uriData.length + " bytes, fo data " + foData.length+ " bytes");
for (int i = 0; i < uriData.length; i++) {
if (uriData[i] != foData[i])
throw new Exception("unexpected data returned at offset " + i
+ ", uri data " + uriData[i] + ", fo data " + foData[i]);
}
throw new AssertionError("cannot find difference");
}
} finally {
// In principle, simply closing the result of urlconn.getInputStream()
// should have been sufficient. But the internal JarURLConnection
// does not close the JarFile in an expeditious manner, thus preventing
// jtreg from deleting the jar file before starting the next test.
// Therefore we force access to the JarURLConnection to close the
// JarFile when necessary.
if (urlconn instanceof JarURLConnection) {
JarURLConnection jarconn = (JarURLConnection) urlconn;
jarconn.getJarFile().close();
}
}
}
void checkCoverage(String label, Set<String> found, String... expect) throws Exception {
Set<String> e = new TreeSet<String>(Arrays.asList(expect));
if (!found.equals(e)) {
e.removeAll(found);
throw new Exception("expected " + label + " not used: " + e);
}
}
JavacFileManager createFileManager() {
return createFileManager(false, false);
}
JavacFileManager createFileManager(boolean useJavaUtilZip) {
return createFileManager(useJavaUtilZip, false);
}
JavacFileManager createFileManager(boolean useJavaUtilZip, boolean useSymbolFile) {
// javac should really not be using system properties like this
// -- it should really be using (hidden) options -- but until then
// take care to leave system properties as we find them, so as not
// to adversely affect other tests that might follow.
String prev = System.getProperty("useJavaUtilZip");
boolean resetProperties = false;
try {
if (useJavaUtilZip) {
System.setProperty("useJavaUtilZip", "true");
resetProperties = true;
} else if (System.getProperty("useJavaUtilZip") != null) {
System.getProperties().remove("useJavaUtilZip");
resetProperties = true;
}
Context c = new Context();
if (!useSymbolFile) {
Options options = Options.instance(c);
options.put("ignore.symbol.file", "true");
}
return new JavacFileManager(c, false, null);
} finally {
if (resetProperties) {
if (prev == null) {
System.getProperties().remove("useJavaUtilZip");
} else {
System.setProperty("useJavaUtilZip", prev);
}
}
}
}
File createDir(String name, String... entries) throws Exception {
File dir = new File(name);
if (!dir.mkdirs())
throw new Exception("cannot create directories " + dir);
for (String e: entries) {
writeFile(new File(dir, e), e);
}
return dir;
}
File createJar(String name, String... entries) throws IOException {
File jar = new File(name);
OutputStream out = new FileOutputStream(jar);
try {
JarOutputStream jos = new JarOutputStream(out);
for (String e: entries) {
jos.putNextEntry(new ZipEntry(e));
jos.write(e.getBytes());
}
jos.close();
} finally {
out.close();
}
return jar;
}
File findRtJar() throws Exception {
File java_home = new File(System.getProperty("java.home"));
if (java_home.getName().equals("jre"))
java_home = java_home.getParentFile();
File rt_jar = new File(new File(new File(java_home, "jre"), "lib"), "rt.jar");
if (!rt_jar.exists())
throw new Exception("can't find rt.jar");
return rt_jar;
}
byte[] read(InputStream in) throws IOException {
byte[] data = new byte[1024];
int offset = 0;
try {
int n;
while ((n = in.read(data, offset, data.length - offset)) != -1) {
offset += n;
if (offset == data.length)
data = Arrays.copyOf(data, 2 * data.length);
}
} finally {
in.close();
}
return Arrays.copyOf(data, offset);
}
void writeFile(File f, String s) throws IOException {
f.getParentFile().mkdirs();
FileWriter out = new FileWriter(f);
try {
out.write(s);
} finally {
out.close();
}
}
}