Skip to content

Commit fd1b8c9

Browse files
matozoidmatozoid
authored
Merge pull request javaparser#2514 from matozoid/issue_2513_lex_pres_comments
Fixes for comments & lexical preservation
2 parents 175d87c + abb8d1d commit fd1b8c9

File tree

18 files changed

+702
-659
lines changed

18 files changed

+702
-659
lines changed

‎javaparser-core-testing/src/test/java/com/github/javaparser/ast/ListObservationTest.java

Lines changed: 230 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,230 @@
1+
package com.github.javaparser.ast;
2+
3+
import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
4+
import com.github.javaparser.ast.body.FieldDeclaration;
5+
import com.github.javaparser.ast.expr.SimpleName;
6+
import com.github.javaparser.ast.observer.AstObserver;
7+
import com.github.javaparser.ast.observer.ObservableProperty;
8+
import com.github.javaparser.ast.type.PrimitiveType;
9+
import org.junit.jupiter.api.Test;
10+
11+
import java.util.Arrays;
12+
import java.util.LinkedList;
13+
import java.util.List;
14+
15+
import static com.github.javaparser.StaticJavaParser.parse;
16+
import static org.assertj.core.api.Assertions.assertThat;
17+
import static org.junit.jupiter.api.Assertions.assertEquals;
18+
import static org.junit.jupiter.api.Assertions.assertNotNull;
19+
20+
public class ListObservationTest {
21+
22+
private FieldDeclaration createIntField(String name) {
23+
return new FieldDeclaration(new NodeList<>(), PrimitiveType.intType(), name);
24+
}
25+
26+
private AstObserver createObserver(List<String> changes) {
27+
return new AstObserver() {
28+
@Override
29+
public void propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
30+
changes.add(String.format("change of property %s for %s: from '%s' to '%s'", property, observedNode, oldValue, newValue));
31+
}
32+
33+
@Override
34+
public void parentChange(Node observedNode, Node previousParent, Node newParent) {
35+
changes.add(String.format("setting parent for %s: was %s, now is %s", observedNode, previousParent, newParent));
36+
}
37+
38+
@Override
39+
public void listChange(NodeList<?> observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved) {
40+
changes.add(String.format("'%s' %s in list at %d", nodeAddedOrRemoved, type, index));
41+
}
42+
43+
@Override
44+
public void listReplacement(NodeList<?> observedNode, int index, Node oldNode, Node newNode) {
45+
changes.add(String.format("'%s' %s in list at %d", oldNode, ListChangeType.REMOVAL, index));
46+
changes.add(String.format("'%s' %s in list at %d", newNode, ListChangeType.ADDITION, index));
47+
}
48+
};
49+
}
50+
@Test
51+
void addAllWithoutIndex() {
52+
List<String> changes = new LinkedList<>();
53+
String code = "class A { void foo(int p) { }}";
54+
CompilationUnit cu = parse(code);
55+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
56+
cd.getMembers().register(createObserver(changes));
57+
58+
cd.getMembers().addAll(Arrays.asList(createIntField("a"), createIntField("b"), createIntField("c")));
59+
assertEquals(Arrays.asList("'int a;' ADDITION in list at 1",
60+
"'int b;' ADDITION in list at 2",
61+
"'int c;' ADDITION in list at 3"), changes);
62+
}
63+
64+
@Test
65+
void addAllWithIndex() {
66+
List<String> changes = new LinkedList<>();
67+
String code = "class A { void foo(int p) { }}";
68+
CompilationUnit cu = parse(code);
69+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
70+
cd.getMembers().register(createObserver(changes));
71+
72+
cd.getMembers().addAll(0, Arrays.asList(createIntField("a"), createIntField("b"), createIntField("c")));
73+
assertEquals(Arrays.asList("'int a;' ADDITION in list at 0",
74+
"'int b;' ADDITION in list at 1",
75+
"'int c;' ADDITION in list at 2"), changes);
76+
}
77+
78+
@Test
79+
void clear() {
80+
List<String> changes = new LinkedList<>();
81+
String code = "class A { int a; int b; int c; }";
82+
CompilationUnit cu = parse(code);
83+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
84+
cd.getMembers().register(createObserver(changes));
85+
86+
cd.getMembers().clear();
87+
assertEquals(Arrays.asList("'int a;' REMOVAL in list at 0",
88+
"'int b;' REMOVAL in list at 0",
89+
"'int c;' REMOVAL in list at 0"), changes);
90+
}
91+
92+
@Test
93+
void set() {
94+
List<String> changes = new LinkedList<>();
95+
String code = "class A { int a; int b; int c; }";
96+
CompilationUnit cu = parse(code);
97+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
98+
cd.getMembers().register(createObserver(changes));
99+
100+
cd.getMembers().set(1, createIntField("d"));
101+
assertEquals(Arrays.asList("'int b;' REMOVAL in list at 1",
102+
"'int d;' ADDITION in list at 1"), changes);
103+
}
104+
105+
@Test
106+
void removeNode() {
107+
List<String> changes = new LinkedList<>();
108+
String code = "class A { int a; int b; int c; int d; int e; }";
109+
CompilationUnit cu = parse(code);
110+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
111+
cd.getMembers().register(createObserver(changes));
112+
113+
cd.getMembers().remove(cd.getFieldByName("c").get());
114+
assertThat(changes).containsExactlyInAnyOrder("'int c;' REMOVAL in list at 2");
115+
}
116+
117+
@Test
118+
void removeFirstNode() {
119+
List<String> changes = new LinkedList<>();
120+
String code = "class A { int a; int b; int c; int d; int e; }";
121+
CompilationUnit cu = parse(code);
122+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
123+
cd.getMembers().register(createObserver(changes));
124+
125+
cd.getMembers().removeFirst();
126+
assertThat(changes).containsExactlyInAnyOrder("'int a;' REMOVAL in list at 0");
127+
assertEquals(cd.getMembers().size(), 4);
128+
129+
for (int i = 3; i >= 0; i--) {
130+
assertNotNull(cd.getMembers().removeFirst());
131+
assertEquals(cd.getMembers().size(), i);
132+
}
133+
134+
assertEquals(cd.getMembers().size(), 0);
135+
}
136+
137+
@Test
138+
void removeLastNode() {
139+
List<String> changes = new LinkedList<>();
140+
String code = "class A { int a; int b; int c; int d; int e; }";
141+
CompilationUnit cu = parse(code);
142+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
143+
cd.getMembers().register(createObserver(changes));
144+
145+
cd.getMembers().removeLast();
146+
assertThat(changes).containsExactlyInAnyOrder("'int e;' REMOVAL in list at 4");
147+
assertEquals(cd.getMembers().size(), 4);
148+
149+
for (int i = 3; i >= 0; i--) {
150+
assertNotNull(cd.getMembers().removeLast());
151+
assertEquals(cd.getMembers().size(), i);
152+
}
153+
154+
assertEquals(cd.getMembers().size(), 0);
155+
}
156+
157+
@Test
158+
void removeObject() {
159+
List<String> changes = new LinkedList<>();
160+
String code = "class A { int a; int b; int c; int d; int e; }";
161+
CompilationUnit cu = parse(code);
162+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
163+
cd.getMembers().register(createObserver(changes));
164+
165+
cd.getMembers().remove("hi");
166+
assertThat(changes).isEmpty();
167+
}
168+
169+
@Test
170+
void removeAll() {
171+
List<String> changes = new LinkedList<>();
172+
String code = "class A { int a; int b; int c; int d; int e; }";
173+
CompilationUnit cu = parse(code);
174+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
175+
cd.getMembers().register(createObserver(changes));
176+
177+
cd.getMembers().removeAll(Arrays.asList(cd.getFieldByName("b").get(), "foo", cd.getFieldByName("d").get()));
178+
assertThat(changes).containsExactlyInAnyOrder(
179+
"'int b;' REMOVAL in list at 1",
180+
"'int d;' REMOVAL in list at 2");
181+
}
182+
183+
@Test
184+
void retainAll() {
185+
List<String> changes = new LinkedList<>();
186+
String code = "class A { int a; int b; int c; int d; int e; }";
187+
CompilationUnit cu = parse(code);
188+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
189+
cd.getMembers().register(createObserver(changes));
190+
191+
cd.getMembers().retainAll(Arrays.asList(cd.getFieldByName("b").get(), "foo", cd.getFieldByName("d").get()));
192+
assertThat(changes).containsExactlyInAnyOrder(
193+
"'int a;' REMOVAL in list at 0",
194+
"'int c;' REMOVAL in list at 1",
195+
"'int e;' REMOVAL in list at 2");
196+
}
197+
198+
@Test
199+
void replaceAll() {
200+
List<String> changes = new LinkedList<>();
201+
String code = "class A { int a; int b; int c; }";
202+
CompilationUnit cu = parse(code);
203+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
204+
cd.getMembers().register(createObserver(changes));
205+
206+
cd.getMembers().replaceAll(bodyDeclaration -> {
207+
FieldDeclaration clone = (FieldDeclaration) bodyDeclaration.clone();
208+
SimpleName id = clone.getVariable(0).getName();
209+
id.setIdentifier(id.getIdentifier().toUpperCase());
210+
return clone;
211+
});
212+
assertThat(changes).containsExactlyInAnyOrder(
213+
"'int a;' REMOVAL in list at 0", "'int A;' ADDITION in list at 0",
214+
"'int b;' REMOVAL in list at 1", "'int B;' ADDITION in list at 1",
215+
"'int c;' REMOVAL in list at 2", "'int C;' ADDITION in list at 2");
216+
}
217+
218+
@Test
219+
void removeIf() {
220+
List<String> changes = new LinkedList<>();
221+
String code = "class A { int a; int longName; int c; }";
222+
CompilationUnit cu = parse(code);
223+
ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
224+
cd.getMembers().register(createObserver(changes));
225+
226+
cd.getMembers().removeIf(m -> ((FieldDeclaration) m).getVariable(0).getName().getIdentifier().length() > 3);
227+
assertThat(changes).containsExactlyInAnyOrder("'int longName;' REMOVAL in list at 1");
228+
}
229+
230+
}

0 commit comments

Comments
 (0)