/*******************************************************************************
* Copyright (c) 2011, 2012 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jdt.debug.tests.ui;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import org.eclipse.core.runtime.Assert;
/**
* Helper class for accessing classes and members which cannot be accessed using standard Java
* access control like private or package visible elements.
*
* @since 3.7
*/
public class Accessor {
/** The class to access. */
private Class<?> fClass;
/** The instance to access. */
private Object fInstance;
/**
* Creates an accessor for the given <code>instance</code> and <code>class</code>. Only
* non-inherited members that particular <code>class</code> can be accessed.
*
* @param instance
* the instance
* @param clazz
* the class
*/
public Accessor(Object instance, Class<?> clazz) {
org.eclipse.core.runtime.Assert.isNotNull(instance);
Assert.isNotNull(clazz);
fInstance = instance;
fClass = clazz;
}
/**
* Creates an accessor for the given <code>instance</code> and <code>class</code>. Only
* non-inherited members that particular <code>class</code> can be accessed.
*
* @param instance
* the instance
* @param className
* the name of the class
* @param classLoader
* the class loader to use i.e. <code>getClass().getClassLoader()</code>
*/
public Accessor(Object instance, String className, ClassLoader classLoader) {
Assert.isNotNull(instance);
Assert.isNotNull(className);
Assert.isNotNull(classLoader);
fInstance = instance;
try {
fClass = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException e) {
fail();
} catch (ExceptionInInitializerError e) {
fail();
}
}
/**
* Creates an accessor for the given class.
* <p>
* In order to get the type information from the given arguments they must all be instanceof
* Object. Use {@link #Accessor(String, ClassLoader, Class[], Object[])} if this is not the
* case.
* </p>
*
* @param className
* the name of the class
* @param classLoader
* the class loader to use i.e. <code>getClass().getClassLoader()</code>
* @param constructorArgs
* the constructor arguments which must all be instance of Object
*/
public Accessor(String className, ClassLoader classLoader, Object[] constructorArgs) {
this(className, classLoader, getTypes(constructorArgs), constructorArgs);
}
/**
* Creates an accessor for the given class.
*
* @param className
* the name of the class
* @param classLoader
* the class loader to use i.e. <code>getClass().getClassLoader()</code>
* @param constructorTypes
* the types of the constructor arguments
* @param constructorArgs
* the constructor arguments
*/
public Accessor(String className, ClassLoader classLoader, Class<?>[] constructorTypes, Object[] constructorArgs) {
try {
fClass = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException e) {
fail();
} catch (ExceptionInInitializerError e) {
fail();
}
Constructor<?> constructor = null;
try {
constructor = fClass.getDeclaredConstructor(constructorTypes);
} catch (SecurityException e2) {
fail();
} catch (NoSuchMethodException e2) {
fail();
}
Assert.isNotNull(constructor);
constructor.setAccessible(true);
try {
fInstance = constructor.newInstance(constructorArgs);
} catch (IllegalArgumentException e) {
fail();
} catch (InvocationTargetException e) {
fail();
} catch (InstantiationException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
}
/**
* Creates an accessor for the given class.
* <p>
* This constructor is used to access static stuff.
* </p>
*
* @param className
* the name of the class
* @param classLoader
* the class loader to use i.e. <code>getClass().getClassLoader()</code>
*/
public Accessor(String className, ClassLoader classLoader) {
try {
fClass = Class.forName(className, true, classLoader);
} catch (ClassNotFoundException e) {
fail();
} catch (ExceptionInInitializerError e) {
fail();
}
}
/**
* Creates an accessor for the given class.
* <p>
* This constructor is used to access static stuff.
* </p>
*
* @param clazz
* the class
*/
public Accessor(Class<?> clazz) {
Assert.isNotNull(clazz);
fClass = clazz;
}
/**
* Invokes the method with the given method name and arguments.
* <p>
* In order to get the type information from the given arguments all those arguments must be
* instance of Object. Use {@link #invoke(String, Class[], Object[])} if this is not the case.
* </p>
*
* @param methodName
* the method name
* @param arguments
* the method arguments which must all be instance of Object
* @return the method return value
*/
public Object invoke(String methodName, Object[] arguments) {
return invoke(methodName, getTypes(arguments), arguments);
}
/**
* Invokes the method with the given method name and arguments.
*
* @param methodName
* the method name
* @param types
* the argument types
* @param arguments
* the method arguments
* @return the method return value
*/
public Object invoke(String methodName, Class<?>[] types, Object[] arguments) {
Method method = null;
try {
method = fClass.getDeclaredMethod(methodName, types);
} catch (SecurityException e) {
fail();
} catch (NoSuchMethodException ex) {
fail();
}
Assert.isNotNull(method);
method.setAccessible(true);
try {
return method.invoke(fInstance, arguments);
} catch (IllegalArgumentException e) {
fail();
} catch (InvocationTargetException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
return null;
}
/**
* Assigns the given value to the field with the given name.
*
* @param fieldName
* the field name
* @param value
* the value to assign to the field
*/
public void set(String fieldName, Object value) {
Field field = getField(fieldName);
try {
field.set(fInstance, value);
} catch (IllegalArgumentException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
}
/**
* Assigns the given value to the field with the given name.
*
* @param fieldName
* the field name
* @param value
* the value to assign to the field
*/
public void set(String fieldName, boolean value) {
Field field = getField(fieldName);
try {
field.setBoolean(fInstance, value);
} catch (IllegalArgumentException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
}
/**
* Assigns the given value to the field with the given name.
*
* @param fieldName
* the field name
* @param value
* the value to assign to the field
*/
public void set(String fieldName, int value) {
Field field = getField(fieldName);
try {
field.setInt(fInstance, value);
} catch (IllegalArgumentException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
}
/**
* Returns the value of the field with the given name.
*
* @param fieldName
* the field name
* @return the value of the field
*/
public Object get(String fieldName) {
Field field = getField(fieldName);
try {
return field.get(fInstance);
} catch (IllegalArgumentException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
// Unreachable code
return null;
}
/**
* Returns the value of the field with the given name.
*
* @param fieldName
* the field name
* @return the value of the field
*/
public boolean getBoolean(String fieldName) {
Field field = getField(fieldName);
try {
return field.getBoolean(fInstance);
} catch (IllegalArgumentException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
// Unreachable code
return false;
}
/**
* Returns the value of the field with the given name.
*
* @param fieldName
* the field name
* @return the value of the field
*/
public int getInt(String fieldName) {
Field field = getField(fieldName);
try {
return field.getInt(fInstance);
} catch (IllegalArgumentException e) {
fail();
} catch (IllegalAccessException e) {
fail();
}
// Unreachable code
return 0;
}
public Field getField(String fieldName) {
Field field = null;
try {
field = fClass.getDeclaredField(fieldName);
} catch (SecurityException e) {
fail();
} catch (NoSuchFieldException e) {
fail();
}
field.setAccessible(true);
return field;
}
private static Class<?>[] getTypes(Object[] objects) {
if (objects == null)
return null;
int length = objects.length;
Class<?>[] classes = new Class[length];
for (int i = 0; i < length; i++) {
Assert.isNotNull(objects[i]);
classes[i] = objects[i].getClass();
}
return classes;
}
private void fail() {
Assert.isTrue(false);
}
}