}

  private static Set<Method> findInterruptibleMethods(Class<?> interfaceType) {
    Set<Method> set = Sets.newHashSet();
    for (Method m : interfaceType.getMethods()) {
      if (declaresInterruptedEx(m)) {
        set.add(m);
      }
    }
    return set;
  }

  private static boolean declaresInterruptedEx(Method method) {
    for (Class<?> exType : method.getExceptionTypes()) {

    for (Method method : getInstanceMethodsToTest(instance.getClass(), minimalVisibility)) {
      testMethod(instance, method);
    }
  }

  ImmutableList<Method> getInstanceMethodsToTest(Class<?> c, Visibility minimalVisibility) {
    ImmutableList.Builder<Method> builder = ImmutableList.builder();
    for (Method method : minimalVisibility.getInstanceMethods(c)) {

   *       {@code cls}, no test is performed.
   *   <li>Equality test is not performed on method return values unless the method is a non-private
   *       static factory method whose return type is {@code cls} or {@code cls}'s subtype.
   *   <li>Inequality check is not performed against state mutation methods such as {@link
   *       List#add}, or functional update methods such as {@link

        final Method equalsMethod = ClassUtil.getMethod(getClass(), "equals", Object.class);
        assertThat(MethodUtil.isHashCodeMethod(equalsMethod), is(not(true)));
    }

    /**
     *
     */
    @Test
    public void testIsToStringMethod() {
        final Method toStringMethod = ClassUtil.getMethod(getClass(), "toString");
        assertThat(MethodUtil.isToStringMethod(toStringMethod), is(true));

pkg log/slog, method (Value) Any() interface{} #56345
pkg log/slog, method (Value) Bool() bool #56345
pkg log/slog, method (Value) Duration() time.Duration #56345
pkg log/slog, method (Value) Equal(Value) bool #56345
pkg log/slog, method (Value) Float64() float64 #56345
pkg log/slog, method (Value) Group() []Attr #56345
pkg log/slog, method (Value) Int64() int64 #56345
pkg log/slog, method (Value) Kind() Kind #56345

    Method[] methods = getMostConcreteMethods(interfaceType);
    AccessibleObject.setAccessible(methods, true);
    for (Method method : methods) {
      // Under java 8, interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for JDK 7 compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }

    Method[] methods = getMostConcreteMethods(interfaceType);
    AccessibleObject.setAccessible(methods, true);
    for (Method method : methods) {
      // Under java 8, interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for JDK 7 compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }

    subscriber.invokeSubscriberMethod(FIXTURE_ARGUMENT);

    assertTrue("Subscriber must call provided method", methodCalled);
    assertTrue(
        "Subscriber argument must be exactly the provided object.",
        methodArgument == FIXTURE_ARGUMENT);
  }

  public void testInvokeSubscriberMethod_exceptionWrapping() throws Throwable {
    Method method = getTestSubscriberMethod("exceptionThrowingMethod");

    final Method method;

    MethodInvokable(Method method) {
      super(method);
      this.method = method;
    }

    @Override
    @CheckForNull
    final Object invokeInternal(@CheckForNull Object receiver, @Nullable Object[] args)
        throws InvocationTargetException, IllegalAccessException {
      return method.invoke(receiver, args);
    }

    @Override

      Class<?> c, ImmutableSet<String> ignore) {
    ImmutableSet.Builder<String> methods = ImmutableSet.builder();
    for (Method method : c.getMethods()) {
      if (Modifier.isStatic(method.getModifiers()) || ignore.contains(method.getName())) {
        continue;
      }
      StringBuilder signature =
          new StringBuilder()
              .append(typeName(method.getReturnType()))
              .append(" ")