hibernate-commits

[<pao...@us...>]

Update of /cvsroot/hibernate/HibernateExt/metadata/src/test/org/hibernate/test/reflection/java
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv21308/metadata/src/test/org/hibernate/test/reflection/java

Modified Files:
	JavaReflectionManagerTest.java Foo.java FooFather.java 
	JavaXClassTest.java 
Added Files:
	TestAnnotation.java XAnnotatedElementTest.java 
	JavaXPropertyTest.java 
Removed Files:
	JavaXAnnotatedElementTest.java JavaXMemberTest.java 
Log Message:
Support for generics in reflection layer

--- NEW FILE: TestAnnotation.java ---
package org.hibernate.test.reflection.java;

import static java.lang.annotation.ElementType.TYPE;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

import java.lang.annotation.Retention;
import java.lang.annotation.Target;

@Target( { TYPE, METHOD, FIELD })
@Retention(RUNTIME)
public @interface TestAnnotation {
	String name() default "abc";
}

--- NEW FILE: XAnnotatedElementTest.java ---
package org.hibernate.test.reflection.java;

import javax.persistence.Transient;

import junit.framework.TestCase;

import org.hibernate.reflection.XAnnotatedElement;
import org.hibernate.test.reflection.java.generics.TestAnnotation;

/**
 * @author Paolo Perrotta
 */
public abstract class XAnnotatedElementTest extends TestCase {

	public void testKnowsWhetherAnAnnotationIsPresent() {
		assertTrue( getConcreteInstance().isAnnotationPresent( TestAnnotation.class ) );
		assertFalse( getConcreteInstance().isAnnotationPresent( Transient.class ) );
	}

	public void testReturnsSpecificAnnotations() {
		TestAnnotation ent = getConcreteInstance().getAnnotation( TestAnnotation.class );
		assertEquals( "xyz", ent.name() );
	}

	protected abstract XAnnotatedElement getConcreteInstance();
}

--- NEW FILE: JavaXPropertyTest.java ---
package org.hibernate.test.reflection.java;

import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import junit.framework.AssertionFailedError;

import org.hibernate.reflection.ReflectionManager;
import org.hibernate.reflection.XClass;
import org.hibernate.reflection.XProperty;
import org.hibernate.reflection.java.JavaXFactory;
import org.hibernate.test.reflection.java.generics.Dad;
import org.hibernate.test.reflection.java.generics.Son;

/**
 * @author Paolo Perrotta
 */
public class JavaXPropertyTest extends XAnnotatedElementTest {

	private ReflectionManager factory = new JavaXFactory();
	private XClass dadAsSeenFromSon = factory.toXClass( Son.class ).getSuperclass();

	public void testFollowsJavaBeansConventionsForPropertyNames() throws Exception {
		List<String> properties = new LinkedList<String>();
		properties.add( "collectionProperty" );
		properties.add( "methodProperty" );
		properties.add( "primitiveProperty" );
		properties.add( "primitiveArrayProperty" );
		properties.add( "arrayProperty" );
		properties.add( "propertyStartingWithIs" );
		List<XProperty> methodProperties = dadAsSeenFromSon.getDeclaredProperties( "property" );
		assertEquals( properties.size(), methodProperties.size() );
		for ( XProperty member : methodProperties )
			assertTrue( properties.contains( member.getName() ) );
		List<XProperty> fieldProperties = dadAsSeenFromSon.getDeclaredProperties( "field" );
		XProperty field = fieldProperties.get( 0 );
		assertEquals( "fieldProperty", field.getName() );
	}

	public void testPropertiesWithParametricTypesAreIgnored() {
		assertEquals( 6, dadAsSeenFromSon.getDeclaredProperties( "property" ).size() );
		XClass dadAsSeenFromItself = ReflectionManager.INSTANCE.toXClass( Dad.class );
		assertEquals( 4, dadAsSeenFromItself.getDeclaredProperties( "property" ).size() );
	}

	public void testCanBeASimpleType() {
		List<XProperty> declaredProperties = dadAsSeenFromSon.getDeclaredProperties( "field" );
		XProperty p = getPropertyNamed_from( "fieldProperty", declaredProperties );
		assertTrue( factory.equals( p.getType(), String.class ));
		assertTrue( factory.equals( p.getElementClass(), String.class ));
		assertTrue( factory.equals( p.getClassOrElementClass(), String.class ));
		assertNull( p.getCollectionClass() );
		assertFalse( p.isArray() );
		assertFalse( p.isCollection() );
	}

	public void testCanBeAnArray() {
		List<XProperty> declaredProperties = dadAsSeenFromSon.getDeclaredProperties( "property" );
		XProperty p = getPropertyNamed_from( "arrayProperty", declaredProperties );
		
		// TODO: this truly sucks. the problem is that I can't get a reference to a specific array class
		// at runtime. is there any way to do that in Java?
		assertNull( p.getType() );
		
		assertTrue( factory.equals( p.getElementClass(), String.class ));
		assertTrue( factory.equals( p.getClassOrElementClass(), String.class ));
		assertNull( p.getCollectionClass() );
		assertTrue( p.isArray() );
		assertFalse( p.isCollection() );
	}

	public void testCanBeAnArrayOfPrimitives() {
		List<XProperty> declaredProperties = dadAsSeenFromSon.getDeclaredProperties( "property" );
		XProperty p = getPropertyNamed_from( "primitiveArrayProperty", declaredProperties );
		assertTrue( factory.equals( p.getType(), int[].class ));
		assertTrue( factory.equals( p.getElementClass(), int.class ));
		assertTrue( factory.equals( p.getClassOrElementClass(), int.class ));
		assertNull( p.getCollectionClass() );
		assertTrue( p.isArray() );
		assertFalse( p.isCollection() );
	}

	public void testCanBeACollection() {
		List<XProperty> declaredProperties = dadAsSeenFromSon.getDeclaredProperties( "property" );
		XProperty p = getPropertyNamed_from( "collectionProperty", declaredProperties );
		assertTrue( factory.equals( p.getType(), Map.class ));
		assertTrue( factory.equals( p.getElementClass(), String.class ));
		assertTrue( factory.equals( p.getClassOrElementClass(), Map.class ));
		assertEquals( Map.class, p.getCollectionClass() );
		assertFalse( p.isArray() );
		assertTrue( p.isCollection() );
	}

	private XProperty getPropertyNamed_from(String name, List<XProperty> properties) {
		for ( XProperty p : properties )
			if ( p.getName().equals( name ) )
				return p;
		throw new AssertionFailedError( "No property '" + name + "' found" );
	}

	public void testSupportsMethodsStartingWithIs() throws Exception {
		assertEquals( "methodProperty", getConcreteInstance().getName() );
	}

	@Override
	protected XProperty getConcreteInstance() {
		XClass xClass = ReflectionManager.INSTANCE.toXClass( Dad.class );
		List<XProperty> properties = xClass.getDeclaredProperties( "property" );
		for ( XProperty p : properties )
			if ( p.getName().equals( "methodProperty" ) )
				return p;
		throw new AssertionFailedError( "Cannot find Foo.getMethodProperty()" );
	}
}

Index: JavaReflectionManagerTest.java
===================================================================
RCS file: /cvsroot/hibernate/HibernateExt/metadata/src/test/org/hibernate/test/reflection/java/JavaReflectionManagerTest.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- JavaReflectionManagerTest.java	24 Jan 2006 16:01:03 -0000	1.1
+++ JavaReflectionManagerTest.java	13 Feb 2006 19:14:35 -0000	1.2
@@ -5,23 +5,39 @@
 import org.hibernate.reflection.ReflectionManager;
 import org.hibernate.reflection.XClass;
 
+import com.sun.org.apache.xpath.internal.operations.Number;
+
 /**
  * @author Paolo Perrotta
  */
 public class JavaReflectionManagerTest extends TestCase {
 
-    public void testReturnsAnXClassThatWrapsTheGivenClass() {
-        XClass<Integer> xc = ReflectionManager.INSTANCE.toXClass(Integer.class);
-        assertEquals("java.lang.Integer", xc.getName());
-    }
+	private ReflectionManager rm = ReflectionManager.INSTANCE;
 
-    public void testReturnsSameXClassForSameClass() {
-        XClass<?> xc1 = ReflectionManager.INSTANCE.toXClass(void.class);
-        XClass<?> xc2 = ReflectionManager.INSTANCE.toXClass(void.class);
-        assertSame(xc2, xc1);
-    }
-    
-    public void testReturnsNullForANullClass() {
-        assertNull(ReflectionManager.INSTANCE.toXClass(null));
-    }
+	public void testReturnsAnXClassThatWrapsTheGivenClass() {
+		XClass xc = rm.toXClass( Integer.class );
+		assertEquals( "java.lang.Integer", xc.getName() );
+	}
+
+	public void testReturnsSameXClassForSameClass() {
+		XClass xc1 = rm.toXClass( void.class );
+		XClass xc2 = rm.toXClass( void.class );
+		assertSame( xc2, xc1 );
+	}
+
+	public void testReturnsNullForANullClass() {
+		assertNull( rm.toXClass( null ) );
+	}
+
+	public void testComparesXClassesWithClasses() {
+		XClass xc = rm.toXClass( Integer.class );
+		assertTrue( rm.equals( xc, Integer.class ) );
+	}
+
+	public void testSupportsNullsInComparisons() {
+		XClass xc = rm.toXClass( Integer.class );
+		assertFalse( rm.equals( null, Number.class ) );
+		assertFalse( rm.equals( xc, null ) );
+		assertTrue( rm.equals( null, null ) );
+	}
 }

Index: Foo.java
===================================================================
RCS file: /cvsroot/hibernate/HibernateExt/metadata/src/test/org/hibernate/test/reflection/java/Foo.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- Foo.java	24 Jan 2006 16:01:03 -0000	1.1
+++ Foo.java	13 Feb 2006 19:14:35 -0000	1.2
@@ -2,32 +2,30 @@
 
 import java.util.List;
 
-import javax.persistence.Entity;
-
-
 /**
  * @author Paolo Perrotta
  */
-@Entity(name="xyz")
+@TestAnnotation(name = "xyz")
 public class Foo extends FooFather {
 
-    public static Integer staticField;
-    
-    public Integer fieldProperty;
+	public static Integer staticField;
 
-    public List<String> getCollectionProperty() {
-        return null;
-    }
-    
-    public Integer getMethodProperty() {
-        return null;
-    }
+	Integer fieldProperty;
 
-    public int getPrimitiveProperty() {
-        return 0;
-    }
+	public List<String> getCollectionProperty() {
+		return null;
+	}
 
-    public static Integer getStaticThing() {
-        return null;
-    }
+	@TestAnnotation(name = "xyz")
+	public Integer getMethodProperty() {
+		return null;
+	}
+
+	public int getPrimitiveProperty() {
+		return 0;
+	}
+
+	public static Integer getStaticThing() {
+		return null;
+	}
 }

Index: FooFather.java
===================================================================
RCS file: /cvsroot/hibernate/HibernateExt/metadata/src/test/org/hibernate/test/reflection/java/FooFather.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- FooFather.java	24 Jan 2006 16:01:03 -0000	1.1
+++ FooFather.java	13 Feb 2006 19:14:35 -0000	1.2
@@ -7,17 +7,17 @@
  */
 public abstract class FooFather<T> {
 
-    public Integer fatherField;
+	public Integer fatherField;
 
-    public Boolean isFatherMethod() {
-        return null;
-    }
-    
-    public T getParameterizedProperty() {
-        return null;
-    }
-    
-    public List<T> getParameterizedCollectionProperty() {
-        return null;
-    }
+	public Boolean isFatherMethod() {
+		return null;
+	}
+
+	public T getParameterizedProperty() {
+		return null;
+	}
+
+	public List<T> getParameterizedCollectionProperty() {
+		return null;
+	}
 }

Index: JavaXClassTest.java
===================================================================
RCS file: /cvsroot/hibernate/HibernateExt/metadata/src/test/org/hibernate/test/reflection/java/JavaXClassTest.java,v
retrieving revision 1.1
retrieving revision 1.2
diff -u -d -r1.1 -r1.2
--- JavaXClassTest.java	24 Jan 2006 16:01:03 -0000	1.1
+++ JavaXClassTest.java	13 Feb 2006 19:14:35 -0000	1.2
@@ -2,64 +2,79 @@
 
 import java.util.List;
 
-import junit.framework.TestCase;
-
 import org.hibernate.annotations.CacheModeType;
 import org.hibernate.reflection.ReflectionManager;
+import org.hibernate.reflection.XAnnotatedElement;
 import org.hibernate.reflection.XClass;
 import org.hibernate.reflection.XProperty;
+import org.hibernate.test.reflection.java.generics.Dad;
+import org.hibernate.test.reflection.java.generics.Grandpa;
+import org.hibernate.test.reflection.java.generics.Son;
 
 /**
  * @author Paolo Perrotta
  */
-public class JavaXClassTest extends TestCase {
+public class JavaXClassTest extends XAnnotatedElementTest {
 
-    XClass<Foo> clazz = ReflectionManager.INSTANCE.toXClass(Foo.class);
-    XClass<FooFather> fatherClazz = ReflectionManager.INSTANCE.toXClass(FooFather.class);
+	XClass clazz;
 
-    public void testHasAName() throws Exception {
-        assertSame("org.hibernate.test.reflection.java.Foo", clazz.getName());
-    }
+	XClass fatherClazz = ReflectionManager.INSTANCE.toXClass( Grandpa.class );
 
-    public void testHasASuperclass() throws Exception {
-        assertSame(fatherClazz, clazz.getSuperclass());
-    }
+	@Override
+	protected void setUp() {
+		clazz = ReflectionManager.INSTANCE.toXClass( Son.class ).getSuperclass();
+	}
 
-    public void testHasAPackage() throws Exception {
-        assertEquals("org.hibernate.test.reflection.java", clazz.getPackage().getName());
-    }
+	public void testHasAnOwnerClass() {
+		// The "owner" is the "point of view" through which we see a class.
+		// Since Dad is an Entity, getting it through Son.getSuperclass() gives
+		// us a view of Dad with Son as an owner.
+		XClass sameView = ReflectionManager.INSTANCE.toXClass( Son.class ).getSuperclass();
+		XClass differentView = ReflectionManager.INSTANCE.toXClass( Dad.class );
+		assertSame( sameView, clazz );
+		assertNotSame( differentView, clazz );
+	}
 
-    public void testCanBeAssignableFromAnotherXClass() throws Exception {
-        assertFalse(clazz.isAssignableFrom(fatherClazz));
-        assertTrue(fatherClazz.isAssignableFrom(clazz));
-    }
-    
-    public void testCanBeConvertedToAJavaClass() throws Exception {
-        assertSame(Foo.class, clazz.toClass());
-    }
-    
-    public void testExtractsPublicFieldsAsProperties() {
-        List<XProperty> fieldProperties = clazz.getDeclaredProperties("field");
-        assertEquals(1, fieldProperties.size());
-    }
+	public void testHasAName() {
+		assertSame( "org.hibernate.test.reflection.java.generics.Dad", clazz.getName() );
+	}
 
-    public void testExtractsPublicMethodsAsProperties() {
-        List<XProperty> methodProperties = clazz.getDeclaredProperties("property");
-        assertEquals(3, methodProperties.size());
-    }
-    
-    public void testCanBeAbstract() {
-        assertFalse(clazz.isAbstract());
-        assertTrue(ReflectionManager.INSTANCE.toXClass(FooFather.class).isAbstract());
-    }
-    
-    public void testCanBeAPrimitive() throws Exception {
-        assertFalse(clazz.isPrimitive());
-        assertTrue(ReflectionManager.INSTANCE.toXClass(int.class).isPrimitive());
-    }
-    
-    public void testCanBeAnEnum() throws Exception {
-        assertFalse(clazz.isEnum());
-        assertTrue(ReflectionManager.INSTANCE.toXClass(CacheModeType.class).isEnum());
-    }
+	public void testHasASuperclass() {
+		assertEquals( fatherClazz, clazz.getSuperclass() );
+	}
+
+	public void testCanBeAssignableFromAnotherXClass() {
+		assertFalse( clazz.isAssignableFrom( fatherClazz ) );
+		assertTrue( fatherClazz.isAssignableFrom( clazz ) );
+	}
+
+	public void testExtractsPublicFieldsAsProperties() {
+		List<XProperty> fieldProperties = clazz.getDeclaredProperties( "field" );
+		assertEquals( 1, fieldProperties.size() );
+	}
+
+	public void testExtractsPublicMethodsAsProperties() {
+		List<XProperty> methodProperties = clazz.getDeclaredProperties( "property" );
+		assertEquals( 6, methodProperties.size() );
+	}
+
+	public void testCanBeAbstract() {
+		assertFalse( clazz.isAbstract() );
+		assertTrue( ReflectionManager.INSTANCE.toXClass( Grandpa.class ).isAbstract() );
+	}
+
+	public void testCanBeAPrimitive() {
+		assertFalse( clazz.isPrimitive() );
+		assertTrue( ReflectionManager.INSTANCE.toXClass( int.class ).isPrimitive() );
+	}
+
+	public void testCanBeAnEnum() {
+		assertFalse( clazz.isEnum() );
+		assertTrue( ReflectionManager.INSTANCE.toXClass( CacheModeType.class ).isEnum() );
+	}
+
+	@Override
+	protected XAnnotatedElement getConcreteInstance() {
+		return ReflectionManager.INSTANCE.toXClass( Dad.class );
+	}
 }

--- JavaXAnnotatedElementTest.java DELETED ---

--- JavaXMemberTest.java DELETED ---