1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
package com.github.javaparser.printer.lexicalpreservation;
import com.github.javaparser.ast.Modifier;
import com.github.javaparser.ast.body.FieldDeclaration;
import com.github.javaparser.ast.body.MethodDeclaration;
import com.github.javaparser.ast.body.VariableDeclarator;
import com.github.javaparser.ast.expr.Expression;
import com.github.javaparser.ast.expr.NameExpr;
import com.github.javaparser.ast.expr.NullLiteralExpr;
import com.github.javaparser.ast.stmt.ReturnStmt;
import com.github.javaparser.ast.type.ArrayType;
import com.github.javaparser.ast.type.PrimitiveType;
import org.junit.Test;
import java.io.IOException;
import java.util.EnumSet;
/**
* These tests are more "high level" than the ones in LexicalPreservingPrinterTest.
* The idea is to perform some transformations on the code, print it back and see if the generated code
* is the expected one. We do not care about the internal state of LexicalPreservingPrinter, just the visible result.
*/
public class TransformationsTest extends AbstractLexicalPreservingTest {
@Test
public void unchangedSimpleClasses() throws IOException {
assertUnchanged("Example1");
assertUnchanged("Example2");
}
@Test
public void unchangedComplexFile() throws IOException {
assertUnchanged("Example4");
}
@Test
public void example1() throws IOException {
considerExample("Example1_original");
cu.getClassByName("A").get().getFieldByName("a").get().setModifiers(EnumSet.of(Modifier.STATIC));
assertTransformed("Example1", cu);
}
@Test
public void example2() throws IOException {
considerExample("Example2_original");
cu.getClassByName("A").get().getFieldByName("a").get().getVariable(0).setInitializer("10");
assertTransformed("Example2", cu);
}
@Test
public void example3() throws IOException {
considerExample("Example3_original");
cu.getClassByName("A").get().getFieldByName("a").get().getVariable(0).setInitializer((Expression) null);
assertTransformed("Example3", cu);
}
@Test
public void example5() throws IOException {
considerExample("Example5_original");
cu.getClassByName("A").get().getFieldByName("a").get().getVariable(0).setInitializer(new NullLiteralExpr());
assertTransformed("Example5", cu);
}
@Test
public void example6() throws IOException {
considerExample("Example6_original");
cu.getClassByName("A").get().getFieldByName("a").get().getVariable(0).setName("someOtherName");
assertTransformed("Example6", cu);
}
@Test
public void example7() throws IOException {
considerExample("Example7_original");
cu.getClassByName("A").get().getFieldByName("a").get().getVariable(0).setType(new ArrayType(PrimitiveType.intType()));
assertTransformed("Example7", cu);
}
@Test
public void example8() throws IOException {
considerExample("Example8_original");
FieldDeclaration fd = (FieldDeclaration) cu.getClassByName("A").get().getMember(0).asFieldDeclaration();
fd.addVariable(new VariableDeclarator(PrimitiveType.intType(), "b"));
assertTransformed("Example8", cu);
}
@Test
public void example9() throws IOException {
considerExample("Example9_original");
FieldDeclaration fd = (FieldDeclaration) cu.getClassByName("A").get().getMember(0).asFieldDeclaration();
fd.addVariable(new VariableDeclarator(new ArrayType(PrimitiveType.intType()), "b"));
assertTransformed("Example9", cu);
}
@Test
public void example10() throws IOException {
considerExample("Example10_original");
cu.getClassByName("A").get().getMembers().remove(0);
assertTransformed("Example10", cu);
}
@Test
public void exampleParam1() throws IOException {
considerExample("Example_param1_original");
MethodDeclaration md = (MethodDeclaration) cu.getClassByName("A").get().getMember(0).asMethodDeclaration();
md.addParameter("int", "p1");
assertTransformed("Example_param1", cu);
}
@Test
public void exampleParam2() throws IOException {
considerExample("Example_param1_original");
MethodDeclaration md = (MethodDeclaration) cu.getClassByName("A").get().getMember(0).asMethodDeclaration();
md.addParameter(new ArrayType(PrimitiveType.intType()), "p1");
md.addParameter("char", "p2");
assertTransformed("Example_param2", cu);
}
@Test
public void exampleParam3() throws IOException {
considerExample("Example_param3_original");
MethodDeclaration md = (MethodDeclaration) cu.getClassByName("A").get().getMember(0).asMethodDeclaration();
md.getParameters().remove(0);
assertTransformed("Example_param3", cu);
}
@Test
public void exampleParam4() throws IOException {
considerExample("Example_param3_original");
MethodDeclaration md = (MethodDeclaration) cu.getClassByName("A").get().getMember(0).asMethodDeclaration();
md.getParameters().remove(1);
assertTransformed("Example_param4", cu);
}
@Test
public void exampleParam5() throws IOException {
considerExample("Example_param3_original");
MethodDeclaration md = (MethodDeclaration) cu.getClassByName("A").get().getMember(0).asMethodDeclaration();
md.setType(PrimitiveType.intType());
assertTransformed("Example_param5b", cu);
md.getBody().get().getStatements().add(new ReturnStmt(new NameExpr("p1")));
assertTransformed("Example_param5", cu);
}
}
|
