1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 package org.eclipse.aether.util.graph.visitor;
20
21 import java.io.File;
22 import java.util.Arrays;
23 import java.util.HashSet;
24 import java.util.List;
25 import java.util.Objects;
26 import java.util.Set;
27 import java.util.concurrent.atomic.AtomicBoolean;
28 import java.util.stream.Collectors;
29
30 import org.eclipse.aether.graph.DependencyNode;
31 import org.eclipse.aether.graph.DependencyVisitor;
32 import org.eclipse.aether.internal.test.util.DependencyGraphParser;
33 import org.junit.jupiter.api.Test;
34
35 import static org.junit.jupiter.api.Assertions.*;
36
37 public class NodeListGeneratorTest {
38
39 private DependencyNode parse(String resource) throws Exception {
40 return new DependencyGraphParser("visitor/ordered-list/").parseResource(resource);
41 }
42
43 private void assertSequence(List<DependencyNode> actual, String... expected) {
44 assertEquals(expected.length, actual.size(), actual.toString());
45 for (int i = 0; i < expected.length; i++) {
46 DependencyNode node = actual.get(i);
47 assertEquals(expected[i], node.getDependency().getArtifact().getArtifactId(), actual.toString());
48 }
49 }
50
51 @Test
52 void testPreOrder() throws Exception {
53 DependencyNode root = parse("simple.txt");
54
55 NodeListGenerator nodeListGenerator = new NodeListGenerator();
56 PreorderDependencyNodeConsumerVisitor visitor = new PreorderDependencyNodeConsumerVisitor(nodeListGenerator);
57 root.accept(visitor);
58
59 assertSequence(nodeListGenerator.getNodes(), "a", "b", "c", "d", "e");
60 }
61
62 @Test
63 void testPreOrderDuplicateSuppression() throws Exception {
64 DependencyNode root = parse("cycles.txt");
65
66 NodeListGenerator nodeListGenerator = new NodeListGenerator();
67 PreorderDependencyNodeConsumerVisitor visitor = new PreorderDependencyNodeConsumerVisitor(nodeListGenerator);
68 root.accept(visitor);
69
70 assertSequence(nodeListGenerator.getNodes(), "a", "b", "c", "d", "e");
71 }
72
73 @Test
74 void testPostOrder() throws Exception {
75 DependencyNode root = parse("simple.txt");
76
77 NodeListGenerator nodeListGenerator = new NodeListGenerator();
78 PostorderDependencyNodeConsumerVisitor visitor = new PostorderDependencyNodeConsumerVisitor(nodeListGenerator);
79 root.accept(visitor);
80
81 assertSequence(nodeListGenerator.getNodes(), "c", "b", "e", "d", "a");
82 }
83
84 @Test
85 void testPostOrderDuplicateSuppression() throws Exception {
86 DependencyNode root = parse("cycles.txt");
87
88 NodeListGenerator nodeListGenerator = new NodeListGenerator();
89 PostorderDependencyNodeConsumerVisitor visitor = new PostorderDependencyNodeConsumerVisitor(nodeListGenerator);
90 root.accept(visitor);
91
92 assertSequence(nodeListGenerator.getNodes(), "c", "b", "e", "d", "a");
93 }
94
95 @Test
96 void testLevelOrder() throws Exception {
97 DependencyNode root = parse("simple.txt");
98
99 NodeListGenerator nodeListGenerator = new NodeListGenerator();
100 LevelOrderDependencyNodeConsumerVisitor visitor =
101 new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
102 root.accept(visitor);
103
104 assertSequence(nodeListGenerator.getNodes(), "a", "b", "d", "c", "e");
105 }
106
107 @Test
108 void testLevelOrderDuplicateSuppression() throws Exception {
109 DependencyNode root = parse("cycles.txt");
110
111 NodeListGenerator nodeListGenerator = new NodeListGenerator();
112 LevelOrderDependencyNodeConsumerVisitor visitor =
113 new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
114 root.accept(visitor);
115
116 assertSequence(nodeListGenerator.getNodes(), "a", "b", "d", "c", "e");
117 }
118
119 @Test
120 void testEmptyResolvedClassPath() throws Exception {
121 DependencyNode root = parse("simple.txt");
122
123 NodeListGenerator nodeListGenerator = new NodeListGenerator();
124 LevelOrderDependencyNodeConsumerVisitor visitor =
125 new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
126 root.accept(visitor);
127
128 assertEquals(5, nodeListGenerator.getNodes().size());
129 assertEquals(0, nodeListGenerator.getDependencies(false).size());
130 assertEquals(5, nodeListGenerator.getDependencies(true).size());
131 assertEquals(0, nodeListGenerator.getArtifacts(false).size());
132 assertEquals(5, nodeListGenerator.getArtifacts(true).size());
133 assertEquals(0, nodeListGenerator.getFiles().size());
134 assertEquals("", nodeListGenerator.getClassPath());
135 }
136
137 @Test
138 void testFullyResolvedClassPath() throws Exception {
139 DependencyNode root = parse("simple.txt");
140 DependencyVisitor fileSetter = new DependencyVisitor() {
141 @Override
142 public boolean visitEnter(DependencyNode node) {
143 node.setArtifact(node.getArtifact()
144 .setFile(new File(node.getDependency().getArtifact().getArtifactId())));
145 return true;
146 }
147
148 @Override
149 public boolean visitLeave(DependencyNode node) {
150 return true;
151 }
152 };
153 root.accept(fileSetter);
154
155 NodeListGenerator nodeListGenerator = new NodeListGenerator();
156 LevelOrderDependencyNodeConsumerVisitor visitor =
157 new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
158 root.accept(visitor);
159
160 Set<String> fileNames = nodeListGenerator.getNodes().stream()
161 .map(n -> n.getArtifact().getFile())
162 .filter(Objects::nonNull)
163 .map(File::getName)
164 .collect(Collectors.toSet());
165 String classPath = nodeListGenerator.getClassPath();
166 String[] splitClassPath = classPath.split(File.pathSeparator);
167 Set<String> classPathNames =
168 Arrays.stream(splitClassPath).map(File::new).map(File::getName).collect(Collectors.toSet());
169
170 assertEquals(5, nodeListGenerator.getNodes().size());
171 assertEquals(5, nodeListGenerator.getDependencies(false).size());
172 assertEquals(5, nodeListGenerator.getDependencies(true).size());
173 assertEquals(5, nodeListGenerator.getArtifacts(false).size());
174 assertEquals(5, nodeListGenerator.getArtifacts(true).size());
175 assertEquals(5, nodeListGenerator.getFiles().size());
176 assertEquals(fileNames, classPathNames);
177 }
178
179 @Test
180 void testIncompletelyResolvedEmptyClassPath() throws Exception {
181 DependencyNode root = parse("simple.txt");
182 AtomicBoolean alternator = new AtomicBoolean(false);
183 HashSet<String> fileNames = new HashSet<>();
184 DependencyVisitor fileSetter = new DependencyVisitor() {
185 @Override
186 public boolean visitEnter(DependencyNode node) {
187 alternator.set(!alternator.get());
188 if (alternator.get()) {
189 String fileName = node.getDependency().getArtifact().getArtifactId();
190 fileNames.add(fileName);
191 node.setArtifact(node.getArtifact().setFile(new File(fileName)));
192 }
193 return true;
194 }
195
196 @Override
197 public boolean visitLeave(DependencyNode node) {
198 return true;
199 }
200 };
201 root.accept(fileSetter);
202
203 NodeListGenerator nodeListGenerator = new NodeListGenerator();
204 LevelOrderDependencyNodeConsumerVisitor visitor =
205 new LevelOrderDependencyNodeConsumerVisitor(nodeListGenerator);
206 root.accept(visitor);
207
208 String classPath = nodeListGenerator.getClassPath();
209 String[] splitClassPath = classPath.split(File.pathSeparator);
210 Set<String> classPathNames =
211 Arrays.stream(splitClassPath).map(File::new).map(File::getName).collect(Collectors.toSet());
212
213 assertEquals(5, nodeListGenerator.getNodes().size());
214 assertEquals(3, nodeListGenerator.getDependencies(false).size());
215 assertEquals(5, nodeListGenerator.getDependencies(true).size());
216 assertEquals(3, nodeListGenerator.getArtifacts(false).size());
217 assertEquals(5, nodeListGenerator.getArtifacts(true).size());
218 assertEquals(3, nodeListGenerator.getFiles().size());
219 assertEquals(fileNames, classPathNames);
220 }
221 }