package org.hivedb.util;
import org.hivedb.util.classgen.GenerateInstance;
import org.hivedb.util.classgen.GeneratedClassFactory;
import org.hivedb.util.classgen.ReflectionTools;
import org.hivedb.util.classgen.ReflectionTools.SetterWrapper;
import org.junit.Assert;
import org.junit.Test;
import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
public class TestReflectionTools {
@Test
public void testGetPropertyNameOfAccessor() {
Assert.assertEquals(
ReflectionTools.getPropertyNameOfAccessor(
ReflectionTools.getGetterOfProperty(Foo.class, "stroo")),
"stroo");
}
@Test
public void testIsGetter() {
Assert.assertTrue(
ReflectionTools.isGetter(
ReflectionTools.getGetterOfProperty(Foo.class, "stroo").getName()));
try {
Assert.assertFalse(
ReflectionTools.isGetter(
Foo.class.getMethod("obtainCircumlocution", new Class[] {String.class})));
} catch (Exception e) {
throw new RuntimeException(e);
}
Assert.assertFalse(
ReflectionTools.isGetter(
ReflectionTools.getSetterWrapperOfProperty(Foo.class, "orama").getRealSetter().getName()));
}
@Test
public void testIsSetter() {
Assert.assertFalse(
ReflectionTools.isSetter(
ReflectionTools.getGetterOfProperty(Foo.class, "stroo").getName()));
try {
Assert.assertFalse(
ReflectionTools.isSetter(
Foo.class.getMethod("obtainCircumlocution", new Class[] {String.class})));
} catch (Exception e) {
throw new RuntimeException(e);
}
Assert.assertTrue(
ReflectionTools.isSetter(
ReflectionTools.getSetterWrapperOfProperty(Foo.class, "orama").getRealSetter().getName()));
}
@Test
public void testDoesSetterExist() {
Assert.assertTrue(
ReflectionTools.doesRealSetterExist(
ReflectionTools.getGetterOfProperty(Foo.class, "orama")));
Assert.assertFalse(
ReflectionTools.doesRealSetterExist(
ReflectionTools.getGetterOfProperty(Foo.class, "stroo")));
}
@Test
public void testGetCorrespondingSetterWrapper() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
SetterWrapper setterWrapper = ReflectionTools.getCorrespondingSetterWrapper(foo, "getStroo", String.class);
setterWrapper.invoke(foo, "x");
Assert.assertEquals(foo.getStroo(), "x");
setterWrapper = ReflectionTools.getCorrespondingSetterWrapper(ReflectionTools.getGetterOfProperty(Foo.class, "stroo"));
setterWrapper.invoke(foo, "y");
Assert.assertEquals(foo.getStroo(), "y");
}
@Test
public void testGetCorrespondingGetter() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
Method getter = ReflectionTools.getCorrespondingGetter(foo, "setStroo");
try {
Assert.assertEquals(getter.invoke(foo, new Object[] {}), foo.getStroo());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void testGetGetterOfProperty() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
Method getter = ReflectionTools.getGetterOfProperty(Foo.class, "stroo");
try {
Assert.assertEquals(getter.invoke(foo, new Object[] {}), foo.getStroo());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void testGetSetterWrapperOfProperty() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
SetterWrapper setterWrapper = ReflectionTools.getSetterWrapperOfProperty(Foo.class, "stroo");
setterWrapper.invoke(foo, "x");
Assert.assertEquals(foo.getStroo(), "x");
}
@Test
public void testGetSetterOfProperty() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
Method setter = ReflectionTools.getSetterOfProperty(Foo.class, "orama");
try {
setter.invoke(foo, "x");
} catch (Exception e) {
throw new RuntimeException(e);
}
Assert.assertEquals(foo.getOrama(), "x");
}
@Test
public void testGetDeclaredPublicMethods() {
try {
Assert.assertEquals(
new HashSet(ReflectionTools.getDeclaredPublicMethods(Foo.class)).hashCode(),
new HashSet(Arrays.asList(new Method[] {
Foo.class.getMethod("getStroo", new Class[] {}),
Foo.class.getMethod("getIoo", new Class[] {}),
Foo.class.getMethod("getCoos", new Class[] {}),
Foo.class.getMethod("getShoos", new Class[] {}),
Foo.class.getMethod("obtainCircumlocution", new Class[] {String.class}),
Foo.class.getMethod("setOrama", new Class[] {String.class}),
Foo.class.getMethod("getOrama", new Class[] {}),
})).hashCode());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void testDoesImplementOrExtend() {
Assert.assertTrue(ReflectionTools.doesImplementOrExtend(
GeneratedClassFactory.getGeneratedClass(Foo.class),
Foo.class));
Assert.assertTrue(ReflectionTools.doesImplementOrExtend(
Fooer.class,
Foo.class));
Assert.assertTrue(ReflectionTools.doesImplementOrExtend(
Fooimp.class,
Foo.class));
Assert.assertTrue(ReflectionTools.doesImplementOrExtend(
new Class[] {Fooimp.class, Boo.class},
Foo.class));
Assert.assertFalse(ReflectionTools.doesImplementOrExtend(
new Class[] {Boo.class, Coo.class},
Foo.class));
}
@Test
public void testWhichIsImplemented() {
Assert.assertEquals(
ReflectionTools.whichIsImplemented(
Fooimp.class,
Arrays.asList(new Class[] {Foo.class, Boo.class, Coo.class})),
Foo.class);
}
@Test
public void testGetNullFields() {
try {
Assert.assertEquals(
new HashSet(
ReflectionTools.getNullFields( GeneratedClassFactory.newInstance(Foo.class), Foo.class )).hashCode(),
new HashSet(Arrays.asList(new Method[] {
Foo.class.getMethod("getStroo", new Class[] {}),
Foo.class.getMethod("getIoo", new Class[] {}),
Foo.class.getMethod("getCoos", new Class[] {}),
Foo.class.getMethod("getShoos", new Class[] {}),
Foo.class.getMethod("getOrama", new Class[] {}),
})).hashCode());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
@Test
public void testInvokeGetters() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
Collection<Method> getters = ReflectionTools.getGetters(Foo.class);
Collection objects = ReflectionTools.invokeGetters(foo, ReflectionTools.getGetters(Foo.class));
Iterator<Object> iterator = objects.iterator();
for (Method getter : getters) {
Object obj = iterator.next();
try {
Assert.assertEquals(obj, getter.invoke(foo, new Object[] {}));
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
@Test
public void testInvokeGetter() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
Object obj = ReflectionTools.invokeGetter(foo, "stroo");
Assert.assertEquals(obj, foo.getStroo());
}
@Test
public void testInvokeSetter() {
Foo foo = new GenerateInstance<Foo>(Foo.class).generate();
ReflectionTools.invokeSetter(foo, "stroo", "x");
Assert.assertEquals("x", foo.getStroo());
}
@Test
public void testGetCollectionType() {
Assert.assertEquals(ReflectionTools.getCollectionItemType(Foo.class, "coos"), Coo.class);
// Assert that extended interfaces can get the generic type
Assert.assertEquals(ReflectionTools.getCollectionItemType(Fooer.class, "coos"), Coo.class);
// Assert that implementations can get the generic type
Assert.assertEquals(ReflectionTools.getCollectionItemType(Fooimp.class, "coos"), Coo.class);
// Assert that subclasses can get the generic type
Assert.assertEquals(ReflectionTools.getCollectionItemType(Fooimpimp.class, "coos"), Coo.class);
}
@Test
public void testGetUniqueComplexPropertyTypes() {
// Collection<Class<?>> classes = new HashSet<Class<?>>(ReflectionTools.getUniqueComplexPropertyTypes(Arrays.asList(new Class[] {Foo.class})));
// Assert.assertEquals(classes, new HashSet<Class<?>>((Collection<? extends Class<?>>) Arrays.asList(new Class[] {Foo.class,Coo.class,Boo.class})));
}
/*
* private interface Foo {
* Stack-walking on our proxy objects will yield ReflectionTools as caller
* class and the security check on method.invoke will fail if Foo is not
* public or method.setAccesible(true) is called prior invocation.
*/
public interface Foo {
String getStroo();
Integer getIoo();
Collection<Coo> getCoos();
Collection<Short> getShoos();
String obtainCircumlocution(String puppy);
void setOrama(String rama);
String getOrama();
}
private interface Coo {
Float getFloo();
Collection<Boo> getBoos();
}
private interface Boo {
Double getDoo();
}
private interface Fooer extends Foo {
String getWhatever();
}
private class Fooimp implements Foo {
public Fooimp() {
}
public Collection<Coo> getCoos() {
return null;
}
public Integer getIoo() {
return null;
}
public Collection<Short> getShoos() {
return null;
}
public String getStroo() {
return null;
}
public String getOrama() {
return null;
}
public String obtainCircumlocution(String puppy) {
return null;
}
public void setOrama(String rama) {
}
}
private class Fooimpimp extends Fooimp {
public Integer getIoo() {
return null;
}
public Collection<Short> getShoos() {
return null;
}
public String getStroo() {
return null;
}}
}