public static GetStaticGraph generate(String className) { ClassNode targetClass = DependencyAnalysis.getClassNode(className); GetStaticGraph staticUsageTree = new GetStaticGraph(); if (targetClass != null) handle(staticUsageTree, targetClass, 0); if (Properties.INSTRUMENT_PARENT) { handleSuperClasses(staticUsageTree, targetClass); } return staticUsageTree; }
private static Map<String, Set<String>> createStaticFields( String targetClassName) { GetStaticGraph getStaticGraph = GetStaticGraphGenerator .generate(targetClassName); return getStaticGraph.getStaticFields(); }
private static void handle(GetStaticGraph staticUsageTree, String className, String methodName, int depth) { ClassNode cn = DependencyAnalysis.getClassNode(className); if (cn == null) return; handle(staticUsageTree, cn, methodName, depth); }
public static void initializeExceptionMap(String className) { ClassNode targetClass = DependencyAnalysis.getClassNode(className); if (targetClass != null) { for (MethodNode mn : targetClass.methods) { logger.debug("Method: " + mn.name); handleMethodNode(targetClass, mn); handleMethodCalls(targetClass, mn); } } }
/** * Descend into a <clinit> */ private static void handleClassInitializer(GetStaticGraph staticUsageTree, ClassNode cn, MethodNode mn, String owner, int depth) { if (!staticUsageTree.hasStaticMethodCall(cn.name, mn.name + mn.desc, owner, CLASS_INIT_NAME)) { // Add call from mn to methodCall to callgraph staticUsageTree.addStaticMethodCall(cn.name, mn.name + mn.desc, owner, CLASS_INIT_NAME); // handle callee's <clinit> handle(staticUsageTree, owner, CLASS_INIT_NAME, depth); } }
@Override public String toString() { return getSourceClass() + "." + getSourceMethod() + " -> " + getTargetClass() + "." + targetField; } }
@Override public String toString() { return getSourceClass() + "." + getSourceMethod() + " -> " + getTargetClass() + "." + targetMethod; }
private static void handleDependency(String className) { ClassNode targetClass = DependencyAnalysis.getClassNode(className); if(targetClass != null){ for(MethodNode mn : targetClass.methods) { logger.debug("Method: " + mn.name); handleMethodNode(targetClass, mn); } } }
@Override public boolean isAccessible() { return TestUsageChecker.canUse(method); }
public Call(String classname, String methodName) { this.className = classname; this.methodName = methodName; approxHcode = computeApproximatedHashCode(); hcode = computeHashCode(); }
/** * Start analysis from target class * * @param className */ public static void analyzeClass(String className, List<String> classPath) throws RuntimeException, ClassNotFoundException { initInheritanceTree(classPath); analyze(className, classPath); }
/** * For now use the cache provided by dependency analysis * * @param className * @return */ private ClassNode getClassNode(String className) { return DependencyAnalysis.getClassNode(className); }
@Override public String toString() { return "Branch " + branchGoal + " in context: " + context.toString(); }
public static ConcreteClassAnalyzer getInstance() { if(instance == null) instance = new ConcreteClassAnalyzer(); return instance; }
/** * Instance accessor * * @return */ public static synchronized TestCluster getInstance() { if (instance == null) { instance = new TestCluster(); } // TODO: Need property to switch between test clusters return instance; }
private boolean isTargetClassName(String className) { // TODO: Need to replace this in the long term return TestCluster.isTargetClassName(className); }
@Override public boolean isAccessible() { return TestUsageChecker.canUse(field); }
public Call(Call call) { this.className = call.className; this.methodName = call.methodName; approxHcode = computeApproximatedHashCode(); hcode = computeHashCode(); }
@Override public String toString() { return "Branch " + branchGoal + " in context: " + context.toString(); }
@Override public boolean isAccessible() { return TestUsageChecker.canUse(constructor); }