NodeListTest.java revision 1ff8db9b9d9fdd6c9655d9d37761a00e98ab6d04 
1/*
2 * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
3 * Copyright (C) 2011, 2013-2016 The JavaParser Team.
4 *
5 * This file is part of JavaParser.
6 *
7 * JavaParser can be used either under the terms of
8 * a) the GNU Lesser General Public License as published by
9 *     the Free Software Foundation, either version 3 of the License, or
10 *     (at your option) any later version.
11 * b) the terms of the Apache License
12 *
13 * You should have received a copy of both licenses in LICENCE.LGPL and
14 * LICENCE.APACHE. Please refer to those files for details.
15 *
16 * JavaParser is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 * GNU Lesser General Public License for more details.
20 */
21
22package com.github.javaparser.ast;
23
24import com.github.javaparser.JavaParser;
25import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
26import com.github.javaparser.ast.body.FieldDeclaration;
27import com.github.javaparser.ast.expr.SimpleName;
28import com.github.javaparser.ast.observer.AstObserver;
29import com.github.javaparser.ast.observer.ObservableProperty;
30import com.github.javaparser.ast.type.PrimitiveType;
31import org.junit.Test;
32
33import java.util.Arrays;
34import java.util.EnumSet;
35import java.util.LinkedList;
36import java.util.List;
37
38import static org.junit.Assert.assertEquals;
39
40public class NodeListTest {
41
42    private AstObserver createObserver(List<String> changes) {
43        return new AstObserver() {
44            @Override
45            public void propertyChange(Node observedNode, ObservableProperty property, Object oldValue, Object newValue) {
46                changes.add(String.format("change of property %s for %s: from '%s' to '%s'", property, observedNode, oldValue, newValue));
47            }
48
49            @Override
50            public void parentChange(Node observedNode, Node previousParent, Node newParent) {
51                changes.add(String.format("setting parent for %s: was %s, now is %s", observedNode, previousParent, newParent));
52            }
53
54            @Override
55            public void listChange(NodeList observedNode, ListChangeType type, int index, Node nodeAddedOrRemoved) {
56                changes.add(String.format("'%s' %s in list at %d", nodeAddedOrRemoved, type, index));
57            }
58        };
59    }
60
61    private FieldDeclaration createIntField(String name) {
62        return new FieldDeclaration(EnumSet.noneOf(Modifier.class), PrimitiveType.intType(), name);
63    }
64
65    @Test
66    public void addAllWithoutIndex() {
67        List<String> changes = new LinkedList<>();
68        String code = "class A { void foo(int p) { }}";
69        CompilationUnit cu = JavaParser.parse(code);
70        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
71        cd.getMembers().register(createObserver(changes));
72
73        cd.getMembers().addAll(Arrays.asList(createIntField("a"), createIntField("b"), createIntField("c")));
74        assertEquals(Arrays.asList("'int a;' ADDITION in list at 1",
75                "'int b;' ADDITION in list at 2",
76                "'int c;' ADDITION in list at 3"), changes);
77    }
78
79    @Test
80    public void addAllWithIndex() {
81        List<String> changes = new LinkedList<>();
82        String code = "class A { void foo(int p) { }}";
83        CompilationUnit cu = JavaParser.parse(code);
84        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
85        cd.getMembers().register(createObserver(changes));
86
87        cd.getMembers().addAll(0, Arrays.asList(createIntField("a"), createIntField("b"), createIntField("c")));
88        assertEquals(Arrays.asList("'int a;' ADDITION in list at 0",
89                "'int b;' ADDITION in list at 1",
90                "'int c;' ADDITION in list at 2"), changes);
91    }
92
93    @Test
94    public void clear() {
95        List<String> changes = new LinkedList<>();
96        String code = "class A { int a; int b; int c; }";
97        CompilationUnit cu = JavaParser.parse(code);
98        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
99        cd.getMembers().register(createObserver(changes));
100
101        cd.getMembers().clear();
102        assertEquals(Arrays.asList("'int a;' REMOVAL in list at 0",
103                "'int b;' REMOVAL in list at 0",
104                "'int c;' REMOVAL in list at 0"), changes);
105    }
106
107    @Test
108    public void set() {
109        List<String> changes = new LinkedList<>();
110        String code = "class A { int a; int b; int c; }";
111        CompilationUnit cu = JavaParser.parse(code);
112        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
113        cd.getMembers().register(createObserver(changes));
114
115        cd.getMembers().set(1, createIntField("d"));
116        assertEquals(Arrays.asList("'int b;' REMOVAL in list at 1",
117                "'int d;' ADDITION in list at 1"), changes);
118    }
119
120    @Test
121    public void removeNode() {
122        List<String> changes = new LinkedList<>();
123        String code = "class A { int a; int b; int c; int d; int e; }";
124        CompilationUnit cu = JavaParser.parse(code);
125        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
126        cd.getMembers().register(createObserver(changes));
127
128        cd.getMembers().remove(cd.getFieldByName("c").get());
129        assertEquals(Arrays.asList("'int c;' REMOVAL in list at 2"), changes);
130    }
131
132    @Test
133    public void removeObject() {
134        List<String> changes = new LinkedList<>();
135        String code = "class A { int a; int b; int c; int d; int e; }";
136        CompilationUnit cu = JavaParser.parse(code);
137        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
138        cd.getMembers().register(createObserver(changes));
139
140        cd.getMembers().remove("hi");
141        assertEquals(Arrays.asList(), changes);
142    }
143
144    @Test
145    public void removeAll() {
146        List<String> changes = new LinkedList<>();
147        String code = "class A { int a; int b; int c; int d; int e; }";
148        CompilationUnit cu = JavaParser.parse(code);
149        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
150        cd.getMembers().register(createObserver(changes));
151
152        cd.getMembers().removeAll(Arrays.asList(cd.getFieldByName("b").get(), "foo", cd.getFieldByName("d").get()));
153        assertEquals(Arrays.asList("'int b;' REMOVAL in list at 1",
154                "'int d;' REMOVAL in list at 2"), changes);
155    }
156
157    @Test
158    public void retainAll() {
159        List<String> changes = new LinkedList<>();
160        String code = "class A { int a; int b; int c; int d; int e; }";
161        CompilationUnit cu = JavaParser.parse(code);
162        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
163        cd.getMembers().register(createObserver(changes));
164
165        cd.getMembers().retainAll(Arrays.asList(cd.getFieldByName("b").get(), "foo", cd.getFieldByName("d").get()));
166        assertEquals(Arrays.asList("'int a;' REMOVAL in list at 0",
167                "'int c;' REMOVAL in list at 1",
168                "'int e;' REMOVAL in list at 2"), changes);
169    }
170
171    @Test
172    public void replaceAll() {
173        List<String> changes = new LinkedList<>();
174        String code = "class A { int a; int b; int c; }";
175        CompilationUnit cu = JavaParser.parse(code);
176        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
177        cd.getMembers().register(createObserver(changes));
178
179        cd.getMembers().replaceAll(bodyDeclaration -> {
180            FieldDeclaration clone = (FieldDeclaration) bodyDeclaration.clone();
181            SimpleName id = clone.getVariable(0).getName();
182            id.setIdentifier(id.getIdentifier().toUpperCase());
183            return clone;
184        });
185        assertEquals(Arrays.asList("'int a;' REMOVAL in list at 0", "'int A;' ADDITION in list at 0",
186                "'int b;' REMOVAL in list at 1", "'int B;' ADDITION in list at 1",
187                "'int c;' REMOVAL in list at 2", "'int C;' ADDITION in list at 2"), changes);
188    }
189
190    @Test
191    public void removeIf() {
192        List<String> changes = new LinkedList<>();
193        String code = "class A { int a; int longName; int c; }";
194        CompilationUnit cu = JavaParser.parse(code);
195        ClassOrInterfaceDeclaration cd = cu.getClassByName("A").get();
196        cd.getMembers().register(createObserver(changes));
197
198        cd.getMembers().removeIf(m -> ((FieldDeclaration) m).getVariable(0).getName().getIdentifier().length() > 3);
199        assertEquals(Arrays.asList("'int longName;' REMOVAL in list at 1"), changes);
200    }
201}
202