1 | /* |
2 | * Copyright (c) 2001-2009, Jean Tessier |
3 | * All rights reserved. |
4 | * |
5 | * Redistribution and use in source and binary forms, with or without |
6 | * modification, are permitted provided that the following conditions |
7 | * are met: |
8 | * |
9 | * * Redistributions of source code must retain the above copyright |
10 | * notice, this list of conditions and the following disclaimer. |
11 | * |
12 | * * Redistributions in binary form must reproduce the above copyright |
13 | * notice, this list of conditions and the following disclaimer in the |
14 | * documentation and/or other materials provided with the distribution. |
15 | * |
16 | * * Neither the name of Jean Tessier nor the names of his contributors |
17 | * may be used to endorse or promote products derived from this software |
18 | * without specific prior written permission. |
19 | * |
20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
22 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
23 | * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR |
24 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
25 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
26 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
27 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF |
28 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING |
29 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
30 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
31 | */ |
32 | |
33 | package com.jeantessier.dependency; |
34 | |
35 | import junit.framework.*; |
36 | |
37 | public class TestLinkMaximizerSystematic extends TestCase { |
38 | private NodeFactory factory; |
39 | |
40 | private PackageNode a; |
41 | private ClassNode a_A; |
42 | private FeatureNode a_A_a; |
43 | |
44 | private PackageNode b; |
45 | private ClassNode b_B; |
46 | private FeatureNode b_B_b; |
47 | |
48 | protected void setUp() throws Exception { |
49 | factory = new NodeFactory(); |
50 | |
51 | a = factory.createPackage("a"); |
52 | a_A = factory.createClass("a.A"); |
53 | a_A_a = factory.createFeature("a.A.a()"); |
54 | |
55 | b = factory.createPackage("b"); |
56 | b_B = factory.createClass("b.B"); |
57 | b_B_b = factory.createFeature("b.B.b()"); |
58 | } |
59 | |
60 | public void testPackagePackage() { |
61 | a.addDependency(b); |
62 | |
63 | Visitor visitor = new LinkMaximizer(); |
64 | visitor.traverseNodes(factory.getPackages().values()); |
65 | |
66 | assertEquals("a outbound", 1, a.getOutboundDependencies().size()); |
67 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
68 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
69 | assertEquals("a_A outbound", 0, a_A.getOutboundDependencies().size()); |
70 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
71 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
72 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
73 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
74 | assertEquals("b inbound", 1, b.getInboundDependencies().size()); |
75 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
76 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
77 | assertEquals("b_B inbound", 0, b_B.getInboundDependencies().size()); |
78 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
79 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
80 | } |
81 | |
82 | public void testPackageClass() { |
83 | a.addDependency(b_B); |
84 | |
85 | Visitor visitor = new LinkMaximizer(); |
86 | visitor.traverseNodes(factory.getPackages().values()); |
87 | |
88 | assertEquals("a outbound", 2, a.getOutboundDependencies().size()); |
89 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
90 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
91 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
92 | assertEquals("a_A outbound", 0, a_A.getOutboundDependencies().size()); |
93 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
94 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
95 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
96 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
97 | assertEquals("b inbound", 1, b.getInboundDependencies().size()); |
98 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
99 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
100 | assertEquals("b_B inbound", 1, b_B.getInboundDependencies().size()); |
101 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
102 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
103 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
104 | } |
105 | |
106 | public void testPackageFeature() { |
107 | a.addDependency(b_B_b); |
108 | |
109 | Visitor visitor = new LinkMaximizer(); |
110 | visitor.traverseNodes(factory.getPackages().values()); |
111 | |
112 | assertEquals("a outbound", 3, a.getOutboundDependencies().size()); |
113 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
114 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
115 | assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b)); |
116 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
117 | assertEquals("a_A outbound", 0, a_A.getOutboundDependencies().size()); |
118 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
119 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
120 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
121 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
122 | assertEquals("b inbound", 1, b.getInboundDependencies().size()); |
123 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
124 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
125 | assertEquals("b_B inbound", 1, b_B.getInboundDependencies().size()); |
126 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
127 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
128 | assertEquals("b_B_b inbound", 1, b_B_b.getInboundDependencies().size()); |
129 | assertTrue("Missing b.B.b <-- a", b_B_b.getInboundDependencies().contains(a)); |
130 | } |
131 | |
132 | public void testClassPackage() { |
133 | a_A.addDependency(b); |
134 | |
135 | Visitor visitor = new LinkMaximizer(); |
136 | visitor.traverseNodes(factory.getPackages().values()); |
137 | |
138 | assertEquals("a outbound", 1, a.getOutboundDependencies().size()); |
139 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
140 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
141 | assertEquals("a_A outbound", 1, a_A.getOutboundDependencies().size()); |
142 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
143 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
144 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
145 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
146 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
147 | assertEquals("b inbound", 2, b.getInboundDependencies().size()); |
148 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
149 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
150 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
151 | assertEquals("b_B inbound", 0, b_B.getInboundDependencies().size()); |
152 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
153 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
154 | } |
155 | |
156 | public void testClassClass() { |
157 | a_A.addDependency(b_B); |
158 | |
159 | Visitor visitor = new LinkMaximizer(); |
160 | visitor.traverseNodes(factory.getPackages().values()); |
161 | |
162 | assertEquals("a outbound", 2, a.getOutboundDependencies().size()); |
163 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
164 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
165 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
166 | assertEquals("a_A outbound", 2, a_A.getOutboundDependencies().size()); |
167 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
168 | assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B)); |
169 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
170 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
171 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
172 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
173 | assertEquals("b inbound", 2, b.getInboundDependencies().size()); |
174 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
175 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
176 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
177 | assertEquals("b_B inbound", 2, b_B.getInboundDependencies().size()); |
178 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
179 | assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A)); |
180 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
181 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
182 | } |
183 | |
184 | public void testClassClassSparse() { |
185 | a.addDependency(b); |
186 | a_A.addDependency(b_B); |
187 | |
188 | Visitor visitor = new LinkMaximizer(); |
189 | visitor.traverseNodes(factory.getPackages().values()); |
190 | |
191 | assertEquals("a outbound", 2, a.getOutboundDependencies().size()); |
192 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
193 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
194 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
195 | assertEquals("a_A outbound", 2, a_A.getOutboundDependencies().size()); |
196 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
197 | assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B)); |
198 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
199 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
200 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
201 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
202 | assertEquals("b inbound", 2, b.getInboundDependencies().size()); |
203 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
204 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
205 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
206 | assertEquals("b_B inbound", 2, b_B.getInboundDependencies().size()); |
207 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
208 | assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A)); |
209 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
210 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
211 | } |
212 | |
213 | public void testClassFeature() { |
214 | a_A.addDependency(b_B_b); |
215 | |
216 | Visitor visitor = new LinkMaximizer(); |
217 | visitor.traverseNodes(factory.getPackages().values()); |
218 | |
219 | assertEquals("a outbound", 3, a.getOutboundDependencies().size()); |
220 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
221 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
222 | assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b)); |
223 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
224 | assertEquals("a_A outbound", 3, a_A.getOutboundDependencies().size()); |
225 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
226 | assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B)); |
227 | assertTrue("Missing a.A --> b.B.b", a_A.getOutboundDependencies().contains(b_B_b)); |
228 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
229 | assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size()); |
230 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
231 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
232 | assertEquals("b inbound", 2, b.getInboundDependencies().size()); |
233 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
234 | assertTrue("Missing b <-- a_A", b.getInboundDependencies().contains(a_A)); |
235 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
236 | assertEquals("b_B inbound", 2, b_B.getInboundDependencies().size()); |
237 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
238 | assertTrue("Missing b.B <-- a_A", b_B.getInboundDependencies().contains(a_A)); |
239 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
240 | assertEquals("b_B_b inbound", 2, b_B_b.getInboundDependencies().size()); |
241 | assertTrue("Missing b.B.b <-- a", b_B_b.getInboundDependencies().contains(a)); |
242 | assertTrue("Missing b.B.b <-- a_A", b_B_b.getInboundDependencies().contains(a_A)); |
243 | } |
244 | |
245 | public void testFeaturePackage() { |
246 | a_A_a.addDependency(b); |
247 | |
248 | Visitor visitor = new LinkMaximizer(); |
249 | visitor.traverseNodes(factory.getPackages().values()); |
250 | |
251 | assertEquals("a outbound", 1, a.getOutboundDependencies().size()); |
252 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
253 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
254 | assertEquals("a_A outbound", 1, a_A.getOutboundDependencies().size()); |
255 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
256 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
257 | assertEquals("a_A_a outbound", 1, a_A_a.getOutboundDependencies().size()); |
258 | assertTrue("Missing a.A.a --> b", a_A_a.getOutboundDependencies().contains(b)); |
259 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
260 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
261 | assertEquals("b inbound", 3, b.getInboundDependencies().size()); |
262 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
263 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
264 | assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a)); |
265 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
266 | assertEquals("b_B inbound", 0, b_B.getInboundDependencies().size()); |
267 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
268 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
269 | } |
270 | |
271 | public void testFeatureClass() { |
272 | a_A_a.addDependency(b_B); |
273 | |
274 | Visitor visitor = new LinkMaximizer(); |
275 | visitor.traverseNodes(factory.getPackages().values()); |
276 | |
277 | assertEquals("a outbound", 2, a.getOutboundDependencies().size()); |
278 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
279 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
280 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
281 | assertEquals("a_A outbound", 2, a_A.getOutboundDependencies().size()); |
282 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
283 | assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B)); |
284 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
285 | assertEquals("a_A_a outbound", 2, a_A_a.getOutboundDependencies().size()); |
286 | assertTrue("Missing a.A.a --> b", a_A_a.getOutboundDependencies().contains(b)); |
287 | assertTrue("Missing a.A.a --> b.B", a_A_a.getOutboundDependencies().contains(b_B)); |
288 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
289 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
290 | assertEquals("b inbound", 3, b.getInboundDependencies().size()); |
291 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
292 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
293 | assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a)); |
294 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
295 | assertEquals("b_B inbound", 3, b_B.getInboundDependencies().size()); |
296 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
297 | assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A)); |
298 | assertTrue("Missing b.B <-- a.A.a", b_B.getInboundDependencies().contains(a_A_a)); |
299 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
300 | assertEquals("b_B_b inbound", 0, b_B_b.getInboundDependencies().size()); |
301 | } |
302 | |
303 | public void testFeatureFeature() { |
304 | a_A_a.addDependency(b_B_b); |
305 | |
306 | Visitor visitor = new LinkMaximizer(); |
307 | visitor.traverseNodes(factory.getPackages().values()); |
308 | |
309 | assertEquals("a outbound", 3, a.getOutboundDependencies().size()); |
310 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
311 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
312 | assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b)); |
313 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
314 | assertEquals("a_A outbound", 3, a_A.getOutboundDependencies().size()); |
315 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
316 | assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B)); |
317 | assertTrue("Missing a.A --> b.B.b", a_A.getOutboundDependencies().contains(b_B_b)); |
318 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
319 | assertEquals("a_A_a outbound", 3, a_A_a.getOutboundDependencies().size()); |
320 | assertTrue("Missing a.A.a --> b", a_A_a.getOutboundDependencies().contains(b)); |
321 | assertTrue("Missing a.A.a --> b.B", a_A_a.getOutboundDependencies().contains(b_B)); |
322 | assertTrue("Missing a.A.a --> b.B.b", a_A_a.getOutboundDependencies().contains(b_B_b)); |
323 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
324 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
325 | assertEquals("b inbound", 3, b.getInboundDependencies().size()); |
326 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
327 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
328 | assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a)); |
329 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
330 | assertEquals("b_B inbound", 3, b_B.getInboundDependencies().size()); |
331 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
332 | assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A)); |
333 | assertTrue("Missing b.B <-- a.A.a", b_B.getInboundDependencies().contains(a_A_a)); |
334 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
335 | assertEquals("b_B_b inbound", 3, b_B_b.getInboundDependencies().size()); |
336 | assertTrue("Missing b.B.b <-- a", b_B_b.getInboundDependencies().contains(a)); |
337 | assertTrue("Missing b.B.b <-- a.A", b_B_b.getInboundDependencies().contains(a_A)); |
338 | assertTrue("Missing b.B.b <-- a.A.a", b_B_b.getInboundDependencies().contains(a_A_a)); |
339 | } |
340 | |
341 | public void testFeatureFeatureSparse() { |
342 | a.addDependency(b); |
343 | a_A.addDependency(b_B); |
344 | a_A_a.addDependency(b_B_b); |
345 | |
346 | Visitor visitor = new LinkMaximizer(); |
347 | visitor.traverseNodes(factory.getPackages().values()); |
348 | |
349 | assertEquals("a outbound", 3, a.getOutboundDependencies().size()); |
350 | assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b)); |
351 | assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B)); |
352 | assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b)); |
353 | assertEquals("a inbound", 0, a.getInboundDependencies().size()); |
354 | assertEquals("a_A outbound", 3, a_A.getOutboundDependencies().size()); |
355 | assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b)); |
356 | assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B)); |
357 | assertTrue("Missing a.A --> b.B.b", a_A.getOutboundDependencies().contains(b_B_b)); |
358 | assertEquals("a_A inbound", 0, a_A.getInboundDependencies().size()); |
359 | assertEquals("a_A_a outbound", 3, a_A_a.getOutboundDependencies().size()); |
360 | assertTrue("Missing a.A.a --> b", a_A_a.getOutboundDependencies().contains(b)); |
361 | assertTrue("Missing a.A.a --> b.B", a_A_a.getOutboundDependencies().contains(b_B)); |
362 | assertTrue("Missing a.A.a --> b.B.b", a_A_a.getOutboundDependencies().contains(b_B_b)); |
363 | assertEquals("a_A_a inbound", 0, a_A_a.getInboundDependencies().size()); |
364 | assertEquals("b outbound", 0, b.getOutboundDependencies().size()); |
365 | assertEquals("b inbound", 3, b.getInboundDependencies().size()); |
366 | assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a)); |
367 | assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A)); |
368 | assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a)); |
369 | assertEquals("b_B outbound", 0, b_B.getOutboundDependencies().size()); |
370 | assertEquals("b_B inbound", 3, b_B.getInboundDependencies().size()); |
371 | assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a)); |
372 | assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A)); |
373 | assertTrue("Missing b.B <-- a.A.a", b_B.getInboundDependencies().contains(a_A_a)); |
374 | assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size()); |
375 | assertEquals("b_B_b inbound", 3, b_B_b.getInboundDependencies().size()); |
376 | assertTrue("Missing b.B.b <-- a", b_B_b.getInboundDependencies().contains(a)); |
377 | assertTrue("Missing b.B.b <-- a.A", b_B_b.getInboundDependencies().contains(a_A)); |
378 | assertTrue("Missing b.B.b <-- a.A.a", b_B_b.getInboundDependencies().contains(a_A_a)); |
379 | } |
380 | } |