Java CtExecutableReference类代码示例

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
@Override
public void process(CtInvocation ctElement) {
    CtExecutableReference executable = ctElement.getExecutable();
    if (executable.isConstructor()) {
        return;
    }
    String key = executable.toString();
    CtTypeReference declaringType = executable.getDeclaringType();
    if (declaringType.getPackage() != null) {
        key = declaringType.getPackage().getSimpleName() + "." + executable.getSimpleName();
    }
    if (!statMethod.containsKey(key)) {
        statMethod.put(key, 1);
    } else {
        statMethod.put(key, statMethod.get(key) + 1);
    }
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
@SuppressWarnings("unchecked")
static CtExpression<?> generateSingletonList(CtTypeReference type, String nameMethod, Class<?> typeOfCollection) {
    final Factory factory = type.getFactory();
    final CtType<?> collectionsType = factory.Type().get(Collections.class);
    final CtTypeAccess<?> accessToCollections = factory.createTypeAccess(collectionsType.getReference());
    final CtMethod<?> singletonListMethod = collectionsType.getMethodsByName(nameMethod).get(0);
    final CtExecutableReference executableReference = factory.Core().createExecutableReference();
    executableReference.setStatic(true);
    executableReference.setSimpleName(singletonListMethod.getSimpleName());
    executableReference.setDeclaringType(collectionsType.getReference());
    executableReference.setType(factory.createCtTypeReference(typeOfCollection));
    if (!type.getActualTypeArguments().isEmpty() &&
            type.getActualTypeArguments().stream().allMatch(ValueCreatorHelper::canGenerateAValueForType)) {
        executableReference.setParameters(type.getActualTypeArguments());
        List<CtExpression<?>> parameters = type.getActualTypeArguments().stream()
                .map(ValueCreator::generateRandomValue).collect(Collectors.toList());
        return factory.createInvocation(accessToCollections, executableReference, parameters);
    } else {
        return factory.createInvocation(accessToCollections, executableReference,
                factory.createConstructorCall(factory.Type().createReference(Object.class))
        );
    }
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static List<CtStatement> buildSnippetAssertCollection(Factory factory, String expression, Collection value) {
	final CtVariableAccess variableRead = factory.createVariableRead(
			factory.createLocalVariableReference().setSimpleName(expression),
			false
	);
	final CtExecutableReference contains = factory.Type().get(Collection.class).getMethodsByName("contains").get(0).getReference();
	return (List<CtStatement>) value.stream().map(factory::createLiteral)
			.map(o ->
					buildInvocation(factory, "assertTrue",
							Collections.singletonList(factory.createInvocation(variableRead,
									contains, (CtLiteral) o
									)
							)
					)
			)
			.collect(Collectors.toList());
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
/**
 * Call static methods on imported class
 *  @param ctExecutableReferences
 * @param threadRef
 * @param argsCandidates
 */
private Candidates collectStaticMethods(Set<CtExecutableReference> ctExecutableReferences, ThreadReference threadRef, Candidates argsCandidates) {
    Candidates results = new Candidates();
    Iterator<CtExecutableReference> it = ctExecutableReferences.iterator();
    while (it.hasNext()) {
        CtExecutableReference next = it.next();
        List<ReferenceType> refs = threadRef.virtualMachine().classesByName(next.getDeclaringType().getQualifiedName());
        if (refs.size() == 0) {
            continue;
        }

        ReferenceType ref = refs.get(0);
        Expression exp = AccessFactory.variable(next.getDeclaringType().getQualifiedName(), ref, nopolContext);
        List<Method> methods = getMethods(exp, ref, true, threadRef, next.getSimpleName());
        results.addAll(callMethods(exp, threadRef, methods, argsCandidates));
    }
    return results;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
private CtStatement createInvocation(CtVariable target, CtMethod method, List<CtVariable> vars, boolean staticParam) {
    Factory f = method.getFactory();
    CtStatement res = null;
    List<CtExpression> params = new LinkedList<>();
    if (VarFinder.fillParameter(params, method, vars, staticParam)) {
        CtExpression ttarget = null;
        if(target != null) {
            ttarget = f.Code().createVariableRead(VarFinder.createRef(target), target.getModifiers().contains(ModifierKind.STATIC));
        }
        CtExecutableReference exeRef = method.getReference();
        CtExpression[] array = params.toArray(new CtExpression[params.size()]);
        res = f.Code().createInvocation(ttarget, exeRef, array);
        toRemove.add(method);
    }
    return res;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
static CtExpression<?> generateEmptyCollection(CtTypeReference type, String nameMethod, Class<?> typeOfCollection) {
    final Factory factory = type.getFactory();
    final CtType<?> collectionsType = factory.Type().get(Collections.class);
    final CtTypeAccess<?> accessToCollections = factory.createTypeAccess(collectionsType.getReference());
    final CtMethod<?> singletonListMethod = collectionsType.getMethodsByName(nameMethod).get(0);
    final CtExecutableReference<?> executableReference = factory.Core().createExecutableReference();
    executableReference.setStatic(true);
    executableReference.setSimpleName(singletonListMethod.getSimpleName());
    executableReference.setDeclaringType(collectionsType.getReference());
    executableReference.setType(factory.createCtTypeReference(typeOfCollection));
    return factory.createInvocation(accessToCollections, executableReference);
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
private static CtInvocation buildInvocation(Factory factory, String methodName, List<CtExpression> arguments) {
	final CtInvocation invocation = factory.createInvocation();
	final CtExecutableReference<?> executableReference = factory.Core().createExecutableReference();
	executableReference.setStatic(true);
	executableReference.setSimpleName(methodName);
	executableReference.setDeclaringType(factory.createCtTypeReference(org.junit.Assert.class));
	invocation.setExecutable(executableReference);
	invocation.setArguments(arguments); // TODO
	invocation.setType(factory.Type().voidPrimitiveType());
	invocation.setTarget(factory.createTypeAccess(factory.createCtTypeReference(org.junit.Assert.class)));
	return invocation;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
@Override
 public boolean isToBeProcessed(CtInvocation<?> candidate) {
     if (!candidate.getExecutable().getSimpleName().contains("assert")) {
         return false;
     }
     CtExecutableReference<?> executable = candidate.getExecutable();
     CtPackageReference executablePackage = executable.getDeclaringType()
             .getPackage();
     if (executablePackage == null
             || !executablePackage.getSimpleName().contains("junit")) {
         return false;
     }
     CtMethod<?> parentMethod = candidate.getParent(CtMethod.class);
     if (parentMethod == null) {
         return false;
     }
     createExecutionMethod(candidate);
     return super.isToBeProcessed(candidate);
     /*
* boolean found = false; for (TestCase testCase : faillingTest) { if
* (testCase.className().equals(parentClass.getQualifiedName())) { if
* (testCase.testName().equals(parentMethod.getSimpleName())) { found =
* true; break; } } }
* 
* return found;
*/
 }
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
CtInvocation createObserve(CtMethod getter, CtInvocation invocationToGetter) {
	CtTypeAccess accessToLogger =
			factory.createTypeAccess(factory.createCtTypeReference(Logger.class));
	CtExecutableReference refObserve = factory.Type().get(Logger.class)
			.getMethodsByName("observe").get(0).getReference();
	return factory.createInvocation(
			accessToLogger,
			refObserve,
			factory.createLiteral(getKey(getter)),
			invocationToGetter
	);
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
public static CtInvocation createAssert(String name, CtExpression... parameters) {
	final Factory factory = parameters[0].getFactory();
	CtTypeAccess accessToAssert =
			factory.createTypeAccess(factory.createCtTypeReference(Assert.class));
	CtExecutableReference assertEquals = factory.Type().get(Assert.class)
			.getMethodsByName(name).get(0).getReference();
	return factory.createInvocation(
			accessToAssert,
			assertEquals,
			parameters[0],
			parameters[1]
	);
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
private List<CtTypeReference<?>> getCreatedTypes() {
	if (createdTypes == null) {
		createdTypes = new ArrayList<CtTypeReference<?>>();
		for (CtExecutableReference<?> m : getFactoryType().getDeclaredExecutables()) {
			createdTypes.add(m.getType());
		}
	}
	return createdTypes;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
private boolean isTypeChecking(CtExecutableReference exe) {
    List<CtTypeReference> params = exe.getParameters();
    for(CtTypeReference p : params) {
        if (p.getSimpleName().equals("Type")) return true;
    }
    return false;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
private CtExpression getTypeParam(CtInvocation invocation) {
    CtExecutableReference exe = invocation.getExecutable();
    List<CtTypeReference> params = exe.getParameters();
    for(CtTypeReference p : params) {
        if (p.getSimpleName().equals("Type")) return (CtExpression) invocation.getArguments().get(params.indexOf(p));
    }
    return null;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
private boolean parametersMatch(CtConstructorCall curCall, CtExecutableReference candidate) {
    if(curCall.getArguments().size() != candidate.getParameters().size()) return false;
    List<CtExpression> args = curCall.getArguments();
    List<CtTypeReference> params = candidate.getParameters();
    for(int i = 0; i < args.size(); i++) {
        if(!args.get(i).getType().equals(params.get(i))) return false;
    }
    return true;
}
 

import spoon.reflect.reference.CtExecutableReference; //导入依赖的package包/类
public Map<CtExecutableReference, Integer> getStatMethod() {
    return statMethod;
}