* governing permissions and limitations under the License.
 */
package org.codelibs.core.beans.impl;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;

import org.codelibs.core.beans.BeanDesc;
import org.codelibs.core.beans.MethodDesc;

     */
    public static boolean isAbstract(final int modifier) {
        return Modifier.isAbstract(modifier);
    }

    /**
     * Checks if the specified modifier is static.
     *
     * @param modifier
     *            the modifier to check
     * @return true if static, false otherwise
     */
    public static boolean isStatic(final int modifier) {

        return (Class<T>) returnType;
    }

    @Override
    public boolean isPublic() {
        return MethodUtil.isPublic(method);
    }

    @Override
    public boolean isStatic() {
        return MethodUtil.isStatic(method);
    }

    @Override
    public boolean isFinal() {
        return MethodUtil.isFinal(method);
    }

    @Override
    public boolean isAbstract() {

        return (Class<T>) fieldType;
    }

    @Override
    public boolean isPublic() {
        return FieldUtil.isPublicField(field);
    }

    @Override
    public boolean isStatic() {
        return !FieldUtil.isInstanceField(field);
    }

    @Override
    public boolean isFinal() {
        return FieldUtil.isFinalField(field);
    }

    @Override

    val store = context.getStore(Namespace.create(StartStop::class.java))

    val staticFields =
      findAnnotatedFields(
        context.requiredTestClass,
        StartStop::class.java,
      ) { Modifier.isStatic(it.modifiers) }

    for (field in staticFields) {
      field.setAccessible(true)
      val server = field.get(null) as? MockWebServer ?: continue

    @DisplayName("Test all constants are public static final")
    void testConstantsArePublicStaticFinal() {
        Field[] fields = SecurityInfo.class.getDeclaredFields();

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

        // 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,

 */
package org.codelibs.core.beans.impl;

import static org.codelibs.core.TestUtil.sameClass;
import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.CoreMatchers.not;
import static org.hamcrest.CoreMatchers.notNullValue;
import static org.hamcrest.CoreMatchers.sameInstance;
import static org.junit.Assert.assertThat;

import java.util.List;
import java.util.Map;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class SourceMetaDataVisitor extends VoidVisitorAdapter<ClassMetaDataRepository<ClassMetaData>> {
    private static final Pattern GETTER_METHOD_NAME = Pattern.compile("(get|is)(.+)");
    private static final Pattern SETTER_METHOD_NAME = Pattern.compile("set(.+)");
    private final List<ClassMetaData> allClasses = new ArrayList<ClassMetaData>();

		return "", obj.ABI0, false
	}
	name = p.qualifySymbol(name)
	// Parse optional <> (indicates a static symbol) or
	// <ABIxxx> (selecting text symbol with specific ABI).
	noErrMsg := false
	isStatic, abi := p.symRefAttrs(name, noErrMsg)
	if isStatic {
		return "", obj.ABI0, false // This function rejects static symbols.
	}
	tok = p.next()
	if tok.ScanToken == '+' {
		if p.next().ScanToken != scanner.Int {