for (Field field : fields) {
            int modifiers = field.getModifiers();
            assertTrue(Modifier.isPublic(modifiers), "Field " + field.getName() + " should be public");
            assertTrue(Modifier.isStatic(modifiers), "Field " + field.getName() + " should be static");
            assertTrue(Modifier.isFinal(modifiers), "Field " + field.getName() + " should be final");
        }
    }

    @Test

  public final boolean isPrivate() {
    return Modifier.isPrivate(getModifiers());
  }

  /** Returns true if the element is static. */
  public final boolean isStatic() {
    return Modifier.isStatic(getModifiers());
  }

  /**
   * Returns {@code true} if this method is final, per {@code Modifier.isFinal(getModifiers())}.
   *

// true, otherwise returns (false, obj.ABI0).
func (p *Parser) symRefAttrs(name string, issueError bool) (bool, obj.ABI) {
	abi := obj.ABI0
	isStatic := false
	if p.peek() != '<' {
		return isStatic, abi
	}
	p.next()
	tok := p.peek()
	if tok == '>' {
		isStatic = true
	} else if tok == scanner.Ident {
		abistr := p.get(scanner.Ident).String()
		if !p.allowABI {
			if issueError {

        assertThat(hoge.getFieldName(), is("HOGE"));
        assertThat(hoge.getFieldType(), is(sameClass(String.class)));
        assertThat(hoge.isPublic(), is(true));
        assertThat(hoge.isStatic(), is(true));
        assertThat(hoge.isFinal(), is(true));
        assertThat(hoge.isParameterized(), is(not(true)));
        final ParameterizedClassDesc parameterizedClassDesc = hoge.getParameterizedClassDesc();

            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");
            assertTrue(Modifier.isFinal(m), e.getKey() + " must be final");
            assertEquals(String.class, f.getType(), e.getKey() + " must be String");

            assertEquals("Return type should be String", String.class, method.getReturnType());

            // Check that it's static
            assertTrue("Method should be static", java.lang.reflect.Modifier.isStatic(method.getModifiers()));

            // Check that it's public
            assertTrue("Method should be public", java.lang.reflect.Modifier.isPublic(method.getModifiers()));

            // Check parameter count

import static com.google.common.collect.Lists.transform;
import static com.google.common.collect.Sets.difference;
import static java.lang.reflect.Modifier.isPublic;
import static java.lang.reflect.Modifier.isStatic;
import static java.util.Arrays.asList;
import static org.junit.Assert.assertThrows;

import com.google.common.base.Function;
import com.google.common.base.Joiner;
import java.lang.reflect.Method;

            // When
            var field = Handler.class.getField("DEFAULT_HTTPS_PORT");

            // Then
            assertTrue(Modifier.isPublic(field.getModifiers()));
            assertTrue(Modifier.isStatic(field.getModifiers()));
            assertTrue(Modifier.isFinal(field.getModifiers()));
            assertEquals(int.class, field.getType());
        }
    }

    @Nested
    @DisplayName("Deprecation Tests")

        try {
            // parse(String)
            Method parseMethod = KuromojiCSVUtil.class.getMethod("parse", String.class);
            assertTrue("parse should be static", java.lang.reflect.Modifier.isStatic(parseMethod.getModifiers()));
            assertTrue("parse should be public", java.lang.reflect.Modifier.isPublic(parseMethod.getModifiers()));

        if (Invokable.from(method).isStatic()) {
          builder.add(method);
        }
      }
      return builder.build();
    }

    final Iterable<Method> getInstanceMethods(Class<?> cls) {
      ConcurrentMap<Signature, Method> map = Maps.newConcurrentMap();
      for (Method method : getVisibleMethods(cls)) {
        if (!Invokable.from(method).isStatic()) {