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.util.Arrays; import java.util.HashSet; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Set; import org.evosuite.PackageInfo; import org.evosuite.coverage.mutation.Mutation; import org.evosuite.coverage.mutation.MutationPool; import org.evosuite.graphs.cfg.BytecodeInstruction; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; import org.objectweb.asm.tree.AbstractInsnNode; 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.Frame; /** * <p>ReplaceArithmeticOperator class.</p> * * @author Gordon Fraser */ public class ReplaceArithmeticOperator implements MutationOperator { public static final String NAME = "ReplaceArithmeticOperator"; private static Set<Integer> opcodesInt = new HashSet<Integer>(); private static Set<Integer> opcodesLong = new HashSet<Integer>(); private static Set<Integer> opcodesFloat = new HashSet<Integer>(); private static Set<Integer> opcodesDouble = new HashSet<Integer>(); private int numVariable = 0; static { opcodesInt.addAll(Arrays .asList(new Integer[] { Opcodes.IADD, Opcodes.ISUB, Opcodes.IMUL, Opcodes.IDIV, Opcodes.IREM })); opcodesLong.addAll(Arrays .asList(new Integer[] { Opcodes.LADD, Opcodes.LSUB, Opcodes.LMUL, Opcodes.LDIV, Opcodes.LREM })); opcodesFloat.addAll(Arrays .asList(new Integer[] { Opcodes.FADD, Opcodes.FSUB, Opcodes.FMUL, Opcodes.FDIV, Opcodes.FREM })); opcodesDouble.addAll(Arrays .asList(new Integer[] { Opcodes.DADD, Opcodes.DSUB, Opcodes.DMUL, Opcodes.DDIV, Opcodes.DREM })); } private String getOp(int opcode) { switch (opcode) { case Opcodes.IADD: case Opcodes.LADD: case Opcodes.FADD: case Opcodes.DADD: return "+"; case Opcodes.ISUB: case Opcodes.LSUB: case Opcodes.FSUB: case Opcodes.DSUB: return "-"; case Opcodes.IMUL: case Opcodes.LMUL: case Opcodes.FMUL: case Opcodes.DMUL: return "*"; case Opcodes.IDIV: case Opcodes.LDIV: case Opcodes.FDIV: case Opcodes.DDIV: return "/"; case Opcodes.IREM: case Opcodes.LREM: case Opcodes.FREM: case Opcodes.DREM: return "%"; } throw new RuntimeException("Unknown opcode: " + opcode); } /** * <p>getNextIndex</p> * * @param mn a {@link org.objectweb.asm.tree.MethodNode} object. * @return a int. */ @SuppressWarnings("rawtypes") public static int getNextIndex(MethodNode mn) { Iterator it = mn.localVariables.iterator(); int max = 0; int next = 0; while (it.hasNext()) { LocalVariableNode var = (LocalVariableNode) it.next(); int index = var.index; if (index >= max) { max = index; next = max + Type.getType(var.desc).getSize(); } } if (next == 0) next = getNextIndexFromLoad(mn); return next; } @SuppressWarnings("rawtypes") private static int getNextIndexFromLoad(MethodNode mn) { Iterator it = mn.instructions.iterator(); int index = 0; while (it.hasNext()) { AbstractInsnNode node = (AbstractInsnNode) it.next(); if (node instanceof VarInsnNode) { VarInsnNode varNode = (VarInsnNode) node; int varIndex = varNode.var; switch (varNode.getOpcode()) { case Opcodes.ALOAD: case Opcodes.ILOAD: case Opcodes.FLOAD: case Opcodes.IALOAD: case Opcodes.BALOAD: case Opcodes.CALOAD: case Opcodes.AALOAD: case Opcodes.ASTORE: case Opcodes.ISTORE: case Opcodes.FSTORE: case Opcodes.IASTORE: case Opcodes.BASTORE: case Opcodes.CASTORE: case Opcodes.AASTORE: index = Math.max(index, varIndex + 1); break; case Opcodes.DLOAD: case Opcodes.DSTORE: case Opcodes.LLOAD: case Opcodes.LSTORE: case Opcodes.DALOAD: case Opcodes.DASTORE: case Opcodes.LALOAD: case Opcodes.LASTORE: index = Math.max(index, varIndex + 2); break; } } } return index; } /* (non-Javadoc) * @see org.evosuite.cfg.instrumentation.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) { numVariable = getNextIndex(mn); List<Mutation> mutations = new LinkedList<Mutation>(); InsnNode node = (InsnNode) instruction.getASMNode(); for (int opcode : getMutations(node.getOpcode())) { InsnNode mutation = new InsnNode(opcode); // insert mutation into pool Mutation mutationObject = MutationPool.addMutation(className, methodName, NAME + " " + getOp(node.getOpcode()) + " -> " + getOp(opcode), instruction, mutation, getInfectionDistance(node.getOpcode(), opcode)); mutations.add(mutationObject); } return mutations; } private Set<Integer> getMutations(int opcode) { Set<Integer> replacement = new HashSet<Integer>(); if (opcodesInt.contains(opcode)) replacement.addAll(opcodesInt); else if (opcodesLong.contains(opcode)) replacement.addAll(opcodesLong); else if (opcodesFloat.contains(opcode)) replacement.addAll(opcodesFloat); else if (opcodesDouble.contains(opcode)) replacement.addAll(opcodesDouble); replacement.remove(opcode); return replacement; } /** * <p>getInfectionDistance</p> * * @param opcodeOrig a int. * @param opcodeNew a int. * @return a {@link org.objectweb.asm.tree.InsnList} object. */ public InsnList getInfectionDistance(int opcodeOrig, int opcodeNew) { InsnList distance = new InsnList(); if (opcodesInt.contains(opcodeOrig)) { distance.add(new InsnNode(Opcodes.DUP2)); distance.add(new LdcInsnNode(opcodeOrig)); distance.add(new LdcInsnNode(opcodeNew)); distance.add(new MethodInsnNode(Opcodes.INVOKESTATIC, PackageInfo.getNameWithSlash(ReplaceArithmeticOperator.class), "getInfectionDistanceInt", "(IIII)D", false)); } else if (opcodesLong.contains(opcodeOrig)) { distance.add(new VarInsnNode(Opcodes.LSTORE, numVariable)); distance.add(new InsnNode(Opcodes.DUP2)); distance.add(new VarInsnNode(Opcodes.LLOAD, numVariable)); distance.add(new InsnNode(Opcodes.DUP2_X2)); distance.add(new LdcInsnNode(opcodeOrig)); distance.add(new LdcInsnNode(opcodeNew)); distance.add(new MethodInsnNode(Opcodes.INVOKESTATIC, PackageInfo.getNameWithSlash(ReplaceArithmeticOperator.class), "getInfectionDistanceLong", "(JJII)D", false)); numVariable += 2; } else if (opcodesFloat.contains(opcodeOrig)) { distance.add(new InsnNode(Opcodes.DUP2)); distance.add(new LdcInsnNode(opcodeOrig)); distance.add(new LdcInsnNode(opcodeNew)); distance.add(new MethodInsnNode(Opcodes.INVOKESTATIC, PackageInfo.getNameWithSlash(ReplaceArithmeticOperator.class), "getInfectionDistanceFloat", "(FFII)D", false)); } else if (opcodesDouble.contains(opcodeOrig)) { distance.add(new VarInsnNode(Opcodes.DSTORE, numVariable)); distance.add(new InsnNode(Opcodes.DUP2)); distance.add(new VarInsnNode(Opcodes.DLOAD, numVariable)); distance.add(new InsnNode(Opcodes.DUP2_X2)); distance.add(new LdcInsnNode(opcodeOrig)); distance.add(new LdcInsnNode(opcodeNew)); distance.add(new MethodInsnNode(Opcodes.INVOKESTATIC, PackageInfo.getNameWithSlash(ReplaceArithmeticOperator.class), "getInfectionDistanceDouble", "(DDII)D", false)); numVariable += 2; } return distance; } private static boolean hasDivZeroError(int opcode) { switch (opcode) { case Opcodes.IDIV: case Opcodes.IREM: case Opcodes.FDIV: case Opcodes.FREM: case Opcodes.LDIV: case Opcodes.LREM: case Opcodes.DDIV: case Opcodes.DREM: return true; default: return false; } } /** * <p>getInfectionDistanceInt</p> * * @param x a int. * @param y a int. * @param opcodeOrig a int. * @param opcodeNew a int. * @return a double. */ public static double getInfectionDistanceInt(int x, int y, int opcodeOrig, int opcodeNew) { if (y == 0) { return hasDivZeroError(opcodeOrig) == hasDivZeroError(opcodeNew) ? 1.0 : 0.0; } int origValue = calculate(x, y, opcodeOrig); int newValue = calculate(x, y, opcodeNew); return origValue == newValue ? 1.0 : 0.0; } /** * <p>getInfectionDistanceLong</p> * * @param x a long. * @param y a long. * @param opcodeOrig a int. * @param opcodeNew a int. * @return a double. */ public static double getInfectionDistanceLong(long x, long y, int opcodeOrig, int opcodeNew) { if (y == 0L) { return hasDivZeroError(opcodeOrig) == hasDivZeroError(opcodeNew) ? 1.0 : 0.0; } long origValue = calculate(x, y, opcodeOrig); long newValue = calculate(x, y, opcodeNew); return origValue == newValue ? 1.0 : 0.0; } /** * <p>getInfectionDistanceFloat</p> * * @param x a float. * @param y a float. * @param opcodeOrig a int. * @param opcodeNew a int. * @return a double. */ public static double getInfectionDistanceFloat(float x, float y, int opcodeOrig, int opcodeNew) { if (y == 0.0F) { return hasDivZeroError(opcodeOrig) == hasDivZeroError(opcodeNew) ? 1.0 : 0.0; } float origValue = calculate(x, y, opcodeOrig); float newValue = calculate(x, y, opcodeNew); return origValue == newValue ? 1.0 : 0.0; } /** * <p>getInfectionDistanceDouble</p> * * @param x a double. * @param y a double. * @param opcodeOrig a int. * @param opcodeNew a int. * @return a double. */ public static double getInfectionDistanceDouble(double x, double y, int opcodeOrig, int opcodeNew) { if (y == 0.0) { return hasDivZeroError(opcodeOrig) == hasDivZeroError(opcodeNew) ? 1.0 : 0.0; } double origValue = calculate(x, y, opcodeOrig); double newValue = calculate(x, y, opcodeNew); return origValue == newValue ? 1.0 : 0.0; } /** * <p>calculate</p> * * @param x a int. * @param y a int. * @param opcode a int. * @return a int. */ public static int calculate(int x, int y, int opcode) { switch (opcode) { case Opcodes.IADD: return x + y; case Opcodes.ISUB: return x - y; case Opcodes.IMUL: return x * y; case Opcodes.IDIV: return x / y; case Opcodes.IREM: return x % y; } throw new RuntimeException("Unknown integer opcode: " + opcode); } /** * <p>calculate</p> * * @param x a long. * @param y a long. * @param opcode a int. * @return a long. */ public static long calculate(long x, long y, int opcode) { switch (opcode) { case Opcodes.LADD: return x + y; case Opcodes.LSUB: return x - y; case Opcodes.LMUL: return x * y; case Opcodes.LDIV: return x / y; case Opcodes.LREM: return x % y; } throw new RuntimeException("Unknown integer opcode: " + opcode); } /** * <p>calculate</p> * * @param x a float. * @param y a float. * @param opcode a int. * @return a float. */ public static float calculate(float x, float y, int opcode) { switch (opcode) { case Opcodes.FADD: return x + y; case Opcodes.FSUB: return x - y; case Opcodes.FMUL: return x * y; case Opcodes.FDIV: return x / y; case Opcodes.FREM: return x % y; } throw new RuntimeException("Unknown integer opcode: " + opcode); } /** * <p>calculate</p> * * @param x a double. * @param y a double. * @param opcode a int. * @return a double. */ public static double calculate(double x, double y, int opcode) { switch (opcode) { case Opcodes.DADD: return x + y; case Opcodes.DSUB: return x - y; case Opcodes.DMUL: return x * y; case Opcodes.DDIV: return x / y; case Opcodes.DREM: return x % y; } throw new RuntimeException("Unknown integer opcode: " + opcode); } /* (non-Javadoc) * @see org.evosuite.cfg.instrumentation.mutation.MutationOperator#isApplicable(org.evosuite.cfg.BytecodeInstruction) */ /** {@inheritDoc} */ @Override public boolean isApplicable(BytecodeInstruction instruction) { AbstractInsnNode node = instruction.getASMNode(); int opcode = node.getOpcode(); if (opcodesInt.contains(opcode)) return true; else if (opcodesLong.contains(opcode)) return true; else if (opcodesFloat.contains(opcode)) return true; else if (opcodesDouble.contains(opcode)) return true; return false; } }