Example usage for org.objectweb.asm.tree InsnList add

List of usage examples for org.objectweb.asm.tree InsnList add

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.tree.*
  5. InsnList
  6. add

Introduction

In this page you can find the example usage for org.objectweb.asm.tree InsnList add.

Prototype

public void add(final InsnList insnList)

Source Link

Document

Adds the given instructions to the end of this list.

Usage

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

/**
 * <p>//from w  w  w .j ava 2 s . c  o  m
 * copy
 * </p>
 *
 * @param orig
 *            a {@link org.objectweb.asm.tree.InsnList} object.
 * @return a {@link org.objectweb.asm.tree.InsnList} object.
 */
public static InsnList copy(InsnList orig) {
    Iterator<?> it = orig.iterator();
    InsnList copy = new InsnList();
    while (it.hasNext()) {
        AbstractInsnNode node = (AbstractInsnNode) it.next();

        if (node instanceof VarInsnNode) {
            VarInsnNode vn = (VarInsnNode) node;
            copy.add(new VarInsnNode(vn.getOpcode(), vn.var));
        } else if (node instanceof FieldInsnNode) {
            FieldInsnNode fn = (FieldInsnNode) node;
            copy.add(new FieldInsnNode(fn.getOpcode(), fn.owner, fn.name, fn.desc));
        } else if (node instanceof InsnNode) {
            if (node.getOpcode() != Opcodes.POP)
                copy.add(new InsnNode(node.getOpcode()));
        } else if (node instanceof LdcInsnNode) {
            copy.add(new LdcInsnNode(((LdcInsnNode) node).cst));
        } else {
            throw new RuntimeException("Unexpected node type: " + node.getClass());
        }
    }
    return copy;
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

/**
 * <p>/*from w  w w  . j a v a  2 s  . c  om*/
 * addPrimitiveDistanceCheck
 * </p>
 *
 * @param distance
 *            a {@link org.objectweb.asm.tree.InsnList} object.
 * @param type
 *            a {@link org.objectweb.asm.Type} object.
 * @param mutant
 *            a {@link org.objectweb.asm.tree.InsnList} object.
 */
public static void addPrimitiveDistanceCheck(InsnList distance, Type type, InsnList mutant) {
    distance.add(cast(type, Type.DOUBLE_TYPE));
    distance.add(copy(mutant));
    distance.add(cast(type, Type.DOUBLE_TYPE));
    distance.add(new MethodInsnNode(Opcodes.INVOKESTATIC, PackageInfo.getNameWithSlash(ReplaceVariable.class),
            "getDistance", "(DD)D", false));
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

/**
 * <p>/*w ww.  j a v a2 s  .c o m*/
 * addReferenceDistanceCheck
 * </p>
 *
 * @param distance
 *            a {@link org.objectweb.asm.tree.InsnList} object.
 * @param type
 *            a {@link org.objectweb.asm.Type} object.
 * @param mutant
 *            a {@link org.objectweb.asm.tree.InsnList} object.
 */
public static void addReferenceDistanceCheck(InsnList distance, Type type, InsnList mutant) {
    distance.add(copy(mutant));
    distance.add(new MethodInsnNode(Opcodes.INVOKESTATIC, PackageInfo.getNameWithSlash(ReplaceVariable.class),
            "getDistance", "(Ljava/lang/Object;Ljava/lang/Object;)D", false));
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

/**
 * <p>//from   w  w  w.  ja va 2  s  .  c  om
 * getInfectionDistance
 * </p>
 *
 * @param type
 *            a {@link org.objectweb.asm.Type} object.
 * @param original
 *            a {@link org.objectweb.asm.tree.AbstractInsnNode} object.
 * @param mutant
 *            a {@link org.objectweb.asm.tree.InsnList} object.
 * @return a {@link org.objectweb.asm.tree.InsnList} object.
 */
public InsnList getInfectionDistance(Type type, AbstractInsnNode original, InsnList mutant) {
    // TODO: Treat reference types different!

    InsnList distance = new InsnList();

    if (original instanceof VarInsnNode) {
        VarInsnNode node = (VarInsnNode) original;
        distance.add(new VarInsnNode(node.getOpcode(), node.var));
        if (type.getDescriptor().startsWith("L") || type.getDescriptor().startsWith("["))
            addReferenceDistanceCheck(distance, type, mutant);
        else
            addPrimitiveDistanceCheck(distance, type, mutant);

    } else if (original instanceof FieldInsnNode) {
        if (original.getOpcode() == Opcodes.GETFIELD)
            distance.add(new InsnNode(Opcodes.DUP)); //make sure to re-load this for GETFIELD

        FieldInsnNode node = (FieldInsnNode) original;
        distance.add(new FieldInsnNode(node.getOpcode(), node.owner, node.name, node.desc));
        if (type.getDescriptor().startsWith("L") || type.getDescriptor().startsWith("["))
            addReferenceDistanceCheck(distance, type, mutant);
        else
            addPrimitiveDistanceCheck(distance, type, mutant);

    } else if (original instanceof IincInsnNode) {
        distance.add(Mutation.getDefaultInfectionDistance());
    }
    return distance;
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

private Map<String, InsnList> getLocalReplacements(MethodNode mn, String desc, AbstractInsnNode node,
        Frame frame) {/*  w  w w .  j a  v  a  2 s  . c o  m*/
    Map<String, InsnList> replacements = new HashMap<String, InsnList>();

    //if (desc.equals("I"))
    //   return replacements;

    int otherNum = -1;
    if (node instanceof VarInsnNode) {
        VarInsnNode vNode = (VarInsnNode) node;
        otherNum = vNode.var;
    }
    if (otherNum == -1)
        return replacements;

    int currentId = mn.instructions.indexOf(node);
    logger.info("Looking for replacements at position " + currentId + " of variable " + otherNum + " of type "
            + desc);

    //   return replacements;

    for (Object v : mn.localVariables) {
        LocalVariableNode localVar = (LocalVariableNode) v;
        int startId = mn.instructions.indexOf(localVar.start);
        int endId = mn.instructions.indexOf(localVar.end);
        logger.info("Checking local variable " + localVar.name + " of type " + localVar.desc + " at index "
                + localVar.index);
        if (!localVar.desc.equals(desc))
            logger.info("- Types do not match");
        if (localVar.index == otherNum)
            logger.info("- Replacement = original");
        if (currentId < startId)
            logger.info("- Out of scope (start)");
        if (currentId > endId)
            logger.info("- Out of scope (end)");
        BasicValue newValue = (BasicValue) frame.getLocal(localVar.index);
        if (newValue == BasicValue.UNINITIALIZED_VALUE)
            logger.info("- Not initialized");

        if (localVar.desc.equals(desc) && localVar.index != otherNum && currentId >= startId
                && currentId <= endId && newValue != BasicValue.UNINITIALIZED_VALUE) {

            logger.info("Adding local variable " + localVar.name + " of type " + localVar.desc + " at index "
                    + localVar.index + ",  " + startId + "-" + endId + ", " + currentId);
            InsnList list = new InsnList();
            if (node.getOpcode() == Opcodes.GETFIELD) {
                list.add(new InsnNode(Opcodes.POP)); // Remove field owner from stack
            }

            list.add(new VarInsnNode(getLoadOpcode(localVar), localVar.index));
            replacements.put(localVar.name, list);
        }
    }
    return replacements;
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

private Map<String, InsnList> getLocalReplacementsInc(MethodNode mn, String desc, IincInsnNode node,
        Frame frame) {/*w w w.j  a  va  2s . co m*/
    Map<String, InsnList> replacements = new HashMap<String, InsnList>();

    int otherNum = -1;
    otherNum = node.var;
    int currentId = mn.instructions.indexOf(node);

    for (Object v : mn.localVariables) {
        LocalVariableNode localVar = (LocalVariableNode) v;
        int startId = mn.instructions.indexOf(localVar.start);
        int endId = mn.instructions.indexOf(localVar.end);
        logger.info("Checking local variable " + localVar.name + " of type " + localVar.desc + " at index "
                + localVar.index);
        if (!localVar.desc.equals(desc))
            logger.info("- Types do not match: " + localVar.name);
        if (localVar.index == otherNum)
            logger.info("- Replacement = original " + localVar.name);
        if (currentId < startId)
            logger.info("- Out of scope (start) " + localVar.name);
        if (currentId > endId)
            logger.info("- Out of scope (end) " + localVar.name);
        BasicValue newValue = (BasicValue) frame.getLocal(localVar.index);
        if (newValue == BasicValue.UNINITIALIZED_VALUE)
            logger.info("- Not initialized");

        if (localVar.desc.equals(desc) && localVar.index != otherNum && currentId >= startId
                && currentId <= endId && newValue != BasicValue.UNINITIALIZED_VALUE) {

            logger.info("Adding local variable " + localVar.name + " of type " + localVar.desc + " at index "
                    + localVar.index);
            InsnList list = new InsnList();
            list.add(new IincInsnNode(localVar.index, node.incr));
            replacements.put(localVar.name, list);
        }
    }
    return replacements;
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

private Map<String, InsnList> getFieldReplacements(MethodNode mn, String className, String desc,
        AbstractInsnNode node) {//  w  w  w.  j a va2  s  .c o m
    Map<String, InsnList> alternatives = new HashMap<String, InsnList>();

    boolean isStatic = (mn.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;

    String otherName = "";
    if (node instanceof FieldInsnNode) {
        FieldInsnNode fNode = (FieldInsnNode) node;
        otherName = fNode.name;
    }
    try {
        logger.info("Checking class " + className);
        Class<?> clazz = Class.forName(className, false, ReplaceVariable.class.getClassLoader());

        for (Field field : TestClusterUtils.getFields(clazz)) {
            // We have to use a special version of canUse to avoid
            // that we access the CUT before it is fully initialised
            if (!canUse(field))
                continue;

            Type type = Type.getType(field.getType());
            logger.info("Checking replacement field variable " + field.getName());

            if (field.getName().equals(otherName))
                continue;

            if (isStatic && !(Modifier.isStatic(field.getModifiers())))
                continue;

            if (type.getDescriptor().equals(desc)) {
                logger.info("Adding replacement field variable " + field.getName());
                InsnList list = new InsnList();
                if (node.getOpcode() == Opcodes.GETFIELD) {
                    list.add(new InsnNode(Opcodes.POP)); // Remove field owner from stack
                }

                // new fieldinsnnode
                if (Modifier.isStatic(field.getModifiers()))
                    list.add(new FieldInsnNode(Opcodes.GETSTATIC, className.replace('.', '/'), field.getName(),
                            type.getDescriptor()));
                else {
                    list.add(new VarInsnNode(Opcodes.ALOAD, 0)); // this
                    list.add(new FieldInsnNode(Opcodes.GETFIELD, className.replace('.', '/'), field.getName(),
                            type.getDescriptor()));
                }
                alternatives.put(field.getName(), list);
            } else {
                logger.info("Descriptor does not match: " + field.getName() + " - " + type.getDescriptor());
            }
        }
    } catch (Throwable t) {
        logger.info("Class not found: " + className);
        // TODO Auto-generated catch block
        //e.printStackTrace();
    }
    return alternatives;
}

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

/**
 * Generates the instructions to cast a numerical value from one type to
 * another./*from w w w  . ja v  a 2  s  .c o m*/
 *
 * @param from
 *            the type of the top stack value
 * @param to
 *            the type into which this value must be cast.
 * @return a {@link org.objectweb.asm.tree.InsnList} object.
 */
public static InsnList cast(final Type from, final Type to) {
    InsnList list = new InsnList();

    if (from != to) {
        if (from == Type.DOUBLE_TYPE) {
            if (to == Type.FLOAT_TYPE) {
                list.add(new InsnNode(Opcodes.D2F));
            } else if (to == Type.LONG_TYPE) {
                list.add(new InsnNode(Opcodes.D2L));
            } else {
                list.add(new InsnNode(Opcodes.D2I));
                list.add(cast(Type.INT_TYPE, to));
            }
        } else if (from == Type.FLOAT_TYPE) {
            if (to == Type.DOUBLE_TYPE) {
                list.add(new InsnNode(Opcodes.F2D));
            } else if (to == Type.LONG_TYPE) {
                list.add(new InsnNode(Opcodes.F2L));
            } else {
                list.add(new InsnNode(Opcodes.F2I));
                list.add(cast(Type.INT_TYPE, to));
            }
        } else if (from == Type.LONG_TYPE) {
            if (to == Type.DOUBLE_TYPE) {
                list.add(new InsnNode(Opcodes.L2D));
            } else if (to == Type.FLOAT_TYPE) {
                list.add(new InsnNode(Opcodes.L2F));
            } else {
                list.add(new InsnNode(Opcodes.L2I));
                list.add(cast(Type.INT_TYPE, to));
            }
        } else {
            if (to == Type.BYTE_TYPE) {
                list.add(new InsnNode(Opcodes.I2B));
            } else if (to == Type.CHAR_TYPE) {
                list.add(new InsnNode(Opcodes.I2C));
            } else if (to == Type.DOUBLE_TYPE) {
                list.add(new InsnNode(Opcodes.I2D));
            } else if (to == Type.FLOAT_TYPE) {
                list.add(new InsnNode(Opcodes.I2F));
            } else if (to == Type.LONG_TYPE) {
                list.add(new InsnNode(Opcodes.I2L));
            } else if (to == Type.SHORT_TYPE) {
                list.add(new InsnNode(Opcodes.I2S));
            }
        }
    }
    return list;
}

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

License:Open Source License

@Override
protected AbstractInsnNode transformMethodInsnNode(MethodNode mn, MethodInsnNode methodNode) {
    if (methodNode.owner.equals(Type.getInternalName(BooleanHelper.class)))
        return methodNode;

    methodNode.desc = this.booleanTestabilityTransformation.transformMethodDescriptor(methodNode.owner,
            methodNode.name, methodNode.desc);
    methodNode.name = DescriptorMapping.getInstance().getMethodName(methodNode.owner, methodNode.name,
            methodNode.desc);/*from  w  w  w . ja  va  2 s .  co m*/
    if (DescriptorMapping.getInstance().isBooleanMethod(methodNode.desc)) {
        BooleanTestabilityTransformation.logger.info("Method needs value transformation: " + methodNode.name);
        if (DescriptorMapping.getInstance().hasBooleanParameters(methodNode.desc)) {
            BooleanTestabilityTransformation.logger
                    .info("Method needs parameter transformation: " + methodNode.name);
            TransformationStatistics.transformBackToBooleanParameter();
            int firstBooleanParameterIndex = -1;
            Type[] types = Type.getArgumentTypes(methodNode.desc);
            for (int i = 0; i < types.length; i++) {
                if (types[i].getDescriptor().equals("Z")) {
                    if (firstBooleanParameterIndex == -1) {
                        firstBooleanParameterIndex = i;
                        break;
                    }
                }
            }
            if (firstBooleanParameterIndex != -1) {
                int numOfPushs = types.length - 1 - firstBooleanParameterIndex;
                //                        int numOfPushs = types.length - firstBooleanParameterIndex;

                if (numOfPushs == 0) {
                    if (!(methodNode.getPrevious().getOpcode() == Opcodes.ICONST_1
                            || methodNode.getPrevious().getOpcode() == Opcodes.ICONST_0)) {

                        //the boolean parameter is the last parameter
                        MethodInsnNode booleanHelperInvoke = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                Type.getInternalName(BooleanHelper.class), "intToBoolean",
                                Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] { Type.INT_TYPE }));
                        mn.instructions.insertBefore(methodNode, booleanHelperInvoke);
                    }
                } else {
                    InsnList insnlist = new InsnList();

                    for (int i = 0; i < numOfPushs; i++) {
                        MethodInsnNode booleanHelperPushParameter;
                        if (types[types.length - 1 - i] == Type.BOOLEAN_TYPE
                                || types[types.length - 1 - i] == Type.CHAR_TYPE
                                || types[types.length - 1 - i] == Type.BYTE_TYPE
                                || types[types.length - 1 - i] == Type.SHORT_TYPE
                                || types[types.length - 1 - i] == Type.INT_TYPE
                                || types[types.length - 1 - i] == Type.FLOAT_TYPE
                                || types[types.length - 1 - i] == Type.LONG_TYPE
                                || types[types.length - 1 - i] == Type.DOUBLE_TYPE) {
                            if (types[types.length - 1 - i] == Type.BOOLEAN_TYPE) {
                                booleanHelperPushParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "pushParameter",
                                        Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { Type.INT_TYPE }));
                            } else {
                                booleanHelperPushParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "pushParameter",
                                        Type.getMethodDescriptor(Type.VOID_TYPE,
                                                new Type[] { types[types.length - 1 - i] }));
                            }
                        } else {
                            booleanHelperPushParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                    Type.getInternalName(BooleanHelper.class), "pushParameter",
                                    Type.getMethodDescriptor(Type.VOID_TYPE,
                                            new Type[] { Type.getType(Object.class) }));
                        }

                        insnlist.add(booleanHelperPushParameter);
                    }
                    for (int i = firstBooleanParameterIndex; i < types.length; i++) {
                        if (i == firstBooleanParameterIndex) {
                            MethodInsnNode booleanHelperInvoke = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                    Type.getInternalName(BooleanHelper.class), "intToBoolean",
                                    Type.getMethodDescriptor(Type.BOOLEAN_TYPE, new Type[] { Type.INT_TYPE }));
                            insnlist.add(booleanHelperInvoke);
                        } else {
                            MethodInsnNode booleanHelperPopParameter;
                            boolean objectNeedCast = false;
                            if (types[i] == Type.BOOLEAN_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterBooleanFromInt",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.CHAR_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterChar",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.BYTE_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterByte",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.SHORT_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterShort",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.INT_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterInt",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.FLOAT_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterFloat",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.LONG_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterLong",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else if (types[i] == Type.DOUBLE_TYPE) {
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterDouble",
                                        Type.getMethodDescriptor(types[i], new Type[] {}));
                            } else {
                                objectNeedCast = true;
                                booleanHelperPopParameter = new MethodInsnNode(Opcodes.INVOKESTATIC,
                                        Type.getInternalName(BooleanHelper.class), "popParameterObject",
                                        Type.getMethodDescriptor(Type.getType(Object.class), new Type[] {}));
                            }

                            insnlist.add(booleanHelperPopParameter);
                            if (objectNeedCast) {
                                TypeInsnNode tin = new TypeInsnNode(Opcodes.CHECKCAST,
                                        types[i].getInternalName());
                                insnlist.add(tin);
                            }
                        }

                    }
                    mn.instructions.insertBefore(methodNode, insnlist);
                }
            }
        }
        if (Type.getReturnType(methodNode.desc).equals(Type.BOOLEAN_TYPE)) {
            BooleanTestabilityTransformation.logger
                    .info("Method needs return transformation: " + methodNode.name);
            TransformationStatistics.transformBackToBooleanParameter();
            MethodInsnNode n = new MethodInsnNode(Opcodes.INVOKESTATIC,
                    Type.getInternalName(BooleanHelper.class), "booleanToInt",
                    Type.getMethodDescriptor(Type.INT_TYPE, new Type[] { Type.BOOLEAN_TYPE }));
            mn.instructions.insert(methodNode, n);
            return n;
        }
    } else {
        BooleanTestabilityTransformation.logger.info("Method needs no transformation: " + methodNode.name);
    }

    // TODO: If this is a method that is not transformed, and it requires a Boolean parameter
    // then we need to convert this boolean back to an int
    // For example, we could use flow analysis to determine the point where the value is added to the stack
    // and insert a conversion function there
    return methodNode;
}

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 {// w w w. j  a v  a 2s .c om
            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;
}