239649 and primitives no longer all resolved by default

weaver5/java5-src/org/aspectj/weaver/reflect/DeferredResolvedPointcutDefinition.java

 package org.aspectj.weaver.reflect;
 
 import org.aspectj.weaver.ResolvedPointcutDefinition;
-import org.aspectj.weaver.ResolvedType;
 import org.aspectj.weaver.UnresolvedType;
 
 /**
- * When a Java15ReflectionBasedDelegate gets the pointcuts for a given class it 
- * tries to resolve them before returning.
- * This can cause problems if the resolution of one pointcut in the type depends
- * on another pointcut in the same type. 
- * Therefore the algorithm proceeds in two phases, first we create and store
- * instances of this class in the pointcuts array, and once that is done, we
- * come back round and resolve the actual pointcut expression. This means that
- * if we recurse doing resolution, we will find the named pointcut we are 
- * looking for!
+ * When a Java15ReflectionBasedDelegate gets the pointcuts for a given class it tries to resolve them before returning. This can
+ * cause problems if the resolution of one pointcut in the type depends on another pointcut in the same type. Therefore the
+ * algorithm proceeds in two phases, first we create and store instances of this class in the pointcuts array, and once that is
+ * done, we come back round and resolve the actual pointcut expression. This means that if we recurse doing resolution, we will find
+ * the named pointcut we are looking for!
  * 
  * @author adrian colyer
- *
+ * 
  */
 public class DeferredResolvedPointcutDefinition extends ResolvedPointcutDefinition {
 
-	public DeferredResolvedPointcutDefinition(UnresolvedType declaringType,
-			int modifiers, String name, UnresolvedType[] parameterTypes) {
-		super(declaringType, modifiers, name, parameterTypes,
-				ResolvedType.VOID, null);
+	public DeferredResolvedPointcutDefinition(UnresolvedType declaringType, int modifiers, String name,
+			UnresolvedType[] parameterTypes) {
+		super(declaringType, modifiers, name, parameterTypes, UnresolvedType.VOID, null);
 	}
-	
+
 }

weaver5/java5-src/org/aspectj/weaver/reflect/Java15ReflectionBasedReferenceTypeDelegate.java

 
 	private ResolvedMember createGenericMethodMember(Method forMethod) {
 		ReflectionBasedResolvedMemberImpl ret = new ReflectionBasedResolvedMemberImpl(org.aspectj.weaver.Member.METHOD,
-				getGenericResolvedType(), forMethod.getModifiers(), typeConverter.fromType(forMethod.getReturnType()), forMethod
-						.getName(), typeConverter.fromTypes(forMethod.getParameterTypes()), typeConverter.fromTypes(forMethod
+				getGenericResolvedType(), forMethod.getModifiers(), typeConverter.fromType(forMethod.getReturnType()),
+				forMethod.getName(), typeConverter.fromTypes(forMethod.getParameterTypes()), typeConverter.fromTypes(forMethod
 						.getExceptionTypes()), forMethod);
 		ret.setAnnotationFinder(this.annotationFinder);
 		ret.setGenericSignatureInformationProvider(new Java15GenericSignatureInformationProvider(this.getWorld()));
 		ReflectionBasedResolvedMemberImpl ret = new ReflectionBasedResolvedMemberImpl(org.aspectj.weaver.Member.METHOD,
 				getGenericResolvedType(), forConstructor.getModifiers(),
 				// to return what BCEL returns the return type is void
-				ResolvedType.VOID,// getGenericResolvedType(),
+				UnresolvedType.VOID,// getGenericResolvedType(),
 				"<init>", typeConverter.fromTypes(forConstructor.getParameterTypes()), typeConverter.fromTypes(forConstructor
 						.getExceptionTypes()), forConstructor);
 		ret.setAnnotationFinder(this.annotationFinder);

weaver5/java5-testsrc/org/aspectj/weaver/reflect/ReflectionBasedReferenceTypeDelegateTest.java

  * ******************************************************************/
 package org.aspectj.weaver.reflect;
 
-
 import java.lang.reflect.Method;
 import java.util.HashSet;
 import java.util.Set;
 	protected ReflectionWorld world;
 	private ResolvedType objectType;
 	private ResolvedType classType;
-	
+
 	public void testIsAspect() {
 		assertFalse(objectType.isAspect());
 	}
-	
+
 	public void testIsAnnotationStyleAspect() {
 		assertFalse(objectType.isAnnotationStyleAspect());
 	}
-	
+
 	public void testIsInterface() {
 		assertFalse(objectType.isInterface());
 		assertTrue(world.resolve("java.io.Serializable").isInterface());
 	}
-	
+
 	public void testIsEnum() {
 		assertFalse(objectType.isEnum());
 	}
-	
+
 	public void testIsAnnotation() {
 		assertFalse(objectType.isAnnotation());
 	}
-	
+
 	public void testIsAnnotationWithRuntimeRetention() {
 		assertFalse(objectType.isAnnotationWithRuntimeRetention());
 	}
-	
+
 	public void testIsClass() {
 		assertTrue(objectType.isClass());
 		assertFalse(world.resolve("java.io.Serializable").isClass());
 	}
-	
+
 	public void testIsGeneric() {
 		assertFalse(objectType.isGenericType());
 	}
-	
+
 	public void testIsExposedToWeaver() {
 		assertFalse(objectType.isExposedToWeaver());
 	}
-	
+
 	public void testHasAnnotation() {
 		assertFalse(objectType.hasAnnotation(UnresolvedType.forName("Foo")));
 	}
-	
+
 	public void testGetAnnotations() {
-		assertEquals("no entries",0,objectType.getAnnotations().length);
+		assertEquals("no entries", 0, objectType.getAnnotations().length);
 	}
-	
+
 	public void testGetAnnotationTypes() {
-		assertEquals("no entries",0,objectType.getAnnotationTypes().length);
+		assertEquals("no entries", 0, objectType.getAnnotationTypes().length);
 	}
-	
+
 	public void testGetTypeVariables() {
-		assertEquals("no entries",0,objectType.getTypeVariables().length);
+		assertEquals("no entries", 0, objectType.getTypeVariables().length);
 	}
-	
+
 	public void testGetPerClause() {
 		assertNull(objectType.getPerClause());
 	}
-	
+
 	public void testGetModifiers() {
-		assertEquals(Object.class.getModifiers(),objectType.getModifiers());
+		assertEquals(Object.class.getModifiers(), objectType.getModifiers());
 	}
-	
+
 	public void testGetSuperclass() {
-		assertTrue("Superclass of object should be null, but it is: "+objectType.getSuperclass(),objectType.getSuperclass()==null);
-		assertEquals(objectType,world.resolve("java.lang.Class").getSuperclass());
+		assertTrue("Superclass of object should be null, but it is: " + objectType.getSuperclass(),
+				objectType.getSuperclass() == null);
+		assertEquals(objectType, world.resolve("java.lang.Class").getSuperclass());
 		ResolvedType d = world.resolve("reflect.tests.D");
-		assertEquals(world.resolve("reflect.tests.C"),d.getSuperclass());
+		assertEquals(world.resolve("reflect.tests.C"), d.getSuperclass());
 	}
-	
 
 	protected int findMethod(String name, ResolvedMember[] methods) {
-		for (int i=0; i<methods.length; i++) {
+		for (int i = 0; i < methods.length; i++) {
 			if (name.equals(methods[i].getName())) {
 				return i;
 			}
 		}
 		return -1;
 	}
-	
+
 	protected int findMethod(String name, int numArgs, ResolvedMember[] methods) {
-		for (int i=0; i<methods.length; i++) {
+		for (int i = 0; i < methods.length; i++) {
 			if (name.equals(methods[i].getName()) && (methods[i].getParameterTypes().length == numArgs)) {
 				return i;
 			}
 		}
 		return -1;
 	}
-	
+
 	public void testGetDeclaredMethods() {
 		ResolvedMember[] methods = objectType.getDeclaredMethods();
 		assertEquals(Object.class.getDeclaredMethods().length + Object.class.getDeclaredConstructors().length, methods.length);
-		
+
 		ResolvedType c = world.resolve("reflect.tests.C");
 		methods = c.getDeclaredMethods();
-		assertEquals(3,methods.length);
+		assertEquals(3, methods.length);
 		int idx = findMethod("foo", methods);
 		assertTrue(idx > -1);
-		
-		assertEquals(world.resolve("java.lang.String"),methods[idx].getReturnType());
+
+		assertEquals(world.resolve("java.lang.String"), methods[idx].getReturnType());
 		assertEquals(1, methods[idx].getParameterTypes().length);
-		assertEquals(objectType,methods[idx].getParameterTypes()[0]);
-		assertEquals(1,methods[idx].getExceptions().length);
-		assertEquals(world.resolve("java.lang.Exception"),methods[idx].getExceptions()[0]);
+		assertEquals(objectType, methods[idx].getParameterTypes()[0]);
+		assertEquals(1, methods[idx].getExceptions().length);
+		assertEquals(world.resolve("java.lang.Exception"), methods[idx].getExceptions()[0]);
 		int baridx = findMethod("bar", methods);
 		int initidx = findMethod("<init>", methods);
 		assertTrue(baridx > -1);
 		assertTrue(initidx > -1);
 		assertTrue(baridx != initidx && baridx != idx && idx <= 2 && initidx <= 2 && baridx <= 2);
-		
+
 		ResolvedType d = world.resolve("reflect.tests.D");
 		methods = d.getDeclaredMethods();
-		assertEquals(2,methods.length);
+		assertEquals(2, methods.length);
 
 		classType = world.resolve("java.lang.Class");
 		methods = classType.getDeclaredMethods();
-		assertEquals(Class.class.getDeclaredMethods().length + Class.class.getDeclaredConstructors().length, methods.length); 
+		assertEquals(Class.class.getDeclaredMethods().length + Class.class.getDeclaredConstructors().length, methods.length);
 	}
-	
+
 	public void testGetDeclaredFields() {
 		ResolvedMember[] fields = objectType.getDeclaredFields();
-		assertEquals(0,fields.length);
+		assertEquals(0, fields.length);
 
 		ResolvedType c = world.resolve("reflect.tests.C");
 		fields = c.getDeclaredFields();
-		
-		assertEquals(2,fields.length);
-		assertEquals("f",fields[0].getName());
-		assertEquals("s",fields[1].getName());
-		assertEquals(ResolvedType.INT,fields[0].getReturnType());
-		assertEquals(world.resolve("java.lang.String"),fields[1].getReturnType());
+
+		assertEquals(2, fields.length);
+		assertEquals("f", fields[0].getName());
+		assertEquals("s", fields[1].getName());
+		assertEquals(UnresolvedType.INT, fields[0].getReturnType());
+		assertEquals(world.resolve("java.lang.String"), fields[1].getReturnType());
 	}
-	
+
 	public void testGetDeclaredInterfaces() {
 		ResolvedType[] interfaces = objectType.getDeclaredInterfaces();
-		assertEquals(0,interfaces.length);
+		assertEquals(0, interfaces.length);
 
 		ResolvedType d = world.resolve("reflect.tests.D");
 		interfaces = d.getDeclaredInterfaces();
-		assertEquals(1,interfaces.length);
-		assertEquals(world.resolve("java.io.Serializable"),interfaces[0]);
-    }
-	
+		assertEquals(1, interfaces.length);
+		assertEquals(world.resolve("java.io.Serializable"), interfaces[0]);
+	}
+
 	public void testGetDeclaredPointcuts() {
 		ResolvedMember[] pointcuts = objectType.getDeclaredPointcuts();
-		assertEquals(0,pointcuts.length);
+		assertEquals(0, pointcuts.length);
 	}
-	
-	
-	
+
 	public void testSerializableSuperclass() {
 		ResolvedType serializableType = world.resolve("java.io.Serializable");
 		ResolvedType superType = serializableType.getSuperclass();
-        assertTrue("Superclass of serializable should be Object but was "+superType,superType.equals(UnresolvedType.OBJECT));    
+		assertTrue("Superclass of serializable should be Object but was " + superType, superType.equals(UnresolvedType.OBJECT));
 
-        BcelWorld bcelworld = new BcelWorld();
-        bcelworld.setBehaveInJava5Way(true);
-        ResolvedType bcelSupertype = bcelworld.resolve(UnresolvedType.SERIALIZABLE).getSuperclass();
-        assertTrue("Should be null but is "+bcelSupertype,bcelSupertype.equals(UnresolvedType.OBJECT));
+		BcelWorld bcelworld = new BcelWorld();
+		bcelworld.setBehaveInJava5Way(true);
+		ResolvedType bcelSupertype = bcelworld.resolve(UnresolvedType.SERIALIZABLE).getSuperclass();
+		assertTrue("Should be null but is " + bcelSupertype, bcelSupertype.equals(UnresolvedType.OBJECT));
 	}
-	
-	public void testSubinterfaceSuperclass() {		
+
+	public void testSubinterfaceSuperclass() {
 		ResolvedType ifaceType = world.resolve("java.security.Key");
 		ResolvedType superType = ifaceType.getSuperclass();
-		assertTrue("Superclass should be Object but was "+superType,superType.equals(UnresolvedType.OBJECT));  
+		assertTrue("Superclass should be Object but was " + superType, superType.equals(UnresolvedType.OBJECT));
 
-        BcelWorld bcelworld = new BcelWorld();
-        bcelworld.setBehaveInJava5Way(true);
-        ResolvedType bcelSupertype = bcelworld.resolve("java.security.Key").getSuperclass();
-        assertTrue("Should be null but is "+bcelSupertype,bcelSupertype.equals(UnresolvedType.OBJECT));
+		BcelWorld bcelworld = new BcelWorld();
+		bcelworld.setBehaveInJava5Way(true);
+		ResolvedType bcelSupertype = bcelworld.resolve("java.security.Key").getSuperclass();
+		assertTrue("Should be null but is " + bcelSupertype, bcelSupertype.equals(UnresolvedType.OBJECT));
 	}
-	
+
 	public void testVoidSuperclass() {
 		ResolvedType voidType = world.resolve(Void.TYPE);
 		ResolvedType superType = voidType.getSuperclass();
 		assertNull(superType);
-		   
-        BcelWorld bcelworld = new BcelWorld();
-        bcelworld.setBehaveInJava5Way(true);
-        ResolvedType bcelSupertype = bcelworld.resolve("void").getSuperclass();
-        assertTrue("Should be null but is "+bcelSupertype,bcelSupertype==null);
+
+		BcelWorld bcelworld = new BcelWorld();
+		bcelworld.setBehaveInJava5Way(true);
+		ResolvedType bcelSupertype = bcelworld.resolve("void").getSuperclass();
+		assertTrue("Should be null but is " + bcelSupertype, bcelSupertype == null);
 	}
 
 	public void testIntSuperclass() {
 		ResolvedType superType = voidType.getSuperclass();
 		assertNull(superType);
 
-        BcelWorld bcelworld = new BcelWorld();
-        bcelworld.setBehaveInJava5Way(true);
-        ResolvedType bcelSupertype = bcelworld.resolve("int").getSuperclass();
-        assertTrue("Should be null but is "+bcelSupertype,bcelSupertype==null);
+		BcelWorld bcelworld = new BcelWorld();
+		bcelworld.setBehaveInJava5Way(true);
+		ResolvedType bcelSupertype = bcelworld.resolve("int").getSuperclass();
+		assertTrue("Should be null but is " + bcelSupertype, bcelSupertype == null);
 	}
-	
-    public void testGenericInterfaceSuperclass_BcelWorldResolution() {
-        BcelWorld bcelworld = new BcelWorld();
-        bcelworld.setBehaveInJava5Way(true);
-        
-        UnresolvedType javaUtilMap = UnresolvedType.forName("java.util.Map");
-        
-        ReferenceType rawType = (ReferenceType) bcelworld.resolve(javaUtilMap);
-        assertTrue("Should be the raw type ?!? "+rawType.getTypekind(),rawType.isRawType());
-        
-        ReferenceType genericType = (ReferenceType)rawType.getGenericType();
-        assertTrue("Should be the generic type ?!? "+genericType.getTypekind(),genericType.isGenericType());
-        
-        ResolvedType rt = rawType.getSuperclass();
-        assertTrue("Superclass for Map raw type should be Object but was "+rt,rt.equals(UnresolvedType.OBJECT));         
-        
-        ResolvedType rt2 = genericType.getSuperclass();
-        assertTrue("Superclass for Map generic type should be Object but was "+rt2,rt2.equals(UnresolvedType.OBJECT));         
-    }
-    
-    // FIXME asc maybe.  The reflection list of methods returned doesn't include <clinit> (the static initializer) ... is that really a problem.
-    public void testCompareSubclassDelegates() {
-    	
-    	boolean barfIfClinitMissing = false;
-        world.setBehaveInJava5Way(true);
-        
-        BcelWorld bcelWorld = new BcelWorld(getClass().getClassLoader(),IMessageHandler.THROW,null);
-        bcelWorld.setBehaveInJava5Way(true);
-        UnresolvedType javaUtilHashMap = UnresolvedType.forName("java.util.HashMap");
-        ReferenceType rawType =(ReferenceType)bcelWorld.resolve(javaUtilHashMap );
-        
-        ReferenceType rawReflectType =(ReferenceType)world.resolve(javaUtilHashMap );
-        ResolvedMember[] rms1 = rawType.getDelegate().getDeclaredMethods();
-        ResolvedMember[] rms2 = rawReflectType.getDelegate().getDeclaredMethods();
-        StringBuffer errors = new StringBuffer();
-        Set one = new HashSet();
-        for (int i = 0; i < rms1.length; i++) {
+
+	public void testGenericInterfaceSuperclass_BcelWorldResolution() {
+		BcelWorld bcelworld = new BcelWorld();
+		bcelworld.setBehaveInJava5Way(true);
+
+		UnresolvedType javaUtilMap = UnresolvedType.forName("java.util.Map");
+
+		ReferenceType rawType = (ReferenceType) bcelworld.resolve(javaUtilMap);
+		assertTrue("Should be the raw type ?!? " + rawType.getTypekind(), rawType.isRawType());
+
+		ReferenceType genericType = (ReferenceType) rawType.getGenericType();
+		assertTrue("Should be the generic type ?!? " + genericType.getTypekind(), genericType.isGenericType());
+
+		ResolvedType rt = rawType.getSuperclass();
+		assertTrue("Superclass for Map raw type should be Object but was " + rt, rt.equals(UnresolvedType.OBJECT));
+
+		ResolvedType rt2 = genericType.getSuperclass();
+		assertTrue("Superclass for Map generic type should be Object but was " + rt2, rt2.equals(UnresolvedType.OBJECT));
+	}
+
+	// FIXME asc maybe. The reflection list of methods returned doesn't include <clinit> (the static initializer) ... is that really
+	// a problem.
+	public void testCompareSubclassDelegates() {
+
+		boolean barfIfClinitMissing = false;
+		world.setBehaveInJava5Way(true);
+
+		BcelWorld bcelWorld = new BcelWorld(getClass().getClassLoader(), IMessageHandler.THROW, null);
+		bcelWorld.setBehaveInJava5Way(true);
+		UnresolvedType javaUtilHashMap = UnresolvedType.forName("java.util.HashMap");
+		ReferenceType rawType = (ReferenceType) bcelWorld.resolve(javaUtilHashMap);
+
+		ReferenceType rawReflectType = (ReferenceType) world.resolve(javaUtilHashMap);
+		ResolvedMember[] rms1 = rawType.getDelegate().getDeclaredMethods();
+		ResolvedMember[] rms2 = rawReflectType.getDelegate().getDeclaredMethods();
+		StringBuffer errors = new StringBuffer();
+		Set one = new HashSet();
+		for (int i = 0; i < rms1.length; i++) {
 			one.add(rms1[i].toString());
 		}
-        Set two = new HashSet();
-        for (int i = 0; i < rms2.length; i++) {
+		Set two = new HashSet();
+		for (int i = 0; i < rms2.length; i++) {
 			two.add(rms2[i].toString());
 		}
-        for (int i = 0;i<rms2.length;i++) {
-        	if (!one.contains(rms2[i].toString())) {
-        		errors.append("Couldn't find "+rms2[i].toString()+" in the bcel set\n");
-        	}
-        }
-        for (int i = 0;i<rms1.length;i++) {
-        	if (!two.contains(rms1[i].toString())) {
-        		if (!barfIfClinitMissing && rms1[i].getName().equals("<clinit>")) continue;
-        		errors.append("Couldn't find "+rms1[i].toString()+" in the reflection set\n");
-        	}
-        }
-        assertTrue("Errors:"+errors.toString(),errors.length()==0);
-        
-        // the good old ibm vm seems to offer clinit through its reflection support (see pr145322)
-        if (rms1.length==rms2.length) return;
-        if (barfIfClinitMissing) {
-        	// the numbers must be exact
-            assertEquals(rms1.length,rms2.length);        	
-        } else {
-        	// the numbers can be out by one in favour of bcel
-        	if (rms1.length!=(rms2.length+1)) {
-        		for (int i = 0; i < rms1.length; i++) {
-					System.err.println("bcel"+i+" is "+rms1[i]);
+		for (int i = 0; i < rms2.length; i++) {
+			if (!one.contains(rms2[i].toString())) {
+				errors.append("Couldn't find " + rms2[i].toString() + " in the bcel set\n");
+			}
+		}
+		for (int i = 0; i < rms1.length; i++) {
+			if (!two.contains(rms1[i].toString())) {
+				if (!barfIfClinitMissing && rms1[i].getName().equals("<clinit>"))
+					continue;
+				errors.append("Couldn't find " + rms1[i].toString() + " in the reflection set\n");
+			}
+		}
+		assertTrue("Errors:" + errors.toString(), errors.length() == 0);
+
+		// the good old ibm vm seems to offer clinit through its reflection support (see pr145322)
+		if (rms1.length == rms2.length)
+			return;
+		if (barfIfClinitMissing) {
+			// the numbers must be exact
+			assertEquals(rms1.length, rms2.length);
+		} else {
+			// the numbers can be out by one in favour of bcel
+			if (rms1.length != (rms2.length + 1)) {
+				for (int i = 0; i < rms1.length; i++) {
+					System.err.println("bcel" + i + " is " + rms1[i]);
 				}
-        		for (int i = 0; i < rms2.length; i++) {
-					System.err.println("refl"+i+" is "+rms2[i]);
+				for (int i = 0; i < rms2.length; i++) {
+					System.err.println("refl" + i + " is " + rms2[i]);
 				}
-        	}
-        	assertTrue("Should be one extra (clinit) in BCEL case, but bcel="+rms1.length+" reflect="+rms2.length,rms1.length==rms2.length+1);
-        }
-    }
-
-    public void testArrayArgsSig() throws Exception {
-    	Method invokeMethod = Method.class.getMethod("invoke", new Class[] { Object.class, Object[].class});
-    	ResolvedMember reflectionMethod = ReflectionBasedReferenceTypeDelegateFactory.createResolvedMethod(invokeMethod, world);
-    	String exp = "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;";
-    	assertTrue("Expected: \n"+exp+"\n but got:\n"+reflectionMethod.getSignature(), reflectionMethod.getSignature().equals(exp));
-    }
-    	    
-	// todo: array of int	
+			}
+			assertTrue("Should be one extra (clinit) in BCEL case, but bcel=" + rms1.length + " reflect=" + rms2.length,
+					rms1.length == rms2.length + 1);
+		}
+	}
+
+	public void testArrayArgsSig() throws Exception {
+		Method invokeMethod = Method.class.getMethod("invoke", new Class[] { Object.class, Object[].class });
+		ResolvedMember reflectionMethod = ReflectionBasedReferenceTypeDelegateFactory.createResolvedMethod(invokeMethod, world);
+		String exp = "(Ljava/lang/Object;[Ljava/lang/Object;)Ljava/lang/Object;";
+		assertTrue("Expected: \n" + exp + "\n but got:\n" + reflectionMethod.getSignature(), reflectionMethod.getSignature()
+				.equals(exp));
+	}
+
+	// todo: array of int
 
 	protected void setUp() throws Exception {
 		world = new ReflectionWorld(getClass().getClassLoader());

weaver5/java5-testsrc/org/aspectj/weaver/reflect/ReflectionWorldTest.java

 import junit.framework.TestCase;
 
 import org.aspectj.weaver.ResolvedType;
+import org.aspectj.weaver.UnresolvedType;
 import org.aspectj.weaver.World;
 
 public class ReflectionWorldTest extends TestCase {
 		World world = new ReflectionWorld(getClass().getClassLoader());
 		ResolvedType rt = world.resolve("java.lang.Object");
 		assertNotNull(rt);
-		assertEquals("Ljava/lang/Object;",rt.getSignature());
+		assertEquals("Ljava/lang/Object;", rt.getSignature());
 	}
-	
+
 	public void testArrayTypes() {
 		IReflectionWorld world = new ReflectionWorld(getClass().getClassLoader());
 		String[] strArray = new String[1];
 		ResolvedType rt = world.resolve(strArray.getClass());
 		assertTrue(rt.isArray());
 	}
-	
+
 	public void testPrimitiveTypes() {
 		IReflectionWorld world = new ReflectionWorld(getClass().getClassLoader());
-		assertEquals("int",ResolvedType.INT,world.resolve(int.class));
-		assertEquals("void",ResolvedType.VOID,world.resolve(void.class));
+		assertEquals("int", UnresolvedType.INT, world.resolve(int.class));
+		assertEquals("void", UnresolvedType.VOID, world.resolve(void.class));
 	}
-	
+
 }