/*
* @Test public void testSearchedCaseStmtHasCorrectTypes()
* { List<ASTStatement> statements = getOrderedNodes(ASTStatement.class,
* TEST7); List<ASTExpression> expressions =
* getOrderedNodes(ASTExpression.class, TEST7);
*
* ASTStatement st = statements.get(0); ASTStatement st1 =
* statements.get(1); ASTStatement st2 = statements.get(2); ASTStatement st3
* = statements.get(3);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-st(0)="+st.
* getBeginLine());
*
* ASTExpression ex = expressions.get(0); ASTExpression ex1 =
* expressions.get(1); ASTExpression ex2 = expressions.get(2); ASTExpression
* ex3 = expressions.get(3); ASTExpression ex4 = expressions.get(4);
* System.err.println("ASTExpression="+ex );
*
* DataFlowNode dfn = null; //dfn = ex.getDataFlowNode().getFlow().get(0);
* //dfn = st.getDataFlowNode().getFlow().get(0); dfn = (DataFlowNode)
* st.getDataFlowNode(); System.err.println("DataFlowNode(st-0)="+dfn ) ;
* System.err.println("DataFlowNode(st-1)="+st1.getDataFlowNode() ) ;
* System.err.println("DataFlowNode(st-2)="+st2.getDataFlowNode() ) ;
* System.err.println("DataFlowNode(st-3)="+st3.getDataFlowNode() ) ;
*
* System.err.println("DataFlowNode(ex-0)="+ex.getDataFlowNode() ) ;
* System.err.println("DataFlowNode(ex-1)="+ex1.getDataFlowNode() ) ;
* System.err.println("DataFlowNode(ex-2)="+ex2.getDataFlowNode() ) ;
* System.err.println("DataFlowNode(ex-3)="+ex3.getDataFlowNode() ) ;
* System.err.println("DataFlowNode(ex-4)="+ex4.getDataFlowNode() ) ;
* List<DataFlowNode> dfns = dfn.getFlow();
* System.err.println("DataFlowNodes List size="+dfns.size()) ; DataFlowNode
* firstDfn = dfns.get(0); System.err.println("firstDataFlowNode="+firstDfn
* ) ;
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(0)="+dfn);
* dfn = st.getDataFlowNode().getFlow().get(1);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(1)="+dfn);
* dfn = st.getDataFlowNode().getFlow().get(2);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(2)="+dfn);
* assertTrue(dfn.isType(NodeType.SWITCH_START)); dfn =
* st.getDataFlowNode().getFlow().get(3);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(3)="+dfn);
* assertTrue(dfn.isType(NodeType.CASE_LAST_STATEMENT)); //dfn =
* st.getDataFlowNode().getFlow().get(4);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(5)="+dfn);
* assertTrue(dfn.isType(NodeType.CASE_LAST_STATEMENT)); dfn =
* st.getDataFlowNode().getFlow().get(5);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(7)="+dfn);
* assertTrue(dfn.isType(NodeType.SWITCH_LAST_DEFAULT_STATEMENT)); dfn =
* st.getDataFlowNode().getFlow().get(6);
* System.err.println("testSearchedCaseStmtHasCorrectTypes-dfn(8)="+dfn);
* assertTrue(dfn.isType(NodeType.SWITCH_END)); }
*/
@Test
public void testLabelledStmtHasCorrectTypes() {
ASTExpression exp = getOrderedNodes(ASTExpression.class, TEST8).get(0);
DataFlowNode dfn = exp.getDataFlowNode().getFlow().get(2);
assertEquals(3, dfn.getLine());
assertTrue(dfn.isType(NodeType.LABEL_STATEMENT));
}
/**
* Calculate the boolean complexity of the given expression. NPath boolean complexity is the sum
* of && and || tokens. This is calculated by summing the number of children of the &&'s (minus
* one) and the children of the ||'s (minus one).
*
* <p>Note that this calculation applies to Cyclomatic Complexity as well.
*
* @param expr control structure expression
* @return complexity of the boolean expression
*/
public static int sumExpressionComplexity(ASTExpression expr) {
LOGGER.entering(CLASS_NAME, "visit(ASTExpression)");
if (expr == null) {
LOGGER.exiting(CLASS_NAME, "visit(ASTExpression)", 0);
return 0;
}
List<ASTConditionalAndExpression> andNodes =
expr.findDescendantsOfType(ASTConditionalAndExpression.class);
List<ASTConditionalOrExpression> orNodes =
expr.findDescendantsOfType(ASTConditionalOrExpression.class);
int children = 0;
for (ASTConditionalOrExpression element : orNodes) {
children += element.jjtGetNumChildren();
children--;
}
for (ASTConditionalAndExpression element : andNodes) {
children += element.jjtGetNumChildren();
children--;
}
LOGGER.exiting(CLASS_NAME, "visit(ASTExpression)", children);
return children;
}
@Test
public void testWhileStmtHasCorrectTypes() {
ASTExpression exp = getOrderedNodes(ASTExpression.class, TEST4).get(0);
DataFlowNode dfn = exp.getDataFlowNode().getFlow().get(2);
assertTrue(dfn.isType(NodeType.WHILE_EXPR));
dfn = exp.getDataFlowNode().getFlow().get(3);
assertTrue(dfn.isType(NodeType.WHILE_LAST_STATEMENT));
}
@Test
public void testIfStmtHasCorrectTypes() {
ASTExpression exp = getOrderedNodes(ASTExpression.class, TEST3).get(0);
assertEquals(5, exp.getDataFlowNode().getFlow().size());
DataFlowNode dfn = exp.getDataFlowNode().getFlow().get(2);
assertTrue(dfn.isType(NodeType.IF_EXPR));
assertEquals(3, dfn.getLine());
dfn = exp.getDataFlowNode().getFlow().get(3);
assertTrue(dfn.isType(NodeType.IF_LAST_STATEMENT_WITHOUT_ELSE));
assertEquals(3, dfn.getLine());
}
/**
* Java ASTStatementExpression equivalent is inferred as an Expression() which has an
* UnlabelledStatement as a parent.
*/
@Test
public void testExpressionParentChildLinks() {
ASTExpression ex = getOrderedNodes(ASTExpression.class, TEST1).get(0);
DataFlowNode dfn = ex.getDataFlowNode();
assertEquals(3, dfn.getLine());
assertTrue(dfn.getNode() instanceof ASTExpression);
List<DataFlowNode> dfns = dfn.getParents();
assertEquals(1, dfns.size());
DataFlowNode parentDfn = dfns.get(0);
assertEquals(2, parentDfn.getLine());
assertTrue(parentDfn.getNode() instanceof ASTProgramUnit);
ASTProgramUnit exParent = (ASTProgramUnit) parentDfn.getNode();
// Validate the two-way link between Program Unit and Statement
assertEquals(ex, exParent.getDataFlowNode().getChildren().get(0).getNode());
assertEquals(exParent, ex.getDataFlowNode().getParents().get(0).getNode());
}
@Test
public void testForStmtHasCorrectTypes() {
ASTExpression exp = getOrderedNodes(ASTExpression.class, TEST5).get(0);
DataFlowNode dfn = null;
dfn = exp.getDataFlowNode().getFlow().get(0);
assertTrue(dfn instanceof StartOrEndDataFlowNode);
dfn = exp.getDataFlowNode().getFlow().get(1);
assertTrue(dfn.getNode() instanceof ASTProgramUnit);
assertEquals(2, dfn.getLine());
dfn = exp.getDataFlowNode().getFlow().get(2);
assertEquals(3, dfn.getLine());
assertTrue(dfn.isType(NodeType.FOR_EXPR));
assertTrue(dfn.isType(NodeType.FOR_BEFORE_FIRST_STATEMENT));
dfn = exp.getDataFlowNode().getFlow().get(3);
assertEquals(3, dfn.getLine());
assertTrue(dfn.isType(NodeType.FOR_END));
}
@Test
public void testSimpleCaseStmtHasCorrectTypes() {
ASTExpression exp = getOrderedNodes(ASTExpression.class, TEST6).get(0);
DataFlowNode dfn = null;
dfn = exp.getDataFlowNode().getFlow().get(0);
assertTrue(dfn instanceof StartOrEndDataFlowNode);
dfn = exp.getDataFlowNode().getFlow().get(1);
assertEquals(2, dfn.getLine());
assertTrue(dfn.getNode() instanceof ASTProgramUnit);
dfn = exp.getDataFlowNode().getFlow().get(2);
assertEquals(4, dfn.getLine());
assertTrue(dfn.isType(NodeType.SWITCH_START));
assertTrue(dfn.isType(NodeType.CASE_LAST_STATEMENT));
dfn = exp.getDataFlowNode().getFlow().get(3);
assertEquals(5, dfn.getLine());
assertTrue(dfn.isType(NodeType.CASE_LAST_STATEMENT));
assertTrue(dfn.isType(NodeType.BREAK_STATEMENT));
dfn = exp.getDataFlowNode().getFlow().get(4);
assertEquals(6, dfn.getLine());
assertTrue(dfn.isType(NodeType.SWITCH_LAST_DEFAULT_STATEMENT));
assertTrue(dfn.isType(NodeType.BREAK_STATEMENT));
dfn = exp.getDataFlowNode().getFlow().get(5);
assertEquals(7, dfn.getLine());
assertTrue(dfn.isType(NodeType.SWITCH_END));
}
