Java TokenTypes.ENUM_DEF属性代码示例

@Test
public void testGetAcceptableTokens() {
    final MethodCountCheck methodCountCheckObj =
        new MethodCountCheck();
    final int[] actual = methodCountCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CLASS_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.METHOD_DEF,
    };

    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

@Test
public void testGetAcceptableTokens() {
    final AnnotationLocationCheck constantNameCheckObj = new AnnotationLocationCheck();
    final int[] actual = constantNameCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.PARAMETER_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.TYPECAST,
        TokenTypes.LITERAL_THROWS,
        TokenTypes.IMPLEMENTS_CLAUSE,
        TokenTypes.TYPE_ARGUMENT,
        TokenTypes.LITERAL_NEW,
        TokenTypes.DOT,
        TokenTypes.ANNOTATION_FIELD_DEF,
        };
    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        TokenTypes.METHOD_CALL,
        TokenTypes.CLASS_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_TRY,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.PARAMETER_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.SLIST,
        TokenTypes.ENUM_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_NEW,
    };
}
 

@Override
public final void visitToken(DetailAST ast) {
    if (ast.getType() == TokenTypes.PACKAGE_DEF) {
        processPackage(ast);
    }
    else if (ast.getType() == TokenTypes.IMPORT) {
        processImport(ast);
    }
    else if (ast.getType() == TokenTypes.CLASS_DEF
             || ast.getType() == TokenTypes.INTERFACE_DEF
             || ast.getType() == TokenTypes.ENUM_DEF) {
        processClass(ast);
    }
    else {
        if (ast.getType() == TokenTypes.METHOD_DEF) {
            processTypeParams(ast);
        }
        processAST(ast);
    }
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.INTERFACE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.STATIC_INIT,
        TokenTypes.OBJBLOCK,
        TokenTypes.LAMBDA,
    };
}
 

@Test
public void testGetAcceptableTokens() {
    final ClassFanOutComplexityCheck classFanOutComplexityCheckObj =
        new ClassFanOutComplexityCheck();
    final int[] actual = classFanOutComplexityCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.PACKAGE_DEF,
        TokenTypes.IMPORT,
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.TYPE,
        TokenTypes.LITERAL_NEW,
        TokenTypes.LITERAL_THROWS,
        TokenTypes.ANNOTATION_DEF,
    };
    Assert.assertNotNull("Acceptable tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid acceptable tokens", expected, actual);
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.CLASS_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.METHOD_DEF,
    };
}
 

@Test
public void testGetRequiredTokens() {
    final OuterTypeNumberCheck checkObj = new OuterTypeNumberCheck();
    final int[] expected = {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ANNOTATION_DEF,
    };
    assertArrayEquals("Default required tokens are invalid",
        expected, checkObj.getRequiredTokens());
}
 

/**
 * Returns the scope of the surrounding "block".
 * @param node the node to return the scope for
 * @return the Scope of the surrounding block
 */
public static Scope getSurroundingScope(DetailAST node) {
    Scope returnValue = null;
    for (DetailAST token = node.getParent();
         token != null;
         token = token.getParent()) {
        final int type = token.getType();
        if (type == TokenTypes.CLASS_DEF
            || type == TokenTypes.INTERFACE_DEF
            || type == TokenTypes.ANNOTATION_DEF
            || type == TokenTypes.ENUM_DEF) {
            final DetailAST mods =
                token.findFirstToken(TokenTypes.MODIFIERS);
            final Scope modScope = getScopeFromMods(mods);
            if (returnValue == null || returnValue.isIn(modScope)) {
                returnValue = modScope;
            }
        }
        else if (type == TokenTypes.LITERAL_NEW) {
            returnValue = Scope.ANONINNER;
            // because Scope.ANONINNER is not in any other Scope
            break;
        }
    }

    return returnValue;
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ANNOTATION_DEF,
        TokenTypes.ANNOTATION_FIELD_DEF,
        TokenTypes.PARAMETER_DEF,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.ENUM_CONSTANT_DEF,
    };
}
 

@Test
public void testGetAcceptableTokens() {
    final JavadocTypeCheck javadocTypeCheck = new JavadocTypeCheck();

    final int[] actual = javadocTypeCheck.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.INTERFACE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ANNOTATION_DEF,
    };

    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

@Override
public void visitToken(DetailAST ast) {
    if (ast.getType() == TokenTypes.INTERFACE_DEF) {
        checkInterfaceModifiers(ast);
    }
    else if (ast.getType() == TokenTypes.ENUM_DEF) {
        checkEnumDef(ast);
    }
    else {
        if (ast.getType() == TokenTypes.CTOR_DEF) {
            if (isEnumMember(ast)) {
                checkEnumConstructorModifiers(ast);
            }
            else {
                checkClassConstructorModifiers(ast);
            }
        }
        else if (ast.getType() == TokenTypes.METHOD_DEF) {
            processMethods(ast);
        }
        else if (ast.getType() == TokenTypes.RESOURCE) {
            processResources(ast);
        }

        if (isInterfaceOrAnnotationMember(ast)) {
            processInterfaceOrAnnotation(ast);
        }
    }
}
 

@Override
public void visitToken(DetailAST ast) {
    switch (ast.getType()) {
        case TokenTypes.PACKAGE_DEF:
            visitPackageDef(ast);
            break;
        case TokenTypes.IMPORT:
            fileContext.registerImport(ast);
            break;
        case TokenTypes.CLASS_DEF:
        case TokenTypes.INTERFACE_DEF:
        case TokenTypes.ANNOTATION_DEF:
        case TokenTypes.ENUM_DEF:
            visitClassDef(ast);
            break;
        case TokenTypes.TYPE:
            fileContext.visitType(ast);
            break;
        case TokenTypes.LITERAL_NEW:
            fileContext.visitLiteralNew(ast);
            break;
        case TokenTypes.LITERAL_THROWS:
            fileContext.visitLiteralThrows(ast);
            break;
        default:
            throw new IllegalArgumentException("Unknown type: " + ast);
    }
}
 

@Override
public void leaveToken(DetailAST ast) {
    switch (ast.getType()) {
        case TokenTypes.CLASS_DEF:
        case TokenTypes.INTERFACE_DEF:
        case TokenTypes.ANNOTATION_DEF:
        case TokenTypes.ENUM_DEF:
            leaveClassDef();
            break;
        default:
            // Do nothing
    }
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        TokenTypes.PACKAGE_DEF,
        TokenTypes.IMPORT,
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.LITERAL_NEW,
    };
}