private void verifyArrayFieldTypeAnnotations(Class c) throws NoSuchFieldException, NoSuchMethodException { Annotation anno; AnnotatedType at; at = c.getDeclaredField("typeAnnotatedArray").getAnnotatedType(); anno = at.getAnnotations()[0]; verifyTestAnn(arrayTA[0], anno, "array1"); arrayTA[0] = anno; for (int i = 1; i <= 3; i++) { at = ((AnnotatedArrayType) at).getAnnotatedGenericComponentType(); anno = at.getAnnotations()[0]; verifyTestAnn(arrayTA[i], anno, "array" + (i + 1)); arrayTA[i] = anno; } }
private void verifyMethodTypeAnnotations(Class c) throws NoSuchFieldException, NoSuchMethodException { Annotation anno; Executable typeAnnotatedMethod = c.getDeclaredMethod("typeAnnotatedMethod", TypeAnnotatedTestClass.class); anno = typeAnnotatedMethod.getAnnotatedReturnType().getAnnotations()[0]; verifyTestAnn(returnTA, anno, "return"); returnTA = anno; anno = typeAnnotatedMethod.getTypeParameters()[0].getAnnotations()[0]; verifyTestAnn(methodTypeParameterTA, anno, "methodTypeParameter"); methodTypeParameterTA = anno; anno = typeAnnotatedMethod.getAnnotatedParameterTypes()[0].getAnnotations()[0]; verifyTestAnn(formalParameterTA, anno, "formalParameter"); formalParameterTA = anno; anno = typeAnnotatedMethod.getAnnotatedExceptionTypes()[0].getAnnotations()[0]; verifyTestAnn(throwsTA, anno, "throws"); throwsTA = anno; }
private void verifyInnerFieldTypeAnnotations(Class c) throws NoSuchFieldException, NoSuchMethodException { AnnotatedType at = c.getDeclaredField("typeAnnotatedInner").getAnnotatedType(); Annotation anno = at.getAnnotations()[0]; verifyTestAnn(innerTA, anno, "inner"); innerTA = anno; }
/** * instantiate an object from a given string * @param c class of the object to instantiate * @param s string to instantiate from * @return instance of the specified class * @throws NoSuchMethodException * @throws IllegalAccessException * @throws InvocationTargetException */ @SuppressWarnings("unchecked") private static <T> T castFromStr(Class<T> c, String s) throws NoSuchMethodException , IllegalAccessException , InvocationTargetException { if (String.class == c) return (T) s; Method m = c.getMethod("valueOf", String.class); if (null == m) { throw new NoSuchMethodException ( "Class " + c.getName() + " does not have the valueOf() method." ); } return (T) m.invoke(null, s); }
public static void main(String argv[]) throws NoSuchFieldException, NoSuchMethodException { if (argv.length == 1 && argv[0].equals("buildagent")) { buildAgent(); return; } if (inst == null) { throw new RuntimeException("Instrumentation object was null"); } RedefineAnnotations test = new RedefineAnnotations(); test.testTransformAndVerify(); }
private void testTransformAndVerify() throws NoSuchFieldException, NoSuchMethodException { Class<TypeAnnotatedTestClass> c = TypeAnnotatedTestClass.class; Class<?> myClass = c; /* * Verify that the expected annotations are where they should be before transform. */ verifyClassTypeAnnotations(c); verifyFieldTypeAnnotations(c); verifyMethodTypeAnnotations(c); try { inst.addTransformer(new Transformer(), true); inst.retransformClasses(myClass); } catch (UnmodifiableClassException e) { throw new RuntimeException(e); } /* * Verify that the expected annotations are where they should be after transform. * Also verify that before and after are equal. */ verifyClassTypeAnnotations(c); verifyFieldTypeAnnotations(c); verifyMethodTypeAnnotations(c); }
private void verifyFieldTypeAnnotations(Class c) throws NoSuchFieldException, NoSuchMethodException { verifyBasicFieldTypeAnnotations(c); verifyInnerFieldTypeAnnotations(c); verifyArrayFieldTypeAnnotations(c); verifyMapFieldTypeAnnotations(c); }
private void verifyBasicFieldTypeAnnotations(Class c) throws NoSuchFieldException, NoSuchMethodException { Annotation anno = c.getDeclaredField("typeAnnotatedBoolean").getAnnotatedType().getAnnotations()[0]; verifyTestAnn(fieldTA, anno, "field"); fieldTA = anno; }
private void verifyMapFieldTypeAnnotations(Class c) throws NoSuchFieldException, NoSuchMethodException { Annotation anno; AnnotatedType atBase; AnnotatedType atParameter; atBase = c.getDeclaredField("typeAnnotatedMap").getAnnotatedType(); anno = atBase.getAnnotations()[0]; verifyTestAnn(mapTA[0], anno, "map1"); mapTA[0] = anno; atParameter = ((AnnotatedParameterizedType) atBase). getAnnotatedActualTypeArguments()[0]; anno = ((AnnotatedWildcardType) atParameter).getAnnotations()[0]; verifyTestAnn(mapTA[1], anno, "map2"); mapTA[1] = anno; anno = ((AnnotatedWildcardType) atParameter). getAnnotatedUpperBounds()[0].getAnnotations()[0]; verifyTestAnn(mapTA[2], anno, "map3"); mapTA[2] = anno; atParameter = ((AnnotatedParameterizedType) atBase). getAnnotatedActualTypeArguments()[1]; anno = ((AnnotatedParameterizedType) atParameter).getAnnotations()[0]; verifyTestAnn(mapTA[3], anno, "map4"); mapTA[3] = anno; anno = ((AnnotatedParameterizedType) atParameter). getAnnotatedActualTypeArguments()[0].getAnnotations()[0]; verifyTestAnn(mapTA[4], anno, "map5"); mapTA[4] = anno; }
/** * Given a TEnum class and integer value, this method will return * the associated constant from the given TEnum class. * This method MUST be modified should the name of the 'findByValue' method * change. * * @param enumClass TEnum from which to return a matching constant. * @param value Value for which to return the constant. * * @return The constant in 'enumClass' whose value is 'value' or null if * something went wrong. */ public static TEnum getByValue(Class<? extends TEnum> enumClass, int value) { try { Method method = enumClass.getMethod("findByValue", int.class); return (TEnum) method.invoke(null, value); } catch (NoSuchMethodException nsme) { return null; } catch (IllegalAccessException iae) { return null; } catch (InvocationTargetException ite) { return null; } }
public void testApp() { Method method = null; try { method = Tracepoints.class.getDeclaredMethod("tracepoint0"); assertNotNull("Method Tracepoints.tracepoint0 is null.", method); } catch (NoSuchMethodException e) { assertTrue("Method tracepoint0 not found in class Tracepoints.", false); } PerfTracepoint tracepoint = method.getAnnotation(PerfTracepoint.class); assertNotNull("PerfTracepoint instance is null.", tracepoint); }
/** * Get the base class of classParam, for top level classes this returns null. For enums, inner and anonymous classes * it returns the enclosing class. The intent is to use this for enum support in Java 5+. * * @param classParam * class to get enclosing class of * @return Enclosing class * @throws NoSuchMethodException * when run in pre Java 5. */ private static Class getBaseClass(Class classParam) throws NoSuchMethodException { String methodName = "getEnclosingClass"; Method method = null; Class result = null; try { method = classParam.getClass().getMethod(methodName, (Class[]) null); result = (Class) method.invoke(classParam, (Object[]) null); } catch (Exception ex) { throw new NoSuchMethodException(ex.getMessage()); } return result; }
