* The following is an example of proper usage of this class: * *
* // Retrieves the value of the property "name"
* String name = {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link PropertyName#ofType(Class) ofType}(String.class).{@link PropertyType#in(Object) in}(person).{@link Invoker#get() get}();
*
* // Sets the value of the property "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link PropertyName#ofType(Class) ofType}(String.class).{@link PropertyType#in(Object) in}(person).{@link Invoker#set(Object) set}("Yoda");
*
* // Retrieves the value of the property "powers"
* List<String> powers = {@link org.fest.reflect.core.Reflection#property(String) property}("powers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link PropertyTypeRef#in(Object) in}(jedi).{@link Invoker#get() get}();
*
* // Sets the value of the property "powers"
* List<String> powers = new ArrayList<String>();
* powers.add("heal");
* {@link org.fest.reflect.core.Reflection#property(String) property}("powers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link PropertyTypeRef#in(Object) in}(jedi).{@link Invoker#set(Object) set}(powers);
*
*
*
* @author Alex Ruiz
*
* @since 1.2
*/
public final class PropertyName {
/**
* Creates a new {@link PropertyName}: the starting point of the fluent interface for accessing properties using
* Bean Introspection.
* @param name the name of the property to access using Bean Introspection.
* @return the created PropertyName.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static PropertyName startPropertyAccess(String name) {
validateIsNotNullOrEmpty(name);
return new PropertyName(name);
}
private static void validateIsNotNullOrEmpty(String name) {
if (name == null) throw new NullPointerException("The name of the property to access should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the property to access should not be empty");
}
private final String name;
private PropertyName(String name) {
this.name = name;
}
/**
* Sets the type of the property to access.
* @param null.
*/
public * For example: * *
* List<String> powers = {@link org.fest.reflect.core.Reflection#property(String) property}("powers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link PropertyTypeRef#in(Object) in}(jedi).{@link Invoker#get() get}();
*
*
* @param null.
*/
public * The following is an example of proper usage of this class: * *
* // Retrieves the value of the property "name"
* String name = {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link PropertyName#ofType(Class) ofType}(String.class).{@link PropertyType#in(Object) in}(person).{@link Invoker#get() get}();
*
* // Sets the value of the property "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link PropertyName#ofType(Class) ofType}(String.class).{@link PropertyType#in(Object) in}(person).{@link Invoker#set(Object) set}("Yoda");
*
*
*
* @param null.
* @throws ReflectionError if a property with a matching name and type cannot be found.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Retrieves the value of the property "powers"
* List<String> powers = {@link org.fest.reflect.core.Reflection#property(String) property}("powers").{@link PropertyName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link #in(Object) in}(jedi).{@link Invoker#get() get}();
*
* // Sets the value of the property "powers"
* List<String> powers = new ArrayList<String>();
* powers.add("heal");
* {@link org.fest.reflect.core.Reflection#property(String) property}("powers").{@link PropertyName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link #in(Object) in}(jedi).{@link Invoker#set(Object) set}(powers);
*
*
*
* @param null.
* @throws ReflectionError if a property with a matching name and type cannot be found.
*/
public InvokerProvides a "fluent" API for property access via the Bean Instrospection API.
Note: Classes in this package are not intended to be used directly. To use them, you need to use the
class {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Retrieves the value of the property "name"
String name = {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link org.fest.reflect.beanproperty.PropertyName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.beanproperty.PropertyType#in(Object) in}(person).{@link org.fest.reflect.beanproperty.Invoker#get() get}();
// Sets the value of the property "name" to "Yoda"
{@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link org.fest.reflect.beanproperty.PropertyName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.beanproperty.PropertyType#in(Object) in}(person).{@link org.fest.reflect.beanproperty.Invoker#set(Object) set}("Yoda");
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/constructor/ 0000775 0000000 0000000 00000000000 12112453432 0026653 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/constructor/Invoker.java 0000664 0000000 0000000 00000007146 12112453432 0031143 0 ustar 00root root 0000000 0000000 /*
* Created on Oct 31, 2006
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.constructor;
import static org.fest.reflect.util.Accessibles.makeAccessible;
import static org.fest.reflect.util.Accessibles.setAccessibleIgnoringExceptions;
import static org.fest.reflect.util.Throwables.targetOf;
import static org.fest.util.Strings.concat;
import java.lang.reflect.Constructor;
import java.util.Arrays;
import org.fest.reflect.exception.ReflectionError;
/**
* Understands the invocation of a constructor via Java Reflection.
* @param * The following is an example of proper usage of the classes in this package: * *
* // Equivalent to call 'new Person()'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#in in}(Person.class).{@link #newInstance newInstance}();
*
* // Equivalent to call 'new Person("Yoda")'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#withParameterTypes(Class...) withParameterTypes}(String.class).{@link ParameterTypes#in(Class) in}(Person.class).{@link #newInstance newInstance}("Yoda");
*
*
*
* @author Alex Ruiz
* @author Yvonne Wang
*/
public final class InvokerT by calling a constructor with the given arguments.
* @param args the arguments to pass to the constructor (can be zero or more).
* @return the created instance of T.
* @throws ReflectionError if a new instance cannot be created.
*/
public T newInstance(Object... args) {
boolean accessible = constructor.isAccessible();
try {
makeAccessible(constructor);
T newInstance = constructor.newInstance(args);
return newInstance;
} catch (Throwable t) {
Throwable cause = targetOf(t);
if (cause instanceof RuntimeException) throw (RuntimeException) cause;
throw new ReflectionError("Unable to create a new object from the enclosed constructor", cause);
} finally {
setAccessibleIgnoringExceptions(constructor, accessible);
}
}
/**
* Returns the "real" constructor managed by this class.
* @return the "real" constructor managed by this class.
*/
public Constructor* The following is an example of proper usage of the classes in this package: * *
* // Equivalent to call 'new Person()'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#in in}(Person.class).{@link Invoker#newInstance newInstance}();
*
* // Equivalent to call 'new Person("Yoda")'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#withParameterTypes(Class...) withParameterTypes}(String.class).{@link ParameterTypes#in(Class) in}(Person.class).{@link Invoker#newInstance newInstance}("Yoda");
*
*
*
* @author Alex Ruiz
* @author Yvonne Wang
*/
public final class ParameterTypes {
static ParameterTypes newParameterTypes(Class[] parameterTypes) {
if (parameterTypes == null) throw new NullPointerException("The array of parameter types should not be null");
return new ParameterTypes(parameterTypes);
}
private final Class[] parameterTypes;
private ParameterTypes(Class[] parameterTypes) {
this.parameterTypes = parameterTypes;
}
/**
* Creates a new constructor invoker.
* @param * The following is an example of proper usage of the classes in this package: * *
* // Equivalent to call 'new Person()'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#in in}(Person.class).{@link Invoker#newInstance newInstance}();
*
* // Equivalent to call 'new Person("Yoda")'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#withParameterTypes(Class...) withParameterTypes}(String.class).{@link ParameterTypes#in(Class) in}(Person.class).{@link Invoker#newInstance newInstance}("Yoda");
*
*
*
* @author Alex Ruiz
* @author Yvonne Wang
*/
public final class TargetType {
/**
* Creates a new {@link TargetType}.
* @return the created TargetType.
*/
public static TargetType startConstructorAccess() {
return new TargetType();
}
private TargetType() {}
/**
* Creates a new constructor invoker.
* @param null.
*/
public ParameterTypes withParameterTypes(Class... parameterTypes) {
return newParameterTypes(parameterTypes);
}
} fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/constructor/package.html 0000664 0000000 0000000 00000003732 12112453432 0031141 0 ustar 00root root 0000000 0000000
Provides a "fluent" API for constructor invocation via the Java Reflection API.
Note: Classes in this package are not intended to be used directly. To use them, you need to use the
class {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Equivalent to call 'new Person()'
Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link org.fest.reflect.constructor.TargetType#in in}(Person.class).{@link org.fest.reflect.constructor.Invoker#newInstance(Object...) newInstance}();
// Equivalent to call 'new Person("Yoda")'
Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link org.fest.reflect.constructor.TargetType#withParameterTypes(Class...) withParameterTypes}(String.class).{@link org.fest.reflect.constructor.ParameterTypes#in(Class) in}(Person.class).{@link org.fest.reflect.constructor.Invoker#newInstance(Object...) newInstance}("Yoda");
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/core/ 0000775 0000000 0000000 00000000000 12112453432 0025216 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/core/Reflection.java 0000664 0000000 0000000 00000035232 12112453432 0030160 0 ustar 00root root 0000000 0000000 /*
* Created on Oct 31, 2006
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.core;
import static org.fest.reflect.beanproperty.PropertyName.startPropertyAccess;
import static org.fest.reflect.constructor.TargetType.startConstructorAccess;
import static org.fest.reflect.field.FieldName.beginFieldAccess;
import static org.fest.reflect.field.StaticFieldName.beginStaticFieldAccess;
import static org.fest.reflect.innerclass.StaticInnerClassName.startStaticInnerClassAccess;
import static org.fest.reflect.method.MethodName.startMethodAccess;
import static org.fest.reflect.method.StaticMethodName.startStaticMethodAccess;
import static org.fest.reflect.type.Type.newType;
import org.fest.reflect.beanproperty.PropertyName;
import org.fest.reflect.beanproperty.PropertyType;
import org.fest.reflect.constructor.TargetType;
import org.fest.reflect.field.FieldName;
import org.fest.reflect.field.FieldTypeRef;
import org.fest.reflect.field.StaticFieldName;
import org.fest.reflect.field.StaticFieldType;
import org.fest.reflect.field.StaticFieldTypeRef;
import org.fest.reflect.innerclass.StaticInnerClassName;
import org.fest.reflect.method.Invoker;
import org.fest.reflect.method.MethodName;
import org.fest.reflect.method.MethodReturnTypeRef;
import org.fest.reflect.method.StaticMethodName;
import org.fest.reflect.method.StaticMethodReturnTypeRef;
import org.fest.reflect.reference.TypeRef;
import org.fest.reflect.type.Type;
/**
* Understands the entry point for the classes in this package.
* * The following is an example of proper usage of the classes in this package: * *
* // Loads the class 'org.republic.Jedi'
* Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#load() load}();
*
* // Loads the class 'org.republic.Jedi' as 'org.republic.Person' (Jedi extends Person)
* Class<Person> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#loadAs(Class) loadAs}(Person.class);
*
* // Loads the class 'org.republic.Jedi' using a custom class loader
* Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#withClassLoader(ClassLoader) withClassLoader}(myClassLoader).{@link org.fest.reflect.type.TypeLoader#load() load}();
*
* // Gets the inner class 'Master' in the declaring class 'Jedi':
* Class<?> masterClass = {@link org.fest.reflect.core.Reflection#staticInnerClass(String) staticInnerClass}("Master").{@link org.fest.reflect.innerclass.StaticInnerClassName#in(Class) in}(Jedi.class).{@link org.fest.reflect.innerclass.Invoker#get() get}();
*
* // Equivalent to call 'new Person()'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#in in}(Person.class).{@link org.fest.reflect.constructor.Invoker#newInstance(Object...) newInstance}();
*
* // Equivalent to call 'new Person("Yoda")'
* Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link TargetType#withParameterTypes(Class...) withParameterTypes}(String.class).{@link org.fest.reflect.constructor.ParameterTypes#in(Class) in}(Person.class).{@link org.fest.reflect.constructor.Invoker#newInstance(Object...) newInstance}("Yoda");
*
* // Retrieves the value of the field "name"
* String name = {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link org.fest.reflect.field.FieldName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.field.FieldType#in(Object) in}(person).{@link org.fest.reflect.field.Invoker#get() get}();
*
* // Sets the value of the field "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link org.fest.reflect.field.FieldName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.field.FieldType#in(Object) in}(person).{@link org.fest.reflect.field.Invoker#set(Object) set}("Yoda");
*
* // Retrieves the value of the field "powers"
* List<String> powers = {@link org.fest.reflect.core.Reflection#field(String) field}("powers").{@link FieldName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link FieldTypeRef#in(Object) in}(jedi).{@link org.fest.reflect.field.Invoker#get() get}();
*
* // Equivalent to call 'person.setName("Luke")'
* {@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link org.fest.reflect.method.MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link org.fest.reflect.method.MethodParameterTypes#in(Object) in}(person)
* .{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}("Luke");
*
* // Equivalent to call 'jedi.getPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#method(String) method}("getPowers").{@link MethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link MethodReturnTypeRef#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
* // Retrieves the value of the static field "count" in Person.class
* int count = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link org.fest.reflect.field.Invoker#get() get}();
*
* // Sets the value of the static field "count" to 3 in Person.class
* {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link org.fest.reflect.field.Invoker#set(Object) set}(3);
*
* // Retrieves the value of the static field "commonPowers" in Jedi.class
* List<String> commmonPowers = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("commonPowers").{@link StaticFieldName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link StaticFieldTypeRef#in(Class) in}(Jedi.class).{@link org.fest.reflect.field.Invoker#get() get}();
*
* // Equivalent to call 'person.concentrate()'
* {@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link org.fest.reflect.method.MethodName#in(Object) in}(person).{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'person.getName()'
* String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link org.fest.reflect.method.MethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link org.fest.reflect.method.MethodReturnType#in(Object) in}(person)
* .{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.setCommonPower("Jump")'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("setCommonPower").{@link org.fest.reflect.method.StaticMethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link org.fest.reflect.method.StaticMethodParameterTypes#in(Class) in}(Jedi.class)
* .{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}("Jump");
*
* // Equivalent to call 'Jedi.addPadawan()'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("addPadawan").{@link org.fest.reflect.method.StaticMethodName#in(Class) in}(Jedi.class).{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.commonPowerCount()'
* String name = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("commonPowerCount").{@link org.fest.reflect.method.StaticMethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link org.fest.reflect.method.StaticMethodReturnType#in(Class) in}(Jedi.class)
* .{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.getCommonPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link StaticMethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
* // Retrieves the value of the property "name"
* String name = {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link PropertyName#ofType(Class) ofType}(String.class).{@link PropertyType#in(Object) in}(person).{@link org.fest.reflect.beanproperty.Invoker#get() get}();
*
* // Sets the value of the property "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#property(String) property}("name").{@link PropertyName#ofType(Class) ofType}(String.class).{@link PropertyType#in(Object) in}(person).{@link org.fest.reflect.beanproperty.Invoker#set(Object) set}("Yoda");
*
*
*
* @author Alex Ruiz
* @author Yvonne Wang
* @author Ivan Hristov
*/
public final class Reflection {
/**
* Starting point of the fluent interface for loading a class dynamically.
* @param name the name of the class to load.
* @return the starting point of the method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
* @since 1.1
*/
public static Type type(String name) {
return newType(name);
}
/**
* Starting point of the fluent interface for accessing static inner class via reflection.
* @param name the name of the static inner class to access.
* @return the starting point of the method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
* @since 1.1
*/
public static StaticInnerClassName staticInnerClass(String name) {
return startStaticInnerClassAccess(name);
}
/**
* Starting point of the fluent interface for accessing fields via reflection.* Nested field are supported with dot notation, e.g.
"person.address.street".
* * Let's look how it works on an example : * *
* Let's say we have the following simple service:
*
* public class BusinessService {
* private NotificationService notificationService = new NotificationService();
* //... logic goes here
* }
*
* Where NotificationService is defined as follows:
*
* public class NotificationService {
* private Logger logger = new Logger();
* private IClientStatusDao clientStatusDao = new ClientStatusDao();
* //... logic goes here
* }
*
* And our ClientStatusDao looks like:
*
* public class ClientStatusDao implements IClientStatusDao {
* private final Session session = new SessionImpl();
* //... logic goes here
* }
*
* Let's say we want to change the {@code logger} field of {@code NotificationService} within our instance of {@code BusinessService}, we can do this:
*
* field("notificationService.logger").ofType(Logger.class).in(businessService).set(loggerMock);
*
* You can also set the deeply nested {@code session} field within {@code ClientStatusDao} like this:
*
* field("notificationService.clientStatusDao.session").ofType(Session.class).in(businessService).set(sessionMock);
*
*
* @param name the name of the field to access.
* @return the starting point of the method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static FieldName field(String name) {
return beginFieldAccess(name);
}
/**
* Starting point of the fluent interface for accessing static fields via reflection.
* @param name the name of the static field to access.
* @return the starting point of the method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static StaticFieldName staticField(String name) {
return beginStaticFieldAccess(name);
}
/**
* Starting point of the fluent interface for invoking methods via reflection.
* @param name the name of the method to invoke.
* @return the starting point of the method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static MethodName method(String name) {
return startMethodAccess(name);
}
/**
* Starting point of the fluent interface for invoking static methods via reflection.
* @param name the name of the static method to invoke.
* @return the starting point of the static method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static StaticMethodName staticMethod(String name) {
return startStaticMethodAccess(name);
}
/**
* Starting point of the fluent interface for invoking constructors via reflection.
* @return the starting point of the method chain.
*/
public static TargetType constructor() {
return startConstructorAccess();
}
/**
* Starting point of the fluent interface for accessing properties via Bean Introspection.
* @param name the name of the property to access.
* @return the starting point of the method chain.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
* @since 1.2
*/
public static PropertyName property(String name) {
return startPropertyAccess(name);
}
private Reflection() {}
}
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/core/package.html 0000664 0000000 0000000 00000013671 12112453432 0027507 0 ustar 00root root 0000000 0000000
Provides a "fluent" API that makes usage of the Java Reflection API easier and improves code readability.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Loads the class 'org.republic.Jedi'
Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link org.fest.reflect.type.Type#load() load}();
// Loads the class 'org.republic.Jedi' as 'org.republic.Person' (Jedi extends Person)
Class<Person> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link org.fest.reflect.type.Type#loadAs(Class) loadAs}(Person.class);
// Loads the class 'org.republic.Jedi' using a custom class loader
Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link org.fest.reflect.type.Type#withClassLoader(ClassLoader) withClassLoader}(myClassLoader).{@link org.fest.reflect.type.TypeLoader#load() load}();
// Gets the inner class 'Master' in the declaring class 'Jedi':
Class<?> masterClass = {@link org.fest.reflect.core.Reflection#staticInnerClass(String) staticInnerClass}("Master").{@link org.fest.reflect.innerclass.StaticInnerClassName#in(Class) in}(Jedi.class).{@link org.fest.reflect.innerclass.Invoker#get() get}();
// Equivalent to call 'new Person()'
Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link org.fest.reflect.constructor.TargetType#in in}(Person.class).{@link org.fest.reflect.constructor.Invoker#newInstance(Object...) newInstance}();
// Equivalent to call 'new Person("Yoda")'
Person p = {@link org.fest.reflect.core.Reflection#constructor() constructor}().{@link org.fest.reflect.constructor.TargetType#withParameterTypes(Class...) withParameterTypes}(String.class).{@link org.fest.reflect.constructor.ParameterTypes#in(Class) in}(Person.class).{@link org.fest.reflect.constructor.Invoker#newInstance(Object...) newInstance}("Yoda");
// Retrieves the value of the field "name"
String name = {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link org.fest.reflect.field.FieldName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.field.FieldType#in(Object) in}(person).{@link org.fest.reflect.field.Invoker#get() get}();
// Sets the value of the field 'name' to "Yoda"
{@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link org.fest.reflect.field.FieldName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.field.FieldType#in(Object) in}(person).{@link org.fest.reflect.field.Invoker#set(Object) set}("Yoda");
// Equivalent to call 'jedi.getPowers()'
List<String> powers = {@link org.fest.reflect.core.Reflection#method(String) method}("getPowers").{@link org.fest.reflect.method.MethodName#withReturnType(org.fest.reflect.reference.TypeRef) withReturnType}(new {@link org.fest.reflect.reference.TypeRef TypeRef}<List<String>>() {})
.{@link org.fest.reflect.method.MethodReturnTypeRef#in(Object) in}(person)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
// Equivalent to call 'person.setName("Luke")'
{@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link org.fest.reflect.method.MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
.{@link org.fest.reflect.method.MethodParameterTypes#in(Object) in}(person)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}("Luke");
// Equivalent to call 'person.concentrate()'
{@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link org.fest.reflect.method.MethodName#in(Object) in}(person).{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
// Equivalent to call 'person.getName()'
String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link org.fest.reflect.method.MethodName#withReturnType(Class) withReturnType}(String.class)
.{@link org.fest.reflect.method.MethodReturnType#in(Object) in}(person)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
// Equivalent to call 'Jedi.getCommonPowers()'
List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link org.fest.reflect.method.StaticMethodName#withReturnType(org.fest.reflect.reference.TypeRef) withReturnType}(new {@link org.fest.reflect.reference.TypeRef TypeRef}<List<String>>() {})
.{@link org.fest.reflect.method.StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/exception/ 0000775 0000000 0000000 00000000000 12112453432 0026264 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/exception/ReflectionError.java 0000664 0000000 0000000 00000002432 12112453432 0032234 0 ustar 00root root 0000000 0000000 /*
* Created on Nov 16, 2006
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.exception;
/**
* Understands an error raised when using reflection.
*
* @author Alex Ruiz
*/
public final class ReflectionError extends RuntimeException {
private static final long serialVersionUID = 1L;
/**
* Creates a new {@link ReflectionError}.
* @param message the detail message.
*/
public ReflectionError(String message) {
super(message);
}
/**
* Creates a new {@link ReflectionError}.
* @param message the detail message.
* @param cause the cause of the exception.
*/
public ReflectionError(String message, Throwable cause) {
super(message, cause);
}
}
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/exception/package.html 0000664 0000000 0000000 00000001602 12112453432 0030544 0 ustar 00root root 0000000 0000000
Exceptions used in the FEST-Reflect module.
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/field/ 0000775 0000000 0000000 00000000000 12112453432 0025351 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/field/DecoratedInvoker.java 0000664 0000000 0000000 00000014331 12112453432 0031446 0 ustar 00root root 0000000 0000000 /* * Created on Mar 18, 2012 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2006-2009 the original author or authors. */ package org.fest.reflect.field; import java.lang.reflect.Proxy; import org.fest.reflect.field.decorator.DecoratorInvocationHandler; import org.fest.reflect.field.decorator.RuntimeExceptionShield; /** * A decorated invoker allowing to ignore some exceptions or returning decorator result instead of field result. * @author Ivan Hristov */ public final class DecoratedInvoker* If {@link DecoratedInvoker#ignoringDecoratorExceptions() ignoringDecoratorExceptions()} is used in combination with this * method and an exception is thrown, the default value will be returned (as defined by JLS) for all primitives or null for all * non-primitive. *
* Example :
* If a {@link RuntimeException} is thrown while executing one of the decorated IExampleService field methods which
* returns primitive boolean value, the default value false will be returned.
*
*
* field("fieldName").ofType(IExampleService.class).in(target)
* .postDecorateWith(postDecoratorService)
* .returningDecoratorResult()
* .ignoringDecoratorExceptions();
*
* In case of several decorators attached to a field, the result from the latest will be returned.
*
* Example 1:
* The result from the preDecoratorService will be returned
*
*
* field("fieldName").ofType(IExampleService.class).in(target)
* .preDecorateWith(preDecoratorService)
* .returningDecoratorResult();
*
* Example 2:* The result from the postDecoratorService will be returned * *
* field("fieldName").ofType(IExampleService.class).in(target)
* .postDecorateWith(postDecoratorService)
* .returningDecoratorResult();
*
* Example 3:* The result from the preDecoratorService will be returned, since it's the latest attached decorator. * *
* field("fieldName").ofType(IExampleService.class).in(target)
* .postDecorateWith(postDecoratorService)
* .returningDecoratorResult()
* .preDecorateWith(preDecoratorService)
* .returningDecoratorResult();
*
*/
public DecoratedInvoker
* Note that if there are more than one pre-decorators assigned to a field they will be executed starting from the last attached
* decorator.
* @param decorator which methods be called before the same targeted object methods
* @return the {@link DecoratedInvoker} pre decorating the target field interface with given decorator.
*/
public DecoratedInvoker
* Note that if there are more than one post-decorators assigned to a field they will be executed starting from the first
* attached decorator.
* @param decorator which methods be called after the same targeted object methods
* @return the {@link DecoratedInvoker} post decorating the target field interface with given decorator.
*/
public DecoratedInvoker
* The following is an example of proper usage of this class:
*
*
* For example:
*
*
* // Retrieves the value of the field "name"
* String name = {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link FieldName#ofType(Class) ofType}(String.class).{@link FieldType#in(Object) in}(person).{@link Invoker#get() get}();
*
* // Sets the value of the field "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link FieldName#ofType(Class) ofType}(String.class).{@link FieldType#in(Object) in}(person).{@link Invoker#set(Object) set}("Yoda");
*
* // Retrieves the value of the field "powers"
* List<String> powers = {@link org.fest.reflect.core.Reflection#field(String) field}("powers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link FieldTypeRef#in(Object) in}(jedi).{@link Invoker#get() get}();
*
* // Sets the value of the field "powers"
* List<String> powers = new ArrayList<String>();
* powers.add("heal");
* {@link org.fest.reflect.core.Reflection#field(String) field}("powers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link FieldTypeRef#in(Object) in}(jedi).{@link Invoker#set(Object) set}(powers);
*
* {@link FieldName}: the starting point of the fluent interface for accessing fields using Java
* Reflection.
* @param name the name of the field to access using Java Reflection.
* @return the created FieldName.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static FieldName beginFieldAccess(String name) {
validateIsNotNullOrEmpty(name);
return new FieldName(name);
}
private static void validateIsNotNullOrEmpty(String name) {
if (name == null) throw new NullPointerException("The name of the field to access should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the field to access should not be empty");
}
private FieldName(String name) {
this.path = new ArrayListnull.
*/
public
* List<String> powers = {@link org.fest.reflect.core.Reflection#field(String) field}("powers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link FieldTypeRef#in(Object) in}(jedi).{@link Invoker#get() get}();
*
*
null.
* @since 1.1
*/
public * The following is an example of proper usage of this class: * *
* // Retrieves the value of the field "name"
* String name = {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link FieldName#ofType(Class) ofType}(String.class).{@link FieldType#in(Object) in}(person).{@link Invoker#get() get}();
*
* // Sets the value of the field "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link FieldName#ofType(Class) ofType}(String.class).{@link FieldType#in(Object) in}(person).{@link Invoker#set(Object) set}("Yoda");
*
*
*
* @param null.
* @throws ReflectionError if a field with a matching name and type cannot be found.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Retrieves the value of the field "powers"
* List<String> powers = {@link org.fest.reflect.core.Reflection#field(String) field}("powers").{@link FieldName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link #in(Object) in}(jedi).{@link Invoker#get() get}();
*
* // Sets the value of the field "powers"
* List<String> powers = new ArrayList<String>();
* powers.add("heal");
* {@link org.fest.reflect.core.Reflection#field(String) field}("powers").{@link FieldName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link #in(Object) in}(jedi).{@link Invoker#set(Object) set}(powers);
*
*
*
* @param null.
* @throws ReflectionError if a field with a matching name and type cannot be found.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Retrieves the value of the field "name"
* String name = {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link FieldName#ofType(Class) ofType}(String.class).{@link FieldType#in(Object) in}(person).{@link Invoker#get() get}();
*
* // Sets the value of the field "name" to "Yoda"
* {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link FieldName#ofType(Class) ofType}(String.class).{@link FieldType#in(Object) in}(person).{@link Invoker#set(Object) set}("Yoda");
*
* // Retrieves the value of the static field "count"
* int count = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link Invoker#get() get}();
*
* // Sets the value of the static field "count" to 3
* {@link org.fest.reflect.core.Reflection#staticField(String) field}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link Invoker#set(Object) set}(3);
*
*
*
*
* @param * Each execution of a targeted object's method will be first performed on the same method of the {@code decorator} object. The * result (if any) from the invocation of the targeted object's method will be returned but you can choose to return the * decorator result if you want to. *
* Be aware: *
* Example: Assuming we have the following code: * *
* interface IUploadFileService {
* boolean upload(String file, String destination);
* }
*
* public class FileManager {
*
* private IUploadFileService uploadFileService;
* private static final String DEFAULT_DESTINATION = "http://example.org/default/destination/";
*
* public void manage(String fileName) {
* if( uploadFileService.upload(fileName, DEFAULT_DESTINATION) ) {
* System.out.println("File "+fileName+" sent to "+DEFAULT_DESTINATION);
* } else {
* System.out.println("Unable to sent "+fileName+" to "+DEFAULT_DESTINATION);
* }
* }
* }
*
*
* Let's say we want to decorate the uploadFileService.upload(...) part, so that additional functionality is executed
* before the actual uploadFileService.upload(...) logic, the following code will do the job:
*
*
* IUploadFileService uploadFileServiceDecorator = ...;
* FileManager fileManager = new FileManager();
*
* field("uploadFileService").ofType(IUploadFileService.class)
* .in(fileManager)
* .preDecorateWith(uploadFileServiceDecorator);
*
* However, if there is an exception when calling uploadFileServiceDecorator.upload(fileName, DEFAULT_DESTINATION)
* the default program's flow will be interrupted and the uploadFileService.upload(fileName, DEFAULT_DESTINATION)
* will not be executed.
*
* @param decorator which methods be called before the same targeted object methods
* @return the {@link DecoratedInvoker} pre decorating the target field interface with given decorator.
*/
public DecoratedInvoker
* After each execution of a targeted object's method, the same method of the {@code decorator} object will be called. The
* result (if any) from the invocation of the targeted object's method will be returned but you can choose to return the
* decorator result if you want to.
*
* Be aware:
*
* Example: Assuming we have the following code:
*
*
* @param decorator which methods be called after the same targeted object methods
* @return the {@link DecoratedInvoker} post decorating the target field interface with given decorator.
*/
public DecoratedInvoker
* The following is an example of proper usage of this class:
*
*
* For example:
*
*
* interface IUploadFileService {
* boolean upload(String file, String destination);
* }
*
* public class FileManager {
*
* private IUploadFileService uploadFileService;
* private static final String DEFAULT_DESTINATION = "http://example.org/default/destination/";
*
* public void manage(String fileName) {
* if( uploadFileService.upload(fileName, DEFAULT_DESTINATION) ) {
* System.out.println("File "+fileName+" sent to "+DEFAULT_DESTINATION);
* } else {
* System.out.println("Unable to sent "+fileName+" to "+DEFAULT_DESTINATION);
* }
* }
* }
*
*
* Let's say we want to decorate the uploadFileService.upload(...) part, so that additional functionality is executed
* before the actual uploadFileService.upload(...) logic, the following code will do the job:
*
*
* IUploadFileService uploadFileServiceDecorator = ...;
* FileManager fileManager = new FileManager();
*
* field("uploadFileService").ofType(IUploadFileService.class)
* .in(fileManager)
* .postDecorateWith(uploadFileServiceDecorator);
*
* However, if there is an exception when calling uploadFileServiceDecorator.upload(fileName, DEFAULT_DESTINATION)
* the default program's flow will be interrupted and the uploadFileService.upload(fileName, DEFAULT_DESTINATION)
* will not be executed.
*
* // Retrieves the value of the static field "count"
* int count = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link Invoker#get() get}();
*
* // Sets the value of the static field "count" to 3
* {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link Invoker#set(Object) set}(3);
*
* // Retrieves the value of the static field "commonPowers"
* List<String> commmonPowers = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("commonPowers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link StaticFieldTypeRef#in(Class) in}(Jedi.class).{@link Invoker#get() get}();
*
* // Sets the value of the static field "commonPowers"
* List<String> commonPowers = new ArrayList<String>();
* commonPowers.add("jump");
* {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("commonPowers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link StaticFieldTypeRef#in(Class) in}(Jedi.class).{@link Invoker#set(Object) set}(commonPowers);
*
* {@link StaticFieldName}: the starting point of the fluent interface for accessing static fields
* using Java Reflection.
* @param name the name of the field to access using Java Reflection.
* @return the created StaticFieldName.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static StaticFieldName beginStaticFieldAccess(String name) {
validateIsNotNullOrEmpty(name);
return new StaticFieldName(name);
}
private static void validateIsNotNullOrEmpty(String name) {
if (name == null) throw new NullPointerException("The name of the static field to access should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the static field to access should not be empty");
}
private final String name;
private StaticFieldName(String name) {
this.name = name;
}
/**
* Sets the type of the field to access.
* @param null.
*/
public
* List<String> commmonPowers = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("commonPowers").{@link #ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link StaticFieldTypeRef#in(Class) in}(Jedi.class).{@link Invoker#get() get}();
*
*
null.
*/
public * The following is an example of proper usage of this class: * *
* // Retrieves the value of the static field "count"
* int count = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link Invoker#get() get}();
*
* // Sets the value of the static field "count" to 3
* {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link StaticFieldName#ofType(Class) ofType}(int.class).{@link StaticFieldType#in(Class) in}(Person.class).{@link Invoker#set(Object) set}(3);
*
*
*
* @param null.
* @throws ReflectionError if a static field with a matching name and type cannot be found.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Retrieves the value of the static field "commonPowers"
* List<String> commmonPowers = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("commonPowers").{@link StaticFieldName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link StaticFieldTypeRef#in(Class) in}(Jedi.class).{@link Invoker#get() get}();
*
* // Sets the value of the static field "commonPowers"
* List<String> commonPowers = new ArrayList<String>();
* commonPowers.add("jump");
* {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("commonPowers").{@link StaticFieldName#ofType(TypeRef) ofType}(new {@link TypeRef TypeRef}<List<String>>() {}).{@link StaticFieldTypeRef#in(Class) in}(Jedi.class).{@link Invoker#set(Object) set}(commonPowers);
*
*
*
* @param null.
* @throws ReflectionError if a static field with a matching name and type cannot be found.
*/
public InvokerProvides a "fluent" API for field access via the Java Reflection API.
Note: Classes in this package are not intended to be used directly. To use them, you need to use the
class {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Retrieves the value of the field "name"
String name = {@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link org.fest.reflect.field.FieldName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.field.FieldType#in(Object) in}(person).{@link org.fest.reflect.field.Invoker#get() get}();
// Sets the value of the field "name" to "Yoda"
{@link org.fest.reflect.core.Reflection#field(String) field}("name").{@link org.fest.reflect.field.FieldName#ofType(Class) ofType}(String.class).{@link org.fest.reflect.field.FieldType#in(Object) in}(person).{@link org.fest.reflect.field.Invoker#set(Object) set}("Yoda");
// Retrieves the value of the static field "count"
int count = {@link org.fest.reflect.core.Reflection#staticField(String) staticField}("count").{@link org.fest.reflect.field.StaticFieldName#ofType(Class) ofType}(int.class).{@link org.fest.reflect.field.StaticFieldType#in(Class) in}(Person.class).{@link org.fest.reflect.field.Invoker#get() get}();
// Sets the value of the static field "count" to 3
{@link org.fest.reflect.core.Reflection#staticField(String) field}("count").{@link org.fest.reflect.field.StaticFieldName#ofType(Class) ofType}(int.class).{@link org.fest.reflect.field.StaticFieldType#in(Class) in}(Person.class).{@link org.fest.reflect.field.Invoker#set(Object) set}(3);
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/innerclass/ 0000775 0000000 0000000 00000000000 12112453432 0026427 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/innerclass/Invoker.java 0000664 0000000 0000000 00000004241 12112453432 0030710 0 ustar 00root root 0000000 0000000 /*
* Created on Jan 25, 2009
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2009 the original author or authors.
*/
package org.fest.reflect.innerclass;
import static org.fest.util.Strings.concat;
import org.fest.reflect.exception.ReflectionError;
/**
* Understands how to obtain a reference to a static inner class.
*
* @author Alex Ruiz
*
* @since 1.1
*/
public class Invoker {
static Invoker newInvoker(Class declaringClass, String innerClassName) {
if (declaringClass == null) throw new NullPointerException("The declaring class should not be null");
return new Invoker(declaringClass, innerClassName);
}
private final Class declaringClass;
private final String innerClassName;
private Invoker(Class declaringClass, String innerClassName) {
this.declaringClass = declaringClass;
this.innerClassName = innerClassName;
}
/**
* Returns a reference to the static inner class with the specified name in the specified declaring class.
* @return a reference to the static inner class with the specified name in the specified declaring class.
* @throws ReflectionError if the static inner class does not exist (since 1.2).
*/
public Class get() {
String namespace = declaringClass.getName();
for (Class innerClass : declaringClass.getDeclaredClasses())
if (innerClass.getName().equals(expectedInnerClassName(namespace))) return innerClass;
throw new ReflectionError(concat("The static inner class <", innerClassName, "> cannot be found in ",
declaringClass.getName()));
}
private String expectedInnerClassName(String namespace) {
return concat(namespace, "$", innerClassName);
}
}
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/innerclass/StaticInnerClassName.java 0000664 0000000 0000000 00000005561 12112453432 0033313 0 ustar 00root root 0000000 0000000 /*
* Created on Jan 25, 2009
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2009 the original author or authors.
*/
package org.fest.reflect.innerclass;
import static org.fest.reflect.innerclass.Invoker.newInvoker;
import static org.fest.util.Strings.isEmpty;
/**
* Understands the name of a static inner class.
*
* Let's assume we have the class Jedi, which contains two static inner classes: Master and
* Padawan.
*
*
* public class Jedi {
*
* public static class Master {}
*
* public static class Padawan {}
* }
*
*
*
* The following example shows how to get a reference to the inner class Master:
*
*
* Class<?> masterClass = {@link org.fest.reflect.core.Reflection#staticInnerClass(String) staticInnerClass}("Master").{@link org.fest.reflect.innerclass.StaticInnerClassName#in(Class) in}(Jedi.class).{@link org.fest.reflect.innerclass.Invoker#get() get}();
*
*
*
* @author Alex Ruiz
*
* @since 1.1
*/
public final class StaticInnerClassName {
/**
* Creates a new {@link StaticInnerClassName}.
* @param name the name of the static inner class to obtain.
* @return the created StaticInnerClassName.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static StaticInnerClassName startStaticInnerClassAccess(String name) {
validateIsNotNullOrEmpty(name);
return new StaticInnerClassName(name);
}
private static void validateIsNotNullOrEmpty(String name) {
if (name == null) throw new NullPointerException("The name of the static inner class to access should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the static inner class to access should not be empty");
}
private final String name;
private StaticInnerClassName(String name) {
this.name = name;
}
/**
* Specifies the declaring class of the static inner class to obtain.
* @param declaringClass the declaring class.
* @return an object responsible for obtaining a reference to a static inner class.
* @throws NullPointerException if the given declaring class is null.
*/
public Invoker in(Class declaringClass) {
return newInvoker(declaringClass, name);
}
}
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/innerclass/package.html 0000664 0000000 0000000 00000003172 12112453432 0030713 0 ustar 00root root 0000000 0000000
Provides a "fluent" API for accessing static inner classes via the Java Reflection API.
Note: Classes in this package are not intended to be used directly. To use them, you need to use the
class {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Gets the inner class 'Master' in the declaring class 'Jedi':
Class<?> masterClass = {@link org.fest.reflect.core.Reflection#staticInnerClass(String) staticInnerClass}("Master").{@link org.fest.reflect.innerclass.StaticInnerClassName#in(Class) in}(Jedi.class).{@link org.fest.reflect.innerclass.Invoker#get() get}();
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/method/ 0000775 0000000 0000000 00000000000 12112453432 0025546 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/method/Invoker.java 0000664 0000000 0000000 00000012023 12112453432 0030024 0 ustar 00root root 0000000 0000000 /*
* Created on Oct 31, 2006
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.method;
import static org.fest.reflect.util.Accessibles.makeAccessible;
import static org.fest.reflect.util.Accessibles.setAccessibleIgnoringExceptions;
import static org.fest.reflect.util.Throwables.targetOf;
import static org.fest.util.Arrays.format;
import static org.fest.util.Strings.concat;
import static org.fest.util.Strings.quote;
import java.lang.reflect.Method;
import org.fest.reflect.exception.ReflectionError;
/**
* Understands the use of reflection to access a method from an object.
* * *
* // Equivalent to call 'person.setName("Luke")'
* {@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link MethodParameterTypes#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}("Luke");
*
* // Equivalent to call 'person.concentrate()'
* {@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link MethodName#in(Object) in}(person).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'person.getName()'
* String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link MethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link MethodReturnType#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param * The following is an example of proper usage of this class: * *
* // Equivalent to call 'person.setName("Luke")'
* {@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link MethodParameterTypes#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}("Luke");
*
* // Equivalent to call 'person.concentrate()'
* {@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link MethodName#in(Object) in}(person).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'person.getName()'
* String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link MethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link MethodReturnType#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'jedi.getPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#method(String) method}("getPowers").{@link MethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link MethodReturnTypeRef#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @author Yvonne Wang
* @author Alex Ruiz
*/
public final class MethodName {
/**
* Creates a new {@link MethodName}: the starting point of the fluent interface for accessing methods using Java
* Reflection.
* @param name the name of the method to invoke using Java Reflection.
* @return the created MethodName.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static MethodName startMethodAccess(String name) {
validateIsNotNullOrEmpty(name);
return new MethodName(name);
}
private static void validateIsNotNullOrEmpty(String name) {
if (name == null) throw new NullPointerException("The name of the method to access should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the method to access should not be empty");
}
private final String name;
private MethodName(String name) {
this.name = name;
}
/**
* Specifies the return type of the method to invoke. This method call is optional if the return type of the method to invoke is
* void.
* @param null.
*/
public void.
* @param null.
* @since 1.1
*/
public null.
*/
public MethodParameterTypesvoid.
* @param target the object containing the method to invoke.
* @return the created method invoker.
* @throws NullPointerException if the given target is null.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Equivalent to call 'person.setName("Luke")'
* {@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link MethodParameterTypes#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}("Luke");
*
* // Equivalent to call 'person.concentrate()'
* {@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link MethodName#in(Object) in}(person).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'person.getName()'
* String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link MethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link MethodReturnType#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param null.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Equivalent to call 'person.setName("Luke")'
* {@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link MethodParameterTypes#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}("Luke");
*
* // Equivalent to call 'person.concentrate()'
* {@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link MethodName#in(Object) in}(person).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'person.getName()'
* String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link MethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link MethodReturnType#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param null.
*/
public Invokernull.
*/
public MethodParameterTypes* The following is an example of proper usage of this class: * *
* // Equivalent to call 'jedi.getPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#method(String) method}("getPowers").{@link MethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link MethodReturnTypeRef#in(Object) in}(person)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param null.
*/
public Invokernull.
*/
public MethodParameterTypes* The following is an example of proper usage of this class: * *
* // Equivalent to call 'Jedi.setCommonPower("Jump")'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("setCommonPower").{@link StaticMethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link StaticMethodParameterTypes#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}("Jump");
*
* // Equivalent to call 'Jedi.addPadawan()'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("addPadawan").{@link StaticMethodName#in(Class) in}(Jedi.class).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.commonPowerCount()'
* String name = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("commonPowerCount").{@link StaticMethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link StaticMethodReturnType#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.getCommonPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link StaticMethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @author Alex Ruiz
*/
public final class StaticMethodName {
/**
* Creates a new {@link StaticMethodName}: the starting point of the fluent interface for accessing static methods
* using Java Reflection.
* @param name the name of the method to access using Java Reflection.
* @return the created StaticMethodName.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static StaticMethodName startStaticMethodAccess(String name) {
validateIsNotNullOrEmpty(name);
return new StaticMethodName(name);
}
private static void validateIsNotNullOrEmpty(String name) {
if (name == null) throw new NullPointerException("The name of the static method to access should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the static method to access should not be empty");
}
private final String name;
private StaticMethodName(String name) {
this.name = name;
}
/**
* Specifies the return type of the static method to invoke. This method call is optional if the return type of the method to
* invoke is void.
* @param null.
*/
public void.
* @param null.
*/
public null.
*/
public StaticMethodParameterTypesvoid.
* @param target the object containing the method to invoke.
* @return the created method invoker.
* @throws NullPointerException if the given target is null.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Equivalent to call 'Jedi.setCommonPower("Jump")'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("setCommonPower").{@link StaticMethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link StaticMethodParameterTypes#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}("Jump");
*
* // Equivalent to call 'Jedi.addPadawan()'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("addPadawan").{@link StaticMethodName#in(Class) in}(Jedi.class).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.commonPowerCount()'
* String name = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("commonPowerCount").{@link StaticMethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link StaticMethodReturnType#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.getCommonPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link StaticMethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param null.
*/
public Invoker* The following is an example of proper usage of this class: * *
* // Equivalent to call 'Jedi.setCommonPower("Jump")'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("setCommonPower").{@link StaticMethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
* .{@link StaticMethodParameterTypes#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}("Jump");
*
* // Equivalent to call 'Jedi.addPadawan()'
* {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("addPadawan").{@link StaticMethodName#in(Class) in}(Jedi.class).{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.commonPowerCount()'
* String name = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("commonPowerCount").{@link StaticMethodName#withReturnType(Class) withReturnType}(String.class)
* .{@link StaticMethodReturnType#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
* // Equivalent to call 'Jedi.getCommonPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link StaticMethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param null.
*/
public Invokernull.
*/
public StaticMethodParameterTypes* The following is an example of proper usage of this class: * *
* // Equivalent to call 'Jedi.getCommonPowers()'
* List<String> powers = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("getCommonPowers").{@link StaticMethodName#withReturnType(TypeRef) withReturnType}(new {@link TypeRef TypeRef}<List<String>>() {})
* .{@link StaticMethodReturnTypeRef#in(Class) in}(Jedi.class)
* .{@link Invoker#invoke(Object...) invoke}();
*
*
*
* @param null.
*/
public Invokernull.
*/
public StaticMethodParameterTypesProvides a "fluent" API for method invocation via the Java Reflection API.
Note: Classes in this package are not intended to be used directly. To use them, you need to use the
class {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Equivalent to call 'person.setName("Luke")'
{@link org.fest.reflect.core.Reflection#method(String) method}("setName").{@link org.fest.reflect.method.MethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
.{@link org.fest.reflect.method.MethodParameterTypes#in(Object) in}(person)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}("Luke");
// Equivalent to call 'person.concentrate()'
{@link org.fest.reflect.core.Reflection#method(String) method}("concentrate").{@link org.fest.reflect.method.MethodName#in(Object) in}(person).{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
// Equivalent to call 'person.getName()'
String name = {@link org.fest.reflect.core.Reflection#method(String) method}("getName").{@link org.fest.reflect.method.MethodName#withReturnType(Class) withReturnType}(String.class)
.{@link org.fest.reflect.method.MethodReturnType#in(Object) in}(person)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
// Equivalent to call 'Jedi.class.setCommonPower("Jump")'
{@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("setCommonPower").{@link org.fest.reflect.method.StaticMethodName#withParameterTypes(Class...) withParameterTypes}(String.class)
.{@link org.fest.reflect.method.StaticMethodParameterTypes#in(Class) in}(Jedi.class)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}("Jump");
// Equivalent to call 'Jedi.class.addPadawan()'
{@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("addPadawan").{@link org.fest.reflect.method.StaticMethodName#in(Class) in}(Jedi.class).{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
// Equivalent to call 'Jedi.class.commonPowerCount()'
String name = {@link org.fest.reflect.core.Reflection#staticMethod(String) staticMethod}("commonPowerCount").{@link org.fest.reflect.method.StaticMethodName#withReturnType(Class) withReturnType}(String.class)
.{@link org.fest.reflect.method.StaticMethodReturnType#in(Class) in}(Jedi.class)
.{@link org.fest.reflect.method.Invoker#invoke(Object...) invoke}();
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/reference/ 0000775 0000000 0000000 00000000000 12112453432 0026224 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/reference/TypeRef.java 0000664 0000000 0000000 00000003607 12112453432 0030453 0 ustar 00root root 0000000 0000000 /*
* Created on Jan 24, 2009
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2009 the original author or authors.
*/
package org.fest.reflect.reference;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import org.fest.reflect.exception.ReflectionError;
/**
* Understands a references a generic type. Based on Neal Gafter's
* TypeReference.
* @param Provides support to use Java Generics overcoming the limitations of erasure. Based on Neal Gafter's Super Type Tokens.
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/type/ 0000775 0000000 0000000 00000000000 12112453432 0025247 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/type/Type.java 0000664 0000000 0000000 00000010733 12112453432 0027037 0 ustar 00root root 0000000 0000000 /* * Created on Jan 23, 2009 * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language * governing permissions and limitations under the License. * * Copyright @2009 the original author or authors. */ package org.fest.reflect.type; import org.fest.reflect.exception.ReflectionError; import static org.fest.reflect.type.TypeLoader.newLoader; import static org.fest.util.Strings.isEmpty; /** * Understands loading a class dynamically. ** The following is an example of proper usage of this class: * *
* // Loads the class 'org.republic.Jedi'
* Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#load() load}();
*
* // Loads the class 'org.republic.Jedi' as 'org.republic.Person' (Jedi extends Person)
* Class<Person> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#loadAs(Class) loadAs}(Person.class);
*
* // Loads the class 'org.republic.Jedi' using a custom class loader
* Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#withClassLoader(ClassLoader) withClassLoader}(myClassLoader).{@link org.fest.reflect.type.TypeLoader#load() load}();
*
*
*
* @author Alex Ruiz
*
* @since 1.1
*/
public final class Type {
/**
* Creates a new {@link Type}: the starting point of the fluent interface for loading classes dynamically.
* @param name the name of the class to load.
* @return the created Type.
* @throws NullPointerException if the given name is null.
* @throws IllegalArgumentException if the given name is empty.
*/
public static Type newType(String name) {
if (name == null) throw new NullPointerException("The name of the class to load should not be null");
if (isEmpty(name)) throw new IllegalArgumentException("The name of the class to load should not be empty");
return new Type(name);
}
private final String name;
private Type(String name) {
this.name = name;
}
/**
* Loads the class with the name specified in this type, using this class' ClassLoader.
* @return the loaded class.
* @throws ReflectionError wrapping any error that occurred during class loading.
*/
public Class load() {
return newLoader(name, thisClassLoader()).load();
}
/**
* Loads the class with the name specified in this type, as the given type, using this class' ClassLoader.
*
* The following example shows how to use this method. Let's assume that we have the class Jedi that extends the
* class Person:
*
*
* Class<Person> type = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#loadAs(Class) loadAs}(Person.class);
*
*
* @param type the given type.
* @param null.
* @throws ReflectionError wrapping any error that occurred during class loading.
*/
public {@link ClassLoader} to use to load the class.
* * Example: * *
* Class<?> type = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#withClassLoader(ClassLoader) withClassLoader}(myClassLoader).{@link TypeLoader#load() load}();
*
*
* @param classLoader the given ClassLoader.
* @return an object responsible of loading a class with the given ClassLoader.
* @throws NullPointerException if the given ClassLoader is null.
*/
public TypeLoader withClassLoader(ClassLoader classLoader) {
return newLoader(name, classLoader);
}
}
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/type/TypeLoader.java 0000664 0000000 0000000 00000007060 12112453432 0030165 0 ustar 00root root 0000000 0000000 /*
* Created on Jan 28, 2009
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2009 the original author or authors.
*/
package org.fest.reflect.type;
import org.fest.reflect.exception.ReflectionError;
import static org.fest.util.Strings.quote;
/**
* Understands loading a class dynamically using a specific {@link ClassLoader}.
*
* @author Alex Ruiz
*
* @since 1.1
*/
public final class TypeLoader {
static TypeLoader newLoader(String name, ClassLoader classLoader) {
if (classLoader == null) throw new NullPointerException("The given class loader should not be null");
return new TypeLoader(name, classLoader);
}
private final String name;
private final ClassLoader classLoader;
private TypeLoader(String name, ClassLoader classLoader) {
this.name = name;
this.classLoader = classLoader;
}
/**
* Loads the class with the name specified in this type, using this class' ClassLoader.
* * Example: * *
* Class<?> type = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#withClassLoader(ClassLoader) withClassLoader}(myClassLoader).{@link TypeLoader#load() load}();
*
*
* @return the loaded class.
* @throws ReflectionError wrapping any error that occurred during class loading.
*/
public Class load() {
try {
return loadType();
} catch (Exception e) {
throw new ReflectionError(unableToLoadClassMessage(null), e);
}
}
/**
* Loads the class with the name specified in this type, as the given type, using this class' ClassLoader.
*
* The following example shows how to use this method. Let's assume that we have the class Jedi that extends the
* class Person:
*
*
* Class<Person> type = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link Type#withClassLoader(ClassLoader) withClassLoader}(myClassLoader).{@link TypeLoader#loadAs(Class) loadAs}(Person.class);
*
*
* @param type the given type.
* @param null.
* @throws ReflectionError wrapping any error that occurred during class loading.
*/
public Provides a "fluent" API for loading classes dynamically.
Note: Classes in this package are not intended to be used directly. To use them, you need to use the
class {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
Here are some examples:
// import static {@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.*;
// Loads the class 'org.republic.Jedi"
Class<?> jediType = {@link org.fest.reflect.core.Reflection#type(String) type}("org.republic.Jedi").{@link org.fest.reflect.type.Type#load() load}();
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/util/ 0000775 0000000 0000000 00000000000 12112453432 0025243 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/util/Accessibles.java 0000664 0000000 0000000 00000005165 12112453432 0030335 0 ustar 00root root 0000000 0000000 /*
* Created on Jan 1, 2008
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2008-2009 the original author or authors.
*/
package org.fest.reflect.util;
import java.lang.reflect.AccessibleObject;
import java.security.AccessController;
import java.security.PrivilegedAction;
/**
* Understands utility methods related to {@link AccessibleObject}s.
*
* @author Alex Ruiz
*/
public final class Accessibles {
/**
* Sets the accessible flag of the given {@link AccessibleObject} to the given boolean
* value, ignoring any thrown exception.
* @param o the given AccessibleObject.
* @param accessible the value to set the accessible flag to.
*/
public static void setAccessibleIgnoringExceptions(AccessibleObject o, boolean accessible) {
try {
setAccessible(o, accessible);
} catch (RuntimeException ignored) {}
}
/**
* Sets the accessible flag of the given {@link AccessibleObject} to true.
* @param o the given AccessibleObject.
* @throws SecurityException if the request is denied.
*/
public static void makeAccessible(AccessibleObject o) {
setAccessible(o, true);
}
/**
* Sets the accessible flag of the given {@link AccessibleObject} to the given boolean
* value.
* @param o the given AccessibleObject.
* @param accessible the value to set the accessible flag to.
* @throws SecurityException if the request is denied.
*/
public static void setAccessible(AccessibleObject o, boolean accessible) {
AccessController.doPrivileged(new SetAccessibleAction(o, accessible));
}
private static class SetAccessibleAction implements PrivilegedAction{@link Throwable}s.
*
* @author Alex Ruiz
* @since 1.2
*/
public final class Throwables {
/**
* Obtains the target of the given {@link Throwable}. If the Throwable is a
* {@link InvocationTargetException}, this method will return the "target exception" (not the cause.) For other
* Throwables, the same instance is returned unmodified.
* @param t the given Throwable.
* @return the target exception, if applicable. Otherwise, this method returns the same Throwable passed as
* argument.
*/
public static Throwable targetOf(Throwable t) {
if (t instanceof InvocationTargetException) return ((InvocationTargetException) t).getTargetException();
return t;
}
private Throwables() {}
}
fest-reflect-fest-reflect-1.4.1/src/main/java/org/fest/reflect/util/package.html 0000664 0000000 0000000 00000001547 12112453432 0027533 0 ustar 00root root 0000000 0000000
Utility methods.
fest-reflect-fest-reflect-1.4.1/src/main/javadoc/ 0000775 0000000 0000000 00000000000 12112453432 0021600 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/main/javadoc/overview.html 0000664 0000000 0000000 00000001200 12112453432 0024325 0 ustar 00root root 0000000 0000000This document is the API specification for the FEST Reflection Module.
In order to use the fluent interface, you need to start with the class
{@link org.fest.reflect.core.Reflection org.fest.reflect.core.Reflection}.
-
#foreach( $subitem in $item.items )
#menuItem( $subitem )
#end
$menu.name
#end #if ( $menu.items && $menu.items.size() > 0 )-
#foreach( $item in $menu.items )
#menuItem( $item )
#end
$i18n.getString( "site-renderer", $locale, "template.lastpublished" ): $dateToday
#if ( $versionPosition.equalsIgnoreCase( $position ) )
| $i18n.getString( "site-renderer", $locale, "template.version" ): ${project.version}
#end
#elseif ( $datePosition.equalsIgnoreCase("left") )
$i18n.getString( "site-renderer", $locale, "template.lastpublished" ): $dateToday
#if ( $versionPosition.equalsIgnoreCase( $position ) )
| $i18n.getString( "site-renderer", $locale, "template.version" ): ${project.version}
#end
#if ( $breadcrumbs && $breadcrumbs.size() > 0 )
| #breadcrumbs( $breadcrumbs )
#end
#end
#elseif ( $versionPosition.equalsIgnoreCase( $position ) )
#if ( ( $versionPosition.equalsIgnoreCase( "right" ) ) || ( $versionPosition.equalsIgnoreCase( "bottom" ) ) )
$prefix $i18n.getString( "site-renderer", $locale, "template.version" ): ${project.version}
#elseif ( ( $versionPosition.equalsIgnoreCase( "navigation-bottom" ) ) || ( $versionPosition.equalsIgnoreCase( "navigation-top" ) ) )
$i18n.getString( "site-renderer", $locale, "template.version" ): ${project.version}
#elseif ( $versionPosition.equalsIgnoreCase("left") )
$i18n.getString( "site-renderer", $locale, "template.version" ): ${project.version}
#if ( $breadcrumbs && $breadcrumbs.size() > 0 )
| #breadcrumbs( $breadcrumbs )
#end
#end
#elseif ( $position.equalsIgnoreCase( "left" ) )
#if ( $breadcrumbs && $breadcrumbs.size() > 0 )
#breadcrumbs( $breadcrumbs )
#end
#end
#end
#macro ( poweredByLogo $poweredBy )
#if( $poweredBy )
#foreach ($item in $poweredBy)
#if( $item.href )
#set ( $href = $PathTool.calculateLink( $item.href, $relativePath ) )
#set ( $href = $href.replaceAll( "\\", "/" ) )
#else
#set ( $href="http://maven.apache.org/" )
#end
#if( $item.name )
#set ( $name = $item.name )
#else
#set ( $name = $i18n.getString( "site-renderer", $locale, "template.builtby" ) )
#set ( $name = "${name} Maven" )
#end
#if( $item.img )
#set ( $img = $item.img )
#else
#set ( $img = "images/logos/maven-feather.png" )
#end
#set ( $img = $PathTool.calculateLink( $img, $relativePath ) )
#set ( $img = $img.replaceAll( "\\", "/" ) )
#end
#else
#end
#end
#publishDate( "navigation-top" $decoration.publishDate $decoration.version )
#mainMenu( $decoration.body.menus )
#publishDate( "navigation-bottom" $decoration.publishDate $decoration.version )
#publishDate( "navigation-bottom" $decoration.publishDate $decoration.version )
$bodyContent
You are being redirected to the wiki page.
{@link Reflection}.
*
* @author Alex Ruiz
* @author Yvonne Wang
*/
public class Reflection_Test {
@Test
public void should_return_fluent_interface_for_constructor() {
verifyTypesAreEqual(TargetType.class, Reflection.constructor());
}
@Test
public void should_return_fluent_interface_for_field() {
verifyTypesAreEqual(FieldName.class, Reflection.field("foo"));
}
@Test
public void should_return_fluent_interface_for_static_field() {
verifyTypesAreEqual(StaticFieldName.class, Reflection.staticField("foo"));
}
@Test
public void should_return_fluent_interface_for_method() {
verifyTypesAreEqual(MethodName.class, Reflection.method("foo"));
}
@Test
public void should_return_fluent_interface_for_static_method() {
verifyTypesAreEqual(StaticMethodName.class, Reflection.staticMethod("foo"));
}
@Test
public void should_return_fluent_interface_for_type() {
verifyTypesAreEqual(Type.class, Reflection.type("foo"));
}
@Test
public void should_return_fluent_interface_for_static_inner_class() {
verifyTypesAreEqual(StaticInnerClassName.class, Reflection.staticInnerClass("foo"));
}
@Test
public void should_return_fluent_interface_for_property() {
verifyTypesAreEqual(PropertyName.class, Reflection.property("foo"));
}
private void verifyTypesAreEqual(Class expected, Object o) {
assertEquals(expected, o.getClass());
}
}
fest-reflect-fest-reflect-1.4.1/src/test/java/org/fest/reflect/field/ 0000775 0000000 0000000 00000000000 12112453432 0025404 5 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/test/java/org/fest/reflect/field/FieldDecoratorCombinedTest.java0000664 0000000 0000000 00000012236 12112453432 0033442 0 ustar 00root root 0000000 0000000 /*
* Created on Mar 19, 2012
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.field;
import static org.fest.reflect.core.Reflection.field;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.junit.Test;
/**
* Tests returning decorator result in case of a decorator exceptions
* @author Ivan Hristov
*
*/
public class FieldDecoratorCombinedTest {
public interface IUploadFileService {
Boolean upload(String file, String destination) throws CustomeException;
}
public interface INotificationService {
void notify(String msg);
}
@SuppressWarnings("serial")
public class CustomeException extends RuntimeException {
public CustomeException() {
super("This is a test exception");
}
}
private class FileManager {
private static final String DEFAULT_DESTINATION = "http://example.org/default/destination/";
private final IUploadFileService uploadFileService;
private INotificationService notificationService;
public FileManager() {
this.uploadFileService = new IUploadFileService() {
public Boolean upload(String file, String destination) {
return false;
}
};
}
public void manage(String fileName) {
notificationService.notify("Upload successful? : " + uploadFileService.upload(fileName, DEFAULT_DESTINATION));
}
}
@Test
public void should_pre_decorate_field_returning_decorator_result_ignoring_custom_exception_in_decorator() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
when(uploadFileServiceMock.upload(anyString(), anyString())).thenThrow(new CustomeException());
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).preDecorateWith(uploadFileServiceMock)//
.returningDecoratorResult().ignoringDecoratorExceptionsOfType(CustomeException.class);
field("notificationService").ofType(INotificationService.class)//
.in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq("Upload successful? : null"));
}
@Test
public void should_post_decorate_field_returning_decorator_result_ignoring_decorator_exceptions() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
when(uploadFileServiceMock.upload(anyString(), anyString())).thenThrow(new RuntimeException());
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).postDecorateWith(uploadFileServiceMock)//
.returningDecoratorResult().ignoringDecoratorExceptions();
field("notificationService").ofType(INotificationService.class)//
.in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq("Upload successful? : null"));
}
@Test
public void should_pre_and_post_decorate_field_returning_decorator_result_ignoring_decorator_exceptions() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
when(uploadFileServiceMock.upload(anyString(), anyString())).thenThrow(new RuntimeException()).thenThrow(
new CustomeException());
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager).preDecorateWith(uploadFileServiceMock)
.ignoringDecoratorExceptions().returningDecoratorResult().postDecorateWith(uploadFileServiceMock)
.ignoringDecoratorExceptionsOfType(CustomeException.class).returningDecoratorResult();
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(2)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq("Upload successful? : null"));
}
}
FieldDecoratorIgnoreExceptionTest.java 0000664 0000000 0000000 00000016455 12112453432 0034754 0 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/test/java/org/fest/reflect/field /*
* Created on Mar 19, 2012
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.field;
import static org.fest.reflect.core.Reflection.field;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import java.net.SocketTimeoutException;
import org.junit.Rule;
import org.junit.Test;
import org.junit.matchers.JUnitMatchers;
import org.junit.rules.ExpectedException;
/**
*
* @author Ivan Hristov
*
*/
public class FieldDecoratorIgnoreExceptionTest {
@Rule
public ExpectedException expectedException = ExpectedException.none();
public interface IUploadFileService {
Boolean upload(String file, String destination) throws SocketTimeoutException;
}
public interface INotifierService {
void notify(String msg);
}
private class FileManager {
private static final String DEFAULT_DESTINATION = "http://example.org/default/destination/";
private final IUploadFileService uploadFileService;
private INotifierService notifierService;
public FileManager() {
this.uploadFileService = new IUploadFileService() {
public Boolean upload(String file, String destination) {
return false;
}
};
}
public void manage(String fileName) throws SocketTimeoutException {
if (uploadFileService.upload(fileName, DEFAULT_DESTINATION)) {
System.out.println("File " + fileName + " sent to " + DEFAULT_DESTINATION);
} else {
notifierService.notify("Unable to send msg!");
}
}
}
@Test
public void should_not_ignore_pre_decorator_exceptions() throws SocketTimeoutException {
// GIVEN
expectedException.expect(SocketTimeoutException.class);
String expectedExceptionMsg = "Expected test exception";
expectedException.expectMessage(JUnitMatchers.containsString(expectedExceptionMsg));
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotifierService notifierServiceMock = mock(INotifierService.class);
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenThrow(new SocketTimeoutException(expectedExceptionMsg));
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).preDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptions();
field("notifierService").ofType(INotifierService.class).in(fileManager).set(notifierServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN there should be an exception
}
@Test
public void should_not_ignore_post_decorator_exceptions() throws SocketTimeoutException {
// GIVEN
expectedException.expect(SocketTimeoutException.class);
String expectedExceptionMsg = "Expected test exception";
expectedException.expectMessage(JUnitMatchers.containsString(expectedExceptionMsg));
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotifierService notifierServiceMock = mock(INotifierService.class);
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenThrow(new SocketTimeoutException(expectedExceptionMsg));
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).postDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptions();
field("notifierService").ofType(INotifierService.class).in(fileManager).set(notifierServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN there should be an exception
}
@Test
public void should_pre_decorate_field_ignoring_decorator_exceptions() throws SocketTimeoutException {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotifierService notifierServiceMock = mock(INotifierService.class);
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenThrow(new RuntimeException("Expected test exception"));
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).preDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptions();
field("notifierService").ofType(INotifierService.class).in(fileManager).set(notifierServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(notifierServiceMock, times(1)).notify(eq("Unable to send msg!"));
}
@Test
public void should_post_decorate_field_ignoring_decorator_exceptions() throws SocketTimeoutException {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotifierService notifierServiceMock = mock(INotifierService.class);
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenThrow(new RuntimeException("Expected test exception"));
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).postDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptions();
field("notifierService").ofType(INotifierService.class).in(fileManager).set(notifierServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
verify(notifierServiceMock, times(1)).notify(eq("Unable to send msg!"));
}
@Test
public void should_pre_and_post_decorate_field_ignoring_decorator_exceptions() throws SocketTimeoutException {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotifierService notifierServiceMock = mock(INotifierService.class);
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenThrow(new SocketTimeoutException("Expected test exception"))//
.thenThrow(new RuntimeException("Expected test exception"))//
.thenThrow(new RuntimeException("Expected test exception"));
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager)//
.preDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptions()//
.postDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptions()//
.preDecorateWith(uploadFileServiceMock).ignoringDecoratorExceptionsOfType(SocketTimeoutException.class);
field("notifierService").ofType(INotifierService.class).in(fileManager).set(notifierServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(3)).upload(eq("testFileName"), anyString());
verify(notifierServiceMock, times(1)).notify(eq("Unable to send msg!"));
}
}
FieldDecoratorReturningDecoratorResultTest.java 0000664 0000000 0000000 00000017724 12112453432 0036671 0 ustar 00root root 0000000 0000000 fest-reflect-fest-reflect-1.4.1/src/test/java/org/fest/reflect/field /*
* Created on Mar 20, 2012
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.field;
import static org.fest.reflect.core.Reflection.field;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.junit.Test;
/**
*
* @author Ivan Hristov
*
*/
public class FieldDecoratorReturningDecoratorResultTest {
public interface IUploadFileService {
String upload(String file, String destination);
}
public interface INotificationService {
void notify(String msg);
}
private class FileManager {
private static final String DEFAULT_DESTINATION = "http://example.org/default/destination/";
private final IUploadFileService uploadFileService;
private INotificationService notificationService;
public FileManager() {
this.uploadFileService = new IUploadFileService() {
public String upload(String file, String destination) {
return "Default result";
}
};
}
public void manage(String fileName) {
notificationService.notify(uploadFileService.upload(fileName, DEFAULT_DESTINATION));
}
}
@Test
public void should_pre_decorate_field_and_return_decorator_result() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
String expectedResult = "pre-decorator result";
when(uploadFileServiceMock.upload(anyString(), anyString())).thenReturn(expectedResult);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).preDecorateWith(uploadFileServiceMock).returningDecoratorResult();
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq(expectedResult));
}
@Test
public void should_post_decorate_field_and_return_decorator_result() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
String expectedResult = "post-decorator result";
when(uploadFileServiceMock.upload(anyString(), anyString())).thenReturn(expectedResult);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).postDecorateWith(uploadFileServiceMock).returningDecoratorResult();
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq(expectedResult));
}
@Test
public void should_pre_and_post_decorate_field_and_return_pre_decorator_result() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
String expectedResult = "pre-decorator result";
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenReturn(expectedResult).thenReturn("post-decorator result");
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager)//
.preDecorateWith(uploadFileServiceMock).returningDecoratorResult().postDecorateWith(uploadFileServiceMock);
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(2)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq(expectedResult));
}
@Test
public void should_pre_and_post_decorate_field_and_return_post_decorator_result() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
String expectedResult = "post-decorator result";
when(uploadFileServiceMock.upload(anyString(), anyString())).thenReturn("pre-decorator result").thenReturn(expectedResult);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager)//
.preDecorateWith(uploadFileServiceMock).postDecorateWith(uploadFileServiceMock).returningDecoratorResult();
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(2)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq(expectedResult));
}
@Test
public void should_pre_and_post_decorate_field_both_returning_results_but_return_post_decorator_result() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
String expectedResult = "post-decorator result";
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenReturn("pre-decorator result").thenReturn(expectedResult);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager)//
.preDecorateWith(uploadFileServiceMock).returningDecoratorResult()//
.postDecorateWith(uploadFileServiceMock).returningDecoratorResult();
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(2)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq(expectedResult));
}
@Test
public void should_pre_and_post_decorate_field_both_returning_results_but_return_pre_decorator_result() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
INotificationService notificationServiceMock = mock(INotificationService.class);
String expectedResult = "pre-decorator result";
when(uploadFileServiceMock.upload(anyString(), anyString()))//
.thenReturn(expectedResult).thenReturn("post-decorator result");
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager)//
.postDecorateWith(uploadFileServiceMock).returningDecoratorResult()//
.preDecorateWith(uploadFileServiceMock).returningDecoratorResult();
field("notificationService").ofType(INotificationService.class).in(fileManager).set(notificationServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(2)).upload(eq("testFileName"), anyString());
verify(notificationServiceMock, times(1)).notify(eq(expectedResult));
}
}
fest-reflect-fest-reflect-1.4.1/src/test/java/org/fest/reflect/field/FieldDecoratorTest.java 0000664 0000000 0000000 00000012723 12112453432 0032002 0 ustar 00root root 0000000 0000000 /*
* Created on Mar 19, 2012
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2006-2009 the original author or authors.
*/
package org.fest.reflect.field;
import static org.fest.reflect.core.Reflection.field;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.*;
import org.junit.Test;
import org.mockito.InOrder;
/**
*
* @author Ivan Hristov
*
*/
public class FieldDecoratorTest {
private static class LogMyName {
private final ILogger logger = new MySmartLogger(this.getClass());
private final String name;
public LogMyName(String name) {
this.name = name;
}
public void logMyName() {
logger.info(name);
}
}
private static class MySmartLogger implements ILogger {
private final Class _clazz;
public MySmartLogger(Class _clazz) {
this._clazz = _clazz;
}
public void info(String infoStr) {
System.out.println(_clazz.getSimpleName() + " : " + infoStr);
}
}
public interface ILogger {
public void info(String infoStr);
}
@Test
public void should_pre_decorate_field() {
// GIVEN
ILogger mySmartLoggerMock = mock(ILogger.class);
LogMyName logMyName = new LogMyName("FEST");
field("logger").ofType(ILogger.class).in(logMyName).preDecorateWith(mySmartLoggerMock);
// WHEN
logMyName.logMyName();
// THEN
verify(mySmartLoggerMock, times(1)).info(eq("FEST"));
}
public interface IUploadFileService {
boolean upload(String file, String destination);
}
private class FileManager {
private static final String DEFAULT_DESTINATION = "http://example.org/default/destination/";
private final IUploadFileService uploadFileService;
public FileManager() {
this.uploadFileService = new IUploadFileService() {
public boolean upload(String file, String destination) {
return false;
}
};
}
public void manage(String fileName) {
if (uploadFileService.upload(fileName, DEFAULT_DESTINATION)) {
System.out.println("File " + fileName + " sent to " + DEFAULT_DESTINATION);
} else {
System.out.println("Unable to sent " + fileName + " to " + DEFAULT_DESTINATION);
}
}
}
@Test
public void should_attach_two_pre_decorators() {
// GIVEN
IUploadFileService firstUploadFileServiceMock = mock(IUploadFileService.class);
IUploadFileService secondUploadFileServiceMock = mock(IUploadFileService.class);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).preDecorateWith(firstUploadFileServiceMock).preDecorateWith(secondUploadFileServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
InOrder inOrder = inOrder(firstUploadFileServiceMock, secondUploadFileServiceMock);
inOrder.verify(secondUploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
inOrder.verify(firstUploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
}
@Test
public void should_post_decorate_field() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager).postDecorateWith(uploadFileServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
}
@Test
public void should_attach_two_post_decorators() {
// GIVEN
IUploadFileService firstUploadFileServiceMock = mock(IUploadFileService.class);
IUploadFileService secondUploadFileServiceMock = mock(IUploadFileService.class);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class)//
.in(fileManager).postDecorateWith(firstUploadFileServiceMock).postDecorateWith(secondUploadFileServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
InOrder inOrder = inOrder(firstUploadFileServiceMock, secondUploadFileServiceMock);
inOrder.verify(firstUploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
inOrder.verify(secondUploadFileServiceMock, times(1)).upload(eq("testFileName"), anyString());
}
@Test
public void should_pre_and_post_decorate_field() {
// GIVEN
IUploadFileService uploadFileServiceMock = mock(IUploadFileService.class);
FileManager fileManager = new FileManager();
field("uploadFileService").ofType(IUploadFileService.class).in(fileManager)
//
.preDecorateWith(uploadFileServiceMock).postDecorateWith(uploadFileServiceMock).preDecorateWith(uploadFileServiceMock);
// WHEN
String fileName = "testFileName";
fileManager.manage(fileName);
// THEN
verify(uploadFileServiceMock, times(3)).upload(eq("testFileName"), anyString());
}
}
fest-reflect-fest-reflect-1.4.1/src/test/java/org/fest/reflect/field/Field_field_Test.java 0000664 0000000 0000000 00000011766 12112453432 0031447 0 ustar 00root root 0000000 0000000 /*
* Created on May 18, 2007
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
* License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language
* governing permissions and limitations under the License.
*
* Copyright @2007-2009 the original author or authors.
*/
package org.fest.reflect.field;
import static org.fest.reflect.util.ExpectedFailures.expectIllegalArgumentException;
import static org.fest.reflect.util.ExpectedFailures.expectNullPointerException;
import static org.fest.reflect.util.ExpectedFailures.expectReflectionError;
import static org.fest.util.Lists.newArrayList;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.fest.reflect.Jedi;
import org.fest.reflect.Person;
import org.fest.reflect.reference.TypeRef;
import org.fest.test.CodeToTest;
/**
* Tests for the fluent interface for accessing fields.
*
* @author Alex Ruiz
*/
public class Field_field_Test {
private Person person;
@Before
public void setUp() {
person = new Person("Luke");
}
@Test
public void should_throw_error_if_field_name_is_null() {
expectNullPointerException("The name of the field to access should not be null").on(new CodeToTest() {
public void run() {
FieldName.beginFieldAccess(null);
}
});
}
@Test
public void should_throw_error_if_field_name_is_empty() {
expectIllegalArgumentException("The name of the field to access should not be empty").on(new CodeToTest() {
public void run() {
FieldName.beginFieldAccess("");
}
});
}
@Test
public void should_throw_error_if_field_type_is_null() {
expectNullPointerException("The type of the field to access should not be null").on(new CodeToTest() {
public void run() {
FieldName.beginFieldAccess("name").ofType((Class) null);
}
});
}
@Test
public void should_throw_error_if_target_is_null() {
expectNullPointerException("Target should not be null").on(new CodeToTest() {
public void run() {
FieldName.beginFieldAccess("name").ofType(String.class).in(null);
}
});
}
@Test
public void should_get_field_value() {
String personName = FieldName.beginFieldAccess("name").ofType(String.class).in(person).get();
assertEquals("Luke", personName);
}
@Test
public void should_set_field_value() {
FieldName.beginFieldAccess("name").ofType(String.class).in(person).set("Leia");
assertEquals("Leia", person.getName());
}
@Test
public void should_return_real_field() {
java.lang.reflect.Field field = FieldName.beginFieldAccess("name").ofType(String.class).in(person).info();
assertNotNull(field);
assertEquals("name", field.getName());
assertEquals(String.class, field.getType());
}
@Test
public void should_throw_error_if_wrong_field_type_was_specified() {
String msg = "The type of the field 'name' in org.fest.reflect.Person should be