private static List<LabelValue> makeList2(Class<? extends Enum> clazz) {
List<LabelValue> list = new ArrayList<LabelValue>();
Method method = ReflectionUtils.findMethod(clazz, "values");
try {
Object[] array = (Object[]) method.invoke(null);
for (Object obj : array) {
Method m = ReflectionUtils.findMethod(clazz, "getLabel");
String cnName = (String) m.invoke(obj);
m = ReflectionUtils.findMethod(clazz, "name");
String name = (String) m.invoke(obj);
LabelValue lv = new LabelValue(cnName, name);
m = ReflectionUtils.findMethod(clazz, "isSelectList");
if (m != null) {
boolean flag = (boolean) m.invoke(obj);
lv.setListFlag(flag);
}
list.add(lv);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return list;
}
protected void init() throws ClassNotFoundException {
this.proxyObjectType =
ClassUtils.resolveClassName(getProxyInterfaceName(), ClassUtils.getDefaultClassLoader());
final Class<?> modelParameterClazz =
ClassUtils.resolveClassName(
"org.springframework.web.servlet.ModelAndView", ClassUtils.getDefaultClassLoader());
this.getModelMapMethod = ReflectionUtils.findMethod(modelParameterClazz, "getModelMap");
this.getViewNameMethod = ReflectionUtils.findMethod(modelParameterClazz, "getViewName");
this.setViewNameMethod =
ReflectionUtils.findMethod(modelParameterClazz, "setViewName", String.class);
}
@Test
public void specifiedOrder() {
Method method =
ReflectionUtils.findMethod(SampleEvents.class, "handleRaw", ApplicationEvent.class);
ApplicationListenerMethodAdapter adapter = createTestInstance(method);
assertEquals(42, adapter.getOrder());
}
private EventTriggerCaller buildCaller(Class<?> domainClazz, String event) {
Method method = ReflectionUtils.findMethod(domainClazz, event);
if (method != null) {
ReflectionUtils.makeAccessible(method);
return new MethodCaller(method);
}
Field field = ReflectionUtils.findField(domainClazz, event);
if (field != null) {
ReflectionUtils.makeAccessible(field);
return new FieldClosureCaller(field);
}
MetaMethod metaMethod = domainMetaClass.getMetaMethod(event, EMPTY_OBJECT_ARRAY);
if (metaMethod != null) {
return new MetaMethodCaller(metaMethod);
}
MetaProperty metaProperty = domainMetaClass.getMetaProperty(event);
if (metaProperty != null) {
return new MetaPropertyClosureCaller(metaProperty);
}
return null;
}
public static Method findGetterMethod(String propertyName, Class<?> entityClass) {
StringBuilder sb = new StringBuilder();
sb.append(GET);
sb.append(Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1));
Method method = ReflectionUtils.findMethod(entityClass, sb.toString());
return method;
}
@Test
public void listenerWithAnnotationValueAndParameter() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleStringAnnotationValueAndParameter", String.class);
supportsEventType(true, method, createGenericEventType(String.class));
}
private void readObject(ObjectInputStream inputStream)
throws IOException, ClassNotFoundException {
inputStream.defaultReadObject();
Method method =
ReflectionUtils.findMethod(this.provider.getType().getClass(), this.methodName);
this.result = ReflectionUtils.invokeMethod(method, this.provider.getType());
}
public static void update() {
try {
final String msg = "DatabaseSchemaUpdater: Begin";
log(msg);
final String applicationName = CommonServiceLocator.getInstance().getAppName();
DAO dao = DAOConfigFactory.getInstance().getDAOFactory(applicationName).getDAO();
Method getConnectionManagerMethod =
ReflectionUtils.findMethod(dao.getClass(), "getConnectionManager");
ReflectionUtils.makeAccessible(getConnectionManagerMethod);
IConnectionManager connectionManager =
(IConnectionManager) ReflectionUtils.invokeMethod(getConnectionManagerMethod, dao);
Connection c = null;
try {
c = connectionManager.getConnection();
update(c);
} finally {
try {
connectionManager.commit();
} catch (Exception e) {
}
connectionManager.closeConnection();
}
} catch (Exception e) {
final String msg = "DatabaseSchemaUpdater: Failed with " + e.getMessage();
log(msg);
}
}
private Object doRequestAttribute(
String methodName, final String attributeName, final String value) throws Exception {
MethodParameter methodParameter =
new MethodParameter(
ReflectionUtils.findMethod(
AnnotatedClass.class, methodName, new Class[] {String.class}),
0);
expect(nativeRequest.getNativeRequest()).andReturn(request);
expect(request.getInputStream())
.andReturn(
new ServletInputStream() {
@Override
public int read() throws IOException {
return -1;
}
});
replayMocks();
Object arg = resolver.resolveArgument(methodParameter, nativeRequest);
verifyMocks();
return arg;
}
@Test
public void listenerWithSeveralTypes() {
Method method = ReflectionUtils.findMethod(SampleEvents.class, "handleStringOrInteger");
supportsEventType(true, method, createGenericEventType(String.class));
supportsEventType(true, method, createGenericEventType(Integer.class));
supportsEventType(false, method, createGenericEventType(Double.class));
}
@Test
public void genericListener() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleGenericString", GenericTestEvent.class);
supportsEventType(true, method, getGenericApplicationEventType("stringEvent"));
}
@Test
public void testOauthClient() throws Exception {
AuthorizationRequest request = new AuthorizationRequest("foo", Collections.singleton("read"));
request.setResourceIdsAndAuthoritiesFromClientDetails(
new BaseClientDetails("foo", "", "", "client_credentials", "ROLE_CLIENT"));
Authentication userAuthentication = null;
OAuth2Request clientAuthentication =
RequestTokenFactory.createOAuth2Request(
request.getRequestParameters(),
request.getClientId(),
request.getAuthorities(),
request.isApproved(),
request.getScope(),
request.getResourceIds(),
request.getRedirectUri(),
request.getResponseTypes(),
request.getExtensions());
OAuth2Authentication oAuth2Authentication =
new OAuth2Authentication(clientAuthentication, userAuthentication);
MethodInvocation invocation =
new SimpleMethodInvocation(this, ReflectionUtils.findMethod(getClass(), "testOauthClient"));
EvaluationContext context = handler.createEvaluationContext(oAuth2Authentication, invocation);
Expression expression =
handler.getExpressionParser().parseExpression("#oauth2.clientHasAnyRole('ROLE_CLIENT')");
assertTrue((Boolean) expression.getValue(context));
}
@Test
public void invokeListenerWithAnnotationValue() {
Method method = ReflectionUtils.findMethod(SampleEvents.class, "handleStringAnnotationClasses");
PayloadApplicationEvent<String> event = new PayloadApplicationEvent<>(this, "test");
invokeListener(method, event);
verify(this.sampleEvents, times(1)).handleStringAnnotationClasses();
}
@Override
protected Object retrieveAction(
GroovyObject controller, String actionName, HttpServletResponse response) {
Class<?> controllerClass = AopProxyUtils.ultimateTargetClass(controller);
Method mAction =
ReflectionUtils.findMethod(
controllerClass, actionName, MethodGrailsControllerHelper.NOARGS);
if (mAction != null) {
ReflectionUtils.makeAccessible(mAction);
if (mAction.getAnnotation(Action.class) != null) {
return mAction;
}
}
try {
return controller.getProperty(actionName);
} catch (MissingPropertyException mpe) {
try {
response.sendError(HttpServletResponse.SC_NOT_FOUND);
return null;
} catch (IOException e) {
throw new ControllerExecutionException("I/O error sending 404 error", e);
}
}
}
@Test
public void invokeListenerWithPayloadWrongType() {
Method method = ReflectionUtils.findMethod(SampleEvents.class, "handleString", String.class);
PayloadApplicationEvent<Long> event = new PayloadApplicationEvent<>(this, 123L);
invokeListener(method, event);
verify(this.sampleEvents, never()).handleString(anyString());
}
@Override
public Object accessValue(Object entity) {
Assert.notNull(entity);
Method method =
ReflectionUtils.findMethod(entity.getClass(), this.getAccessMethodName(), String.class);
return ReflectionUtils.invokeMethod(method, entity);
}
@Test
public void testScopesRegex() throws Exception {
OAuth2Request clientAuthentication =
RequestTokenFactory.createOAuth2Request(
null,
"foo",
null,
false,
Collections.singleton("ns_admin:read"),
null,
null,
null,
null);
Authentication userAuthentication = null;
OAuth2Authentication oAuth2Authentication =
new OAuth2Authentication(clientAuthentication, userAuthentication);
MethodInvocation invocation =
new SimpleMethodInvocation(this, ReflectionUtils.findMethod(getClass(), "testOauthClient"));
EvaluationContext context = handler.createEvaluationContext(oAuth2Authentication, invocation);
Expression expression =
handler.getExpressionParser().parseExpression("#oauth2.hasScopeMatching('.*_admin:read')");
assertTrue((Boolean) expression.getValue(context));
expression =
handler
.getExpressionParser()
.parseExpression("#oauth2.hasAnyScopeMatching('.*_admin:write','.*_admin:read')");
assertTrue((Boolean) expression.getValue(context));
}
@Test
public void genericListenerWrongParameterizedType() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleGenericString", GenericTestEvent.class);
supportsEventType(false, method, getGenericApplicationEventType("longEvent"));
}
@Test
public void listenerWithMoreThanOneParameter() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "moreThanOneParameter", String.class, Integer.class);
this.thrown.expect(IllegalStateException.class);
createTestInstance(method);
}
@Test
public void defaultOrder() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleGenericString", GenericTestEvent.class);
ApplicationListenerMethodAdapter adapter = createTestInstance(method);
assertEquals(0, adapter.getOrder());
}
@Test
public void listenerWithTooManyParameters() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "tooManyParameters", String.class, String.class);
this.thrown.expect(IllegalStateException.class);
createTestInstance(method);
}
@Test
public void invokeListenerWithAnyGenericPayload() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleGenericAnyPayload", EntityWrapper.class);
EntityWrapper<String> payload = new EntityWrapper<>("test");
invokeListener(method, new PayloadApplicationEvent<>(this, payload));
verify(this.sampleEvents, times(1)).handleGenericAnyPayload(payload);
}
@Test
public void invokeListenerWithGenericEvent() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleGenericString", GenericTestEvent.class);
GenericTestEvent<String> event = new SmartGenericTestEvent<>(this, "test");
invokeListener(method, event);
verify(this.sampleEvents, times(1)).handleGenericString(event);
}
@Test
public void invokeListenerWithWrongGenericPayload() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "handleGenericStringPayload", EntityWrapper.class);
EntityWrapper<Integer> payload = new EntityWrapper<>(123);
invokeListener(method, new PayloadApplicationEvent<>(this, payload));
verify(this.sampleEvents, times(0)).handleGenericStringPayload(any());
}
/**
* This method uses reflection to build a valid hash code.
*
* <p>It uses <code>AccessibleObject.setAccessible</code> to gain access to private fields. This
* means that it will throw a security exception if run under a security manager, if the
* permissions are not set up correctly. It is also not as efficient as testing explicitly.
*
* <p>Transient members will not be used, as they are likely derived fields, and not part of the
* value of the <code>Object</code>.
*
* <p>Static fields will not be tested. Superclass fields will be included.
*
* @param obj the object to create a <code>hashCode</code> for
* @return the generated hash code, or zero if the given object is <code>null</code>
*/
public static int reflectionHashCode(Object obj) {
if (obj == null) return 0;
Class<?> targetClass = obj.getClass();
if (isArrayOfPrimitives(obj)) {
// || ObjectUtils.isPrimitiveOrWrapper(targetClass)) {
return ObjectUtils.nullSafeHashCode(obj);
}
if (targetClass.isArray()) {
return reflectionHashCode((Object[]) obj);
}
if (obj instanceof Collection) {
return reflectionHashCode((Collection<?>) obj);
}
if (obj instanceof Map) {
return reflectionHashCode((Map<?, ?>) obj);
}
// determine whether the object's class declares hashCode() or has a
// superClass other than java.lang.Object that declares hashCode()
Class<?> clazz = (obj instanceof Class) ? (Class<?>) obj : obj.getClass();
Method hashCodeMethod = ReflectionUtils.findMethod(clazz, "hashCode", new Class[0]);
if (hashCodeMethod != null) {
return obj.hashCode();
}
// could not find a hashCode other than the one declared by
// java.lang.Object
int hash = INITIAL_HASH;
try {
while (targetClass != null) {
Field[] fields = targetClass.getDeclaredFields();
AccessibleObject.setAccessible(fields, true);
for (int i = 0; i < fields.length; i++) {
Field field = fields[i];
int modifiers = field.getModifiers();
if (!Modifier.isStatic(modifiers) && !Modifier.isTransient(modifiers)) {
hash = MULTIPLIER * hash + reflectionHashCode(field.get(obj));
}
}
targetClass = targetClass.getSuperclass();
}
} catch (IllegalAccessException exception) {
// ///CLOVER:OFF
ReflectionUtils.handleReflectionException(exception);
// ///CLOVER:ON
}
return hash;
}
/**
* Returns the method for the interface
*
* @param resourceInterfaceWithOneMethod
* @param resource
* @return null or a Method
*/
public static Method findMethod(
Class<? extends ResourceAction> resourceInterfaceWithOneMethod, Class<?> resource) {
Method[] resourceMethods = resourceInterfaceWithOneMethod.getMethods();
if (resourceMethods == null || resourceMethods.length != 1) {
// All the interfaces should have just one method.
throw new IllegalArgumentException(
resourceInterfaceWithOneMethod + " should be an interface with just one method.");
}
Method method = ReflectionUtils.findMethod(resource, resourceMethods[0].getName(), null);
return method;
}
/**
* Determine if the annotated field or method requires its dependency.
*
* <p>A 'required' dependency means that autowiring should fail when no beans are found.
* Otherwise, the autowiring process will simply bypass the field or method when no beans are
* found.
*
* @param annotation the Autowired annotation
* @return whether the annotation indicates that a dependency is required
*/
protected boolean determineRequiredStatus(Annotation annotation) {
try {
Method method =
ReflectionUtils.findMethod(annotation.annotationType(), this.requiredParameterName);
return (this.requiredParameterValue
== (Boolean) ReflectionUtils.invokeMethod(method, annotation));
} catch (Exception ex) {
// required by default
return true;
}
}
public UndertowXnioBufferSupport() {
this.xnioBufferPool = new org.xnio.ByteBufferSlicePool(1048, 1048);
this.httpClientConnectCallbackMethod =
ReflectionUtils.findMethod(
UndertowClient.class,
"connect",
ClientCallback.class,
URI.class,
XnioWorker.class,
Pool.class,
OptionMap.class);
this.httpClientConnectMethod =
ReflectionUtils.findMethod(
UndertowClient.class,
"connect",
URI.class,
XnioWorker.class,
Pool.class,
OptionMap.class);
}
public Undertow13BufferSupport() {
this.undertowBufferPool = new DefaultByteBufferPool(false, 1024, -1, 2);
this.httpClientConnectCallbackMethod =
ReflectionUtils.findMethod(
UndertowClient.class,
"connect",
ClientCallback.class,
URI.class,
XnioWorker.class,
ByteBufferPool.class,
OptionMap.class);
this.httpClientConnectMethod =
ReflectionUtils.findMethod(
UndertowClient.class,
"connect",
URI.class,
XnioWorker.class,
ByteBufferPool.class,
OptionMap.class);
}
@Test
public void invokeListenerCheckedException() {
Method method =
ReflectionUtils.findMethod(
SampleEvents.class, "generateCheckedException", GenericTestEvent.class);
GenericTestEvent<String> event = createGenericTestEvent("fail");
this.thrown.expect(UndeclaredThrowableException.class);
this.thrown.expectCause(is(instanceOf(IOException.class)));
invokeListener(method, event);
}
