243 lines
9.1 KiB
Java
243 lines
9.1 KiB
Java
/*
|
|
* Javassist, a Java-bytecode translator toolkit.
|
|
* Copyright (C) 1999- Shigeru Chiba. All Rights Reserved.
|
|
*
|
|
* The contents of this file are subject to the Mozilla Public License Version
|
|
* 1.1 (the "License"); you may not use this file except in compliance with
|
|
* the License. Alternatively, the contents of this file may be used under
|
|
* the terms of the GNU Lesser General Public License Version 2.1 or later,
|
|
* or the Apache License Version 2.0.
|
|
*
|
|
* Software distributed under the License is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
|
|
* for the specific language governing rights and limitations under the
|
|
* License.
|
|
*/
|
|
package scoped;
|
|
|
|
import java.io.File;
|
|
import java.lang.reflect.Method;
|
|
import java.math.BigDecimal;
|
|
import java.net.URL;
|
|
import java.net.URLClassLoader;
|
|
import java.util.Arrays;
|
|
import java.util.Map;
|
|
import java.util.stream.LongStream;
|
|
|
|
import javassist.ClassPool;
|
|
import javassist.CtClass;
|
|
import javassist.CtConstructor;
|
|
import javassist.CtField;
|
|
import javassist.CtMethod;
|
|
import javassist.scopedpool.ScopedClassPool;
|
|
import javassist.scopedpool.ScopedClassPoolRepository;
|
|
import javassist.scopedpool.ScopedClassPoolRepositoryImpl;
|
|
import javassist.scopedpool.SoftValueHashMap;
|
|
import junit.framework.TestCase;
|
|
|
|
|
|
/**
|
|
* ScopedRepositoryTest.
|
|
*
|
|
* @author <a href="adrian@jboss.com">Adrian Brock</a>
|
|
* @version $Revision$
|
|
*/
|
|
public class ScopedRepositoryTestCase extends TestCase
|
|
{
|
|
private static final ScopedClassPoolRepository repository = ScopedClassPoolRepositoryImpl.getInstance();
|
|
|
|
public void testJDKClasses() throws Exception
|
|
{
|
|
ClassPool poolClass = repository.findClassPool(Class.class.getClassLoader());
|
|
assertNotNull(poolClass);
|
|
ClassPool poolString = repository.findClassPool(String.class.getClassLoader());
|
|
assertNotNull(poolString);
|
|
assertEquals(poolClass, poolString);
|
|
}
|
|
|
|
public void testScopedClasses() throws Exception
|
|
{
|
|
ClassLoader cl = getURLClassLoader("test-classes14-jar1");
|
|
ClassPool pool1 = repository.findClassPool(cl);
|
|
CtClass clazz = pool1.get("scoped.jar1.TestClass1");
|
|
assertNotNull(clazz);
|
|
ClassPool poolClass = repository.findClassPool(Class.class.getClassLoader());
|
|
assertNotNull(poolClass);
|
|
assertNotSame(pool1, poolClass);
|
|
}
|
|
|
|
public void testUnscopedAnnotationUsage() throws Exception
|
|
{
|
|
CtClass clazz = getCtClass(UnscopedAnnotationUsage.class);
|
|
checkTestAnnotation(clazz, "notDefault");
|
|
}
|
|
|
|
public void testUnscopedAnnotationDefaultUsage() throws Exception
|
|
{
|
|
CtClass clazz = getCtClass(UnscopedAnnotationDefaultUsage.class);
|
|
checkTestAnnotation(clazz, "defaultValue");
|
|
}
|
|
|
|
public void testScopedAnnotationUsage() throws Exception
|
|
{
|
|
ClassLoader cl = getURLClassLoader("test-classes14-jar1");
|
|
CtClass clazz = getCtClass("scoped.jar1.ScopedAnnotationUsage", cl);
|
|
checkTestAnnotation(clazz, "notDefault");
|
|
}
|
|
|
|
public void testScopedAnnotationDefaultUsage() throws Exception
|
|
{
|
|
ClassLoader cl = getURLClassLoader("test-classes14-jar1");
|
|
CtClass clazz = getCtClass("scoped.jar1.ScopedAnnotationDefaultUsage", cl);
|
|
checkTestAnnotation(clazz, "defaultValue");
|
|
}
|
|
|
|
public void testFullyScopedAnnotationUsage() throws Exception
|
|
{
|
|
ClassLoader cl = getURLClassLoader("test-classes14-jar1");
|
|
CtClass clazz = getCtClass("scoped.jar1.FullyScopedAnnotationUsage", cl);
|
|
checkScopedAnnotation(cl, clazz, "notDefault");
|
|
}
|
|
|
|
public void testFullyScopedAnnotationDefaultUsage() throws Exception
|
|
{
|
|
ClassLoader cl = getURLClassLoader("test-classes14-jar1");
|
|
CtClass clazz = getCtClass("scoped.jar1.FullyScopedAnnotationDefaultUsage", cl);
|
|
checkScopedAnnotation(cl, clazz, "defaultValue");
|
|
}
|
|
|
|
public void testSoftValueHashMap() throws Exception {
|
|
Map<String,Class<?>> map = new SoftValueHashMap<>();
|
|
Class<?> cls = this.getClass();
|
|
assertTrue(map.put(cls.getName(), cls) == null);
|
|
assertTrue(map.put(cls.getName(), cls) == cls);
|
|
assertTrue(map.size() == 1);
|
|
assertTrue(map.get(cls.getName()) == cls);
|
|
assertTrue(map.values().iterator().next() == cls);
|
|
assertTrue(map.entrySet().iterator().next().getValue() == cls);
|
|
assertTrue(map.containsValue(cls));
|
|
assertTrue(map.remove(cls.getName()) == cls);
|
|
assertTrue(map.size() == 0);
|
|
}
|
|
|
|
public void testSoftCache() throws Exception {
|
|
// Overload the heap to test that the map auto cleans
|
|
Map<String,long[]> map = new SoftValueHashMap<>();
|
|
// 12+8*30000000 = +- 252 MB
|
|
long[] data = LongStream.range(0, 30000000).toArray();
|
|
int current = map.size();
|
|
while (current <= map.size()) {
|
|
current = map.size();
|
|
for (int ii = 0; ii < 5; ii++) {
|
|
map.put(current+"-"+ii, Arrays.copyOf(data, data.length));
|
|
}
|
|
}
|
|
assertTrue(current > map.size());
|
|
}
|
|
|
|
protected CtClass getCtClass(Class<?> clazz) throws Exception
|
|
{
|
|
return getCtClass(clazz.getName(), clazz.getClassLoader());
|
|
}
|
|
|
|
protected CtClass getCtClass(String name, ClassLoader cl) throws Exception
|
|
{
|
|
ClassPool pool = repository.findClassPool(cl);
|
|
assertNotNull(pool);
|
|
CtClass clazz = pool.get(name);
|
|
assertNotNull(clazz);
|
|
return clazz;
|
|
}
|
|
|
|
protected void checkTestAnnotation(CtClass ctClass, String value) throws Exception
|
|
{
|
|
checkTestAnnotation(ctClass.getAnnotations(), value);
|
|
checkTestAnnotation(getFieldAnnotations(ctClass), value);
|
|
checkTestAnnotation(getConstructorAnnotations(ctClass), value);
|
|
checkTestAnnotation(getConstructorParameterAnnotations(ctClass), value);
|
|
checkTestAnnotation(getMethodAnnotations(ctClass), value);
|
|
checkTestAnnotation(getMethodParameterAnnotations(ctClass), value);
|
|
}
|
|
|
|
protected void checkTestAnnotation(Object[] annotations, String value) throws Exception
|
|
{
|
|
assertNotNull(annotations);
|
|
assertEquals(1, annotations.length);
|
|
assertNotNull(annotations[0]);
|
|
assertTrue(annotations[0] instanceof TestAnnotation);
|
|
TestAnnotation annotation = (TestAnnotation) annotations[0];
|
|
assertEquals(value, annotation.something());
|
|
}
|
|
|
|
protected void checkScopedAnnotation(ClassLoader cl, CtClass ctClass, String value) throws Exception
|
|
{
|
|
Class<?> annotationClass = cl.loadClass("scoped.jar1.ScopedTestAnnotation");
|
|
checkScopedAnnotation(annotationClass, ctClass.getAnnotations(), value);
|
|
checkScopedAnnotation(annotationClass, getFieldAnnotations(ctClass), value);
|
|
checkScopedAnnotation(annotationClass, getConstructorAnnotations(ctClass), value);
|
|
checkScopedAnnotation(annotationClass, getConstructorParameterAnnotations(ctClass), value);
|
|
checkScopedAnnotation(annotationClass, getMethodAnnotations(ctClass), value);
|
|
checkScopedAnnotation(annotationClass, getMethodParameterAnnotations(ctClass), value);
|
|
}
|
|
|
|
protected void checkScopedAnnotation(Class<?> annotationClass, Object[] annotations, String value) throws Exception
|
|
{
|
|
assertNotNull(annotations);
|
|
assertEquals(1, annotations.length);
|
|
assertNotNull(annotations[0]);
|
|
assertTrue(annotationClass.isInstance(annotations[0]));
|
|
|
|
Method method = annotationClass.getMethod("something", new Class<?>[0]);
|
|
assertEquals(value, method.invoke(annotations[0], (Object[]) null));
|
|
}
|
|
|
|
protected Object[] getFieldAnnotations(CtClass clazz) throws Exception
|
|
{
|
|
CtField field = clazz.getField("aField");
|
|
assertNotNull(field);
|
|
return field.getAnnotations();
|
|
}
|
|
|
|
protected Object[] getMethodAnnotations(CtClass clazz) throws Exception
|
|
{
|
|
CtMethod method = clazz.getMethod("doSomething", "(I)V");
|
|
assertNotNull(method);
|
|
return method.getAnnotations();
|
|
}
|
|
|
|
protected Object[] getMethodParameterAnnotations(CtClass clazz) throws Exception
|
|
{
|
|
CtMethod method = clazz.getMethod("doSomething", "(I)V");
|
|
assertNotNull(method);
|
|
Object[] paramAnnotations = method.getParameterAnnotations();
|
|
assertNotNull(paramAnnotations);
|
|
assertEquals(1, paramAnnotations.length);
|
|
return (Object[]) paramAnnotations[0];
|
|
}
|
|
|
|
protected Object[] getConstructorAnnotations(CtClass clazz) throws Exception
|
|
{
|
|
CtConstructor constructor = clazz.getConstructor("(I)V");
|
|
assertNotNull(constructor);
|
|
return constructor.getAnnotations();
|
|
}
|
|
|
|
protected Object[] getConstructorParameterAnnotations(CtClass clazz) throws Exception
|
|
{
|
|
CtConstructor constructor = clazz.getConstructor("(I)V");
|
|
assertNotNull(constructor);
|
|
Object[] paramAnnotations = constructor.getParameterAnnotations();
|
|
assertNotNull(paramAnnotations);
|
|
assertEquals(1, paramAnnotations.length);
|
|
return (Object[]) paramAnnotations[0];
|
|
}
|
|
|
|
protected ClassLoader getURLClassLoader(String context) throws Exception
|
|
{
|
|
String output = ".";
|
|
File file = new File(output + File.separator + context);
|
|
URL url = file.toURI().toURL();
|
|
return new URLClassLoader(new URL[] { url });
|
|
}
|
|
}
|