Example usage for org.objectweb.asm Opcodes IFEQ

Introduction

In this page you can find the example usage for org.objectweb.asm Opcodes IFEQ.

Prototype

int IFEQ

To view the source code for org.objectweb.asm Opcodes IFEQ.

Click Source Link

Usage

From source file:org.evosuite.instrumentation.testability.transformer.BooleanIfTransformer.java

License:Open Source License

@Override
protected AbstractInsnNode transformJumpInsnNode(MethodNode mn, JumpInsnNode jumpNode) {
    if (jumpNode.getOpcode() == Opcodes.IFNE) {
        if (this.booleanTestabilityTransformation.isBooleanOnStack(mn, jumpNode, 0)) {
            TransformationStatistics.transformedBooleanComparison();
            BooleanTestabilityTransformation.logger.info("Changing IFNE");
            jumpNode.setOpcode(Opcodes.IFGT);
        } else {/* ww  w  .j a  v  a  2s .  c  o m*/
            BooleanTestabilityTransformation.logger.info("Not changing IFNE");
            int insnPosition = mn.instructions.indexOf(jumpNode);
            Frame frame = this.booleanTestabilityTransformation.currentFrames[insnPosition];
            AbstractInsnNode insn = mn.instructions.get(insnPosition - 1);
            BooleanTestabilityTransformation.logger.info("Current node: " + mn.instructions.get(insnPosition));
            BooleanTestabilityTransformation.logger.info("Previous node: " + insn);
            if (insn instanceof MethodInsnNode) {
                MethodInsnNode mi = (MethodInsnNode) insn;
                if (Type.getReturnType(DescriptorMapping.getInstance().getMethodDesc(mi.owner, mi.name,
                        mi.desc)) == Type.BOOLEAN_TYPE) {
                    BooleanTestabilityTransformation.logger.info("Changing IFNE");
                    jumpNode.setOpcode(Opcodes.IFGT);
                }
                BooleanTestabilityTransformation.logger.info("Method: " + mi.name);
            }
            BooleanTestabilityTransformation.logger.info("Stack size: " + frame.getStackSize());

            //logger.info("Top of stack: " + frame.getStack(0));
            for (int i = 0; i < frame.getStackSize(); i++) {
                BooleanTestabilityTransformation.logger.info(i + " Stack: " + frame.getStack(i));
            }
        }
    } else if (jumpNode.getOpcode() == Opcodes.IFEQ) {
        if (this.booleanTestabilityTransformation.isBooleanOnStack(mn, jumpNode, 0)) {
            TransformationStatistics.transformedBooleanComparison();
            BooleanTestabilityTransformation.logger.info("Changing IFEQ");
            jumpNode.setOpcode(Opcodes.IFLE);
        } else {
            BooleanTestabilityTransformation.logger.info("Not changing IFEQ");
            int insnPosition = mn.instructions.indexOf(jumpNode);
            Frame frame = this.booleanTestabilityTransformation.currentFrames[insnPosition];
            AbstractInsnNode insn = mn.instructions.get(insnPosition - 1);
            BooleanTestabilityTransformation.logger.info("Previous node: " + insn);
            if (insn instanceof MethodInsnNode) {
                MethodInsnNode mi = (MethodInsnNode) insn;
                BooleanTestabilityTransformation.logger.info("Method: " + mi.name);
                if (Type.getReturnType(BooleanTestabilityTransformation.getOriginalDesc(mi.owner, mi.name,
                        mi.desc)) == Type.BOOLEAN_TYPE) {
                    BooleanTestabilityTransformation.logger.info("Changing IFEQ");
                    jumpNode.setOpcode(Opcodes.IFLE);
                } else {
                    BooleanTestabilityTransformation.logger.info("Return type: " + Type.getReturnType(
                            BooleanTestabilityTransformation.getOriginalDesc(mi.owner, mi.name, mi.desc)));
                }

            }
            BooleanTestabilityTransformation.logger.info("Stack size: " + frame.getStackSize());
            for (int i = 0; i < frame.getStackSize(); i++) {
                BooleanTestabilityTransformation.logger.info(i + " Stack: " + frame.getStack(i));
            }
        }
    } else if (jumpNode.getOpcode() == Opcodes.IF_ICMPEQ) {
        if (this.booleanTestabilityTransformation.isBooleanOnStack(mn, jumpNode, 0)) {
            InsnList convert = new InsnList();
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.INT_TYPE })));
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.INT_TYPE })));
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "popParameterBooleanFromInt", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] {})));
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "popParameterBooleanFromInt", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] {})));
            mn.instructions.insertBefore(jumpNode, convert);
            TransformationStatistics.transformedBooleanComparison();
        }
    } else if (jumpNode.getOpcode() == Opcodes.IF_ICMPNE) {
        if (this.booleanTestabilityTransformation.isBooleanOnStack(mn, jumpNode, 0)) {
            InsnList convert = new InsnList();
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.INT_TYPE })));
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "pushParameter", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.INT_TYPE })));
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "popParameterBooleanFromInt", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] {})));
            convert.add(new MethodInsnNode(Opcodes.INVOKESTATIC, Type.getInternalName(BooleanHelper.class),
                    "popParameterBooleanFromInt", Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] {})));
            mn.instructions.insertBefore(jumpNode, convert);
            TransformationStatistics.transformedBooleanComparison();
        }
    }
    return jumpNode;
}

---

From source file:org.evosuite.instrumentation.TransformationStatistics.java

License:Open Source License

/**
 * Insertion of pushDistance//w  w w .  j a  v  a2 s .c om
 *
 * @param opcode a int.
 */
public static void insertPush(int opcode) {
    switch (opcode) {
    case Opcodes.IFEQ:
    case Opcodes.IFNE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFLE:
        insertedPushInt0++;
        break;
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ICMPLT:
    case Opcodes.IF_ICMPGE:
    case Opcodes.IF_ICMPGT:
    case Opcodes.IF_ICMPLE:
        insertedPushInt1++;
        break;
    case Opcodes.IFNULL:
    case Opcodes.IFNONNULL:
        insertedPushIntRef++;
        break;
    case Opcodes.IF_ACMPEQ:
    case Opcodes.IF_ACMPNE:
        insertedPushIntNull++;
        break;
    default:
        // GOTO, JSR: Do nothing
    }
}

---

From source file:org.evosuite.regression.bytecode.RegressionClassDiff.java

License:Open Source License

private static String getBranchFamily(int opcode) {
    // The default family is the opcode itself
    // Admittedly we could've use ints/enums for performance, but strings should be interned anyway
    String family = "" + opcode;
    switch (opcode) {
    // copmpare int with zero
    case Opcodes.IFEQ:
    case Opcodes.IFNE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFLE:
        family = "int_zero";
        break;/*from www .j  a v  a2  s . c o  m*/
    // copmpare int with int
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ICMPLT:
    case Opcodes.IF_ICMPGE:
    case Opcodes.IF_ICMPGT:
    case Opcodes.IF_ICMPLE:
        family = "int_int";
        break;
    // copmpare reference with reference
    case Opcodes.IF_ACMPEQ:
    case Opcodes.IF_ACMPNE:
        family = "ref_ref";
        break;
    // compare reference with null
    case Opcodes.IFNULL:
    case Opcodes.IFNONNULL:
        family = "ref_null";
        break;

    }
    return family;
}

---

From source file:org.evosuite.regression.RegressionClassDiff.java

License:Open Source License

public static String getBranchFamily(int opcode) {
    // The default family is the opcode itself
    // Admittedly we could've use ints/enums for performance, but strings should be interned anyway
    String family = "" + opcode;
    switch (opcode) {
    // copmpare int with zero
    case Opcodes.IFEQ:
    case Opcodes.IFNE:
    case Opcodes.IFLT:
    case Opcodes.IFGE:
    case Opcodes.IFGT:
    case Opcodes.IFLE:
        family = "int_zero";
        break;//www.jav  a  2  s. co  m
    // copmpare int with int
    case Opcodes.IF_ICMPEQ:
    case Opcodes.IF_ICMPNE:
    case Opcodes.IF_ICMPLT:
    case Opcodes.IF_ICMPGE:
    case Opcodes.IF_ICMPGT:
    case Opcodes.IF_ICMPLE:
        family = "int_int";
        break;
    // copmpare reference with reference
    case Opcodes.IF_ACMPEQ:
    case Opcodes.IF_ACMPNE:
        family = "ref_ref";
        break;
    // compare reference with null
    case Opcodes.IFNULL:
    case Opcodes.IFNONNULL:
        family = "ref_null";
        break;

    }
    return family;
}

---

From source file:org.evosuite.runtime.instrumentation.MethodCallReplacement.java

License:Open Source License

public void insertMethodCall(MethodCallReplacementMethodAdapter mv, int opcode) {
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, MockFramework.class.getCanonicalName().replace('.', '/'),
            "isEnabled", "()Z", false);
    Label origCallLabel = new Label();
    Label afterOrigCallLabel = new Label();

    Label annotationStartTag = new AnnotatedLabel(true, true);
    annotationStartTag.info = Boolean.TRUE;
    mv.visitLabel(annotationStartTag);/*from  w  w w .  jav a  2 s  . com*/
    mv.visitJumpInsn(Opcodes.IFEQ, origCallLabel);
    Label annotationEndTag = new AnnotatedLabel(true, false);
    annotationEndTag.info = Boolean.FALSE;
    mv.visitLabel(annotationEndTag);

    if (popCallee) {
        Type[] args = Type.getArgumentTypes(desc);
        Map<Integer, Integer> to = new HashMap<Integer, Integer>();
        for (int i = args.length - 1; i >= 0; i--) {
            int loc = mv.newLocal(args[i]);
            mv.storeLocal(loc);
            to.put(i, loc);
        }

        mv.pop();//callee
        if (popUninitialisedReference)
            mv.pop();

        for (int i = 0; i < args.length; i++) {
            mv.loadLocal(to.get(i));
        }
    }
    if (opcode == Opcodes.INVOKESPECIAL && MockList.shouldBeMocked(className.replace('/', '.'))) {
        insertInvokeSpecialForMockedSuperclass(mv);
    } else {
        if (opcode == Opcodes.INVOKESPECIAL) {
            logger.info("Not mocking invokespecial: " + replacementMethodName + " for class " + className);
        }
        mv.visitMethodInsn(opcode, replacementClassName, replacementMethodName, replacementDesc, false);
    }
    mv.visitJumpInsn(Opcodes.GOTO, afterOrigCallLabel);
    mv.visitLabel(origCallLabel);
    mv.getNextVisitor().visitMethodInsn(origOpcode, className, methodName, desc, false); // TODO: What is itf here?
    mv.visitLabel(afterOrigCallLabel);
}

---

From source file:org.evosuite.runtime.instrumentation.MethodCallReplacement.java

License:Open Source License

public void insertConstructorCall(MethodCallReplacementMethodAdapter mv, MethodCallReplacement replacement,
        boolean isSelf) {
    Label origCallLabel = new Label();
    Label afterOrigCallLabel = new Label();

    if (!isSelf) {
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, MockFramework.class.getCanonicalName().replace('.', '/'),
                "isEnabled", "()Z", false);
        Label annotationStartTag = new AnnotatedLabel(true, true);
        annotationStartTag.info = Boolean.TRUE;
        mv.visitLabel(annotationStartTag);
        mv.visitJumpInsn(Opcodes.IFEQ, origCallLabel);
        Label annotationEndTag = new AnnotatedLabel(true, false);
        annotationEndTag.info = Boolean.FALSE;
        mv.visitLabel(annotationEndTag);

        Type[] args = Type.getArgumentTypes(desc);
        Map<Integer, Integer> to = new HashMap<Integer, Integer>();
        for (int i = args.length - 1; i >= 0; i--) {
            int loc = mv.newLocal(args[i]);
            mv.storeLocal(loc);/*from   w w  w  .  j  a v  a 2  s  .co m*/
            to.put(i, loc);
        }

        mv.pop2();//uninitialized reference (which is duplicated)
        mv.newInstance(Type.getType(replacement.replacementClassName));
        mv.dup();

        for (int i = 0; i < args.length; i++) {
            mv.loadLocal(to.get(i));
        }
    }
    mv.visitMethodInsn(Opcodes.INVOKESPECIAL, replacementClassName, replacementMethodName, replacementDesc,
            false);
    if (!isSelf) {
        mv.visitJumpInsn(Opcodes.GOTO, afterOrigCallLabel);
        mv.visitLabel(origCallLabel);
        mv.getNextVisitor().visitMethodInsn(Opcodes.INVOKESPECIAL, className, methodName, desc, false);
        mv.visitLabel(afterOrigCallLabel);
    }
}

---

From source file:org.evosuite.testcase.execution.ExecutionTraceImpl.java

License:Open Source License

/**
 * {@inheritDoc}/*w ww  .j ava  2  s .co m*/
 * 
 * Add branch to currently active method call
 */
@Override
public void branchPassed(int branch, int bytecode_id, double true_distance, double false_distance) {

    assert (true_distance >= 0.0);
    assert (false_distance >= 0.0);
    updateTopStackMethodCall(branch, bytecode_id, true_distance, false_distance);

    // TODO: property should really be called TRACK_GRADIENT_BRANCHES!
    if (Properties.TRACK_BOOLEAN_BRANCHES) {
        if ((true_distance != 0 && true_distance != 1) || (false_distance != 0 && false_distance != 1))
            gradientBranches.add(branch);
    }

    if (traceCoverage) {
        if (!coveredPredicates.containsKey(branch))
            coveredPredicates.put(branch, 1);
        else
            coveredPredicates.put(branch, coveredPredicates.get(branch) + 1);

        if (true_distance == 0.0) {
            if (!coveredTrue.containsKey(branch))
                coveredTrue.put(branch, 1);
            else
                coveredTrue.put(branch, coveredTrue.get(branch) + 1);

        }

        if (false_distance == 0.0) {
            if (!coveredFalse.containsKey(branch))
                coveredFalse.put(branch, 1);
            else
                coveredFalse.put(branch, coveredFalse.get(branch) + 1);
        }
    }

    if (Properties.TRACK_COVERED_GRADIENT_BRANCHES) {
        if (gradientBranches.contains(branch)) {
            if ((coveredTrue.containsKey(branch)))
                gradientBranchesCoveredTrue.add(branch);
            if ((coveredFalse.containsKey(branch)))
                gradientBranchesCoveredFalse.add(branch);
        }
    }

    if (Properties.BRANCH_COMPARISON_TYPES) {
        int opcode = BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT())
                .getBranch(branch).getInstruction().getASMNode().getOpcode();
        int previousOpcode = -2;
        if (BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()).getBranch(branch)
                .getInstruction().getASMNode().getPrevious() != null)
            previousOpcode = BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT())
                    .getBranch(branch).getInstruction().getASMNode().getPrevious().getOpcode();
        boolean cTrue = coveredTrue.containsKey(branch);
        boolean cFalse = coveredFalse.containsKey(branch);
        switch (previousOpcode) {
        case Opcodes.LCMP:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_lcmp, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_lcmp, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_lcmp, branch);
            break;
        case Opcodes.FCMPL:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_fcmpl, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_fcmpl, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_fcmpl, branch);
            break;
        case Opcodes.FCMPG:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_fcmpg, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_fcmpg, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_fcmpg, branch);
            break;
        case Opcodes.DCMPL:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_dcmpl, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_dcmpl, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_dcmpl, branch);
            break;
        case Opcodes.DCMPG:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_dcmpg, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_dcmpg, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_dcmpg, branch);
            break;
        }
        switch (opcode) {
        // copmpare int with zero
        case Opcodes.IFEQ:
        case Opcodes.IFNE:
        case Opcodes.IFLT:
        case Opcodes.IFGE:
        case Opcodes.IFGT:
        case Opcodes.IFLE:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_IntZero, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_IntZero, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_IntZero, branch);
            break;
        // copmpare int with int
        case Opcodes.IF_ICMPEQ:
        case Opcodes.IF_ICMPNE:
        case Opcodes.IF_ICMPLT:
        case Opcodes.IF_ICMPGE:
        case Opcodes.IF_ICMPGT:
        case Opcodes.IF_ICMPLE:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_IntInt, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_IntInt, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_IntInt, branch);
            break;
        // copmpare reference with reference
        case Opcodes.IF_ACMPEQ:
        case Opcodes.IF_ACMPNE:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_RefRef, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_RefRef, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_RefRef, branch);
            break;
        // compare reference with null
        case Opcodes.IFNULL:
        case Opcodes.IFNONNULL:
            trackBranchOpcode(bytecodeInstructionReached, RuntimeVariable.Reached_RefNull, branch);
            if (cTrue)
                trackBranchOpcode(bytecodeInstructionCoveredTrue, RuntimeVariable.Covered_RefNull, branch);
            if (cFalse)
                trackBranchOpcode(bytecodeInstructionCoveredFalse, RuntimeVariable.Covered_RefNull, branch);
            break;

        }
    }

    if (!trueDistances.containsKey(branch))
        trueDistances.put(branch, true_distance);
    else
        trueDistances.put(branch, Math.min(trueDistances.get(branch), true_distance));

    if (!falseDistances.containsKey(branch))
        falseDistances.put(branch, false_distance);
    else
        falseDistances.put(branch, Math.min(falseDistances.get(branch), false_distance));

    if (!trueDistancesSum.containsKey(branch))
        trueDistancesSum.put(branch, true_distance);
    else
        trueDistancesSum.put(branch, trueDistancesSum.get(branch) + true_distance);

    if (!falseDistancesSum.containsKey(branch))
        falseDistancesSum.put(branch, false_distance);
    else
        falseDistancesSum.put(branch, falseDistancesSum.get(branch) + false_distance);

    if (!disableContext && (Properties.INSTRUMENT_CONTEXT || Properties.INSTRUMENT_METHOD_CALLS
            || ArrayUtil.contains(Properties.CRITERION, Criterion.IBRANCH)
            || ArrayUtil.contains(Properties.CRITERION, Criterion.CBRANCH))) {
        updateBranchContextMaps(branch, true_distance, false_distance);
    }

    // This requires a lot of memory and should not really be used
    if (Properties.BRANCH_EVAL) {
        branchesTrace.add(new BranchEval(branch, true_distance, false_distance));
    }
}

---

From source file:org.evosuite.testcase.execution.ExecutionTracer.java

License:Open Source License

/**
 * Called by the instrumented code each time a new branch is taken
 * /*  w  ww.j  av a2  s.  co  m*/
 * @param val
 *            a int.
 * @param opcode
 *            a int.
 * @param branch
 *            a int.
 * @param bytecode_id
 *            a int.
 */
public static void passedBranch(int val, int opcode, int branch, int bytecode_id) {

    ExecutionTracer tracer = getExecutionTracer();
    // logger.info("passedBranch val="+val+", opcode="+opcode+", branch="+branch+", bytecode_id="+bytecode_id);
    if (tracer.disabled)
        return;

    if (isThreadNeqCurrentThread())
        return;

    checkTimeout();

    ConstantPoolManager.getInstance().addDynamicConstant(val);

    // logger.trace("Called passedBranch1 with opcode "+AbstractVisitor.OPCODES[opcode]+" and val "+val+" in branch "+branch);
    double distance_true = 0.0;
    double distance_false = 0.0;
    switch (opcode) {
    case Opcodes.IFEQ:
        distance_true = Math.abs((double) val); // The greater abs is, the
        // further away from 0
        distance_false = distance_true == 0 ? 1.0 : 0.0; // Anything but 0
        // is good
        break;
    case Opcodes.IFNE:
        distance_false = Math.abs((double) val); // The greater abs is, the
        // further away from 0
        distance_true = distance_false == 0 ? 1.0 : 0.0; // Anything but 0
        // leads to NE
        break;
    case Opcodes.IFLT:
        distance_true = val >= 0 ? val + 1.0 : 0.0; // The greater, the
        // further away from < 0
        distance_false = val < 0 ? 0.0 - val + 1.0 : 0.0; // The smaller,
        // the further
        // away from < 0
        break;
    case Opcodes.IFGT:
        distance_true = val <= 0 ? 0.0 - val + 1.0 : 0.0;
        distance_false = val > 0 ? val + 1.0 : 0.0;
        break;
    case Opcodes.IFGE:
        distance_true = val < 0 ? 0.0 - val + 1.0 : 0.0;
        distance_false = val >= 0 ? val + 1.0 : 0.0;
        break;
    case Opcodes.IFLE:
        distance_true = val > 0 ? val + 1.0 : 0.0; // The greater, the
        // further away from < 0
        distance_false = val <= 0 ? 0.0 - val + 1.0 : 0.0; // The smaller,
        // the further
        // away from < 0
        break;
    default:
        logger.error("Unknown opcode: " + opcode);

    }
    // logger.trace("1 Branch distance true : " + distance_true);
    // logger.trace("1 Branch distance false: " + distance_false);

    // Add current branch to control trace
    tracer.trace.branchPassed(branch, bytecode_id, distance_true, distance_false);
}

---

From source file:org.evosuite.testcase.ExecutionTracer.java

License:Open Source License

/**
 * Called by the instrumented code each time a new branch is taken
 * //ww w. j  a  va 2 s  . co  m
 * @param val
 *            a int.
 * @param opcode
 *            a int.
 * @param branch
 *            a int.
 * @param bytecode_id
 *            a int.
 */
public static void passedBranch(int val, int opcode, int branch, int bytecode_id) {

    ExecutionTracer tracer = getExecutionTracer();
    // logger.info("passedBranch val="+val+", opcode="+opcode+", branch="+branch+", bytecode_id="+bytecode_id);
    if (tracer.disabled)
        return;

    if (isThreadNeqCurrentThread())
        return;

    checkTimeout();

    if (Properties.DYNAMIC_SEEDING) {
        ConstantPoolManager.getInstance().addDynamicConstant(val);
    }
    ;

    // logger.trace("Called passedBranch1 with opcode "+AbstractVisitor.OPCODES[opcode]+" and val "+val+" in branch "+branch);
    double distance_true = 0.0;
    double distance_false = 0.0;
    switch (opcode) {
    case Opcodes.IFEQ:
        distance_true = Math.abs((double) val); // The greater abs is, the
        // further away from 0
        distance_false = distance_true == 0 ? 1.0 : 0.0; // Anything but 0
        // is good
        break;
    case Opcodes.IFNE:
        distance_false = Math.abs((double) val); // The greater abs is, the
        // further away from 0
        distance_true = distance_false == 0 ? 1.0 : 0.0; // Anything but 0
        // leads to NE
        break;
    case Opcodes.IFLT:
        distance_true = val >= 0 ? val + 1.0 : 0.0; // The greater, the
        // further away from < 0
        distance_false = val < 0 ? 0.0 - val + 1.0 : 0.0; // The smaller,
        // the further
        // away from < 0
        break;
    case Opcodes.IFGT:
        distance_true = val <= 0 ? 0.0 - val + 1.0 : 0.0;
        distance_false = val > 0 ? val + 1.0 : 0.0;
        break;
    case Opcodes.IFGE:
        distance_true = val < 0 ? 0.0 - val + 1.0 : 0.0;
        distance_false = val >= 0 ? val + 1.0 : 0.0;
        break;
    case Opcodes.IFLE:
        distance_true = val > 0 ? val + 1.0 : 0.0; // The greater, the
        // further away from < 0
        distance_false = val <= 0 ? 0.0 - val + 1.0 : 0.0; // The smaller,
        // the further
        // away from < 0
        break;
    default:
        logger.error("Unknown opcode: {}", opcode);

    }
    // logger.trace("1 Branch distance true : " + distance_true);
    // logger.trace("1 Branch distance false: " + distance_false);

    // Add current branch to control trace
    tracer.trace.branchPassed(branch, bytecode_id, distance_true, distance_false);
}

---

From source file:org.evosuite.TestSuiteGenerator.java

License:Open Source License

private void getBytecodeStatistics() {
    if (Properties.TRACK_BOOLEAN_BRANCHES) {
        int gradientBranchCount = ExecutionTraceImpl.gradientBranches.size() * 2;
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Gradient_Branches,
                gradientBranchCount);/*from  w w  w  .ja v a 2s.c o m*/
    }
    if (Properties.TRACK_COVERED_GRADIENT_BRANCHES) {
        int coveredGradientBranchCount = ExecutionTraceImpl.gradientBranchesCoveredTrue.size()
                + ExecutionTraceImpl.gradientBranchesCoveredFalse.size();
        ClientServices.getInstance().getClientNode()
                .trackOutputVariable(RuntimeVariable.Gradient_Branches_Covered, coveredGradientBranchCount);
    }
    if (Properties.BRANCH_COMPARISON_TYPES) {
        int cmp_intzero = 0, cmp_intint = 0, cmp_refref = 0, cmp_refnull = 0;
        int bc_lcmp = 0, bc_fcmpl = 0, bc_fcmpg = 0, bc_dcmpl = 0, bc_dcmpg = 0;
        for (Branch b : BranchPool.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT())
                .getAllBranches()) {
            int branchOpCode = b.getInstruction().getASMNode().getOpcode();
            int previousOpcode = -2;
            if (b.getInstruction().getASMNode().getPrevious() != null)
                previousOpcode = b.getInstruction().getASMNode().getPrevious().getOpcode();
            switch (previousOpcode) {
            case Opcodes.LCMP:
                bc_lcmp++;
                break;
            case Opcodes.FCMPL:
                bc_fcmpl++;
                break;
            case Opcodes.FCMPG:
                bc_fcmpg++;
                break;
            case Opcodes.DCMPL:
                bc_dcmpl++;
                break;
            case Opcodes.DCMPG:
                bc_dcmpg++;
                break;
            }
            switch (branchOpCode) {
            // copmpare int with zero
            case Opcodes.IFEQ:
            case Opcodes.IFNE:
            case Opcodes.IFLT:
            case Opcodes.IFGE:
            case Opcodes.IFGT:
            case Opcodes.IFLE:
                cmp_intzero++;
                break;
            // copmpare int with int
            case Opcodes.IF_ICMPEQ:
            case Opcodes.IF_ICMPNE:
            case Opcodes.IF_ICMPLT:
            case Opcodes.IF_ICMPGE:
            case Opcodes.IF_ICMPGT:
            case Opcodes.IF_ICMPLE:
                cmp_intint++;
                break;
            // copmpare reference with reference
            case Opcodes.IF_ACMPEQ:
            case Opcodes.IF_ACMPNE:
                cmp_refref++;
                break;
            // compare reference with null
            case Opcodes.IFNULL:
            case Opcodes.IFNONNULL:
                cmp_refnull++;
                break;

            }
        }
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Cmp_IntZero,
                cmp_intzero);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Cmp_IntInt,
                cmp_intint);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Cmp_RefRef,
                cmp_refref);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.Cmp_RefNull,
                cmp_refnull);

        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.BC_lcmp, bc_lcmp);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.BC_fcmpl, bc_fcmpl);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.BC_fcmpg, bc_fcmpg);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.BC_dcmpl, bc_dcmpl);
        ClientServices.getInstance().getClientNode().trackOutputVariable(RuntimeVariable.BC_dcmpg, bc_dcmpg);

        RuntimeVariable[] bytecodeVarsCovered = new RuntimeVariable[] { RuntimeVariable.Covered_lcmp,
                RuntimeVariable.Covered_fcmpl, RuntimeVariable.Covered_fcmpg, RuntimeVariable.Covered_dcmpl,
                RuntimeVariable.Covered_dcmpg, RuntimeVariable.Covered_IntInt, RuntimeVariable.Covered_IntInt,
                RuntimeVariable.Covered_IntZero, RuntimeVariable.Covered_RefRef,
                RuntimeVariable.Covered_RefNull };

        for (RuntimeVariable bcvar : bytecodeVarsCovered) {
            ClientServices.getInstance().getClientNode().trackOutputVariable(bcvar,
                    getBytecodeCount(bcvar, ExecutionTraceImpl.bytecodeInstructionCoveredFalse)
                            + getBytecodeCount(bcvar, ExecutionTraceImpl.bytecodeInstructionCoveredTrue));
        }

        RuntimeVariable[] bytecodeVarsReached = new RuntimeVariable[] { RuntimeVariable.Reached_lcmp,
                RuntimeVariable.Reached_fcmpl, RuntimeVariable.Reached_fcmpg, RuntimeVariable.Reached_dcmpl,
                RuntimeVariable.Reached_dcmpg, RuntimeVariable.Reached_IntInt, RuntimeVariable.Reached_IntInt,
                RuntimeVariable.Reached_IntZero, RuntimeVariable.Reached_RefRef,
                RuntimeVariable.Reached_RefNull };

        for (RuntimeVariable bcvar : bytecodeVarsReached) {
            ClientServices.getInstance().getClientNode().trackOutputVariable(bcvar,
                    getBytecodeCount(bcvar, ExecutionTraceImpl.bytecodeInstructionReached) * 2);
        }

    }

}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• »