private static DetailAST create(int tokenType) { final DetailAST ast = new DetailAST(); ast.setType(tokenType); return ast; }
private static DetailAST createToken(DetailAST root, int type) { final DetailAST result = new DetailAST(); result.setType(type); if (root != null) { root.addChild(result); } return result; }
@Test public void testContainsAnnotationTrue() { final DetailAST ast = new DetailAST(); ast.setType(1); final DetailAST ast2 = new DetailAST(); ast2.setType(TokenTypes.MODIFIERS); ast.addChild(ast2); final DetailAST ast3 = new DetailAST(); ast3.setType(TokenTypes.ANNOTATION); ast2.addChild(ast3); assertTrue("AnnotationUtil should contain " + ast, AnnotationUtil.containsAnnotation(ast)); }
@Override public void initialize(AST ast) { final DetailAST detailAst = (DetailAST) ast; setText(detailAst.getText()); setType(detailAst.getType()); lineNo = detailAst.getLineNo(); columnNo = detailAst.getColumnNo(); hiddenAfter = detailAst.getHiddenAfter(); hiddenBefore = detailAst.getHiddenBefore(); }
@Test public void testContainsAnnotationFalse2() { final DetailAST ast = new DetailAST(); ast.setType(1); final DetailAST ast2 = new DetailAST(); ast2.setType(TokenTypes.MODIFIERS); ast.addChild(ast2); assertFalse("AnnotationUtil should not contain " + ast, AnnotationUtil.containsAnnotation(ast)); }
@Test public void testGetAccessModifierFromModifiersTokenWrongTokenType() { final DetailAST modifiers = new DetailAST(); modifiers.setType(TokenTypes.METHOD_DEF); try { CheckUtil.getAccessModifierFromModifiersToken(modifiers); fail(IllegalArgumentException.class.getSimpleName() + " was expected."); } catch (IllegalArgumentException exc) { final String expectedExceptionMsg = "expected non-null AST-token with type 'MODIFIERS'"; final String actualExceptionMsg = exc.getMessage(); assertEquals("Invalid exception message", expectedExceptionMsg, actualExceptionMsg); } }
@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()); }
@Test @SuppressWarnings("unchecked") public void testStatefulFieldsClearedOnBeginTree2() throws Exception { final DetailAST ast = new DetailAST(); ast.setType(TokenTypes.LITERAL_RETURN); ast.setLineNo(5); final DetailAST child = new DetailAST(); child.setType(TokenTypes.SEMI); ast.addChild(child); final NPathComplexityCheck check = new NPathComplexityCheck(); Assert.assertTrue("Stateful field is not cleared after beginTree", TestUtil.isStatefulFieldClearedDuringBeginTree(check, ast, "isAfterValues", isAfterValues -> ((Collection<Context>) isAfterValues).isEmpty())); }
@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", contextStack -> ((Collection<Context>) contextStack).isEmpty())); }
@Test public void testContainsAnnotationFalse() { final DetailAST ast = new DetailAST(); ast.setType(1); assertFalse("AnnotationUtil should not contain " + ast, AnnotationUtil.containsAnnotation(ast)); }
@Test public void testException() { 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.EXCEPTION.isValidOn(ast)); } ast.setType(TokenTypes.LAMBDA); assertFalse("Should return false when ast type is invalid for current tag", JavadocTagInfo.EXCEPTION.isValidOn(ast)); }
@Test @SuppressWarnings("unchecked") public void testStatefulFieldsClearedOnBeginTree1() throws Exception { final DetailAST ast = new DetailAST(); ast.setType(TokenTypes.LITERAL_ELSE); final NPathComplexityCheck check = new NPathComplexityCheck(); Assert.assertTrue("Stateful field is not cleared after beginTree", TestUtil.isStatefulFieldClearedDuringBeginTree(check, ast, "rangeValues", rangeValues -> ((Collection<Context>) rangeValues).isEmpty())); Assert.assertTrue("Stateful field is not cleared after beginTree", TestUtil.isStatefulFieldClearedDuringBeginTree(check, ast, "expressionValues", expressionValues -> ((Collection<Context>) expressionValues).isEmpty())); }
@Test public void testContainsAnnotationListWithNoAnnotationNode() { final DetailAST ast = new DetailAST(); final DetailAST modifiersAst = new DetailAST(); modifiersAst.setType(TokenTypes.MODIFIERS); ast.addChild(modifiersAst); final List<String> annotations = Collections.singletonList("Override"); final boolean result = AnnotationUtil.containsAnnotation(ast, annotations); assertFalse("An empty ast should lead to a false result", result); }
@Test public void testAstWithoutChildren() { final SuppressWarningsHolder holder = new SuppressWarningsHolder(); final DetailAST methodDef = new DetailAST(); methodDef.setType(TokenTypes.METHOD_DEF); try { holder.visitToken(methodDef); fail("Exception expected"); } catch (IllegalArgumentException ex) { assertEquals("Error message is unexpected", "Identifier AST expected, but get null.", ex.getMessage()); } }
@Test public void testImproperToken() { final IllegalTypeCheck check = new IllegalTypeCheck(); final DetailAST classDefAst = new DetailAST(); classDefAst.setType(TokenTypes.DOT); try { check.visitToken(classDefAst); Assert.fail("IllegalStateException is expected"); } catch (IllegalStateException ex) { // it is OK } }
@Test public void testImproperToken() { final IllegalInstantiationCheck check = new IllegalInstantiationCheck(); final DetailAST lambdaAst = new DetailAST(); lambdaAst.setType(TokenTypes.LAMBDA); try { check.visitToken(lambdaAst); Assert.fail("IllegalArgumentException is expected"); } catch (IllegalArgumentException ex) { // it is OK } }
@Test public void testImproperToken() { final FinalLocalVariableCheck check = new FinalLocalVariableCheck(); final DetailAST lambdaAst = new DetailAST(); lambdaAst.setType(TokenTypes.LAMBDA); try { check.visitToken(lambdaAst); Assert.fail("IllegalStateException is expected"); } catch (IllegalStateException ex) { // it is OK } }
@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 } }
@Test public void testToString() { final DetailAST ast = new DetailAST(); ast.setType(TokenTypes.LITERAL_NEW); ast.setColumnNo(14); ast.setLineNo(15); ast.setText("MyTest"); final FullIdent indent = FullIdent.createFullIdent(ast); Assert.assertEquals("Invalid full indent", "MyTest[15x14]", indent.toString()); }