Examples with IClassCoverage org.jacoco.core.analysis.IClassCoverage used on opensource projects

Example 1 with IClassCoverage

use of org.jacoco.core.analysis.IClassCoverage in project jacoco by jacoco.

the class BundleCoverageImplTest method testCounters.

@Test
public void testCounters() {
    Collection<IClassCoverage> classes = Collections.emptySet();
    Collection<ISourceFileCoverage> sourcefiles = Collections.emptySet();
    final IPackageCoverage p1 = new PackageCoverageImpl("p1", classes, sourcefiles) {

        {
            classCounter = CounterImpl.getInstance(1, 0);
            methodCounter = CounterImpl.getInstance(2, 0);
            branchCounter = CounterImpl.getInstance(3, 0);
            instructionCounter = CounterImpl.getInstance(4, 0);
            lineCounter = CounterImpl.getInstance(5, 0);
        }
    };
    final IPackageCoverage p2 = new PackageCoverageImpl("p1", classes, sourcefiles) {

        {
            classCounter = CounterImpl.getInstance(1, 0);
            methodCounter = CounterImpl.getInstance(2, 0);
            branchCounter = CounterImpl.getInstance(3, 0);
            instructionCounter = CounterImpl.getInstance(4, 0);
            lineCounter = CounterImpl.getInstance(5, 0);
        }
    };
    BundleCoverageImpl bundle = new BundleCoverageImpl("testbundle", Arrays.asList(p1, p2));
    assertEquals(CounterImpl.getInstance(2, 0), bundle.getClassCounter());
    assertEquals(CounterImpl.getInstance(4, 0), bundle.getMethodCounter());
    assertEquals(CounterImpl.getInstance(6, 0), bundle.getBranchCounter());
    assertEquals(CounterImpl.getInstance(8, 0), bundle.getInstructionCounter());
    assertEquals(CounterImpl.getInstance(10, 0), bundle.getLineCounter());
}

Example 2 with IClassCoverage

use of org.jacoco.core.analysis.IClassCoverage in project jacoco by jacoco.

the class BundleCoverageImplTest method testGroupByPackage.

@Test
public void testGroupByPackage() {
    ClassCoverageImpl ca = new ClassCoverageImpl("p1/A", 1, false);
    ca.setSourceFileName("A.java");
    ClassCoverageImpl cb = new ClassCoverageImpl("p2/B", 2, false);
    cb.setSourceFileName("B.java");
    ISourceFileCoverage sb = new SourceFileCoverageImpl("B.java", "p2");
    ISourceFileCoverage sc = new SourceFileCoverageImpl("C.java", "p3");
    BundleCoverageImpl bundle = new BundleCoverageImpl("bundle", Arrays.asList((IClassCoverage) ca, (IClassCoverage) cb), Arrays.asList(sb, sc));
    Collection<IPackageCoverage> packages = bundle.getPackages();
    assertEquals(3, packages.size(), 0.0);
    IPackageCoverage p1 = findPackage("p1", packages);
    assertNotNull(p1);
    assertEquals(Collections.singletonList(ca), p1.getClasses());
    assertTrue(p1.getSourceFiles().isEmpty());
    IPackageCoverage p2 = findPackage("p2", packages);
    assertNotNull(p2);
    assertEquals(Collections.singletonList(cb), p2.getClasses());
    assertEquals(Collections.singletonList(sb), p2.getSourceFiles());
    IPackageCoverage p3 = findPackage("p3", packages);
    assertNotNull(p3);
    assertTrue(p3.getClasses().isEmpty());
    assertEquals(Collections.singletonList(sc), p3.getSourceFiles());
}

Example 3 with IClassCoverage

use of org.jacoco.core.analysis.IClassCoverage in project jacoco by jacoco.

the class PackageCoverageTest method testCountersWithSources.

@Test
public void testCountersWithSources() {
    // Classes with source reference will not considered for counters:
    final ClassCoverageImpl classnode = new ClassCoverageImpl("org/jacoco/test/Sample", 0, false) {

        {
            classCounter = CounterImpl.getInstance(9, 0);
            methodCounter = CounterImpl.getInstance(9, 0);
            branchCounter = CounterImpl.getInstance(9, 0);
            instructionCounter = CounterImpl.getInstance(9, 0);
        }
    };
    classnode.setSourceFileName("Sample.java");
    // Only source files will be considered for counters:
    final ISourceFileCoverage sourceFile = new SourceFileCoverageImpl("Sample.java", "org/jacoco/test/Sample") {

        {
            classCounter = CounterImpl.getInstance(1, 0);
            methodCounter = CounterImpl.getInstance(2, 0);
            branchCounter = CounterImpl.getInstance(3, 0);
            instructionCounter = CounterImpl.getInstance(4, 0);
        }
    };
    PackageCoverageImpl data = new PackageCoverageImpl("org/jacoco/test", Collections.singleton((IClassCoverage) classnode), Collections.singleton(sourceFile));
    assertEquals(CounterImpl.getInstance(1, 0), data.getClassCounter());
    assertEquals(CounterImpl.getInstance(2, 0), data.getMethodCounter());
    assertEquals(CounterImpl.getInstance(3, 0), data.getBranchCounter());
    assertEquals(CounterImpl.getInstance(4, 0), data.getInstructionCounter());
}

Example 4 with IClassCoverage

use of org.jacoco.core.analysis.IClassCoverage in project jacoco by jacoco.

the class BundleCoverageImpl method groupByPackage.

private static Collection<IPackageCoverage> groupByPackage(final Collection<IClassCoverage> classes, final Collection<ISourceFileCoverage> sourcefiles) {
    final Map<String, Collection<IClassCoverage>> classesByPackage = new HashMap<String, Collection<IClassCoverage>>();
    for (final IClassCoverage c : classes) {
        addByName(classesByPackage, c.getPackageName(), c);
    }
    final Map<String, Collection<ISourceFileCoverage>> sourceFilesByPackage = new HashMap<String, Collection<ISourceFileCoverage>>();
    for (final ISourceFileCoverage s : sourcefiles) {
        addByName(sourceFilesByPackage, s.getPackageName(), s);
    }
    final Set<String> packageNames = new HashSet<String>();
    packageNames.addAll(classesByPackage.keySet());
    packageNames.addAll(sourceFilesByPackage.keySet());
    final Collection<IPackageCoverage> result = new ArrayList<IPackageCoverage>();
    for (final String name : packageNames) {
        Collection<IClassCoverage> c = classesByPackage.get(name);
        if (c == null) {
            c = Collections.emptyList();
        }
        Collection<ISourceFileCoverage> s = sourceFilesByPackage.get(name);
        if (s == null) {
            s = Collections.emptyList();
        }
        result.add(new PackageCoverageImpl(name, c, s));
    }
    return result;
}

Example 5 with IClassCoverage

use of org.jacoco.core.analysis.IClassCoverage in project jacoco by jacoco.

the class CoreTutorial method execute.

/**
 * Run this example.
 *
 * @throws Exception
 *             in case of errors
 */
public void execute() throws Exception {
    final String targetName = TestTarget.class.getName();
    // For instrumentation and runtime we need a IRuntime instance
    // to collect execution data:
    final IRuntime runtime = new LoggerRuntime();
    // The Instrumenter creates a modified version of our test target class
    // that contains additional probes for execution data recording:
    final Instrumenter instr = new Instrumenter(runtime);
    InputStream original = getTargetClass(targetName);
    final byte[] instrumented = instr.instrument(original, targetName);
    original.close();
    // Now we're ready to run our instrumented class and need to startup the
    // runtime first:
    final RuntimeData data = new RuntimeData();
    runtime.startup(data);
    // In this tutorial we use a special class loader to directly load the
    // instrumented class definition from a byte[] instances.
    final MemoryClassLoader memoryClassLoader = new MemoryClassLoader();
    memoryClassLoader.addDefinition(targetName, instrumented);
    final Class<?> targetClass = memoryClassLoader.loadClass(targetName);
    // Here we execute our test target class through its Runnable interface:
    final Runnable targetInstance = (Runnable) targetClass.newInstance();
    targetInstance.run();
    // At the end of test execution we collect execution data and shutdown
    // the runtime:
    final ExecutionDataStore executionData = new ExecutionDataStore();
    final SessionInfoStore sessionInfos = new SessionInfoStore();
    data.collect(executionData, sessionInfos, false);
    runtime.shutdown();
    // Together with the original class definition we can calculate coverage
    // information:
    final CoverageBuilder coverageBuilder = new CoverageBuilder();
    final Analyzer analyzer = new Analyzer(executionData, coverageBuilder);
    original = getTargetClass(targetName);
    analyzer.analyzeClass(original, targetName);
    original.close();
    // Let's dump some metrics and line coverage information:
    for (final IClassCoverage cc : coverageBuilder.getClasses()) {
        out.printf("Coverage of class %s%n", cc.getName());
        printCounter("instructions", cc.getInstructionCounter());
        printCounter("branches", cc.getBranchCounter());
        printCounter("lines", cc.getLineCounter());
        printCounter("methods", cc.getMethodCounter());
        printCounter("complexity", cc.getComplexityCounter());
        for (int i = cc.getFirstLine(); i <= cc.getLastLine(); i++) {
            out.printf("Line %s: %s%n", Integer.valueOf(i), getColor(cc.getLine(i).getStatus()));
        }
    }
}