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.junit; import java.io.IOException; import java.io.InputStream; import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Set; import org.apache.commons.lang3.StringUtils; import org.evosuite.PackageInfo; import org.evosuite.Properties; import org.evosuite.TestGenerationContext; import org.evosuite.annotations.EvoSuiteTest; import org.evosuite.classpath.ClassPathHacker; import org.evosuite.classpath.ResourceList; import org.objectweb.asm.ClassReader; import org.objectweb.asm.Opcodes; import org.objectweb.asm.tree.AbstractInsnNode; import org.objectweb.asm.tree.AnnotationNode; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.InsnList; import org.objectweb.asm.tree.MethodInsnNode; import org.objectweb.asm.tree.MethodNode; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * For a given JUnit test class, determine which class it seems to be testing. * * @author Gordon Fraser * */ public class DetermineSUT { private final static Logger logger = LoggerFactory.getLogger(DetermineSUT.class); private String targetName = ""; private Set<String> superClasses = new HashSet<String>(); public static class NoJUnitClassException extends Exception { private static final long serialVersionUID = -7035856440476749976L; } private class TargetClassSorter implements Comparator<String> { private final String targetClass; public TargetClassSorter(String target) { this.targetClass = target; } @Override public int compare(String arg0, String arg1) { double distance1 = StringUtils.getLevenshteinDistance(targetClass, arg0); double distance2 = StringUtils.getLevenshteinDistance(targetClass, arg1); return Double.compare(distance1, distance2); } } public String getSUTName(String fullyQualifiedTargetClass, String targetClassPath) throws NoJUnitClassException { this.targetName = fullyQualifiedTargetClass; try { ClassPathHacker.addFile(targetClassPath); } catch (IOException e1) { // TODO Auto-generated catch block e1.printStackTrace(); } Set<String> targetClasses = ResourceList .getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()) .getAllClasses(targetClassPath, false); Set<String> candidateClasses = new HashSet<String>(); boolean hasJUnit = false; try { candidateClasses.addAll(determineCalledClasses(fullyQualifiedTargetClass, targetClasses)); hasJUnit = true; } catch (ClassNotFoundException e) { // Ignore, the set will be empty? logger.error("Class not found: " + e, e); return ""; } catch (NoJUnitClassException e) { } if (!hasJUnit) throw new NoJUnitClassException(); if (candidateClasses.isEmpty()) return "<UNKNOWN>"; List<String> sortedNames = new ArrayList<String>(candidateClasses); Collections.sort(sortedNames, new TargetClassSorter(fullyQualifiedTargetClass)); //System.out.println("Sorted candidate classes: " + sortedNames); return sortedNames.get(0); } public Set<String> determineCalledClasses(String fullyQualifiedTargetClass, Set<String> targetClasses) throws ClassNotFoundException, NoJUnitClassException { Set<String> calledClasses = new HashSet<String>(); String className = fullyQualifiedTargetClass.replace('.', '/'); try { InputStream is = ClassLoader.getSystemResourceAsStream(className + ".class"); if (is == null) { throw new ClassNotFoundException("Class '" + className + ".class" + "' should be in target project, but could not be found!"); } ClassReader reader = new ClassReader(is); ClassNode classNode = new ClassNode(); reader.accept(classNode, ClassReader.SKIP_FRAMES); superClasses = getSuperClasses(classNode); if (isJUnitTest(classNode)) { handleClassNode(calledClasses, classNode, targetClasses); } else { throw new NoJUnitClassException(); } } catch (IOException e) { e.printStackTrace(); } calledClasses.remove("java.lang.Object"); calledClasses.remove(fullyQualifiedTargetClass); return calledClasses; } @SuppressWarnings("unchecked") private void handleClassNode(Set<String> calledClasses, ClassNode cn, Set<String> targetClasses) throws IOException { List<MethodNode> methods = cn.methods; for (MethodNode mn : methods) { handleMethodNode(calledClasses, cn, mn, targetClasses); } } /** * <p> * isJavaClass * </p> * * @param classNameWithDots * a {@link java.lang.String} object. * @return a boolean. */ public static boolean isJavaClass(String classNameWithDots) { return classNameWithDots.startsWith("java.") // || classNameWithDots.startsWith("javax.") // || classNameWithDots.startsWith("sun.") // || classNameWithDots.startsWith("apple.") || classNameWithDots.startsWith("com.apple."); } private boolean isValidClass(String name) throws IOException { if (isJavaClass(name)) return false; if (name.startsWith("junit")) return false; if (name.startsWith("org.junit")) return false; if (name.startsWith(targetName)) return false; if (superClasses.contains(name)) return false; ClassNode sutNode = loadClassNode(name); if (isJUnitTest(sutNode)) { return false; } return true; } @SuppressWarnings("unchecked") private void handleMethodNode(Set<String> calledClasses, ClassNode cn, MethodNode mn, Set<String> targetClasses) throws IOException { InsnList instructions = mn.instructions; Iterator<AbstractInsnNode> iterator = instructions.iterator(); while (iterator.hasNext()) { AbstractInsnNode insn = iterator.next(); if (insn instanceof MethodInsnNode) { String name = ResourceList.getClassNameFromResourcePath(((MethodInsnNode) insn).owner); if (!targetClasses.contains(name)) continue; if (isValidClass(name)) calledClasses.add(name); } } } @SuppressWarnings("unchecked") private boolean isJUnitTest(ClassNode cn) throws IOException { // We do not consider abstract classes if ((cn.access & Opcodes.ACC_ABSTRACT) == Opcodes.ACC_ABSTRACT) return false; if (hasJUnitSuperclass(cn)) return true; List<MethodNode> methods = cn.methods; for (MethodNode mn : methods) { List<AnnotationNode> annotations = mn.visibleAnnotations; if (annotations != null) { for (AnnotationNode an : annotations) { if (an.desc.equals("Lorg/junit/Test;") || an.desc.equals("L" + PackageInfo.getNameWithSlash(EvoSuiteTest.class) + ";")) return true; } } } return false; } private Set<String> getSuperClasses(ClassNode cn) throws IOException { Set<String> superClasses = new HashSet<>(); String currentSuper = cn.superName; while (!currentSuper.equals("java/lang/Object")) { superClasses.add(ResourceList.getClassNameFromResourcePath(currentSuper)); ClassNode superNode = loadClassNode(currentSuper); currentSuper = superNode.superName; } return superClasses; } private boolean hasJUnitSuperclass(ClassNode cn) throws IOException { if (cn.superName.equals("java/lang/Object")) return false; if (cn.superName.equals("junit/framework/TestCase")) return true; ClassNode superClass = loadClassNode(cn.superName); return hasJUnitSuperclass(superClass); } private ClassNode loadClassNode(String className) throws IOException { ClassReader reader = new ClassReader( ResourceList.getInstance(TestGenerationContext.getInstance().getClassLoaderForSUT()) .getClassAsStream(className)); ClassNode cn = new ClassNode(); reader.accept(cn, ClassReader.SKIP_FRAMES); // | ClassReader.SKIP_DEBUG); return cn; } /** * @param args */ public static void main(String[] args) { if (args.length != 2) { System.err.println("Expected parameters: <TestCase> <Target Classpath>"); return; } Properties.getInstanceSilent(); DetermineSUT det = new DetermineSUT(); try { System.out.println(det.getSUTName(args[0], args[1])); } catch (NoJUnitClassException e) { System.err.println("Found no JUnit test case"); } } }