Java TokenTypes.LITERAL_DO属性代码示例

@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,
    };
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        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,
    };
}
 

@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);
}
 

@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,
    };
}
 

/**
 * 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[] 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,
    };
}
 

@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,
    };
}
 

/**
 * Collects validation details for loops' tokens.
 * @param ast a {@code DetailAST} value
 * @return an object containing all details to make a validation
 */
private static Details getDetailsForLoops(DetailAST ast) {
    DetailAST rcurly = null;
    final DetailAST lcurly;
    final DetailAST nextToken;
    final int tokenType = ast.getType();
    if (tokenType == TokenTypes.LITERAL_DO) {
        nextToken = ast.findFirstToken(TokenTypes.DO_WHILE);
        lcurly = ast.findFirstToken(TokenTypes.SLIST);
        if (lcurly != null) {
            rcurly = lcurly.getLastChild();
        }
    }
    else {
        lcurly = ast.findFirstToken(TokenTypes.SLIST);
        if (lcurly != null) {
            // SLIST could be absent in code like "while(true);"
            rcurly = lcurly.getLastChild();
        }
        nextToken = getNextToken(ast);
    }
    return new Details(lcurly, rcurly, nextToken, false);
}
 

@Override
public int[] getAcceptableTokens() {
    return new int[] {
        TokenTypes.COMMA,
        TokenTypes.SEMI,
        TokenTypes.TYPECAST,
        TokenTypes.LITERAL_IF,
        TokenTypes.LITERAL_ELSE,
        TokenTypes.LITERAL_WHILE,
        TokenTypes.LITERAL_DO,
        TokenTypes.LITERAL_FOR,
        TokenTypes.DO_WHILE,
    };
}
 

@Override
public void leaveToken(DetailAST ast) {
    switch (ast.getType()) {
        case TokenTypes.LITERAL_WHILE:
        case TokenTypes.LITERAL_DO:
        case TokenTypes.LITERAL_FOR:
        case TokenTypes.LITERAL_IF:
        case TokenTypes.LITERAL_SWITCH:
            leaveConditional();
            break;
        case TokenTypes.LITERAL_TRY:
            leaveMultiplyingConditional();
            break;
        case TokenTypes.LITERAL_RETURN:
        case TokenTypes.QUESTION:
            leaveUnitaryOperator();
            break;
        case TokenTypes.LITERAL_CATCH:
            leaveAddingConditional();
            break;
        case TokenTypes.LITERAL_DEFAULT:
            leaveBranch();
            break;
        case TokenTypes.LITERAL_ELSE:
        case TokenTypes.CASE_GROUP:
            leaveBranch();
            branchVisited = false;
            break;
        case TokenTypes.CTOR_DEF:
        case TokenTypes.METHOD_DEF:
        case TokenTypes.INSTANCE_INIT:
        case TokenTypes.STATIC_INIT:
            leaveMethodDef(ast);
            break;
        default:
            break;
    }
}
 

@Override
public int[] getRequiredTokens() {
    return new int[] {
        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,
    };
}
 

/**
 * Checks if a given loop terminated by return, throw or,
 * if allowed break, continue.
 * @param ast loop to check
 * @return true if loop is terminated.
 */
private boolean checkLoop(final DetailAST ast) {
    final DetailAST loopBody;
    if (ast.getType() == TokenTypes.LITERAL_DO) {
        final DetailAST lparen = ast.findFirstToken(TokenTypes.DO_WHILE);
        loopBody = lparen.getPreviousSibling();
    }
    else {
        final DetailAST rparen = ast.findFirstToken(TokenTypes.RPAREN);
        loopBody = rparen.getNextSibling();
    }
    return isTerminated(loopBody, false, false);
}
 

/**
 * Gets first Ast node inside FOR, WHILE or DO-WHILE blocks if variable
 * usage is met only inside the block (not in its declaration!).
 * @param block
 *        Ast node represents FOR, WHILE or DO-WHILE block.
 * @param variable
 *        Variable which is checked for content in block.
 * @return If variable usage is met only inside the block
 *         (not in its declaration!) than return the first Ast node
 *         of this block, otherwise - null.
 */
private static DetailAST getFirstNodeInsideForWhileDoWhileBlocks(
        DetailAST block, DetailAST variable) {
    DetailAST firstNodeInsideBlock = null;

    if (!isVariableInOperatorExpr(block, variable)) {
        final DetailAST currentNode;

        // Find currentNode for DO-WHILE block.
        if (block.getType() == TokenTypes.LITERAL_DO) {
            currentNode = block.getFirstChild();
        }
        // Find currentNode for FOR or WHILE block.
        else {
            // Looking for RPAREN ( ')' ) token to mark the end of operator
            // expression.
            currentNode = block.findFirstToken(TokenTypes.RPAREN).getNextSibling();
        }

        final int currentNodeType = currentNode.getType();

        if (currentNodeType == TokenTypes.SLIST) {
            firstNodeInsideBlock = currentNode.getFirstChild();
        }
        else if (currentNodeType != TokenTypes.EXPR) {
            firstNodeInsideBlock = currentNode;
        }
    }

    return firstNodeInsideBlock;
}
 

@Test
public void testGetRequiredTokens() {
    final JavaNCSSCheck javaNcssCheckObj = new JavaNCSSCheck();
    final int[] actual = javaNcssCheckObj.getRequiredTokens();
    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("Required tokens should not be null", actual);
    Assert.assertArrayEquals("Invalid required tokens", expected, actual);
}
 

@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);
}