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 java.util.*; |
36 | |
37 | import junit.framework.*; |
38 | |
39 | public class TestTransitiveClosureWithTestClass extends TestCase { |
40 | private NodeFactory factory; |
41 | |
42 | private Node _package; |
43 | private Node test_class; |
44 | private Node test_main_method; |
45 | private Node test_Test_method; |
46 | |
47 | private Node java_lang_package; |
48 | private Node java_lang_Object_class; |
49 | private Node java_lang_Object_Object_method; |
50 | private Node java_lang_String_class; |
51 | |
52 | private Node java_util_package; |
53 | private Node java_util_Collections_class; |
54 | private Node java_util_Collections_singleton_method; |
55 | |
56 | private List<String> scopeIncludes; |
57 | |
58 | private RegularExpressionSelectionCriteria startCriteria; |
59 | private RegularExpressionSelectionCriteria stopCriteria; |
60 | |
61 | private NodeFactory resultFactory; |
62 | |
63 | protected void setUp() throws Exception { |
64 | super.setUp(); |
65 | |
66 | factory = new NodeFactory(); |
67 | |
68 | _package = factory.createPackage(""); |
69 | test_class = factory.createClass("test"); |
70 | test_main_method = factory.createFeature("test.main(String[])"); |
71 | test_Test_method = factory.createFeature("test.test()"); |
72 | |
73 | java_lang_package = factory.createPackage("java.lang"); |
74 | java_lang_Object_class = factory.createClass("java.lang.Object"); |
75 | java_lang_Object_Object_method = factory.createFeature("java.lang.Object.Object()"); |
76 | java_lang_String_class = factory.createClass("java.lang.String"); |
77 | |
78 | java_util_package = factory.createPackage("java.util"); |
79 | java_util_Collections_class = factory.createClass("java.util.Collections"); |
80 | java_util_Collections_singleton_method = factory.createFeature("java.util.Collections.singleton(java.lang.Object)"); |
81 | |
82 | test_class.addDependency(java_lang_Object_class); |
83 | test_main_method.addDependency(java_lang_Object_class); |
84 | test_main_method.addDependency(java_lang_Object_Object_method); |
85 | test_main_method.addDependency(java_lang_String_class); |
86 | test_main_method.addDependency(java_util_Collections_singleton_method); |
87 | test_Test_method.addDependency(java_lang_Object_Object_method); |
88 | |
89 | scopeIncludes = new ArrayList<String>(1); |
90 | scopeIncludes.add("/test/"); |
91 | |
92 | startCriteria = new RegularExpressionSelectionCriteria(); |
93 | stopCriteria = new RegularExpressionSelectionCriteria(); |
94 | } |
95 | |
96 | public void testCompleteClosure() { |
97 | startCriteria.setGlobalIncludes(scopeIncludes); |
98 | stopCriteria.setGlobalIncludes(Collections.<String>emptyList()); |
99 | |
100 | compute(factory.getPackages().values()); |
101 | |
102 | assertEquals("Different number of packages", |
103 | factory.getPackages().size(), |
104 | resultFactory.getPackages().size()); |
105 | assertEquals("Different number of classes", |
106 | factory.getClasses().size(), |
107 | resultFactory.getClasses().size()); |
108 | assertEquals("Different number of features", |
109 | factory.getFeatures().size(), |
110 | resultFactory.getFeatures().size()); |
111 | |
112 | for (String key : resultFactory.getPackages().keySet()) { |
113 | assertEquals(factory.getPackages().get(key), resultFactory.getPackages().get(key)); |
114 | assertTrue(factory.getPackages().get(key) != resultFactory.getPackages().get(key)); |
115 | assertEquals("Package " + key + " has different inbound count", |
116 | factory.getPackages().get(key).getInboundDependencies().size(), |
117 | resultFactory.getPackages().get(key).getInboundDependencies().size()); |
118 | assertEquals("Package " + key + " has different outbound count", |
119 | factory.getPackages().get(key).getOutboundDependencies().size(), |
120 | resultFactory.getPackages().get(key).getOutboundDependencies().size()); |
121 | } |
122 | |
123 | for (String key : resultFactory.getClasses().keySet()) { |
124 | assertEquals(factory.getClasses().get(key), resultFactory.getClasses().get(key)); |
125 | assertTrue(factory.getClasses().get(key) != resultFactory.getClasses().get(key)); |
126 | assertEquals("Class " + key + " has different inbound count", |
127 | factory.getClasses().get(key).getInboundDependencies().size(), |
128 | resultFactory.getClasses().get(key).getInboundDependencies().size()); |
129 | assertEquals("Class " + key + " has different outbound count", |
130 | factory.getClasses().get(key).getOutboundDependencies().size(), |
131 | resultFactory.getClasses().get(key).getOutboundDependencies().size()); |
132 | } |
133 | |
134 | for (String key : resultFactory.getFeatures().keySet()) { |
135 | assertEquals(factory.getFeatures().get(key), resultFactory.getFeatures().get(key)); |
136 | assertTrue(factory.getFeatures().get(key) != resultFactory.getFeatures().get(key)); |
137 | assertEquals("Feature " + key + " has different inbound count", |
138 | factory.getFeatures().get(key).getInboundDependencies().size(), |
139 | resultFactory.getFeatures().get(key).getInboundDependencies().size()); |
140 | assertEquals("Feature " + key + " has different outbound count", |
141 | factory.getFeatures().get(key).getOutboundDependencies().size(), |
142 | resultFactory.getFeatures().get(key).getOutboundDependencies().size()); |
143 | } |
144 | } |
145 | |
146 | public void testCopyAllNodesOnly() { |
147 | startCriteria.setGlobalIncludes(scopeIncludes); |
148 | stopCriteria.setMatchingPackages(false); |
149 | stopCriteria.setMatchingClasses(false); |
150 | stopCriteria.setMatchingFeatures(false); |
151 | stopCriteria.setGlobalIncludes("//"); |
152 | |
153 | compute(factory.getPackages().values()); |
154 | |
155 | assertEquals("Different number of packages", |
156 | 1, |
157 | resultFactory.getPackages().size()); |
158 | assertEquals("Different number of classes", |
159 | 1, |
160 | resultFactory.getClasses().size()); |
161 | assertEquals("Different number of features", |
162 | 2, |
163 | resultFactory.getFeatures().size()); |
164 | |
165 | for (String key : resultFactory.getPackages().keySet()) { |
166 | assertEquals(factory.getPackages().get(key), resultFactory.getPackages().get(key)); |
167 | assertTrue(factory.getPackages().get(key) != resultFactory.getPackages().get(key)); |
168 | assertTrue(resultFactory.getPackages().get(key).getInboundDependencies().isEmpty()); |
169 | assertTrue(resultFactory.getPackages().get(key).getOutboundDependencies().isEmpty()); |
170 | } |
171 | |
172 | for (String key : resultFactory.getClasses().keySet()) { |
173 | assertEquals(factory.getClasses().get(key), resultFactory.getClasses().get(key)); |
174 | assertTrue(factory.getClasses().get(key) != resultFactory.getClasses().get(key)); |
175 | assertTrue(resultFactory.getClasses().get(key).getInboundDependencies().isEmpty()); |
176 | assertTrue(resultFactory.getClasses().get(key).getOutboundDependencies().isEmpty()); |
177 | } |
178 | |
179 | for (String key : resultFactory.getFeatures().keySet()) { |
180 | assertEquals(factory.getFeatures().get(key), resultFactory.getFeatures().get(key)); |
181 | assertTrue(factory.getFeatures().get(key) != resultFactory.getFeatures().get(key)); |
182 | assertTrue(resultFactory.getFeatures().get(key).getInboundDependencies().isEmpty()); |
183 | assertTrue(resultFactory.getFeatures().get(key).getOutboundDependencies().isEmpty()); |
184 | } |
185 | } |
186 | |
187 | public void testCopyPackageNodesOnly() { |
188 | startCriteria.setMatchingClasses(false); |
189 | startCriteria.setMatchingFeatures(false); |
190 | startCriteria.setGlobalIncludes(scopeIncludes); |
191 | stopCriteria.setMatchingPackages(false); |
192 | stopCriteria.setMatchingClasses(false); |
193 | stopCriteria.setMatchingFeatures(false); |
194 | stopCriteria.setGlobalIncludes("//"); |
195 | |
196 | compute(factory.getPackages().values()); |
197 | |
198 | assertEquals("Different number of packages", |
199 | 1, |
200 | resultFactory.getPackages().size()); |
201 | assertTrue(resultFactory.getClasses().isEmpty()); |
202 | assertTrue(resultFactory.getFeatures().isEmpty()); |
203 | } |
204 | |
205 | public void testCopyClassNodesOnly() { |
206 | startCriteria.setMatchingPackages(false); |
207 | startCriteria.setMatchingFeatures(false); |
208 | startCriteria.setGlobalIncludes(scopeIncludes); |
209 | stopCriteria.setMatchingPackages(false); |
210 | stopCriteria.setMatchingClasses(false); |
211 | stopCriteria.setMatchingFeatures(false); |
212 | stopCriteria.setGlobalIncludes("//"); |
213 | |
214 | compute(factory.getPackages().values()); |
215 | |
216 | assertEquals("Different number of packages", |
217 | 1, |
218 | resultFactory.getPackages().size()); |
219 | assertEquals("Different number of classes", |
220 | 1, |
221 | resultFactory.getClasses().size()); |
222 | assertTrue(resultFactory.getFeatures().isEmpty()); |
223 | |
224 | for (String key : resultFactory.getPackages().keySet()) { |
225 | assertEquals(factory.getPackages().get(key), resultFactory.getPackages().get(key)); |
226 | assertTrue(factory.getPackages().get(key) != resultFactory.getPackages().get(key)); |
227 | assertTrue(resultFactory.getPackages().get(key).getInboundDependencies().isEmpty()); |
228 | assertTrue(resultFactory.getPackages().get(key).getOutboundDependencies().isEmpty()); |
229 | } |
230 | |
231 | for (String key : resultFactory.getClasses().keySet()) { |
232 | assertEquals(factory.getClasses().get(key), resultFactory.getClasses().get(key)); |
233 | assertTrue(factory.getClasses().get(key) != resultFactory.getClasses().get(key)); |
234 | assertTrue(resultFactory.getClasses().get(key).getInboundDependencies().isEmpty()); |
235 | assertTrue(resultFactory.getClasses().get(key).getOutboundDependencies().isEmpty()); |
236 | } |
237 | } |
238 | |
239 | public void testCopyFeatureNodesOnly() { |
240 | startCriteria.setMatchingPackages(false); |
241 | startCriteria.setMatchingClasses(false); |
242 | startCriteria.setGlobalIncludes(scopeIncludes); |
243 | stopCriteria.setMatchingPackages(false); |
244 | stopCriteria.setMatchingClasses(false); |
245 | stopCriteria.setMatchingFeatures(false); |
246 | stopCriteria.setGlobalIncludes("//"); |
247 | |
248 | compute(factory.getPackages().values()); |
249 | |
250 | assertEquals("Different number of packages", |
251 | 1, |
252 | resultFactory.getPackages().size()); |
253 | assertEquals("Different number of classes", |
254 | 1, |
255 | resultFactory.getClasses().size()); |
256 | assertEquals("Different number of features", |
257 | 2, |
258 | resultFactory.getFeatures().size()); |
259 | |
260 | for (String key : resultFactory.getPackages().keySet()) { |
261 | assertEquals(factory.getPackages().get(key), resultFactory.getPackages().get(key)); |
262 | assertTrue(factory.getPackages().get(key) != resultFactory.getPackages().get(key)); |
263 | assertTrue(resultFactory.getPackages().get(key).getInboundDependencies().isEmpty()); |
264 | assertTrue(resultFactory.getPackages().get(key).getOutboundDependencies().isEmpty()); |
265 | } |
266 | |
267 | for (String key : resultFactory.getClasses().keySet()) { |
268 | assertEquals(factory.getClasses().get(key), resultFactory.getClasses().get(key)); |
269 | assertTrue(factory.getClasses().get(key) != resultFactory.getClasses().get(key)); |
270 | assertTrue(resultFactory.getClasses().get(key).getInboundDependencies().isEmpty()); |
271 | assertTrue(resultFactory.getClasses().get(key).getOutboundDependencies().isEmpty()); |
272 | } |
273 | |
274 | for (String key : resultFactory.getFeatures().keySet()) { |
275 | assertEquals(factory.getFeatures().get(key), resultFactory.getFeatures().get(key)); |
276 | assertTrue(factory.getFeatures().get(key) != resultFactory.getFeatures().get(key)); |
277 | assertTrue(resultFactory.getFeatures().get(key).getInboundDependencies().isEmpty()); |
278 | assertTrue(resultFactory.getFeatures().get(key).getOutboundDependencies().isEmpty()); |
279 | } |
280 | } |
281 | |
282 | public void testCopyNothing() { |
283 | startCriteria.setMatchingPackages(false); |
284 | startCriteria.setMatchingClasses(false); |
285 | startCriteria.setMatchingFeatures(false); |
286 | |
287 | compute(factory.getPackages().values()); |
288 | |
289 | assertTrue(resultFactory.getPackages().isEmpty()); |
290 | assertTrue(resultFactory.getClasses().isEmpty()); |
291 | assertTrue(resultFactory.getFeatures().isEmpty()); |
292 | } |
293 | |
294 | private void compute(Collection<? extends Node> nodes) { |
295 | RegularExpressionSelectionCriteria localStartCriteria = new RegularExpressionSelectionCriteria(); |
296 | localStartCriteria.setGlobalIncludes(startCriteria.getGlobalIncludes()); |
297 | RegularExpressionSelectionCriteria localStopCriteria = new RegularExpressionSelectionCriteria(); |
298 | localStopCriteria.setGlobalIncludes(stopCriteria.getGlobalIncludes()); |
299 | |
300 | TransitiveClosure closure = new TransitiveClosure(localStartCriteria, localStopCriteria); |
301 | closure.traverseNodes(nodes); |
302 | |
303 | RegularExpressionSelectionCriteria localScopeCriteria = new RegularExpressionSelectionCriteria(); |
304 | localScopeCriteria.setMatchingPackages(startCriteria.isMatchingPackages()); |
305 | localScopeCriteria.setMatchingClasses(startCriteria.isMatchingClasses()); |
306 | localScopeCriteria.setMatchingFeatures(startCriteria.isMatchingFeatures()); |
307 | localScopeCriteria.setGlobalIncludes("//"); |
308 | RegularExpressionSelectionCriteria localFilterCriteria = new RegularExpressionSelectionCriteria(); |
309 | localFilterCriteria.setMatchingPackages(stopCriteria.isMatchingPackages()); |
310 | localFilterCriteria.setMatchingClasses(stopCriteria.isMatchingClasses()); |
311 | localFilterCriteria.setMatchingFeatures(stopCriteria.isMatchingFeatures()); |
312 | localFilterCriteria.setGlobalIncludes("//"); |
313 | |
314 | GraphSummarizer summarizer = new GraphSummarizer(localScopeCriteria, localFilterCriteria); |
315 | summarizer.traverseNodes(closure.getFactory().getPackages().values()); |
316 | |
317 | resultFactory = summarizer.getScopeFactory(); |
318 | } |
319 | } |