Java TokenTypes.LITERAL_CATCH属性代码示例

/** @see com.puppycrawl.tools.checkstyle.checks.usage.AbstractUsageCheck */
public boolean mustCheckReferenceCount(DetailAST aAST)
{
    boolean result = false;
    final DetailAST parent = aAST.getParent();
    if (parent != null) {
        if (parent.getType() == TokenTypes.PARAMETERS) {
            final DetailAST grandparent = parent.getParent();
            if (grandparent != null) {
                result = hasBody(grandparent)
                    && (!mIgnoreNonLocal || isLocal(grandparent));
            }
        }
        else if (parent.getType() == TokenTypes.LITERAL_CATCH) {
            result = !mIgnoreCatch;
        }
    }
    return result;
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.QUESTION,
        TokenTypes.LAND,
        TokenTypes.LOR,
    };
}
 

@Test
public void testGetAcceptableTokens() {
    final NPathComplexityCheck npathComplexityCheckObj = new NPathComplexityCheck();
    final int[] actual = npathComplexityCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.STATIC_INIT,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.CASE_GROUP,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.QUESTION,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_DEFAULT,
    };
    Assert.assertNotNull("Acceptable tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid acceptable tokens", expected, actual);
}
 

/**
 * Returns array of acceptable tokens.
 * @return acceptableTokens.
 */
private static int[] makeAcceptableTokens() {
    return new int[] {TokenTypes.ANNOTATION,
        TokenTypes.ANNOTATION_FIELD_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.CTOR_DEF,
        TokenTypes.DOT,
        TokenTypes.ENUM_CONSTANT_DEF,
        TokenTypes.EXPR,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_NEW,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.METHOD_CALL,
        TokenTypes.METHOD_DEF,
        TokenTypes.QUESTION,
        TokenTypes.RESOURCE_SPECIFICATION,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LAMBDA,
    };
}
 

@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 int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_FOR,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_DEFAULT,
        TokenTypes.ARRAY_INIT,
    };
}
 

@Test
public void testGetRequiredTokens() {
    final NPathComplexityCheck npathComplexityCheckObj = new NPathComplexityCheck();
    final int[] actual = npathComplexityCheckObj.getRequiredTokens();
    final int[] expected = {
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.STATIC_INIT,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.CASE_GROUP,
        TokenTypes.LITERAL_TRY,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.QUESTION,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_DEFAULT,
    };
    Assert.assertNotNull("Required tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid required tokens", expected, actual);
}
 

@Test
public void testGetAcceptableTokens() {
    final CyclomaticComplexityCheck cyclomaticComplexityCheckObj =
        new CyclomaticComplexityCheck();
    final int[] actual = cyclomaticComplexityCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CTOR_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.QUESTION,
        TokenTypes.LAND,
        TokenTypes.LOR,
    };
    Assert.assertArrayEquals("Invalid acceptable tokens", expected, actual);
}
 

@Test
public void testGetAcceptableTokens() {
    final EmptyCatchBlockCheck constantNameCheckObj = new EmptyCatchBlockCheck();
    final int[] actual = constantNameCheckObj.getAcceptableTokens();
    final int[] expected = {TokenTypes.LITERAL_CATCH };
    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

@Test
public void testGetAcceptableTokens() {
    final JavaNCSSCheck javaNcssCheckObj = new JavaNCSSCheck();
    final int[] actual = javaNcssCheckObj.getAcceptableTokens();
    final int[] expected = {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
        TokenTypes.INSTANCE_INIT,
        TokenTypes.STATIC_INIT,
        TokenTypes.PACKAGE_DEF,
        TokenTypes.IMPORT,
        TokenTypes.VARIABLE_DEF,
        TokenTypes.CTOR_CALL,
        TokenTypes.SUPER_CTOR_CALL,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.LITERAL_SWITCH,
        TokenTypes.LITERAL_BREAK,
        TokenTypes.LITERAL_CONTINUE,
        TokenTypes.LITERAL_RETURN,
        TokenTypes.LITERAL_THROW,
        TokenTypes.LITERAL_SYNCHRONIZED,
        TokenTypes.LITERAL_CATCH,
        TokenTypes.LITERAL_FINALLY,
        TokenTypes.EXPR,
        TokenTypes.LABELED_STAT,
        TokenTypes.LITERAL_CASE,
        TokenTypes.LITERAL_DEFAULT,
    };
    Assert.assertNotNull("Acceptable tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid acceptable tokens", expected, actual);
}
 

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

/**
 * Collects validation Details.
 * @param ast a {@code DetailAST} value
 * @return object containing all details to make a validation
 */
private static Details getDetails(DetailAST ast) {
    final Details details;
    switch (ast.getType()) {
        case TokenTypes.LITERAL_TRY:
        case TokenTypes.LITERAL_CATCH:
        case TokenTypes.LITERAL_FINALLY:
            details = getDetailsForTryCatchFinally(ast);
            break;
        case TokenTypes.LITERAL_IF:
        case TokenTypes.LITERAL_ELSE:
            details = getDetailsForIfElse(ast);
            break;
        case TokenTypes.LITERAL_DO:
        case TokenTypes.LITERAL_WHILE:
        case TokenTypes.LITERAL_FOR:
            details = getDetailsForLoops(ast);
            break;
        case TokenTypes.LAMBDA:
            details = getDetailsForLambda(ast);
            break;
        default:
            details = getDetailsForOthers(ast);
            break;
    }
    return details;
}
 

@Test
public void testGetAcceptableTokens() {
    final LeftCurlyCheck check = new LeftCurlyCheck();
    final int[] actual = check.getAcceptableTokens();
    final int[] expected = {
        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, };
    assertArrayEquals("Default acceptable tokens are invalid", expected, actual);
}
 

/**
 * Whether the comment might have been used for the next block in a multi-block structure.
 * @param endBlockStmt the end of the current block.
 * @return true, if the comment might have been used for the next
 *     block in a multi-block structure.
 */
private static boolean isCommentForMultiblock(DetailAST endBlockStmt) {
    final DetailAST nextBlock = endBlockStmt.getParent().getNextSibling();
    final int endBlockLineNo = endBlockStmt.getLineNo();
    final DetailAST catchAst = endBlockStmt.getParent().getParent();
    final DetailAST finallyAst = catchAst.getNextSibling();
    return nextBlock != null && nextBlock.getLineNo() == endBlockLineNo
            || finallyAst != null
                && catchAst.getType() == TokenTypes.LITERAL_CATCH
                && finallyAst.getLineNo() == endBlockLineNo;
}
 

@Override
protected boolean mustCheckName(DetailAST ast) {
    boolean checkName = true;
    if (ignoreOverridden && isOverriddenMethod(ast)
            || ast.getParent().getType() == TokenTypes.LITERAL_CATCH
            || CheckUtils.isReceiverParameter(ast)
            || !matchAccessModifiers(getAccessModifier(ast))) {
        checkName = false;
    }
    return checkName;
}