How to use

getEnclosingMethod

method

in

java.lang.Class

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);
 }
}