Examples with Instruction org.jacoco.core.internal.flow.Instruction used on opensource projects

Example 1 with Instruction

use of org.jacoco.core.internal.flow.Instruction in project jacoco by jacoco.

the class MethodAnalyzer method visitEnd.

@Override
public void visitEnd() {
    // Wire jumps:
    for (final Jump j : jumps) {
        LabelInfo.getInstruction(j.target).setPredecessor(j.source, j.branch);
    }
    // Propagate probe values:
    for (final CoveredProbe p : coveredProbes) {
        p.instruction.setCovered(p.branch);
    }
    // Merge:
    for (final Instruction i : instructions) {
        final AbstractInsnNode m = i.getNode();
        final AbstractInsnNode r = findRepresentative(m);
        if (r != m) {
            ignored.add(m);
            nodeToInstruction.get(r).merge(i);
        }
    }
    // Report result:
    coverage.ensureCapacity(firstLine, lastLine);
    for (final Instruction i : instructions) {
        if (ignored.contains(i.getNode())) {
            continue;
        }
        final int total = i.getBranches();
        final int covered = i.getCoveredBranches();
        final ICounter instrCounter = covered == 0 ? CounterImpl.COUNTER_1_0 : CounterImpl.COUNTER_0_1;
        final ICounter branchCounter = total > 1 ? CounterImpl.getInstance(total - covered, covered) : CounterImpl.COUNTER_0_0;
        coverage.increment(instrCounter, branchCounter, i.getLine());
    }
    coverage.incrementMethodCounter();
}

Example 2 with Instruction

use of org.jacoco.core.internal.flow.Instruction in project jacoco by jacoco.

the class MethodAnalyzer method visitInsn.

private void visitInsn() {
    final Instruction insn = new Instruction(currentNode, currentLine);
    nodeToInstruction.put(currentNode, insn);
    instructions.add(insn);
    if (lastInsn != null) {
        insn.setPredecessor(lastInsn, 0);
    }
    final int labelCount = currentLabel.size();
    if (labelCount > 0) {
        for (int i = labelCount; --i >= 0; ) {
            LabelInfo.setInstruction(currentLabel.get(i), insn);
        }
        currentLabel.clear();
    }
    lastInsn = insn;
}

Example 3 with Instruction

use of org.jacoco.core.internal.flow.Instruction in project bazel by bazelbuild.

the class MethodProbesMapper method visitEnd.

/** Finishing the method */
@Override
public void visitEnd() {
    for (Jump jump : jumps) {
        Instruction insn = labelToInsn.get(jump.target);
        insn.setPredecessor(jump.source);
        predecessors.put(insn, jump.source);
    }
    // Compute CovExp for every instruction.
    for (Map.Entry<Integer, Instruction> entry : probeToInsn.entrySet()) {
        int probeId = entry.getKey();
        Instruction ins = entry.getValue();
        Instruction insn = ins;
        CovExp exp = new ProbeExp(probeId);
        // Compute CovExp for the probed instruction.
        CovExp existingExp = insnToCovExp.get(insn);
        if (existingExp != null) {
            // a new branch.
            if (existingExp instanceof BranchExp) {
                BranchExp branchExp = (BranchExp) existingExp;
                branchExp.add(exp);
            } else {
            // This can only happen if the internal data is inconsistent.
            // The instruction is a predecessor of another instruction and also
            // has a probe, but the branch count is not > 1.
            }
        } else {
            if (insn.getBranches() > 1) {
                exp = new BranchExp(exp);
            }
            insnToCovExp.put(insn, exp);
        }
        Instruction predecessor = predecessors.get(insn);
        while (predecessor != null) {
            if (predecessor.getBranches() > 1) {
                boolean isNewBranch = updateBranchPredecessor(predecessor, insn, exp);
                if (!isNewBranch) {
                    // If the branch already exists, no need to visit predecessors any more.
                    break;
                }
            } else {
                // No branch at predecessor, use the same CovExp
                insnToCovExp.put(predecessor, exp);
            }
            insn = predecessor;
            exp = insnToCovExp.get(predecessor);
            predecessor = predecessors.get(insn);
        }
    }
    // Merge branches in the instructions on the same line
    for (Instruction insn : instructions) {
        if (insn.getBranches() > 1) {
            CovExp insnExp = insnToCovExp.get(insn);
            if (insnExp != null && (insnExp instanceof BranchExp)) {
                BranchExp exp = (BranchExp) insnExp;
                BranchExp lineExp = lineToBranchExp.get(insn.getLine());
                if (lineExp == null) {
                    lineToBranchExp.put(insn.getLine(), exp);
                } else {
                    lineExp.merge(exp);
                }
            } else {
            // If we reach here, the internal data of the mapping is inconsistent, either
            // 1) An instruction has branches but we do not create BranchExp for it.
            // 2) An instruction has branches but it does not have an associated CovExp.
            }
        }
    }
}

Example 4 with Instruction

use of org.jacoco.core.internal.flow.Instruction in project bazel by bazelbuild.

the class MethodProbesMapper method visitInsn.

/** Visitor method to append a new Instruction */
private void visitInsn() {
    Instruction instruction = new Instruction(currentLine);
    instructions.add(instruction);
    if (lastInstruction != null) {
        // Update branch of lastInstruction
        instruction.setPredecessor(lastInstruction);
        // Update local cache
        predecessors.put(instruction, lastInstruction);
    }
    for (Label label : currentLabels) {
        labelToInsn.put(label, instruction);
    }
    // Update states
    currentLabels.clear();
    lastInstruction = instruction;
}