227 lines
7.9 KiB
Java
227 lines
7.9 KiB
Java
/*
|
|
* Copyright (c) 2014, 2019, 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.
|
|
*/
|
|
|
|
import java.io.IOException;
|
|
import java.io.OutputStream;
|
|
import java.io.UncheckedIOException;
|
|
import java.lang.annotation.Annotation;
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.nio.file.FileSystem;
|
|
import java.nio.file.FileSystems;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.stream.Collectors;
|
|
import java.util.zip.ZipEntry;
|
|
import java.util.zip.ZipOutputStream;
|
|
|
|
import javax.tools.JavaCompiler;
|
|
import javax.tools.StandardJavaFileManager;
|
|
import javax.tools.ToolProvider;
|
|
|
|
/**
|
|
* Base class for unit tests for StandardJavaFileManager.
|
|
*/
|
|
class SJFM_TestBase {
|
|
|
|
/** Shared compiler instance. */
|
|
JavaCompiler comp;
|
|
|
|
/** A list of items to be closed when the test is complete. */
|
|
List<AutoCloseable> closeables;
|
|
|
|
/**
|
|
* Runs a test. This is the primary entry point and should generally be
|
|
* called from each test's main method.
|
|
* It calls all methods annotated with {@code @Test} with the instances
|
|
* of StandardJavaFileManager to be tested.
|
|
*
|
|
* @throws Exception if the test fails.
|
|
*/
|
|
void run() throws Exception {
|
|
comp = ToolProvider.getSystemJavaCompiler();
|
|
closeables = new ArrayList<>();
|
|
|
|
try (StandardJavaFileManager systemFileManager = comp.getStandardFileManager(null, null, null);
|
|
StandardJavaFileManager customFileManager = new MyStandardJavaFileManager(systemFileManager)) {
|
|
test(systemFileManager);
|
|
test(customFileManager);
|
|
} finally {
|
|
for (AutoCloseable c: closeables) {
|
|
try {
|
|
c.close();
|
|
} catch (IOException e) {
|
|
error("Exception closing " + c + ": " + e);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (errors > 0)
|
|
throw new Exception(errors + " errors occurred");
|
|
}
|
|
|
|
/**
|
|
* Get the file managers to be tested.
|
|
*
|
|
* Currently, two are provided:
|
|
* <ol>
|
|
* <li>the system-provided file manager
|
|
* <li>a custom file manager, which relies on the default methods provided in the
|
|
* StandardJavaFileManager interface
|
|
* </li>
|
|
*
|
|
* @return the file managers to be tested
|
|
*/
|
|
List<StandardJavaFileManager> getTestFileManagers() {
|
|
StandardJavaFileManager systemFileManager = comp.getStandardFileManager(null, null, null);
|
|
StandardJavaFileManager customFileManager = new MyStandardJavaFileManager(systemFileManager);
|
|
return Arrays.asList(systemFileManager, customFileManager);
|
|
}
|
|
|
|
/**
|
|
* Tests a specific file manager, by calling all methods annotated
|
|
* with {@code @Test} passing this file manager as an argument.
|
|
*
|
|
* @param fm the file manager to be tested
|
|
* @throws Exception if the test fails
|
|
*/
|
|
void test(StandardJavaFileManager fm) throws Exception {
|
|
System.err.println("Testing " + fm);
|
|
for (Method m: getClass().getDeclaredMethods()) {
|
|
Annotation a = m.getAnnotation(Test.class);
|
|
if (a != null) {
|
|
try {
|
|
System.err.println("Test " + m.getName());
|
|
m.invoke(this, new Object[] { fm });
|
|
} catch (InvocationTargetException e) {
|
|
Throwable cause = e.getCause();
|
|
throw (cause instanceof Exception) ? ((Exception) cause) : e;
|
|
}
|
|
System.err.println();
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Marker annotation for test cases. */
|
|
@Retention(RetentionPolicy.RUNTIME)
|
|
@interface Test { }
|
|
|
|
/**
|
|
* Returns a series of paths for artifacts in the default file system.
|
|
* The paths are for the .java files in the test.src directory.
|
|
*
|
|
* @return a list of paths
|
|
* @throws IOException
|
|
*/
|
|
List<Path> getTestFilePaths() throws IOException {
|
|
String testSrc = System.getProperty("test.src");
|
|
return Files.list(Paths.get(testSrc))
|
|
.filter(p -> p.getFileName().toString().endsWith(".java"))
|
|
.collect(Collectors.toList());
|
|
}
|
|
|
|
private FileSystem zipfs;
|
|
private List<Path> zipPaths;
|
|
|
|
/**
|
|
* Returns a series of paths for artifacts in a non-default file system.
|
|
* A zip file is created containing copies of the .java files in the
|
|
* test.src directory. The paths that are returned refer to these files.
|
|
*
|
|
* @return a list of paths
|
|
* @throws IOException
|
|
*/
|
|
List<Path> getTestZipPaths() throws IOException {
|
|
if (zipfs == null) {
|
|
Path testZip = createSourceZip();
|
|
zipfs = FileSystems.newFileSystem(testZip);
|
|
closeables.add(zipfs);
|
|
zipPaths = Files.list(zipfs.getRootDirectories().iterator().next())
|
|
.filter(p -> p.getFileName().toString().endsWith(".java"))
|
|
.collect(Collectors.toList());
|
|
}
|
|
return zipPaths;
|
|
}
|
|
|
|
/**
|
|
* Create a zip file containing the contents of the test.src directory.
|
|
*
|
|
* @return a path for the zip file.
|
|
* @throws IOException if there is a problem creating the file
|
|
*/
|
|
private Path createSourceZip() throws IOException {
|
|
Path testSrc = Paths.get(System.getProperty("test.src"));
|
|
Path testZip = Paths.get("test.zip");
|
|
try (OutputStream os = Files.newOutputStream(testZip)) {
|
|
try (ZipOutputStream zos = new ZipOutputStream(os)) {
|
|
Files.list(testSrc)
|
|
.filter(p -> p.getFileName().toString().endsWith(".java"))
|
|
.forEach(p -> {
|
|
try {
|
|
zos.putNextEntry(new ZipEntry(p.getFileName().toString()));
|
|
zos.write(Files.readAllBytes(p));
|
|
zos.closeEntry();
|
|
} catch (IOException ex) {
|
|
throw new UncheckedIOException(ex);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
return testZip;
|
|
}
|
|
|
|
/**
|
|
* Tests whether it is expected that a file manager will be able
|
|
* to create a series of file objects from a series of paths.
|
|
*
|
|
* MyStandardJavaFileManager does not support paths referring to
|
|
* non-default file systems.
|
|
*
|
|
* @param fm the file manager to be tested
|
|
* @param paths the paths to be tested
|
|
* @return
|
|
*/
|
|
boolean isGetFileObjectsSupported(StandardJavaFileManager fm, List<Path> paths) {
|
|
return !(fm instanceof MyStandardJavaFileManager
|
|
&& (paths.get(0).getFileSystem() != FileSystems.getDefault()));
|
|
}
|
|
|
|
/**
|
|
* Report an error.
|
|
*/
|
|
void error(String msg) {
|
|
System.err.println("Error: " + msg);
|
|
errors++;
|
|
}
|
|
|
|
/** Count of errors reported. */
|
|
int errors;
|
|
|
|
}
|