@Override public Collection<Measure> createMeasures() { return convert(delegate.createMeasures()); }
public CoverageMeasuresBuilder convert() { CoverageMeasuresBuilder result = CoverageMeasuresBuilder.create(); for (Map.Entry<Integer, Integer> e : hits.entrySet()) { result.setHits(e.getKey(), e.getValue()); } for (Map.Entry<Integer, Map<String, Integer>> e : branches.entrySet()) { int conditions = e.getValue().size(); int covered = 0; for (Integer taken : e.getValue().values()) { if (taken > 0) { covered++; } } result.setConditions(e.getKey(), conditions, covered); } return result; } }
private List<Integer> getCoveredLines(CoverageMeasuresBuilder builder) { List<Integer> linesCover = newArrayList(); for (Map.Entry<Integer, Integer> hitsByLine : builder.getHitsByLine().entrySet()) { if (hitsByLine.getValue() > 0) { linesCover.add(hitsByLine.getKey()); } } return linesCover; }
@VisibleForTesting void analyze(SensorContext context, FileProvider fileProvider, Coverage coverage) { coverageAggregator.aggregate(wildcardPatternFileProvider, coverage); CoverageMeasuresBuilder coverageMeasureBuilder = CoverageMeasuresBuilder.create(); for (String filePath : coverage.files()) { org.sonar.api.resources.File sonarFile = fileProvider.fromPath(filePath); if (sonarFile != null) { if (coverageConf.languageKey().equals(sonarFile.getLanguage().getKey())) { coverageMeasureBuilder.reset(); for (Map.Entry<Integer, Integer> entry : coverage.hits(filePath).entrySet()) { coverageMeasureBuilder.setHits(entry.getKey(), entry.getValue()); } for (Measure measure : coverageMeasureBuilder.createMeasures()) { context.saveMeasure(sonarFile, measure); } } } else { LOG.debug("Code coverage will not be imported for the following file outside of SonarQube: " + filePath); } } }
private void saveHitsData(Resource resource, SMInputCursor lineCursor) throws ParseException, XMLStreamException { fileMeasuresBuilder.reset(); while (lineCursor.getNext() != null) { // skip class elements on format 2_3_2 if (isClass(lineCursor)) { continue; } final int lineId = Integer.parseInt(lineCursor.getAttrValue("num")); String count = lineCursor.getAttrValue("count"); if (StringUtils.isNotBlank(count)) { fileMeasuresBuilder.setHits(lineId, Integer.parseInt(count)); } else { int trueCount = (int) ParsingUtils.parseNumber(lineCursor.getAttrValue("truecount")); int falseCount = (int) ParsingUtils.parseNumber(lineCursor.getAttrValue("falsecount")); int coveredConditions = 0; if (trueCount > 0) { coveredConditions++; } if (falseCount > 0) { coveredConditions++; } fileMeasuresBuilder.setConditions(lineId, 2, coveredConditions); } } if (resource != null) { for (Measure measure : fileMeasuresBuilder.createMeasures()) { context.saveMeasure(resource, measure); } } }
private void recordCoverageFor(final SMInputCursor line, final CoverageMeasuresBuilder builder) throws XMLStreamException { final int lineId = Integer.parseInt(line.getAttrValue("number")); final int noHits = (int) Math.min( Long.parseLong(line.getAttrValue("hits")), Integer.MAX_VALUE); final String isBranch = line.getAttrValue("branch"); final String conditionText = line.getAttrValue("condition-coverage"); builder.setHits(lineId, noHits); if (StringUtils.equals(isBranch, "true") && StringUtils.isNotBlank(conditionText)) { final String[] conditions = StringUtils.split( StringUtils.substringBetween(conditionText, "(", ")"), "/"); builder.setConditions(lineId, Integer.parseInt(conditions[1]), Integer.parseInt(conditions[0])); } }
@Override public CoverageMeasureBuilder setHits(int lineId, int hits) { delegate.setHits(lineId, hits); return this; }
public DelegateAndConvertMeasureBuilder() { this.delegate = CoverageMeasuresBuilder.create(); }
@Override public CoverageMeasureBuilder setConditions(int lineId, int conditions, int coveredConditions) { delegate.setConditions(lineId, conditions, coveredConditions); return this; }
@Override public CoverageMeasureBuilder reset() { delegate.reset(); return this; }
private CoverageMeasuresBuilder builderFor(final SMInputCursor clazz) throws XMLStreamException { final String fileName = clazz.getAttrValue("filename"); CoverageMeasuresBuilder builder = measuresForReport.get(fileName); if (builder == null) { builder = CoverageMeasuresBuilder.create(); measuresForReport.put(fileName, builder); } return builder; } }
private static CoverageMeasuresBuilder analyzeFile(Resource resource, ISourceFileCoverage coverage) { CoverageMeasuresBuilder builder = CoverageMeasuresBuilder.create(); for (int lineId = coverage.getFirstLine(); lineId <= coverage.getLastLine(); lineId++) { final int hits; ILine line = coverage.getLine(lineId); switch (line.getInstructionCounter().getStatus()) { case ICounter.FULLY_COVERED: case ICounter.PARTLY_COVERED: hits = 1; break; case ICounter.NOT_COVERED: hits = 0; break; case ICounter.EMPTY: continue; default: JaCoCoScalaExtensions.LOG.warn("Unknown status for line {} in {}", lineId, resource); continue; } builder.setHits(lineId, hits); ICounter branchCounter = line.getBranchCounter(); int conditions = branchCounter.getTotalCount(); if (conditions > 0) { int coveredConditions = branchCounter.getCoveredCount(); builder.setConditions(lineId, conditions, coveredConditions); } } return builder; }
private void saveMeasures(final CoverageMeasuresBuilder measureBuilder, final org.sonar.api.resources.File objcfile) { for (final Measure measure : measureBuilder.createMeasures()) { LoggerFactory.getLogger(getClass()).debug("Measure {}", measure.getMetric().getName()); context.saveMeasure(objcfile, measure); } }
private List<Integer> getCoveredLines(CoverageMeasuresBuilder builder) { List<Integer> linesCover = newArrayList(); for (Map.Entry<Integer, Integer> hitsByLine : builder.getHitsByLine().entrySet()) { if (hitsByLine.getValue() > 0) { linesCover.add(hitsByLine.getKey()); } } return linesCover; }
private CoverageMeasuresBuilder analyzeFile(Resource resource, ISourceFileCoverage coverage) { CoverageMeasuresBuilder builder = CoverageMeasuresBuilder.create(); for (int lineId = coverage.getFirstLine(); lineId <= coverage.getLastLine(); lineId++) { final int hits; ILine line = coverage.getLine(lineId); switch (line.getInstructionCounter().getStatus()) { case ICounter.FULLY_COVERED: case ICounter.PARTLY_COVERED: hits = 1; break; case ICounter.NOT_COVERED: hits = 0; break; case ICounter.EMPTY: continue; default: JaCoCoUtils.LOG.warn("Unknown status for line {} in {}", lineId, resource); continue; } builder.setHits(lineId, hits); ICounter branchCounter = line.getBranchCounter(); int conditions = branchCounter.getTotalCount(); if (conditions > 0) { int coveredConditions = branchCounter.getCoveredCount(); builder.setConditions(lineId, conditions, coveredConditions); } } return builder; }
for (Measure measure : fileCoverage.createMeasures()) { context.saveMeasure(resource, measure);
private static List<Integer> getCoveredLines(CoverageMeasuresBuilder builder) { List<Integer> linesCover = newArrayList(); for (Map.Entry<Integer, Integer> hitsByLine : builder.getHitsByLine().entrySet()) { if (hitsByLine.getValue() > 0) { linesCover.add(hitsByLine.getKey()); } } return linesCover; }
private CoverageMeasuresBuilder analyzeFile(Resource resource, ISourceFileCoverage coverage) { CoverageMeasuresBuilder builder = CoverageMeasuresBuilder.create(); for (int lineId = coverage.getFirstLine(); lineId <= coverage.getLastLine(); lineId++) { final int hits; ILine line = coverage.getLine(lineId); switch (line.getInstructionCounter().getStatus()) { case ICounter.FULLY_COVERED: case ICounter.PARTLY_COVERED: hits = 1; break; case ICounter.NOT_COVERED: hits = 0; break; case ICounter.EMPTY: continue; default: JaCoCoExtensions.LOG.warn("Unknown status for line {} in {}", lineId, resource); continue; } builder.setHits(lineId, hits); ICounter branchCounter = line.getBranchCounter(); int conditions = branchCounter.getTotalCount(); if (conditions > 0) { int coveredConditions = branchCounter.getCoveredCount(); builder.setConditions(lineId, conditions, coveredConditions); } } return builder; }
protected void saveMeasureFromLCOVFile(SensorContext context) { String providedPath = settings.getString(JavaScriptPlugin.LCOV_REPORT_PATH); File lcovFile = getIOFile(fileSystem.baseDir(), providedPath); ... LOG.info("Analysing {}", lcovFile); LCOVParser parser = new LCOVParser(fileSystem.baseDir()); Map<String, CoverageMeasuresBuilder> coveredFiles = parser.parseFile(lcovFile); for (InputFile inputFile : fileSystem.inputFiles(mainFilePredicate)) { try { CoverageMeasuresBuilder fileCoverage = coveredFiles.get(inputFile.file().getAbsolutePath()); org.sonar.api.resources.File resource = org.sonar.api.resources.File.create(inputFile.relativePath()); if (fileCoverage != null) { for (Measure measure : fileCoverage.createMeasures()) { context.saveMeasure(resource, measure); } } else { // colour all lines as not executed LOG.debug("Default value of zero will be saved for file: {}", resource.getPath()); LOG.debug("Because: either was not present in LCOV report either was not able to retrieve associated SonarQube resource"); saveZeroValueForResource(resource, context); } } catch (Exception e) { LOG.error("Problem while calculating coverage for " + inputFile.absolutePath(), e); } } }
if (resource != null) { CoverageMeasuresBuilder builder = analyzeFile(resource, coverage); saveMeasures(context, resource, builder.createMeasures()); analyzedResources++;