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/>. */ /** * <p>DescriptorMapping class.</p> * * @author Gordon Fraser */ package org.evosuite.instrumentation.testability; import java.io.IOException; import java.util.HashMap; import java.util.HashSet; import java.util.LinkedList; import java.util.Map; import java.util.Queue; import java.util.Set; import org.evosuite.PackageInfo; import org.evosuite.Properties; import org.evosuite.TestGenerationContext; import org.evosuite.classpath.ResourceList; import org.objectweb.asm.ClassReader; import org.objectweb.asm.Type; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.FieldNode; import org.objectweb.asm.tree.MethodNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class DescriptorMapping { private static int id = 0; private final Map<String, String> descriptorMapping = new HashMap<String, String>(); private static Logger logger = LoggerFactory.getLogger(DescriptorMapping.class); private static DescriptorMapping instance = null; private DescriptorMapping() { } /** * <p>Getter for the field <code>instance</code>.</p> * * @return a {@link DescriptorMapping} object. */ public static DescriptorMapping getInstance() { if (instance == null) instance = new DescriptorMapping(); return instance; } final Map<String, String> originalDesc = new HashMap<String, String>(); final Map<String, String> originalName = new HashMap<String, String>(); private final Map<String, String> nameMapping = new HashMap<String, String>(); /** * <p>shouldTransform</p> * * @param classNameUnknown a {@link java.lang.String} object. * @return a boolean. */ public static boolean shouldTransform(String classNameUnknown) { //return false; String className = classNameUnknown.replace('/', '.'); switch (Properties.TT_SCOPE) { case ALL: return true; case TARGET: if (className.equals(Properties.TARGET_CLASS) || className.startsWith(Properties.TARGET_CLASS + "$")) return true; break; case PREFIX: if (className.startsWith(Properties.PROJECT_PREFIX)) return true; } return false; } /** * <p>isTransformedMethod</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean isTransformedMethod(String className, String methodName, String desc) { logger.info("Initiating transformation of " + methodName); getMethodDesc(className, methodName, desc); // return originalDesc.containsKey(className.replace('.', '/') + "/" + methodName // + desc); return descriptorMapping.containsKey(className.replace('.', '/') + "/" + methodName + desc); } /** * <p>hasTransformedArguments</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean hasTransformedArguments(String className, String methodName, String desc) { getMethodDesc(className, methodName, desc); if (!originalDesc.containsKey(className.replace('.', '/') + "/" + methodName + desc)) { return false; } else { String newDesc = originalDesc.get(className.replace('.', '/') + "/" + methodName + desc); for (Type type : Type.getArgumentTypes(newDesc)) { if (type.equals(Type.BOOLEAN_TYPE)) return true; } return false; } } /** * <p>isTransformedField</p> * * @param className a {@link java.lang.String} object. * @param fieldName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean isTransformedField(String className, String fieldName, String desc) { getFieldDesc(className, fieldName, desc); return descriptorMapping.containsKey(className.replace('.', '/') + "/" + fieldName + desc); } /** * <p>isTransformedOrBooleanMethod</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean isTransformedOrBooleanMethod(String className, String methodName, String desc) { logger.info("Checking method: " + className + "." + methodName + desc); String new_desc = getMethodDesc(className, methodName, desc); logger.info("Transformed desc is " + new_desc); String name = className.replace('.', '/') + "/" + methodName + desc; if (originalDesc.containsKey(name)) { logger.info("Desc is already transformed"); } return originalDesc.containsKey(name) || isBooleanMethod(desc); } private boolean isStringReplacement(String className, String methodName) { //FIXME the class TestabilityTransformation does not seem to exist any more... if (className.equals("org/evosuite/instrumentation/TestabilityTransformation")) { if (methodName.equals("StringEquals") || methodName.equals("StringEqualsIgnoreCase") || methodName.equals("StringIsEmpty") || methodName.equals("StringStartsWith") || methodName.equals("StringEndsWith")) return true; } return false; } /** * <p>isTransformedOrBooleanReturnMethod</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean isTransformedOrBooleanReturnMethod(String className, String methodName, String desc) { if (isStringReplacement(className, methodName)) return true; logger.info("Checking method: " + className + "." + methodName + desc); String new_desc = getMethodDesc(className, methodName, desc); logger.info("Transformed desc is " + new_desc); String name = className.replace('.', '/') + "/" + methodName + desc; if (originalDesc.containsKey(name)) { return Type.getReturnType(originalDesc.get(name)).equals(Type.BOOLEAN_TYPE); } else { return Type.getReturnType(desc).equals(Type.BOOLEAN_TYPE); } } /** * <p>isTransformedOrBooleanField</p> * * @param className a {@link java.lang.String} object. * @param fieldName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean isTransformedOrBooleanField(String className, String fieldName, String desc) { logger.info("Checking field: " + className + "." + fieldName + desc); String new_desc = getFieldDesc(className, fieldName, desc); logger.info("Transformed desc is " + new_desc); String name = className.replace('.', '/') + "/" + fieldName + desc; if (originalDesc.containsKey(name)) { logger.info("Desc is already transformed"); } return originalDesc.containsKey(name) || isBooleanField(desc); } /** * <p>isBooleanMethod</p> * * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean isBooleanMethod(String desc) { Type[] types = Type.getArgumentTypes(desc); for (Type type : types) { if (type.equals(Type.BOOLEAN_TYPE)) { return true; } else if (type.getDescriptor().equals("[Z")) { return true; } } Type type = Type.getReturnType(desc); if (type.equals(Type.BOOLEAN_TYPE)) { return true; } else if (type.getDescriptor().equals("[Z")) { return true; } return false; } /** * <p>hasBooleanParameters</p> * * @param desc a {@link java.lang.String} object. * @return a boolean. */ public boolean hasBooleanParameters(String desc) { for (Type t : Type.getArgumentTypes(desc)) { if (t.equals(Type.BOOLEAN_TYPE)) return true; } return false; } private boolean isInside(String className) { //return false; String classNameWithDots = className.replace('/', '.'); switch (Properties.TT_SCOPE) { case ALL: if (!classNameWithDots.startsWith("java") && !classNameWithDots.startsWith("sun")) return true; case TARGET: if (classNameWithDots.equals(Properties.TARGET_CLASS) || classNameWithDots.startsWith(Properties.TARGET_CLASS + "$")) return true; break; case PREFIX: if (classNameWithDots.startsWith(Properties.PROJECT_PREFIX)) return true; } return false; } private boolean isBooleanField(String desc) { logger.info("Checkign type of field " + desc); return desc.endsWith("Z"); //Type type = Type.getType(desc); //return type.equals(Type.BOOLEAN_TYPE) // || (type.equals(Type.ARRAY) && type.getElementType().equals(Type.BOOLEAN_TYPE)); } private boolean isOutsideMethod(String className, String methodName, String desc) { Set<String> visited = new HashSet<String>(); Queue<String> parents = new LinkedList<String>(); parents.add(className); while (!parents.isEmpty()) { String name = parents.poll(); if (name == null) continue; visited.add(name); logger.info("Visiting class " + name + " while looking for source of " + className + "." + methodName); ClassReader reader; try { reader = new ClassReader( ResourceList.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()) .getClassAsStream(name)); ClassNode parent = new ClassNode(); reader.accept(parent, ClassReader.EXPAND_FRAMES); boolean isInside = isInside(parent.name); //boolean isInside = parent.name.startsWith(Properties.PROJECT_PREFIX.replace(".", // "/")) // || (!Properties.TARGET_CLASS_PREFIX.isEmpty() && parent.name.startsWith(Properties.TARGET_CLASS_PREFIX.replace(".", // "/"))); logger.info("Checking " + parent.name); for (Object o : parent.methods) { MethodNode mn2 = (MethodNode) o; if (mn2.name.equals(methodName) && mn2.desc.equals(desc)) { if (!isInside) { logger.info("Method " + name + " was defined outside the test package"); return true; } else { logger.info("Method " + name + " was defined outside the test package"); //return false; } } } for (Object o : parent.interfaces) { String par = (String) o; if (!visited.contains(par) && !parents.contains(par)) { parents.add(par); } } if (!visited.contains(parent.superName) && !parents.contains(parent.superName)) { parents.add(parent.superName); } } catch (IOException e) { logger.info("Error reading class " + name); } } return false; } private String transformMethodName(String className, String methodName, String desc, String transformedDesc) { Set<String> visited = new HashSet<String>(); Queue<String> parents = new LinkedList<String>(); parents.add(className); while (!parents.isEmpty()) { String name = parents.poll(); if (name == null) continue; visited.add(name); logger.info("Visiting class " + name + " while looking for name clashes of " + className + "." + methodName + transformedDesc); ClassReader reader; try { reader = new ClassReader( ResourceList.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()) .getClassAsStream(name)); ClassNode parent = new ClassNode(); reader.accept(parent, ClassReader.EXPAND_FRAMES); if (originalDesc.containsKey(className + "." + methodName + transformedDesc)) { logger.info("Method " + methodName + " has conflicting transformed method"); return methodName + "_transformed" + (id++); } for (Object o : parent.methods) { MethodNode mn2 = (MethodNode) o; //logger.info("Checking " + parent.name + "." + mn2.name + mn2.desc); if (mn2.name.equals(methodName) && mn2.desc.equals(transformedDesc)) { logger.info("Method " + methodName + " has conflicting method"); if (methodName.equals("<init>")) return null; // TODO: This should be a bit nicer return methodName + "_transformed" + (id++); } } for (Object o : parent.interfaces) { String par = (String) o; if (!visited.contains(par) && !parents.contains(par)) { parents.add(par); } } if (!visited.contains(parent.superName) && !parents.contains(parent.superName)) { parents.add(parent.superName); } } catch (IOException e) { logger.info("Error reading class " + name); } } return methodName; } private boolean isOutsideField(String className, String fieldName, String desc) { Set<String> visited = new HashSet<String>(); Queue<String> parents = new LinkedList<String>(); parents.add(className); while (!parents.isEmpty()) { String name = parents.poll(); if (name == null) continue; visited.add(name); logger.info("Checking class " + name + " while looking for definition of field " + fieldName); ClassReader reader; try { reader = new ClassReader( ResourceList.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()) .getClassAsStream(name)); ClassNode parent = new ClassNode(); reader.accept(parent, ClassReader.EXPAND_FRAMES); boolean isInside = isInside(parent.name); // boolean isInside = parent.name.startsWith(Properties.PROJECT_PREFIX.replace(".", // "/")) // | parent.name.startsWith(Properties.TARGET_CLASS_PREFIX.replace(".", // "/")); for (Object o : parent.fields) { FieldNode mn2 = (FieldNode) o; if (mn2.name.equals(fieldName) && mn2.desc.equals(desc)) { //if ((mn2.access & Opcodes.ACC_SYNTHETIC) == Opcodes.ACC_SYNTHETIC) { // logger.info("Not transforming synthetic field " + mn2.name); // return true; //} if (!isInside) { logger.info("Field " + name + " was defined outside the test package - " + parent.name); return true; } else { logger.info("Field " + name + " was defined inside the test package " + parent.name); return false; } } } for (Object o : parent.interfaces) { String par = (String) o; if (!visited.contains(par) && !parents.contains(par)) { parents.add(par); } } if (!visited.contains(parent.superName) && !parents.contains(parent.superName)) { parents.add(parent.superName); } } catch (IOException e) { logger.info("Error reading class " + name); } } return false; } private String transformMethodDescriptor(String desc) { String new_desc = "("; Type[] types = Type.getArgumentTypes(desc); for (Type type : types) { if (type.equals(Type.BOOLEAN_TYPE)) { new_desc += "I"; } else if (type.getDescriptor().equals("[Z")) { new_desc += "[I"; } else { new_desc += type.getDescriptor(); } } new_desc += ")"; Type type = Type.getReturnType(desc); if (type.equals(Type.BOOLEAN_TYPE)) { new_desc += "I"; } else if (type.getDescriptor().equals("[Z")) { new_desc += "[I"; } else { new_desc += type.getDescriptor(); } return new_desc; } private String transformFieldDescriptor(String className, String desc) { if (!shouldTransform(className)) { return desc; } logger.info("Transforming field instruction " + desc); if (isBooleanField(desc)) { // TODO: Check if this is actually transformed or not if (desc.equals("Z")) return "I"; else if (desc.equals("[Z")) return "[I"; else return desc; } else { return desc; } } /** * <p>getMethodName</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a {@link java.lang.String} object. */ public String getMethodName(String className, String methodName, String desc) { if (!shouldTransform(className)) { return methodName; } String old = className + "." + methodName + desc; old = old.replace('.', '/'); if (isBooleanMethod(desc)) { getMethodDesc(className, methodName, desc); return nameMapping.get(old); } else { if (nameMapping.containsKey(old)) return nameMapping.get(old); else return methodName; } } /** * <p>getMethodDesc</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a {@link java.lang.String} object. */ public String getMethodDesc(String className, String methodName, String desc) { if (!shouldTransform(className)) { return desc; } if (isBooleanMethod(desc)) { String old = className.replace('.', '/') + "/" + methodName + desc; //old = old.replace('.', '/'); if (!descriptorMapping.containsKey(old)) { if (isOutsideMethod(className, methodName, desc)) { logger.info("Is outside method: " + className + "." + methodName); descriptorMapping.put(old, desc); nameMapping.put(old, methodName); } else { logger.info("Is inside method: " + className + "." + methodName); String newDesc = transformMethodDescriptor(desc); String newName = transformMethodName(className, methodName, desc, newDesc); if (newName != null) { descriptorMapping.put(old, newDesc); nameMapping.put(old, newName); //nameMapping.put(className + "." + methodName + newDesc, // newName); logger.info("Keeping transformation from " + old + " to " + descriptorMapping.get(old) + " with new name " + newName); originalDesc.put(className.replace('.', '/') + "/" + newName + newDesc, desc); originalName.put(className.replace('.', '/') + "/" + newName + newDesc, methodName); } else { descriptorMapping.put(old, desc); nameMapping.put(old, methodName); // toDO: Original? originalDesc.put(className.replace('.', '/') + "/" + methodName + newDesc, desc); originalName.put(className.replace('.', '/') + "/" + methodName + newDesc, methodName); } } } return descriptorMapping.get(old); } else { return desc; } } /** * <p>getFieldDesc</p> * * @param className a {@link java.lang.String} object. * @param fieldName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a {@link java.lang.String} object. */ public String getFieldDesc(String className, String fieldName, String desc) { if (!shouldTransform(className)) { return desc; } if (isBooleanField(desc)) { String old = className.replace('.', '/') + "/" + fieldName + desc; //old = old.replace('.', '/'); if (!descriptorMapping.containsKey(old)) { if (isOutsideField(className, fieldName, desc)) { descriptorMapping.put(old, desc); } else { descriptorMapping.put(old, transformFieldDescriptor(className, desc)); originalDesc.put(className.replace('.', '/') + "/" + fieldName + descriptorMapping.get(old), desc); } } return descriptorMapping.get(old); } else { return desc; } } /** * <p>Getter for the field <code>originalName</code>.</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a {@link java.lang.String} object. */ public String getOriginalName(String className, String methodName, String desc) { String key = className.replace('.', '/') + "/" + methodName + desc; if (originalName.containsKey(key)) { logger.info("Found transformed version of " + className + "." + methodName + desc); return originalName.get(key); } else { logger.info("Don't have transformed version of " + className + "." + methodName + desc); return methodName; } } /** * <p>getOriginalDescriptor</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return a {@link java.lang.String} object. */ public String getOriginalDescriptor(String className, String methodName, String desc) { String key = className.replace('.', '/') + "/" + methodName + desc; if (originalDesc.containsKey(key)) { logger.info("Found transformed version of " + className + "." + methodName + desc); return originalDesc.get(key); } else { logger.info("Don't have transformed version of " + className + "." + methodName + desc); return desc; } } /** * <p>getOriginalTypes</p> * * @param className a {@link java.lang.String} object. * @param methodName a {@link java.lang.String} object. * @param desc a {@link java.lang.String} object. * @return an array of {@link org.objectweb.asm.Type} objects. */ public Type[] getOriginalTypes(String className, String methodName, String desc) { String key = className.replace('.', '/') + "/" + methodName + desc; if (originalDesc.containsKey(key)) return org.objectweb.asm.Type.getArgumentTypes(originalDesc.get(key)); else return org.objectweb.asm.Type.getArgumentTypes(desc); } }