Java tutorial
/** * Copyright (C) 2010-2016 Gordon Fraser, Andrea Arcuri and EvoSuite * contributors * * This file is part of EvoSuite. * * EvoSuite is free software: you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published * by the Free Software Foundation, either version 3.0 of the License, or * (at your option) any later version. * * EvoSuite is distributed in the hope that it will be useful, but * WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with EvoSuite. If not, see <http://www.gnu.org/licenses/>. */ /** * */ package org.evosuite.instrumentation.mutation; import java.io.FileDescriptor; import java.lang.reflect.Field; import java.lang.reflect.Modifier; import java.util.HashMap; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; import java.util.Map.Entry; import org.apache.commons.lang3.ClassUtils; import org.evosuite.PackageInfo; import org.evosuite.Properties; import org.evosuite.coverage.mutation.Mutation; import org.evosuite.coverage.mutation.MutationPool; import org.evosuite.graphs.cfg.BytecodeInstruction; import org.evosuite.setup.TestClusterUtils; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.FieldInsnNode; import org.objectweb.asm.tree.IincInsnNode; import org.objectweb.asm.tree.InsnList; import org.objectweb.asm.tree.InsnNode; import org.objectweb.asm.tree.LdcInsnNode; import org.objectweb.asm.tree.LocalVariableNode; import org.objectweb.asm.tree.MethodInsnNode; import org.objectweb.asm.tree.MethodNode; import org.objectweb.asm.tree.VarInsnNode; import org.objectweb.asm.tree.analysis.BasicValue; import org.objectweb.asm.tree.analysis.Frame; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * <p> * ReplaceVariable class. * </p> * * @author Gordon Fraser */ public class ReplaceVariable implements MutationOperator { private static Logger logger = LoggerFactory.getLogger(ReplaceVariable.class); public static final String NAME = "ReplaceVariable"; /* (non-Javadoc) * @see org.evosuite.cfg.instrumentation.mutation.MutationOperator#apply(org.objectweb.asm.tree.MethodNode, java.lang.String, java.lang.String, org.evosuite.cfg.BytecodeInstruction) */ /** {@inheritDoc} */ @Override public List<Mutation> apply(MethodNode mn, String className, String methodName, BytecodeInstruction instruction, Frame frame) { List<Mutation> mutations = new LinkedList<Mutation>(); if (mn.localVariables.isEmpty()) { logger.debug("Have no information about local variables - recompile with full debug information"); return mutations; } logger.debug("Starting variable replacement in " + methodName); try { String origName = getName(mn, instruction.getASMNode()); int numReplacements = 0; for (Entry<String, InsnList> mutation : getReplacements(mn, className, instruction.getASMNode(), frame) .entrySet()) { if (numReplacements++ > Properties.MAX_REPLACE_MUTANTS) { logger.info("Reached maximum number of variable replacements"); break; } // insert mutation into pool Mutation mutationObject = MutationPool.addMutation(className, methodName, NAME + " " + origName + " -> " + mutation.getKey(), instruction, mutation.getValue(), getInfectionDistance(getType(mn, instruction.getASMNode()), instruction.getASMNode(), mutation.getValue())); mutations.add(mutationObject); } } catch (VariableNotFoundException e) { logger.info("Variable not found: " + instruction); } logger.debug("Finished variable replacement in " + methodName); return mutations; } private Type getType(MethodNode mn, AbstractInsnNode node) throws VariableNotFoundException { if (node instanceof VarInsnNode) { LocalVariableNode var = getLocal(mn, node, ((VarInsnNode) node).var); return Type.getType(var.desc); } else if (node instanceof FieldInsnNode) { return Type.getType(((FieldInsnNode) node).desc); } else if (node instanceof IincInsnNode) { IincInsnNode incNode = (IincInsnNode) node; LocalVariableNode var = getLocal(mn, node, incNode.var); return Type.getType(var.desc); } else { throw new RuntimeException("Unknown variable node: " + node); } } private String getName(MethodNode mn, AbstractInsnNode node) throws VariableNotFoundException { if (node instanceof VarInsnNode) { LocalVariableNode var = getLocal(mn, node, ((VarInsnNode) node).var); return var.name; } else if (node instanceof FieldInsnNode) { return ((FieldInsnNode) node).name; } else if (node instanceof IincInsnNode) { IincInsnNode incNode = (IincInsnNode) node; LocalVariableNode var = getLocal(mn, node, incNode.var); return var.name; } else { throw new RuntimeException("Unknown variable node: " + node); } } /** * <p> * 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; } /** * <p> * 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)); } /** * <p> * 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)); } /** * <p> * 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; } /** * <p> * getDistance * </p> * * @param val1 * a double. * @param val2 * a double. * @return a double. */ public static double getDistance(double val1, double val2) { return val1 == val2 ? 1.0 : 0.0; } /** * <p> * getDistance * </p> * * @param obj1 * a {@link java.lang.Object} object. * @param obj2 * a {@link java.lang.Object} object. * @return a double. */ public static double getDistance(Object obj1, Object obj2) { if (obj1 == obj2) return 1.0; else return 0.0; } /** * Retrieve the set of variables that have the same type and are in scope * * @param node * @return */ private Map<String, InsnList> getReplacements(MethodNode mn, String className, AbstractInsnNode node, Frame frame) { Map<String, InsnList> variables = new HashMap<String, InsnList>(); if (node instanceof VarInsnNode) { VarInsnNode var = (VarInsnNode) node; try { LocalVariableNode origVar = getLocal(mn, node, var.var); //LocalVariableNode origVar = (LocalVariableNode) mn.localVariables.get(var.var); logger.debug("Looking for replacements for " + origVar.name + " of type " + origVar.desc + " at index " + origVar.index); // FIXXME: ASM gets scopes wrong, so we only use primitive vars? //if (!origVar.desc.startsWith("L")) variables.putAll(getLocalReplacements(mn, origVar.desc, node, frame)); variables.putAll(getFieldReplacements(mn, className, origVar.desc, node)); } catch (VariableNotFoundException e) { logger.info("Could not find variable, not replacing it: " + var.var); Iterator<?> it = mn.localVariables.iterator(); while (it.hasNext()) { LocalVariableNode n = (LocalVariableNode) it.next(); logger.info(n.index + ": " + n.name); } logger.info(e.toString()); e.printStackTrace(); } } else if (node instanceof FieldInsnNode) { FieldInsnNode field = (FieldInsnNode) node; if (field.owner.replace('/', '.').equals(className)) { logger.info("Looking for replacements for static field " + field.name + " of type " + field.desc); variables.putAll(getLocalReplacements(mn, field.desc, node, frame)); variables.putAll(getFieldReplacements(mn, className, field.desc, node)); } } else if (node instanceof IincInsnNode) { IincInsnNode incNode = (IincInsnNode) node; try { LocalVariableNode origVar = getLocal(mn, node, incNode.var); variables.putAll(getLocalReplacementsInc(mn, origVar.desc, incNode, frame)); } catch (VariableNotFoundException e) { logger.info("Could not find variable, not replacing it: " + incNode.var); } } else { //throw new RuntimeException("Unknown type: " + node); } return variables; } private LocalVariableNode getLocal(MethodNode mn, AbstractInsnNode node, int index) throws VariableNotFoundException { 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 " + localVar.index + " in scope " + startId + " - " + endId); if (currentId >= startId && currentId <= endId && localVar.index == index) return localVar; } throw new VariableNotFoundException("Could not find local variable " + index + " at position " + currentId + ", have variables: " + mn.localVariables.size()); } private Map<String, InsnList> getLocalReplacements(MethodNode mn, String desc, AbstractInsnNode node, Frame frame) { 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; } private Map<String, InsnList> getLocalReplacementsInc(MethodNode mn, String desc, IincInsnNode node, Frame frame) { 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; } private int getLoadOpcode(LocalVariableNode var) { Type type = Type.getType(var.desc); return type.getOpcode(Opcodes.ILOAD); } private Map<String, InsnList> getFieldReplacements(MethodNode mn, String className, String desc, AbstractInsnNode node) { 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; } /** * Generates the instructions to cast a numerical value from one type to * another. * * @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; } /** * This replicates TestUsageChecker.canUse but we need to avoid that * we try to access Properties.getTargetClassAndDontInitialise * * @param f * @return */ public static boolean canUse(Field f) { if (f.getDeclaringClass().equals(java.lang.Object.class)) return false;// handled here to avoid printing reasons if (f.getDeclaringClass().equals(java.lang.Thread.class)) return false;// handled here to avoid printing reasons if (f.isSynthetic()) { logger.debug("Skipping synthetic field " + f.getName()); return false; } if (f.getName().startsWith("ajc$")) { logger.debug("Skipping AspectJ field " + f.getName()); return false; } // in, out, err if (f.getDeclaringClass().equals(FileDescriptor.class)) { return false; } if (Modifier.isPublic(f.getModifiers())) { // It may still be the case that the field is defined in a non-visible superclass of the class // we already know we can use. In that case, the compiler would be fine with accessing the // field, but reflection would start complaining about IllegalAccess! // Therefore, we set the field accessible to be on the safe side TestClusterUtils.makeAccessible(f); return true; } // If default access rights, then check if this class is in the same package as the target class if (!Modifier.isPrivate(f.getModifiers())) { String packageName = ClassUtils.getPackageName(f.getDeclaringClass()); if (packageName.equals(Properties.CLASS_PREFIX)) { TestClusterUtils.makeAccessible(f); return true; } } return false; } /* (non-Javadoc) * @see org.evosuite.cfg.instrumentation.mutation.MutationOperator#isApplicable(org.evosuite.cfg.BytecodeInstruction) */ /** {@inheritDoc} */ @Override public boolean isApplicable(BytecodeInstruction instruction) { return instruction.isLocalVariableUse() || instruction.getASMNode().getOpcode() == Opcodes.GETSTATIC || instruction.getASMNode().getOpcode() == Opcodes.GETFIELD; } }