/**
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.hadoop.hbase;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;
import javax.tools.JavaCompiler;
import javax.tools.ToolProvider;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.experimental.categories.Category;
@Category(SmallTests.class)
public class TestClassFinder {
private static final Log LOG = LogFactory.getLog(TestClassFinder.class);
private static final HBaseCommonTestingUtility testUtil = new HBaseCommonTestingUtility();
private static final String BASEPKG = "tfcpkg";
// Use unique jar/class/package names in each test case with the help
// of these global counters; we are mucking with ClassLoader in this test
// and we don't want individual test cases to conflict via it.
private static AtomicLong testCounter = new AtomicLong(0);
private static AtomicLong jarCounter = new AtomicLong(0);
private static String basePath = null;
@BeforeClass
public static void createTestDir() throws IOException {
basePath = testUtil.getDataTestDir(TestClassFinder.class.getSimpleName()).toString();
if (!basePath.endsWith("/")) {
basePath += "/";
}
// Make sure we get a brand new directory.
File testDir = new File(basePath);
if (testDir.exists()) {
deleteTestDir();
}
assertTrue(testDir.mkdirs());
}
@AfterClass
public static void deleteTestDir() throws IOException {
testUtil.cleanupTestDir(TestClassFinder.class.getSimpleName());
}
@Test
public void testClassFinderCanFindClassesInJars() throws Exception {
long counter = testCounter.incrementAndGet();
FileAndPath c1 = compileTestClass(counter, "", "c1");
FileAndPath c2 = compileTestClass(counter, ".nested", "c2");
FileAndPath c3 = compileTestClass(counter, "", "c3");
packageAndLoadJar(c1, c3);
packageAndLoadJar(c2);
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> allClasses = allClassesFinder.findClasses(
makePackageName("", counter), false);
assertEquals(3, allClasses.size());
}
@Test
public void testClassFinderHandlesConflicts() throws Exception {
long counter = testCounter.incrementAndGet();
FileAndPath c1 = compileTestClass(counter, "", "c1");
FileAndPath c2 = compileTestClass(counter, "", "c2");
packageAndLoadJar(c1, c2);
packageAndLoadJar(c1);
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> allClasses = allClassesFinder.findClasses(
makePackageName("", counter), false);
assertEquals(2, allClasses.size());
}
@Test
public void testClassFinderHandlesNestedPackages() throws Exception {
final String NESTED = ".nested";
final String CLASSNAME1 = "c2";
final String CLASSNAME2 = "c3";
long counter = testCounter.incrementAndGet();
FileAndPath c1 = compileTestClass(counter, "", "c1");
FileAndPath c2 = compileTestClass(counter, NESTED, CLASSNAME1);
FileAndPath c3 = compileTestClass(counter, NESTED, CLASSNAME2);
packageAndLoadJar(c1, c2);
packageAndLoadJar(c3);
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> nestedClasses = allClassesFinder.findClasses(
makePackageName(NESTED, counter), false);
assertEquals(2, nestedClasses.size());
Class<?> nestedClass1 = makeClass(NESTED, CLASSNAME1, counter);
assertTrue(nestedClasses.contains(nestedClass1));
Class<?> nestedClass2 = makeClass(NESTED, CLASSNAME2, counter);
assertTrue(nestedClasses.contains(nestedClass2));
}
@Test
public void testClassFinderFiltersByNameInJar() throws Exception {
final String CLASSNAME = "c1";
final String CLASSNAMEEXCPREFIX = "c2";
long counter = testCounter.incrementAndGet();
FileAndPath c1 = compileTestClass(counter, "", CLASSNAME);
FileAndPath c2 = compileTestClass(counter, "", CLASSNAMEEXCPREFIX + "1");
FileAndPath c3 = compileTestClass(counter, "", CLASSNAMEEXCPREFIX + "2");
packageAndLoadJar(c1, c2, c3);
ClassFinder.FileNameFilter notExcNameFilter = new ClassFinder.FileNameFilter() {
@Override
public boolean isCandidateFile(String fileName, String absFilePath) {
return !fileName.startsWith(CLASSNAMEEXCPREFIX);
}
};
ClassFinder incClassesFinder = new ClassFinder(null, notExcNameFilter, null);
Set<Class<?>> incClasses = incClassesFinder.findClasses(
makePackageName("", counter), false);
assertEquals(1, incClasses.size());
Class<?> incClass = makeClass("", CLASSNAME, counter);
assertTrue(incClasses.contains(incClass));
}
@Test
public void testClassFinderFiltersByClassInJar() throws Exception {
final String CLASSNAME = "c1";
final String CLASSNAMEEXCPREFIX = "c2";
long counter = testCounter.incrementAndGet();
FileAndPath c1 = compileTestClass(counter, "", CLASSNAME);
FileAndPath c2 = compileTestClass(counter, "", CLASSNAMEEXCPREFIX + "1");
FileAndPath c3 = compileTestClass(counter, "", CLASSNAMEEXCPREFIX + "2");
packageAndLoadJar(c1, c2, c3);
final ClassFinder.ClassFilter notExcClassFilter = new ClassFinder.ClassFilter() {
@Override
public boolean isCandidateClass(Class<?> c) {
return !c.getSimpleName().startsWith(CLASSNAMEEXCPREFIX);
}
};
ClassFinder incClassesFinder = new ClassFinder(null, null, notExcClassFilter);
Set<Class<?>> incClasses = incClassesFinder.findClasses(
makePackageName("", counter), false);
assertEquals(1, incClasses.size());
Class<?> incClass = makeClass("", CLASSNAME, counter);
assertTrue(incClasses.contains(incClass));
}
@Test
public void testClassFinderFiltersByPathInJar() throws Exception {
final String CLASSNAME = "c1";
long counter = testCounter.incrementAndGet();
FileAndPath c1 = compileTestClass(counter, "", CLASSNAME);
FileAndPath c2 = compileTestClass(counter, "", "c2");
packageAndLoadJar(c1);
final String excludedJar = packageAndLoadJar(c2);
/* ResourcePathFilter will pass us the resourcePath as a path of a
* URL from the classloader. For Windows, the ablosute path and the
* one from the URL have different file separators.
*/
final String excludedJarResource =
new File(excludedJar).toURI().getRawSchemeSpecificPart();
final ClassFinder.ResourcePathFilter notExcJarFilter =
new ClassFinder.ResourcePathFilter() {
@Override
public boolean isCandidatePath(String resourcePath, boolean isJar) {
return !isJar || !resourcePath.equals(excludedJarResource);
}
};
ClassFinder incClassesFinder = new ClassFinder(notExcJarFilter, null, null);
Set<Class<?>> incClasses = incClassesFinder.findClasses(
makePackageName("", counter), false);
assertEquals(1, incClasses.size());
Class<?> incClass = makeClass("", CLASSNAME, counter);
assertTrue(incClasses.contains(incClass));
}
@Test
public void testClassFinderCanFindClassesInDirs() throws Exception {
// Well, technically, we are not guaranteed that the classes will
// be in dirs, but during normal build they would be.
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> allClasses = allClassesFinder.findClasses(
this.getClass().getPackage().getName(), false);
assertTrue(allClasses.contains(this.getClass()));
assertTrue(allClasses.contains(ClassFinder.class));
}
@Test
public void testClassFinderFiltersByNameInDirs() throws Exception {
final String thisName = this.getClass().getSimpleName();
final ClassFinder.FileNameFilter notThisFilter = new ClassFinder.FileNameFilter() {
@Override
public boolean isCandidateFile(String fileName, String absFilePath) {
return !fileName.equals(thisName + ".class");
}
};
String thisPackage = this.getClass().getPackage().getName();
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> allClasses = allClassesFinder.findClasses(thisPackage, false);
ClassFinder notThisClassFinder = new ClassFinder(null, notThisFilter, null);
Set<Class<?>> notAllClasses = notThisClassFinder.findClasses(thisPackage, false);
assertFalse(notAllClasses.contains(this.getClass()));
assertEquals(allClasses.size() - 1, notAllClasses.size());
}
@Test
public void testClassFinderFiltersByClassInDirs() throws Exception {
final ClassFinder.ClassFilter notThisFilter = new ClassFinder.ClassFilter() {
@Override
public boolean isCandidateClass(Class<?> c) {
return c != TestClassFinder.class;
}
};
String thisPackage = this.getClass().getPackage().getName();
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> allClasses = allClassesFinder.findClasses(thisPackage, false);
ClassFinder notThisClassFinder = new ClassFinder(null, null, notThisFilter);
Set<Class<?>> notAllClasses = notThisClassFinder.findClasses(thisPackage, false);
assertFalse(notAllClasses.contains(this.getClass()));
assertEquals(allClasses.size() - 1, notAllClasses.size());
}
@Test
public void testClassFinderFiltersByPathInDirs() throws Exception {
final String hardcodedThisSubdir = "hbase-common";
final ClassFinder.ResourcePathFilter notExcJarFilter =
new ClassFinder.ResourcePathFilter() {
@Override
public boolean isCandidatePath(String resourcePath, boolean isJar) {
return isJar || !resourcePath.contains(hardcodedThisSubdir);
}
};
String thisPackage = this.getClass().getPackage().getName();
ClassFinder notThisClassFinder = new ClassFinder(notExcJarFilter, null, null);
Set<Class<?>> notAllClasses = notThisClassFinder.findClasses(thisPackage, false);
assertFalse(notAllClasses.contains(this.getClass()));
}
@Test
public void testClassFinderDefaultsToOwnPackage() throws Exception {
// Correct handling of nested packages is tested elsewhere, so here we just assume
// pkgClasses is the correct answer that we don't have to check.
ClassFinder allClassesFinder = new ClassFinder();
Set<Class<?>> pkgClasses = allClassesFinder.findClasses(
ClassFinder.class.getPackage().getName(), false);
Set<Class<?>> defaultClasses = allClassesFinder.findClasses(false);
assertArrayEquals(pkgClasses.toArray(), defaultClasses.toArray());
}
private static class FileAndPath {
String path;
File file;
public FileAndPath(String path, File file) {
this.file = file;
this.path = path;
}
}
private static Class<?> makeClass(String nestedPkgSuffix,
String className, long counter) throws ClassNotFoundException {
return Class.forName(
makePackageName(nestedPkgSuffix, counter) + "." + className + counter);
}
private static String makePackageName(String nestedSuffix, long counter) {
return BASEPKG + counter + nestedSuffix;
}
/**
* Compiles the test class with bogus code into a .class file.
* Unfortunately it's very tedious.
* @param counter Unique test counter.
* @param packageNameSuffix Package name suffix (e.g. ".suffix") for nesting, or "".
* @return The resulting .class file and the location in jar it is supposed to go to.
*/
private static FileAndPath compileTestClass(long counter,
String packageNameSuffix, String classNamePrefix) throws Exception {
classNamePrefix = classNamePrefix + counter;
String packageName = makePackageName(packageNameSuffix, counter);
String javaPath = basePath + classNamePrefix + ".java";
String classPath = basePath + classNamePrefix + ".class";
PrintStream source = new PrintStream(javaPath);
source.println("package " + packageName + ";");
source.println("public class " + classNamePrefix
+ " { public static void main(String[] args) { } };");
source.close();
JavaCompiler jc = ToolProvider.getSystemJavaCompiler();
int result = jc.run(null, null, null, javaPath);
assertEquals(0, result);
File classFile = new File(classPath);
assertTrue(classFile.exists());
return new FileAndPath(packageName.replace('.', '/') + '/', classFile);
}
/**
* Makes a jar out of some class files. Unfortunately it's very tedious.
* @param filesInJar Files created via compileTestClass.
* @return path to the resulting jar file.
*/
private static String packageAndLoadJar(FileAndPath... filesInJar) throws Exception {
// First, write the bogus jar file.
String path = basePath + "jar" + jarCounter.incrementAndGet() + ".jar";
Manifest manifest = new Manifest();
manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
FileOutputStream fos = new FileOutputStream(path);
JarOutputStream jarOutputStream = new JarOutputStream(fos, manifest);
// Directory entries for all packages have to be added explicitly for
// resources to be findable via ClassLoader. Directory entries must end
// with "/"; the initial one is expected to, also.
Set<String> pathsInJar = new HashSet<String>();
for (FileAndPath fileAndPath : filesInJar) {
String pathToAdd = fileAndPath.path;
while (pathsInJar.add(pathToAdd)) {
int ix = pathToAdd.lastIndexOf('/', pathToAdd.length() - 2);
if (ix < 0) {
break;
}
pathToAdd = pathToAdd.substring(0, ix);
}
}
for (String pathInJar : pathsInJar) {
jarOutputStream.putNextEntry(new JarEntry(pathInJar));
jarOutputStream.closeEntry();
}
for (FileAndPath fileAndPath : filesInJar) {
File file = fileAndPath.file;
jarOutputStream.putNextEntry(
new JarEntry(fileAndPath.path + file.getName()));
byte[] allBytes = new byte[(int)file.length()];
FileInputStream fis = new FileInputStream(file);
fis.read(allBytes);
fis.close();
jarOutputStream.write(allBytes);
jarOutputStream.closeEntry();
}
jarOutputStream.close();
fos.close();
// Add the file to classpath.
File jarFile = new File(path);
assertTrue(jarFile.exists());
URLClassLoader urlClassLoader = (URLClassLoader)ClassLoader.getSystemClassLoader();
Method method = URLClassLoader.class
.getDeclaredMethod("addURL", new Class[] { URL.class });
method.setAccessible(true);
method.invoke(urlClassLoader, new Object[] { jarFile.toURI().toURL() });
return jarFile.getAbsolutePath();
}
};