@Override public List<? extends StructureItem> scan(ParserResult info) { GroovyParserResult result = ASTUtils.getParseResult(info); AnalysisResult ar = result.getStructure(); List<? extends ASTElement> elements = ar.getElements(); List<StructureItem> itemList = new ArrayList<StructureItem>(elements.size()); for (ASTElement e : elements) { if (isVisible(e)) { itemList.add(new GroovyStructureItem(e, info)); } } return itemList; }
@Override public AnalysisResult analyse(TestSuiteResult originalResults) { // Get normal results AnalysisResult result = new AnalysisResult(); // Build map of changed tables this.changedTableMap = new HashMap<>(); executor = Executors.newFixedThreadPool(4); for (int id = 0; id < mutants.size(); id++) { Mutant<Schema> mutant = mutants.get(id); executor.submit(new ChangedTableTask(changedTableMap, id, mutant)); } executor.shutdown(); try { executor.awaitTermination(1, TimeUnit.DAYS); } catch (InterruptedException ex) { throw new RuntimeException(ex); } // Build the meta-mutant schema and SQL statements Schema metamutant = MutationAnalysisUtils.mergeMutantsParallel(schema, mutants); createStmts = sqlWriter.writeCreateTableStatements(metamutant); dropStmts = sqlWriter.writeDropTableStatements(metamutant, true); deleteStmts = sqlWriter.writeDeleteFromTableStatements(metamutant); // Build map of results this.resultMap = new HashMap<>(); for (int i = 0; i < mutants.size(); i++) { resultMap.put(i, new TestSuiteResult()); } // Execute test suite executeDropStmts(databaseInteractor); executeCreateStmts(databaseInteractor); for (TestCase testCase : testSuite.getTestCases()) { executeDeleteStmts(databaseInteractor); TestCaseResult normalTestResult = null; Map<Integer, TestCaseResult> failedMutants = new HashMap<>(); Data data = testCase.getState(); normalTestResult = executeInserts(data, normalTestResult, failedMutants, testCase); data = testCase.getData(); normalTestResult = executeInserts(data, normalTestResult, failedMutants, testCase); if (normalTestResult == null) { for (int i = 0; i < mutants.size(); i++) { if (!failedMutants.containsKey(i)) { resultMap.get(i).add(testCase, TestCaseResult.SuccessfulTestCaseResult); } } } } // Build the TestSuiteResult objects for (int i = 0; i < mutants.size(); i++) { TestSuiteResult mutantResult = resultMap.get(i); if (!originalResults.equals(mutantResult)) { result.addKilled(mutants.get(i)); } else { result.addLive(mutants.get(i)); } } executeDropStmts(databaseInteractor); return result; }
@Override public Map<String, List<OffsetRange>> folds(ParserResult info) { ASTNode root = ASTUtils.getRoot(info); if (root == null) { return Collections.emptyMap(); } GroovyParserResult rpr = ASTUtils.getParseResult(info); AnalysisResult analysisResult = rpr.getStructure(); Map<String, List<OffsetRange>> folds = new HashMap<String, List<OffsetRange>>(); List<OffsetRange> codefolds = new ArrayList<OffsetRange>(); folds.put("codeblocks", codefolds); // NOI18N final BaseDocument doc = LexUtilities.getDocument(rpr, false); if (doc == null) { return Collections.emptyMap(); } final OffsetRange[] importsRange = new OffsetRange[1]; final List<OffsetRange> commentsRanges = new ArrayList<OffsetRange>(); doc.render( new Runnable() { @Override public void run() { TokenSequence<?> ts = LexUtilities.getGroovyTokenSequence(doc, 1); int importStart = 0; int importEnd = 0; boolean startSet = false; while (ts != null && ts.isValid() && ts.moveNext()) { Token t = ts.token(); if (t.id() == GroovyTokenId.LITERAL_import) { int offset = ts.offset(); if (!startSet) { importStart = offset; startSet = true; } importEnd = offset; } else if (t.id() == GroovyTokenId.BLOCK_COMMENT) { // does this Block comment (GSF_BLOCK_COMMENT) span // multiple lines? E.g. includes \n ? StringBuffer sb = new StringBuffer(t.text()); if (sb.indexOf("\n") != -1) { int offset = ts.offset(); commentsRanges.add(new OffsetRange(offset, offset + t.length())); } } } try { importEnd = Utilities.getRowEnd(doc, importEnd); importsRange[0] = new OffsetRange(importStart, importEnd); } catch (BadLocationException ble) { Exceptions.printStackTrace(ble); } } }); if (!commentsRanges.isEmpty()) { folds.put("comments", commentsRanges); // NOI18N } try { if (importsRange[0] != null && Utilities.getRowCount(doc, importsRange[0].getStart(), importsRange[0].getEnd()) > 1) { folds.put("imports", Collections.singletonList(importsRange[0])); // NOI18N } addFolds(doc, analysisResult.getElements(), folds, codefolds); } catch (BadLocationException ex) { Exceptions.printStackTrace(ex); } return folds; }
private AnalysisResult scan(GroovyParserResult result) { AnalysisResult analysisResult = new AnalysisResult(); ASTNode root = ASTUtils.getRoot(result); if (root == null) { return analysisResult; } structure = new ArrayList<ASTElement>(); fields = new HashMap<ASTClass, Set<FieldNode>>(); methods = new ArrayList<ASTMethod>(); properties = new HashMap<ASTClass, Set<PropertyNode>>(); AstPath path = new AstPath(); path.descend(root); // TODO: I should pass in a "default" context here to stash methods etc. outside of modules and // classes scan(result, root, path, null, null, null); path.ascend(); // Process fields Map<String, FieldNode> names = new HashMap<String, FieldNode>(); for (ASTClass clz : fields.keySet()) { Set<FieldNode> assignments = fields.get(clz); // Find unique variables if (assignments != null) { for (FieldNode assignment : assignments) { names.put(assignment.getName(), assignment); } // Add unique fields for (FieldNode field : names.values()) { ASTField co = new ASTField(result, field); // co.setIn(AstUtilities.getClassOrModuleName(clz)); co.setIn(clz.getFqn()); // Make sure I don't already have an entry for this field as an // attr_accessor or writer String fieldName = field.getName(); boolean found = false; Set<PropertyNode> nodes = properties.get(clz); if (nodes != null) { for (PropertyNode node : nodes) { if (fieldName.equals(node.getName())) { found = true; break; } } } if (found) { co.setProperty(true); } clz.addChild(co); } names.clear(); } } analysisResult.setElements(structure); return analysisResult; }