private static <T> void processConstructor(CtConstructor<T> c, CtClass<T> toMerge) {
CtStatement firstStmt = c.getBody().getStatements().get(0);
if (firstStmt instanceof CtInvocation) {
CtInvocation<?> superConstructorCall = (CtInvocation) firstStmt;
if (!(superConstructorCall.getExecutable().getDeclaration() instanceof CtConstructor)) return;
CtConstructor superConstructor =
(CtConstructor) superConstructorCall.getExecutable().getDeclaration();
if (superConstructor.getDeclaringType() == toMerge) {
CtBlock superConstructorBody = c.getFactory().Core().clone(superConstructor.getBody());
superConstructorBody.accept(
new CtScanner() {
@Override
public <T> void visitCtParameterReference(CtParameterReference<T> ref) {
int parameterOrder = superConstructor.getParameters().indexOf(ref.getDeclaration());
ref.setDeclaringExecutable(c.getReference());
CtExpression<?> arg = superConstructorCall.getArguments().get(parameterOrder);
if (!(arg instanceof CtVariableAccess))
throw sgce("super() should be directly called in " + c);
CtVariable param = ((CtVariableAccess) arg).getVariable().getDeclaration();
if (!(param instanceof CtParameter))
throw sgce("super() should be directly called in " + c);
ref.setSimpleName(param.getSimpleName());
super.visitCtParameterReference(ref);
}
});
c.getBody().removeStatement(firstStmt);
List<CtStatement> superConstructorBodyStatements = superConstructorBody.getStatements();
for (int i = superConstructorBodyStatements.size() - 1; i >= 0; i--) {
c.getBody().insertBegin(superConstructorBodyStatements.get(i));
}
}
}
}
/**
* Create the content of the condition
*
* @param ctInvocation
* @return
*/
private CtBlock<Object> createThen(CtInvocation<?> ctInvocation) {
CtBlock<Object> thenStatement = ctInvocation.getFactory().Core().createBlock();
thenStatement.addStatement(
(getFactory().Code().createCodeSnippetStatement("System.out.println(\"Else...\")")));
thenStatement.addStatement(
(getFactory()
.Code()
.createCodeSnippetStatement(
"System.out.println(" + Debug.class.getCanonicalName() + ".getSolvedPC())")));
CtAssert<Object> ctAssert = ctInvocation.getFactory().Core().createAssert();
CtCodeSnippetExpression<Boolean> assertExpression =
getFactory().Core().createCodeSnippetExpression();
assertExpression.setValue("false");
ctAssert.setAssertExpression(assertExpression);
ctAssert.setExpression(
getFactory()
.Code()
.createCodeSnippetExpression(
String.format("\"%s\"", ctInvocation.toString().replaceAll("\"", "'"))));
thenStatement.addStatement(ctAssert);
return thenStatement;
}
private void createExecutionMethod(CtInvocation<?> ctInvocation) {
CtClass<?> parent = ctInvocation.getParent(CtClass.class);
if (!parent.isTopLevel()) {
return;
}
if (parent.getModifiers().contains(ModifierKind.ABSTRACT)) {
return;
}
CtTypeReference<String[]> typedReference = getFactory().Class().createReference(String[].class);
if (parent.getMethod("runJPFTest", typedReference) != null) {
return;
}
CtTypeReference<Object> returntypedReference = getFactory().Class().createReference("void");
Set<ModifierKind> modifiers = new LinkedHashSet<ModifierKind>(2);
modifiers.add(ModifierKind.PUBLIC);
modifiers.add(ModifierKind.STATIC);
String invocation = parent.getQualifiedName() + "(";
if (parent.getConstructor() == null) {
// CtTypeReference<?> superClass = parent.getSuperclass();
if (parent.getConstructor(ctInvocation.getFactory().Class().STRING) != null) {
invocation += "\"" + parent.getSimpleName() + "\"";
} else {
return;
}
}
invocation += ")";
CtBlock<?> body = getFactory().Core().createBlock();
String bodyString = "for (String method : methods) {\n";
bodyString += "\t\tSystem.out.println(method);\n\t\t";
bodyString += parent.getQualifiedName() + " instance = new " + invocation + ";\n\t\t";
if (parent.getMethod("setUp") != null) {
bodyString += "instance.setUp();";
}
bodyString +=
parent.getQualifiedName() + ".class.getMethod(method, null).invoke(instance);\n\t\t";
bodyString += "}\n";
body.addStatement(getFactory().Code().createCodeSnippetStatement(bodyString));
HashSet<CtTypeReference<? extends Throwable>> exceptions =
new HashSet<CtTypeReference<? extends Throwable>>();
exceptions.add(getFactory().Class().createReference(Exception.class));
CtMethod<?> method =
getFactory()
.Method()
.create(
parent,
modifiers,
returntypedReference,
"runJPFTest",
new ArrayList<CtParameter<?>>(),
exceptions,
body);
getFactory().Method().createParameter(method, typedReference, "methods");
}
@Override
public <R> void visitCtBlock(CtBlock<R> block) {
int i = 0;
while (i < block.getStatements().size()) {
int size = block.getStatements().size();
CtStatement s = block.getStatement(i);
s.accept(this);
if (block.getStatements().size() >= size) i++;
}
}
/**
* Replaces the element by an statement list containing all unary operators in the element
*
* @param element
*/
private void replaceByUnaryBlock(CtElement element) {
CtBlock<CtUnaryOperator> opBlock = new CtBlockImpl<CtUnaryOperator>();
for (CtUnaryOperator s :
element.getElements(new TypeFilter<CtUnaryOperator>(CtUnaryOperator.class)))
if (s.getKind().compareTo(UnaryOperatorKind.PREINC) >= 0) {
s.setParent(null);
opBlock.addStatement(s);
s.setParent(opBlock);
}
element.replace(opBlock);
}
protected List<CtLocalVariable> getLocalVarInScope(CtStatement stmt) {
List<CtLocalVariable> vars = new ArrayList<>();
try {
CtBlock parentBlock = stmt.getParent(CtBlock.class);
if (parentBlock != null) {
boolean beforeCurrentStmt = true;
int i = 0;
List<CtStatement> stmts = parentBlock.getStatements();
while (beforeCurrentStmt && i < stmts.size()) {
CtStatement currentStatement = stmts.get(i);
i++;
beforeCurrentStmt = beforeCurrentStmt && currentStatement != stmt;
if (currentStatement instanceof CtLocalVariable) {
vars.add((CtLocalVariable) currentStatement);
}
}
vars.addAll(getLocalVarInScope(parentBlock));
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return vars;
}
/**
* Pretty print for the resulting degraded block
*
* @param clonedBody
* @return
*/
public String prettyPrintBody(CtStatement clonedBody) {
String result = "";
if (clonedBody instanceof CtBlock) {
CtBlock block = (CtBlock) clonedBody;
try {
for (int i = 0; i < block.getStatements().size(); i++) {
if (block.getStatement(i) instanceof CtBlock)
result += prettyPrintBody(block.getStatement(i));
else if (block.getStatement(i) != null)
result += block.getStatement(i).toString() + ";\n";
}
} catch (NullPointerException ex) {
log.error("Unable to print the degraded loop!");
}
} else result = clonedBody.toString();
return result;
}
