Java DetailAST.setType方法代码示例

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
/**
 * Create block comment from string content.
 * @param content comment content.
 * @return DetailAST block comment
 */
public static DetailAST createBlockCommentNode(String content) {
    final DetailAST blockCommentBegin = new DetailAST();
    blockCommentBegin.setType(TokenTypes.BLOCK_COMMENT_BEGIN);
    blockCommentBegin.setText(BLOCK_MULTIPLE_COMMENT_BEGIN);
    blockCommentBegin.setLineNo(0);
    blockCommentBegin.setColumnNo(-JAVADOC_START.length());

    final DetailAST commentContent = new DetailAST();
    commentContent.setType(TokenTypes.COMMENT_CONTENT);
    commentContent.setText("*" + content);
    commentContent.setLineNo(0);
    // javadoc should starts at 0 column, so COMMENT_CONTENT node
    // that contains javadoc identifier has -1 column
    commentContent.setColumnNo(-1);

    final DetailAST blockCommentEnd = new DetailAST();
    blockCommentEnd.setType(TokenTypes.BLOCK_COMMENT_END);
    blockCommentEnd.setText(BLOCK_MULTIPLE_COMMENT_END);

    blockCommentBegin.setFirstChild(commentContent);
    commentContent.setNextSibling(blockCommentEnd);
    return blockCommentBegin;
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testParam() {
    final DetailAST ast = new DetailAST();

    final int[] validTypes = {
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
    };
    for (int type: validTypes) {
        ast.setType(type);
        assertTrue("Invalid ast type for current tag: " + ast.getType(),
                JavadocTagInfo.PARAM.isValidOn(ast));
    }

    ast.setType(TokenTypes.LAMBDA);
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.PARAM.isValidOn(ast));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testContainsAnnotationWithComment() {
    final DetailAST astForTest = new DetailAST();
    astForTest.setType(TokenTypes.PACKAGE_DEF);
    final DetailAST child = new DetailAST();
    final DetailAST annotations = new DetailAST();
    final DetailAST annotation = new DetailAST();
    final DetailAST annotationNameHolder = new DetailAST();
    final DetailAST annotationName = new DetailAST();
    final DetailAST comment = new DetailAST();
    annotations.setType(TokenTypes.ANNOTATIONS);
    annotation.setType(TokenTypes.ANNOTATION);
    annotationNameHolder.setType(TokenTypes.AT);
    comment.setType(TokenTypes.BLOCK_COMMENT_BEGIN);
    annotationName.setText("Annotation");

    annotationNameHolder.setNextSibling(annotationName);
    annotation.setFirstChild(comment);
    comment.setNextSibling(annotationNameHolder);
    annotations.setFirstChild(annotation);
    child.setNextSibling(annotations);
    astForTest.setFirstChild(child);

    assertTrue("Annotation should contain " + astForTest,
            AnnotationUtility.containsAnnotation(astForTest, "Annotation"));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testParents() {
    final DetailAST parent = new DetailAST();
    parent.setType(TokenTypes.STATIC_INIT);
    final DetailAST method = new DetailAST();
    method.setType(TokenTypes.METHOD_DEF);
    parent.setFirstChild(method);
    final DetailAST ctor = new DetailAST();
    ctor.setType(TokenTypes.CTOR_DEF);
    method.setNextSibling(ctor);

    final DeclarationOrderCheck check = new DeclarationOrderCheck();

    check.visitToken(method);
    final SortedSet<LocalizedMessage> messages1 = check.getMessages();

    assertEquals("No exception messages expected", 0, messages1.size());

    check.visitToken(ctor);
    final SortedSet<LocalizedMessage> messages2 = check.getMessages();

    assertEquals("No exception messages expected", 0, messages2.size());
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testVisitToken() {
    final CommentsIndentationCheck check = new CommentsIndentationCheck();
    final DetailAST methodDef = new DetailAST();
    methodDef.setType(TokenTypes.METHOD_DEF);
    methodDef.setText("methodStub");
    try {
        check.visitToken(methodDef);
        Assert.fail("IllegalArgumentException should have been thrown!");
    }
    catch (IllegalArgumentException ex) {
        final String msg = ex.getMessage();
        Assert.assertEquals("Invalid exception message",
                "Unexpected token type: methodStub", msg);
    }
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testVersions() {
    final DetailAST ast = new DetailAST();

    final int[] validTypes = {
        TokenTypes.PACKAGE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ANNOTATION_DEF,
    };
    for (int type: validTypes) {
        ast.setType(type);
        assertTrue("Invalid ast type for current tag: " + ast.getType(),
                JavadocTagInfo.VERSION.isValidOn(ast));
    }

    ast.setType(TokenTypes.LAMBDA);
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.VERSION.isValidOn(ast));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testEmptyBlockCommentAst() {
    final DetailAST commentBegin = new DetailAST();
    commentBegin.setType(TokenTypes.BLOCK_COMMENT_BEGIN);
    commentBegin.setText("/*");

    final DetailAST commentContent = new DetailAST();
    commentContent.setType(TokenTypes.COMMENT_CONTENT);
    commentContent.setText("");

    final DetailAST commentEnd = new DetailAST();
    commentEnd.setType(TokenTypes.BLOCK_COMMENT_END);
    commentEnd.setText("*/");

    commentBegin.setFirstChild(commentContent);
    commentContent.setNextSibling(commentEnd);

    assertFalse("Should return false when empty block comment is passed",
            JavadocUtils.isJavadocComment(commentBegin));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testThrows() {
    final DetailAST ast = new DetailAST();

    final int[] validTypes = {
        TokenTypes.METHOD_DEF,
        TokenTypes.CTOR_DEF,
    };
    for (int type: validTypes) {
        ast.setType(type);
        assertTrue("Invalid ast type for current tag: " + ast.getType(),
                JavadocTagInfo.THROWS.isValidOn(ast));
    }

    ast.setType(TokenTypes.LAMBDA);
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.THROWS.isValidOn(ast));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testAuthor() {
    final DetailAST ast = new DetailAST();

    final int[] validTypes = {
        TokenTypes.PACKAGE_DEF,
        TokenTypes.CLASS_DEF,
        TokenTypes.INTERFACE_DEF,
        TokenTypes.ENUM_DEF,
        TokenTypes.ANNOTATION_DEF,
    };
    for (int type: validTypes) {
        ast.setType(type);
        assertTrue("Invalid ast type for current tag: " + ast.getType(),
                JavadocTagInfo.AUTHOR.isValidOn(ast));
    }

    ast.setType(TokenTypes.LAMBDA);
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.AUTHOR.isValidOn(ast));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testContainsAnnotation() {
    final DetailAST astForTest = new DetailAST();
    astForTest.setType(TokenTypes.PACKAGE_DEF);
    final DetailAST child = new DetailAST();
    final DetailAST annotations = new DetailAST();
    final DetailAST annotation = new DetailAST();
    final DetailAST annotationNameHolder = new DetailAST();
    final DetailAST annotationName = new DetailAST();
    annotations.setType(TokenTypes.ANNOTATIONS);
    annotation.setType(TokenTypes.ANNOTATION);
    annotationNameHolder.setType(TokenTypes.AT);
    annotationName.setText("Annotation");

    annotationNameHolder.setNextSibling(annotationName);
    annotation.setFirstChild(annotationNameHolder);
    annotations.setFirstChild(annotation);
    child.setNextSibling(annotations);
    astForTest.setFirstChild(child);

    assertTrue("Annotation should contain " + astForTest,
            AnnotationUtility.containsAnnotation(astForTest, "Annotation"));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testStatefulFieldsClearedOnBeginTree() throws Exception {
    final DetailAST ast = new DetailAST();
    ast.setType(TokenTypes.STATIC_INIT);
    final ExecutableStatementCountCheck check = new ExecutableStatementCountCheck();
    Assert.assertTrue("Stateful field is not cleared after beginTree",
            TestUtil.isStatefulFieldClearedDuringBeginTree(check, ast, "contextStack",
                new Predicate<Object>() {
                    @Override
                    public boolean test(Object contextStack) {
                        return ((Collection<Context>) contextStack).isEmpty();
                    }
                }));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testSerialField() {
    final DetailAST ast = new DetailAST();
    final DetailAST astChild = new DetailAST();
    astChild.setType(TokenTypes.TYPE);
    ast.setFirstChild(astChild);
    final DetailAST astChild2 = new DetailAST();
    astChild2.setType(TokenTypes.ARRAY_DECLARATOR);
    astChild2.setText("ObjectStreamField");
    astChild.setFirstChild(astChild2);

    final int[] validTypes = {
        TokenTypes.VARIABLE_DEF,
    };
    for (int type: validTypes) {
        ast.setType(type);
        assertTrue("Invalid ast type for current tag: " + ast.getType(),
                JavadocTagInfo.SERIAL_FIELD.isValidOn(ast));
    }

    astChild2.setText("1111");
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.SERIAL_FIELD.isValidOn(ast));

    astChild2.setType(TokenTypes.LITERAL_VOID);
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.SERIAL_FIELD.isValidOn(ast));

    ast.setType(TokenTypes.LAMBDA);
    assertFalse("Should return false when ast type is invalid for current tag",
            JavadocTagInfo.SERIAL_FIELD.isValidOn(ast));
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testImproperToken() {
    final DetailAST parent = new DetailAST();
    parent.setType(TokenTypes.STATIC_INIT);
    final DetailAST array = new DetailAST();
    array.setType(TokenTypes.ARRAY_INIT);
    parent.setFirstChild(array);

    final DeclarationOrderCheck check = new DeclarationOrderCheck();

    check.visitToken(array);
    final SortedSet<LocalizedMessage> messages = check.getMessages();

    assertEquals("No exception messages expected", 0, messages.size());
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testImproperToken() {
    final FinalClassCheck finalClassCheck = new FinalClassCheck();
    final DetailAST badAst = new DetailAST();
    final int unsupportedTokenByCheck = TokenTypes.EOF;
    badAst.setType(unsupportedTokenByCheck);
    try {
        finalClassCheck.visitToken(badAst);
        Assert.fail("IllegalStateException is expected");
    }
    catch (IllegalStateException ex) {
        // it is OK
    }
}
 

import com.puppycrawl.tools.checkstyle.api.DetailAST; //导入方法依赖的package包/类
@Test
public void testImproperToken() {
    final IllegalTypeCheck check = new IllegalTypeCheck();

    final DetailAST classDefAst = new DetailAST();
    classDefAst.setType(TokenTypes.CLASS_DEF);

    try {
        check.visitToken(classDefAst);
        Assert.fail("IllegalStateException is expected");
    }
    catch (IllegalStateException ex) {
        // it is OK
    }
}