--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer Initial implementation
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import org.aspectj.weaver.bcel.BcelWorld;
+
+import junit.framework.TestCase;
+
+public class BoundedReferenceTypeTestCase extends TestCase {
+
+ ReferenceType javaLangClass;
+ ReferenceType javaLangObject;
+ BoundedReferenceType extendsClass;
+ BoundedReferenceType superClass;
+ BoundedReferenceType extendsWithExtras;
+
+ public void testSignature() {
+ String extendsSig = extendsClass.getSignature();
+ assertEquals("+Ljava/lang/Class;",extendsSig);
+ assertEquals("-Ljava/lang/Class;",superClass.getSignature());
+ }
+
+ public void testExtendsBounds() {
+ assertFalse("has no lower bound",extendsClass.hasLowerBound());
+ assertNull("no lower bound",extendsClass.getLowerBound());
+ assertEquals(javaLangClass,extendsClass.getUpperBound());
+ assertEquals("no interface bounds",0,extendsClass.getInterfaceBounds().length);
+ }
+
+ public void testSuperBounds() {
+ assertTrue("has lower bound",superClass.hasLowerBound());
+ assertEquals(javaLangClass,superClass.getLowerBound());
+ assertEquals("Ljava/lang/Object;",superClass.getUpperBound().getSignature());
+ assertEquals("no interface bounds",0,superClass.getInterfaceBounds().length);
+ }
+
+ public void testIsExtends() {
+ assertTrue(extendsClass.isExtends);
+ assertFalse(superClass.isExtends);
+ }
+
+ public void testIsSuper() {
+ assertTrue(superClass.isSuper);
+ assertFalse(extendsClass.isSuper);
+ }
+
+ public void testGetDeclaredInterfacesNoAdditions() {
+ ResolvedTypeX[] rt1 = extendsClass.getDeclaredInterfaces();
+ ResolvedTypeX[] rt2 = javaLangClass.getDeclaredInterfaces();
+ assertEquals("same length",rt1.length,rt2.length);
+ for (int i = 0; i < rt2.length; i++) {
+ assertEquals("same methods",rt1[i],rt2[i]);
+ }
+ }
+
+ public void testGetDeclaredInterfacesWithInterfaceBounds() {
+ ResolvedTypeX[] rt1 = extendsWithExtras.getDeclaredInterfaces();
+ ResolvedTypeX[] rt2 = javaLangClass.getDeclaredInterfaces();
+ assertEquals("one extra interface",rt1.length,rt2.length + 1);
+ for (int i = 0; i < rt2.length; i++) {
+ assertEquals("same methods",rt1[i],rt2[i]);
+ }
+ assertEquals("Ljava/util/List;",rt1[rt1.length-1].getSignature());
+ }
+
+ // all other methods in signature are delegated to upper bound...
+ // representative test
+ public void testGetDeclaredMethodsExtends() {
+ ResolvedMember[] rm1 = extendsClass.getDeclaredMethods();
+ ResolvedMember[] rm2 = javaLangClass.getDeclaredMethods();
+ assertEquals("same length",rm1.length,rm2.length);
+ for (int i = 0; i < rm2.length; i++) {
+ assertEquals("same methods",rm1[i],rm2[i]);
+ }
+ }
+
+ public void testGetDeclaredMethodsSuper() {
+ ResolvedMember[] rm1 = superClass.getDeclaredMethods();
+ ResolvedMember[] rm2 = javaLangObject.getDeclaredMethods();
+ assertEquals("same length",rm1.length,rm2.length);
+ for (int i = 0; i < rm2.length; i++) {
+ assertEquals("same methods",rm1[i],rm2[i]);
+ }
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ BcelWorld world = new BcelWorld();
+ javaLangClass = (ReferenceType) world.resolve(TypeX.forName("java/lang/Class"));
+ javaLangObject = (ReferenceType) world.resolve(TypeX.OBJECT);
+ extendsClass = new BoundedReferenceType(javaLangClass,true,world);
+ superClass = new BoundedReferenceType(javaLangClass,false,world);
+ extendsWithExtras = new BoundedReferenceType(javaLangClass,true,world,
+ new ReferenceType[] {(ReferenceType)world.resolve(TypeX.forName("java/util/List"))});
+ }
+}
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer Initial implementation
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import org.aspectj.weaver.bcel.BcelWorld;
+
+import junit.framework.TestCase;
+
+/**
+ * @author colyer
+ *
+ */
+public class GenericsWildCardTypeXTestCase extends TestCase {
+
+ public void testIdentity() {
+ TypeX anything = GenericsWildcardTypeX.GENERIC_WILDCARD;
+ assertEquals("?",anything.getSignature());
+ }
+
+ public void testResolving() {
+ BoundedReferenceType brt = (BoundedReferenceType)
+ GenericsWildcardTypeX.GENERIC_WILDCARD.resolve(new BcelWorld());
+ assertEquals("?",brt.getSignature());
+ assertTrue(brt.isExtends());
+ assertEquals("Ljava/lang/Object;",brt.getUpperBound().getSignature());
+ }
+
+}
/* *******************************************************************
* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
+ * 2005 contributors
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Common Public License v1.0
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
- * PARC initial implementation
+ * PARC initial implementation
+ * Adrian Colyer, canBeParameterized tests
* ******************************************************************/
import junit.framework.TestCase;
import org.aspectj.testing.util.TestUtil;
+import org.aspectj.weaver.bcel.BcelWorld;
/**
* This is a test case for all the portions of Member that don't require a world.
isStaticTest(m, true);
}
+ public void testCanBeParameterizedRegularMethod() {
+ BcelWorld world = new BcelWorld();
+ ResolvedTypeX javaLangClass = world.resolve(TypeX.forName("java/lang/Class"));
+ ResolvedMember[] methods = javaLangClass.getDeclaredMethods();
+ ResolvedMember getAnnotations = null;
+ for (int i = 0; i < methods.length; i++) {
+ if (methods[i].getName().equals("getAnnotations")) {
+ getAnnotations = methods[i];
+ break;
+ }
+ }
+ if (getAnnotations != null) { // so can run on non-Java 5
+// System.out.println("got it");
+ assertFalse(getAnnotations.canBeParameterized());
+ }
+ }
+
+ public void testCanBeParameterizedGenericMethod() {
+ BcelWorld world = new BcelWorld();
+ ResolvedTypeX javaLangClass = world.resolve(TypeX.forName("java/lang/Class"));
+ ResolvedMember[] methods = javaLangClass.getDeclaredMethods();
+ ResolvedMember asSubclass = null;
+ for (int i = 0; i < methods.length; i++) {
+ if (methods[i].getName().equals("asSubclass")) {
+ asSubclass = methods[i];
+ break;
+ }
+ }
+ if (asSubclass != null) { // so can run on non-Java 5
+// System.out.println("got it");
+ assertTrue(asSubclass.canBeParameterized());
+ }
+ }
+
+ public void testCanBeParameterizedMethodInGenericType() {
+ BcelWorld world = new BcelWorld();
+ ResolvedTypeX javaUtilList = world.resolve(TypeX.forName("java/util/List"));
+ ResolvedMember[] methods = javaUtilList.getDeclaredMethods();
+ ResolvedMember add = null;
+ for (int i = 0; i < methods.length; i++) {
+ if (methods[i].getName().equals("add")) {
+ add = methods[i];
+ break;
+ }
+ }
+ if (add != null) { // so can run on non-Java 5
+// System.out.println("got it");
+ assertTrue(add.canBeParameterized());
+ }
+ }
+
private void isStaticTest(Member m, boolean b) {
assertEquals(m + " is static", b, m.isStatic());
}
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer Initial implementation
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import org.aspectj.weaver.bcel.BcelWorld;
+
+import junit.framework.TestCase;
+
+// test cases for Adrian's additions to ReferenceType
+// XXX - couldn't find any unit test cases for the rest of the ReferenceType class
+public class ReferenceTypeTestCase extends TestCase {
+
+ public void testIsGenericTrue() {
+ BcelWorld world = new BcelWorld();
+ TypeX javaLangClass = TypeX.forName("java/lang/Class");
+ ResolvedTypeX rtx = world.resolve(javaLangClass);
+ assertTrue("Resolves to reference type",(rtx instanceof ReferenceType));
+ ReferenceType rt = (ReferenceType) rtx;
+ assertTrue("java.lang.Class is generic",rt.isGeneric());
+ }
+
+ public void testIsGenericFalse() {
+ BcelWorld world = new BcelWorld();
+ TypeX javaLangObject = TypeX.forName("java/lang/Object");
+ ResolvedTypeX rtx = world.resolve(javaLangObject);
+ assertTrue("Resolves to reference type",(rtx instanceof ReferenceType));
+ ReferenceType rt = (ReferenceType) rtx;
+ assertFalse("java.lang.Object is not generic",rt.isGeneric());
+ }
+
+}
--- /dev/null
+/* *******************************************************************
+ * Copyright (c) 2005 Contributors.
+ * All rights reserved.
+ * This program and the accompanying materials are made available
+ * under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution and is available at
+ * http://eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Adrian Colyer Initial implementation
+ * ******************************************************************/
+package org.aspectj.weaver;
+
+import org.aspectj.weaver.bcel.BcelWorld;
+
+import junit.framework.TestCase;
+
+/**
+ * @author colyer
+ *
+ */
+public class TypeVariableReferenceTypeTestCase extends TestCase {
+
+ ReferenceType javaLangClass;
+ ReferenceType javaLangObject;
+ BoundedReferenceType extendsClass;
+ BoundedReferenceType superClass;
+ BoundedReferenceType extendsWithExtras;
+ BcelWorld world;
+
+ public void testConstructionByNameAndBound() {
+ TypeVariableReferenceType tvrt = new TypeVariableReferenceType("T",javaLangClass,true,world);
+ assertEquals("T",tvrt.getTypeVariableName());
+ assertTrue(tvrt.isExtends);
+ assertEquals(javaLangClass,tvrt.getUpperBound());
+ }
+
+ public void testConstructionByNameAndVariable() {
+ TypeVariable tv = new TypeVariable("T",javaLangClass);
+ TypeVariableReferenceType tvrt = new TypeVariableReferenceType(tv,world);
+ assertEquals("T",tvrt.getTypeVariableName());
+ assertTrue(tvrt.isExtends);
+ assertEquals(javaLangClass,tvrt.getUpperBound());
+ }
+
+ protected void setUp() throws Exception {
+ super.setUp();
+ world = new BcelWorld();
+ javaLangClass = (ReferenceType) world.resolve(TypeX.forName("java/lang/Class"));
+ javaLangObject = (ReferenceType) world.resolve(TypeX.OBJECT);
+ extendsClass = new BoundedReferenceType(javaLangClass,true,world);
+ superClass = new BoundedReferenceType(javaLangClass,false,world);
+ extendsWithExtras = new BoundedReferenceType(javaLangClass,true,world,
+ new ReferenceType[] {(ReferenceType)world.resolve(TypeX.forName("java/util/List"))});
+ }
+
+}
// System.err.println(tx.dump());
}
+ public void testTypeXForParameterizedTypes() {
+ TypeX stringType = TypeX.forName("java/lang/String");
+ TypeX listOfStringType = TypeX.forParameterizedTypes("java/util/List", new TypeX[] {stringType});
+ assertEquals("1 type param",1,listOfStringType.typeParameters.length);
+ assertEquals(stringType,listOfStringType.typeParameters[0]);
+ assertTrue(listOfStringType.isParameterized());
+ assertFalse(listOfStringType.isGeneric());
+ }
+
private void checkTX(TypeX tx,boolean shouldBeParameterized,int numberOfTypeParameters) {
assertTrue("Expected parameterization flag to be "+shouldBeParameterized,tx.isParameterized()==shouldBeParameterized);
if (numberOfTypeParameters==0) {
projects / aspectj.git / commitdiff