1 files changed, 242 insertions, 0 deletions
diff --git a/src/test/scoped/ScopedRepositoryTestCase.java b/src/test/scoped/ScopedRepositoryTestCase.java
new file mode 100644
index 00000000..9dca4f56
--- /dev/null
+++ b/src/test/scoped/ScopedRepositoryTestCase.java
@@ -0,0 +1,242 @@
+/*
+ * 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 });
+   }
+}