* @return {@literal true} if it is an instance field
     */
    public static boolean isInstanceField(final Field field) {
        assertArgumentNotNull("field", field);

        return !Modifier.isStatic(field.getModifiers());
    }

    /**
     * Checks if the given field is a public field.
     *
     * @param field the field (must not be {@literal null})
     * @return {@literal true} if it is a public field
     */

     * @return <code>abstract</code> if the method is abstract
     */
    public static boolean isAbstract(final Method method) {
        return Modifier.isAbstract(method.getModifiers());
    }

    /**
     * Returns whether the method is <code>public</code>.
     *
     * @param method
     *            The method. Cannot be {@literal null}

     */
    public static boolean isPublic(final Constructor<?> constructor) {
        assertArgumentNotNull("constructor", constructor);

        return Modifier.isPublic(constructor.getModifiers());
    }

        for (Map.Entry<String, String> e : expected.entrySet()) {
            Field f = SpnegoConstants.class.getField(e.getKey());
            int m = f.getModifiers();

            assertTrue(Modifier.isPublic(m), e.getKey() + " must be public");
            assertTrue(Modifier.isStatic(m), e.getKey() + " must be static");

        // Arrange & Act
        Class<SessionSetupHandler> clazz = SessionSetupHandler.class;

        // Assert
        assertTrue(clazz.isInterface(), "Should be an interface");
        assertTrue(Modifier.isPublic(clazz.getModifiers()), "Interface should be public");
        assertEquals("jcifs.smb", clazz.getPackageName(), "Package must match source");
        assertEquals("SessionSetupHandler", clazz.getSimpleName(), "Simple name must match source");
    }

                      m.getName().equals("writeReplace")
                          && m.getParameterTypes().length == 0
                          // Only package-private methods are a problem.
                          && (m.getModifiers() & (PUBLIC | PROTECTED | PRIVATE)) == 0)
              .transform(Method::getDeclaringClass);
      if (!supersWithPackagePrivateWriteReplace.isPresent()) {
        continue;
      }
      assertWithMessage(

        Map<String, MethodInfo> methodMap = new HashMap<>();

        for (Method method : beanType.getMethods()) {
            if (!Modifier.isStatic(method.getModifiers()) && method.getParameterCount() == 1) {
                Type[] paramTypes = method.getGenericParameterTypes();
                methodMap.putIfAbsent(method.getName(), new MethodInfo(method, paramTypes[0]));
            }

  }

  static ImmutableList<Method> getTestMethods(Class<?> testClass) {
    List<Method> result = new ArrayList<>();
    for (Method method : testClass.getDeclaredMethods()) {
      if (Modifier.isPublic(method.getModifiers())
          && method.getReturnType() == void.class
          && method.getParameterTypes().length == 0
          && method.getName().startsWith("test")) {
        result.add(method);
      }
    }

                      m.getName().equals("writeReplace")
                          && m.getParameterTypes().length == 0
                          // Only package-private methods are a problem.
                          && (m.getModifiers() & (PUBLIC | PROTECTED | PRIVATE)) == 0)
              .transform(Method::getDeclaringClass);
      if (!supersWithPackagePrivateWriteReplace.isPresent()) {
        continue;
      }
      assertWithMessage(

      // Interfaces can have default methods that aren't abstract.
      // No need to verify them.
      // Can't check isDefault() for Android compatibility.
      if (!Modifier.isAbstract(method.getModifiers())) {
        continue;
      }
      // The interface could be package-private or private.
      // filter out equals/hashCode/toString
      if (method.getName().equals("equals")