public static Method callGetEnclosingMethod(Class thiz) { return thiz.getEnclosingMethod(); }
public class SomeClass { public void foo(){ class Local {}; String name = Local.class.getEnclosingMethod().getName(); } }
private String generateMethodDescription(Callable<Boolean> matcher) { String methodDescription = ""; Method enclosingMethod = matcher.getClass().getEnclosingMethod(); if (enclosingMethod != null) { methodDescription = " defined in " + enclosingMethod.toString(); } return methodDescription; } }
/** * @since 2.7 */ public static boolean hasEnclosingMethod(Class<?> cls) { return !isObjectOrPrimitive(cls) && (cls.getEnclosingMethod() != null); }
/** * @since 2.7 */ public static boolean hasEnclosingMethod(Class<?> cls) { return !isObjectOrPrimitive(cls) && (cls.getEnclosingMethod() != null); }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
private String generateMethodDescription(ThrowingRunnable supplier) { String methodDescription = ""; Method enclosingMethod = null; try { enclosingMethod = supplier.getClass().getEnclosingMethod(); } catch (Error ignored) { // A java.lang.InternalError could be thrown when using the Groovy extension using Groovy 2.3.7 for some reason. Bug in Groovy?! } if (enclosingMethod != null) { methodDescription = " defined in " + enclosingMethod.toString(); } return methodDescription; }
String name = new Object(){}.getClass().getEnclosingMethod().getName();
/** * Method for finding enclosing class for non-static inner classes * * @since 1.9 */ public static Class<?> getOuterClass(Class<?> type) { // as above, GAE has some issues... try { // one more: method locals, anonymous, are not good: if (type.getEnclosingMethod() != null) { return null; } if (!Modifier.isStatic(type.getModifiers())) { return type.getEnclosingClass(); } } catch (SecurityException e) { } catch (NullPointerException e) { } return null; }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
/** * Tests whether the class represented by this {@code Class} is defined * locally. */ public boolean isLocalClass() { boolean enclosed = (getEnclosingMethod() != null || getEnclosingConstructor() != null); return enclosed && !isAnonymousClass(); }
/** * @since 2.7 */ public static boolean hasEnclosingMethod(Class<?> cls) { return !isObjectOrPrimitive(cls) && (cls.getEnclosingMethod() != null); }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
private static GenericDeclaration nextLayer(GenericDeclaration decl) { if (decl instanceof Class) { // FIXME: Is the following hierarchy correct?: Class cl = (Class)decl; // RoboVM note: Start of change. Do what the old 4.1.1 code did instead // of AnnotationAccess.getEnclosingMethodOrConstructor(cl) in 4.4.3. decl = cl.getEnclosingMethod(); if (decl != null) { return decl; } decl = cl.getEnclosingConstructor(); if (decl != null) { return decl; } // RoboVM note: End of change, return cl.getEnclosingClass(); } else if (decl instanceof Method) { return ((Method)decl).getDeclaringClass(); } else if (decl instanceof Constructor) { return ((Constructor)decl).getDeclaringClass(); } else { throw new AssertionError(); } }
if (type.getEnclosingMethod() != null) { return "local/anonymous";
@Test @Parameters({ "testdata" }) public void filterOutInJectedTypesFromOptionalValuesTest(XmlTest xmlTest, @Optional("optionaltestdata") String testdata) { JDK15AnnotationFinder finder = new JDK15AnnotationFinder(null); Method curMethod = new Object() {}.getClass().getEnclosingMethod(); FilterOutInJectedTypesResult filterOutResult = org.testng.internal.Parameters.filterOutInJectedTypesFromOptionalValues( curMethod.getParameterTypes(), finder.findOptionalValues(curMethod)); Assert.assertEquals(filterOutResult.getOptionalValues()[0], "optionaltestdata"); Assert.assertEquals(filterOutResult.getParameterTypes()[0], String.class); }
@Override protected String getCallableDescription(final Callable<T> supplier) { final Class<? extends Callable> supplierClass = supplier.getClass(); Method enclosingMethod = supplierClass.getEnclosingMethod(); if (isFieldSupplier(supplierClass)) { return generateFieldSupplierErrorMessage(supplier); } else if (supplierClass.isAnonymousClass() && enclosingMethod != null) { return enclosingMethod.getDeclaringClass().getName() + "." + enclosingMethod.getName() + " Callable"; } else if (isLambdaClass(supplierClass)) { return generateLambdaErrorMessagePrefix(supplierClass, true); } else { return supplierClass.getName(); } }
private boolean mayNeedHiddenThis() { Class<?> declaringClass = constructor.getDeclaringClass(); if (declaringClass.getEnclosingConstructor() != null) { // Enclosed in a constructor, needs hidden this return true; } Method enclosingMethod = declaringClass.getEnclosingMethod(); if (enclosingMethod != null) { // Enclosed in a method, if it's not static, must need hidden this. return !Modifier.isStatic(enclosingMethod.getModifiers()); } else { // Strictly, this doesn't necessarily indicate a hidden 'this' in the case of // static initializer. But there seems no way to tell in that case. :( // This may cause issues when an anonymous class is created inside a static initializer, // and the class's constructor's first parameter happens to be the enclosing class. // In such case, we may mistakenly think that the class is within a non-static context // and the first parameter is the hidden 'this'. return declaringClass.getEnclosingClass() != null && !Modifier.isStatic(declaringClass.getModifiers()); } } }
/** * {@inheritDoc} */ public MethodDescription.InDefinedShape getEnclosingMethod() { Method enclosingMethod = type.getEnclosingMethod(); Constructor<?> enclosingConstructor = type.getEnclosingConstructor(); if (enclosingMethod != null) { return new MethodDescription.ForLoadedMethod(enclosingMethod); } else if (enclosingConstructor != null) { return new MethodDescription.ForLoadedConstructor(enclosingConstructor); } else { return MethodDescription.UNDEFINED; } }
@Test @Parameters({"testdata"}) @SuppressWarnings("unused") public void filterOutInJectedTypesFromOptionalValuesTest( XmlTest xmlTest, @Optional("optionaltestdata") String testdata) { JDK15AnnotationFinder finder = new JDK15AnnotationFinder(null); Method curMethod = new Object() {}.getClass().getEnclosingMethod(); FilterOutInJectedTypesResult filterOutResult = org.testng.internal.Parameters.filterOutInJectedTypesFromOptionalValues( curMethod.getParameterTypes(), finder.findOptionalValues(curMethod)); Assert.assertEquals(filterOutResult.getOptionalValues()[0], "optionaltestdata"); Assert.assertEquals(filterOutResult.getParameterTypes()[0], String.class); } }