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