private void prepareSuite() {
Class<?> benchmarkClass;
try {
benchmarkClass = getClassByName(suiteClassName);
} catch (ExceptionInInitializerError e) {
throw new ExceptionFromUserCodeException(e.getCause());
} catch (ClassNotFoundException ignored) {
throw new NoSuchClassException(suiteClassName);
}
Object s;
try {
Constructor<?> constructor = benchmarkClass.getDeclaredConstructor();
constructor.setAccessible(true);
s = constructor.newInstance();
} catch (InstantiationException ignore) {
throw new AbstractBenchmarkException(benchmarkClass);
} catch (NoSuchMethodException ignore) {
throw new NoParameterlessConstructorException(benchmarkClass);
} catch (IllegalAccessException impossible) {
throw new AssertionError(impossible); // shouldn't happen since we setAccessible(true)
} catch (InvocationTargetException e) {
throw new ExceptionFromUserCodeException(e.getCause());
}
if (s instanceof Benchmark) {
this.suite = (Benchmark) s;
} else {
throw new DoesntImplementBenchmarkException(benchmarkClass);
}
}
/**
* Invoke the method on the instance, with any arguments specified, casting the result of invoking
* the method to the expected return type.
*
* <p>
*
* <p>This method wraps {@link Method#invoke(Object, Object...)}, converting the checked
* exceptions that {@link Method#invoke(Object, Object...)} specifies to runtime exceptions.
*
* <p>
*
* <p>If instructed, this method attempts to set the accessible flag of the method in a {@link
* PrivilegedAction} before invoking the method.
*
* @param setAccessible flag indicating whether method should first be set as accessible
* @param method the method to invoke
* @param instance the instance to invoke the method
* @param args the arguments to the method
* @return the result of invoking the method, or null if the method's return type is void
* @throws RuntimeException if this <code>Method</code> object enforces Java language access
* control and the underlying method is inaccessible or if the underlying method throws an
* exception or if the initialization provoked by this method fails.
* @throws IllegalArgumentException if the method is an instance method and the specified <code>
* instance</code> argument is not an instance of the class or interface declaring the
* underlying method (or of a subclass or implementor thereof); if the number of actual and
* formal parameters differ; if an unwrapping conversion for primitive arguments fails; or if,
* after possible unwrapping, a parameter value cannot be converted to the corresponding
* formal parameter type by a method invocation conversion.
* @throws NullPointerException if the specified <code>instance</code> is null and the method is
* an instance method.
* @throws ClassCastException if the result of invoking the method cannot be cast to the
* expectedReturnType
* @throws ExceptionInInitializerError if the initialization provoked by this method fails.
* @see Method#invoke(Object, Object...)
*/
public static <T> T invokeMethod(
boolean setAccessible,
Method method,
Class<T> expectedReturnType,
Object instance,
Object... args) {
if (setAccessible && !method.isAccessible()) {
setAccessible(method);
}
try {
return expectedReturnType.cast(method.invoke(instance, args));
} catch (IllegalAccessException ex) {
throw new RuntimeException(buildInvokeMethodErrorMessage(method, instance, args), ex);
} catch (IllegalArgumentException ex) {
throw new IllegalArgumentException(buildInvokeMethodErrorMessage(method, instance, args), ex);
} catch (InvocationTargetException ex) {
throw new RuntimeException(
buildInvokeMethodErrorMessage(method, instance, args), ex.getCause());
} catch (NullPointerException ex) {
NullPointerException ex2 =
new NullPointerException(buildInvokeMethodErrorMessage(method, instance, args));
ex2.initCause(ex.getCause());
throw ex2;
} catch (ExceptionInInitializerError e) {
ExceptionInInitializerError e2 =
new ExceptionInInitializerError(buildInvokeMethodErrorMessage(method, instance, args));
e2.initCause(e.getCause());
throw e2;
}
}
/**
* Get the value of the field, on the specified instance, casting the value of the field to the
* expected type.
*
* <p>
*
* <p>This method wraps {@link Field#get(Object)}, converting the checked exceptions that {@link
* Field#get(Object)} specifies to runtime exceptions.
*
* @param <T> the type of the field's value
* @param field the field to operate on
* @param instance the instance from which to retrieve the value
* @param expectedType the expected type of the field's value
* @return the value of the field
* @throws RuntimeException if the underlying field is inaccessible.
* @throws IllegalArgumentException if the specified <code>instance</code> is not an instance of
* the class or interface declaring the underlying field (or a subclass or implementor
* thereof).
* @throws NullPointerException if the specified <code>instance</code> is null and the field is an
* instance field.
* @throws ExceptionInInitializerError if the initialization provoked by this method fails.
*/
public static <T> T getFieldValue(Field field, Object instance, Class<T> expectedType) {
try {
return Reflections.cast(field.get(instance));
} catch (IllegalAccessException e) {
throw new RuntimeException(buildGetFieldValueErrorMessage(field, instance), e);
} catch (NullPointerException ex) {
NullPointerException ex2 =
new NullPointerException(buildGetFieldValueErrorMessage(field, instance));
ex2.initCause(ex.getCause());
throw ex2;
} catch (ExceptionInInitializerError e) {
ExceptionInInitializerError e2 =
new ExceptionInInitializerError(buildGetFieldValueErrorMessage(field, instance));
e2.initCause(e.getCause());
throw e2;
}
}
@AdviseWith(adviceClasses = {PropsUtilAdvice.class})
@Test
public void testClassInitializationFailed() {
System.setProperty(PropsKeys.INTRABAND_IMPL, "NoSuchClass");
try {
MPIHelperUtil.getMPI();
Assert.fail();
} catch (ExceptionInInitializerError eiie) {
Throwable throwable = eiie.getCause();
Assert.assertSame(RuntimeException.class, throwable.getClass());
Assert.assertEquals("Unable to instantiate NoSuchClass", throwable.getMessage());
} finally {
System.clearProperty(PropsKeys.INTRABAND_IMPL);
}
}
/**
* Sets the value of a field on the instance to the specified value.
*
* <p>
*
* <p>This method wraps {@link Field#set(Object, Object)}, converting the checked exceptions that
* {@link Field#set(Object, Object)} specifies to runtime exceptions.
*
* <p>
*
* <p>If instructed, this method attempts to set the accessible flag of the method in a {@link
* PrivilegedAction} before invoking the method.
*
* @param field the field on which to operate, or null if the field is static
* @param instance the instance on which the field value should be set upon
* @param value the value to set the field to
* @throws RuntimeException if the underlying field is inaccessible.
* @throws IllegalArgumentException if the specified <code>instance</code> is not an instance of
* the class or interface declaring the underlying field (or a subclass or implementor
* thereof), or if an unwrapping conversion fails.
* @throws NullPointerException if the specified <code>instance</code> is null and the field is an
* instance field.
* @throws ExceptionInInitializerError if the initialization provoked by this method fails.
* @see Field#set(Object, Object)
*/
public static void setFieldValue(
boolean setAccessible, Field field, Object instance, Object value) {
if (setAccessible && !field.isAccessible()) {
setAccessible(field);
}
try {
field.set(instance, value);
} catch (IllegalAccessException e) {
throw new RuntimeException(buildSetFieldValueErrorMessage(field, instance, value), e);
} catch (NullPointerException ex) {
NullPointerException ex2 =
new NullPointerException(buildSetFieldValueErrorMessage(field, instance, value));
ex2.initCause(ex.getCause());
throw ex2;
} catch (ExceptionInInitializerError e) {
ExceptionInInitializerError e2 =
new ExceptionInInitializerError(buildSetFieldValueErrorMessage(field, instance, value));
e2.initCause(e.getCause());
throw e2;
}
}
/**
* This is used by standalone tools to force static initialization of DatabaseDescriptor, and fail
* if configuration is bad.
*/
public static void initDatabaseDescriptor() {
try {
DatabaseDescriptor.forceStaticInitialization();
} catch (ExceptionInInitializerError e) {
Throwable cause = e.getCause();
boolean logStackTrace =
!(cause instanceof ConfigurationException)
|| ((ConfigurationException) cause).logStackTrace;
System.out.println(
"Exception ("
+ cause.getClass().getName()
+ ") encountered during startup: "
+ cause.getMessage());
if (logStackTrace) {
cause.printStackTrace();
System.exit(3);
} else {
System.err.println(cause.getMessage());
System.exit(3);
}
}
}
/**
* {@linkplain #registerServiceProvider Registers} all factories given by the supplied iterator.
*
* @param factories The factories (or "service providers") to register.
* @param category the category under which to register the providers.
* @param message A buffer where to write the logging message.
* @return {@code true} if at least one factory has been registered.
*/
private <T> boolean register(
final Iterator<T> factories, final Class<T> category, final StringBuilder message) {
boolean newServices = false;
final String lineSeparator = System.getProperty("line.separator", "\n");
while (factories.hasNext()) {
T factory;
try {
factory = factories.next();
} catch (OutOfMemoryError error) {
// Makes sure that we don't try to handle this error.
throw error;
} catch (NoClassDefFoundError error) {
/*
* A provider can't be registered because of some missing dependencies.
* This occurs for example when trying to register the WarpTransform2D
* math transform on a machine without JAI installation. Since the factory
* may not be essential (this is the case of WarpTransform2D), just skip it.
*/
loadingFailure(category, error, false);
continue;
} catch (ExceptionInInitializerError error) {
/*
* If an exception occured during class initialization, log the cause.
* The ExceptionInInitializerError alone doesn't help enough.
*/
final Throwable cause = error.getCause();
if (cause != null) {
loadingFailure(category, cause, true);
}
throw error;
} catch (Error error) {
if (!Classes.getShortClassName(error).equals("ServiceConfigurationError")) {
// We want to handle sun.misc.ServiceConfigurationError only. Unfortunatly, we
// need to rely on reflection because this error class is not a commited API.
// TODO: Check if the error is catchable with JSE 6.
throw error;
}
/*
* Failed to register a factory for a reason probably related to the plugin
* initialisation. It may be some factory-dependent missing resources.
*/
loadingFailure(category, error, true);
continue;
}
if (category.isAssignableFrom(factory.getClass())) {
final Class<? extends T> factoryClass = factory.getClass().asSubclass(category);
/*
* If the factory implements more than one interface and an
* instance were already registered, reuse the same instance
* instead of duplicating it.
*/
final T replacement = getServiceProviderByClass(factoryClass);
if (replacement != null) {
factory = replacement;
// Need to register anyway, because the category may not be
// the same.
}
if (registerServiceProvider(factory, category)) {
/*
* The factory is now registered. Add it to the message to
* be logged. We will log all factories together in a single
* log event because some registration (e.g.
* MathTransformProviders) would be otherwise quite verbose.
*/
message.append(lineSeparator);
message.append(" ");
message.append(factoryClass.getName());
newServices = true;
}
}
}
return newServices;
}
private void processConfigurationModules(final Class<?> cmb) {
for (final Field f : cmb.getFields()) {
if (ReflectionUtilities.isCoercable(ConfigurationModule.class, f.getType())) {
final int mod = f.getModifiers();
boolean ok = true;
if (Modifier.isPrivate(mod)) {
System.err.println("Found private ConfigurationModule " + f);
ok = false;
}
if (!Modifier.isFinal(mod)) {
System.err.println("Found non-final ConfigurationModule " + f);
ok = false;
}
if (!Modifier.isStatic(f.getModifiers())) {
System.err.println("Found non-static ConfigurationModule " + f);
ok = false;
}
if (ok) {
// System.err.println("OK: " + f);
try {
f.setAccessible(true);
final String fS = ReflectionUtilities.getFullName(f);
if (!modules.containsKey(f)) {
modules.put(f, (ConfigurationModule) (f.get(null)));
try {
modules.get(f).assertStaticClean();
} catch (final ClassHierarchyException e) {
System.err.println(fS + ": " + e.getMessage());
}
for (final Entry<String, String> e : modules.get(f).toStringPairs()) {
// System.err.println("e: " + e.getKey() + "=" + e.getValue());
try {
final Node n = ch.getNode(e.getKey());
if (!setters.contains(e.getKey(), fS)) {
setters.put(e.getKey(), fS);
}
if (n instanceof ClassNode) {
final ClassNode<?> cn = (ClassNode<?>) n;
if (!knownClasses.contains(cn)) {
knownClasses.add(cn);
}
}
} catch (final NameResolutionException ex) {
//
}
try {
final String s = e.getValue();
final Node n = ch.getNode(s);
if (!usages.contains(ReflectionUtilities.getFullName(f), s)) {
// System.err.println("Added usage: " + ReflectionUtilities.getFullName(f) +
// "=" + s);
usages.put(s, ReflectionUtilities.getFullName(f));
}
if (n instanceof ClassNode) {
final ClassNode<?> cn = (ClassNode<?>) n;
if (!knownClasses.contains(cn)) {
System.err.println("Added " + cn + " to known classes");
knownClasses.add(cn);
}
}
} catch (final NameResolutionException ex) {
//
}
}
}
} catch (final ExceptionInInitializerError e) {
System.err.println(
"Field " + ReflectionUtilities.getFullName(f) + ": " + e.getCause().getMessage());
} catch (final IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
}
}
