EMMA Coverage Report (generated Mon Nov 29 14:43:38 PST 2010)
[all classes][com.jeantessier.dependency]

COVERAGE SUMMARY FOR SOURCE FILE [TestTransitiveClosureNonMaximized.java]

nameclass, %method, %block, %line, %
TestTransitiveClosureNonMaximized.java100% (1/1)100% (9/9)100% (1660/1660)100% (246/246)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class TestTransitiveClosureNonMaximized100% (1/1)100% (9/9)100% (1660/1660)100% (246/246)
TestTransitiveClosureNonMaximized (): void 100% (1/1)100% (3/3)100% (1/1)
compute (Collection): void 100% (1/1)100% (94/94)100% (22/22)
setUp (): void 100% (1/1)100% (111/111)100% (25/25)
testClassToClassFromClass (): void 100% (1/1)100% (242/242)100% (33/33)
testClassToClassFromPackageList (): void 100% (1/1)100% (242/242)100% (33/33)
testFeatureToFeatureFromFeature (): void 100% (1/1)100% (310/310)100% (42/42)
testFeatureToFeatureFromPackages (): void 100% (1/1)100% (311/311)100% (42/42)
testPackageToPackageFromPackage (): void 100% (1/1)100% (174/174)100% (24/24)
testPackageToPackageFromPackageList (): void 100% (1/1)100% (173/173)100% (24/24)

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 
33package com.jeantessier.dependency;
34 
35import java.util.*;
36 
37import junit.framework.*;
38 
39import org.apache.log4j.*;
40 
41public class TestTransitiveClosureNonMaximized extends TestCase {
42    private NodeFactory factory;
43 
44    private FeatureNode in2;
45    private FeatureNode in1;
46    private FeatureNode base;
47    private FeatureNode out1;
48    private FeatureNode out2;
49    
50    private RegularExpressionSelectionCriteria startCriteria;
51    private RegularExpressionSelectionCriteria stopCriteria;
52 
53    private NodeFactory resultFactory;
54 
55    protected void setUp() throws Exception {
56        super.setUp();
57 
58        factory = new NodeFactory();
59 
60        in2  = factory.createFeature("in2.In2.In2()");
61        in1  = factory.createFeature("in1.In1.In1()");
62        base = factory.createFeature("base.Base.Base()");
63        out1 = factory.createFeature("out1.Out1.Out1()");
64        out2 = factory.createFeature("out2.Out2.Out2()");
65 
66        in2.addDependency(in1);
67        in1.addDependency(base);
68        base.addDependency(out1);
69        out1.addDependency(out2);
70        
71        List<String> scopeIncludes = new ArrayList<String>(1);
72        scopeIncludes.add("/^base/");
73        List<String> filterIncludes = Collections.emptyList();
74        
75        startCriteria = new RegularExpressionSelectionCriteria();
76        startCriteria.setMatchingPackages(false);
77        startCriteria.setMatchingClasses(false);
78        startCriteria.setMatchingFeatures(false);
79        startCriteria.setGlobalIncludes(scopeIncludes);
80 
81        stopCriteria = new RegularExpressionSelectionCriteria();
82        stopCriteria.setMatchingPackages(false);
83        stopCriteria.setMatchingClasses(false);
84        stopCriteria.setMatchingFeatures(false);
85        stopCriteria.setGlobalIncludes(filterIncludes);
86    }
87 
88    public void testFeatureToFeatureFromFeature() {
89        startCriteria.setMatchingFeatures(true);
90        stopCriteria.setMatchingFeatures(true);
91 
92        Logger.getLogger(getClass()).info("Start f2f test from feature ...");
93        compute(Collections.singleton(base));
94        Logger.getLogger(getClass()).info("Stop f2f test from feature ...");
95 
96        assertEquals(5, resultFactory.getFeatures().size());
97        assertTrue(resultFactory.getFeatures().values().contains(in2));
98        assertTrue(resultFactory.getFeatures().values().contains(in1));
99        assertTrue(resultFactory.getFeatures().values().contains(base));
100        assertTrue(resultFactory.getFeatures().values().contains(out1));
101        assertTrue(resultFactory.getFeatures().values().contains(out2));
102 
103        assertEquals(0, resultFactory.createFeature("in2.In2.In2()").getInboundDependencies().size());
104        assertEquals(1, resultFactory.createFeature("in2.In2.In2()").getOutboundDependencies().size());
105        assertEquals(1, resultFactory.createFeature("in1.In1.In1()").getInboundDependencies().size());
106        assertEquals(1, resultFactory.createFeature("in1.In1.In1()").getOutboundDependencies().size());
107        assertEquals(1, resultFactory.createFeature("base.Base.Base()").getInboundDependencies().size());
108        assertEquals(1, resultFactory.createFeature("base.Base.Base()").getOutboundDependencies().size());
109        assertEquals(1, resultFactory.createFeature("out1.Out1.Out1()").getInboundDependencies().size());
110        assertEquals(1, resultFactory.createFeature("out1.Out1.Out1()").getOutboundDependencies().size());
111        assertEquals(1, resultFactory.createFeature("out2.Out2.Out2()").getInboundDependencies().size());
112        assertEquals(0, resultFactory.createFeature("out2.Out2.Out2()").getOutboundDependencies().size());
113 
114        assertEquals(0, resultFactory.createClass("in2.In2").getInboundDependencies().size());
115        assertEquals(0, resultFactory.createClass("in2.In2").getOutboundDependencies().size());
116        assertEquals(0, resultFactory.createClass("in1.In1").getInboundDependencies().size());
117        assertEquals(0, resultFactory.createClass("in1.In1").getOutboundDependencies().size());
118        assertEquals(0, resultFactory.createClass("base.Base").getInboundDependencies().size());
119        assertEquals(0, resultFactory.createClass("base.Base").getOutboundDependencies().size());
120        assertEquals(0, resultFactory.createClass("out1.Out1").getInboundDependencies().size());
121        assertEquals(0, resultFactory.createClass("out1.Out1").getOutboundDependencies().size());
122        assertEquals(0, resultFactory.createClass("out2.Out2").getInboundDependencies().size());
123        assertEquals(0, resultFactory.createClass("out2.Out2").getOutboundDependencies().size());
124 
125        assertEquals(0, resultFactory.createPackage("in2").getInboundDependencies().size());
126        assertEquals(0, resultFactory.createPackage("in2").getOutboundDependencies().size());
127        assertEquals(0, resultFactory.createPackage("in1").getInboundDependencies().size());
128        assertEquals(0, resultFactory.createPackage("in1").getOutboundDependencies().size());
129        assertEquals(0, resultFactory.createPackage("base").getInboundDependencies().size());
130        assertEquals(0, resultFactory.createPackage("base").getOutboundDependencies().size());
131        assertEquals(0, resultFactory.createPackage("out1").getInboundDependencies().size());
132        assertEquals(0, resultFactory.createPackage("out1").getOutboundDependencies().size());
133        assertEquals(0, resultFactory.createPackage("out2").getInboundDependencies().size());
134        assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
135    }
136 
137    public void testFeatureToFeatureFromPackages() {
138        startCriteria.setMatchingFeatures(true);
139        stopCriteria.setMatchingFeatures(true);
140 
141        Logger.getLogger(getClass()).info("Start f2f test from package list ...");
142        compute(factory.getPackages().values());
143        Logger.getLogger(getClass()).info("Stop f2f test from package list ...");
144 
145        assertEquals(5, resultFactory.getFeatures().size());
146        assertTrue(resultFactory.getFeatures().values().contains(in2));
147        assertTrue(resultFactory.getFeatures().values().contains(in1));
148        assertTrue(resultFactory.getFeatures().values().contains(base));
149        assertTrue(resultFactory.getFeatures().values().contains(out1));
150        assertTrue(resultFactory.getFeatures().values().contains(out2));
151 
152        assertEquals(0, resultFactory.createFeature("in2.In2.In2()").getInboundDependencies().size());
153        assertEquals(1, resultFactory.createFeature("in2.In2.In2()").getOutboundDependencies().size());
154        assertEquals(1, resultFactory.createFeature("in1.In1.In1()").getInboundDependencies().size());
155        assertEquals(1, resultFactory.createFeature("in1.In1.In1()").getOutboundDependencies().size());
156        assertEquals(1, resultFactory.createFeature("base.Base.Base()").getInboundDependencies().size());
157        assertEquals(1, resultFactory.createFeature("base.Base.Base()").getOutboundDependencies().size());
158        assertEquals(1, resultFactory.createFeature("out1.Out1.Out1()").getInboundDependencies().size());
159        assertEquals(1, resultFactory.createFeature("out1.Out1.Out1()").getOutboundDependencies().size());
160        assertEquals(1, resultFactory.createFeature("out2.Out2.Out2()").getInboundDependencies().size());
161        assertEquals(0, resultFactory.createFeature("out2.Out2.Out2()").getOutboundDependencies().size());
162 
163        assertEquals(0, resultFactory.createClass("in2.In2").getInboundDependencies().size());
164        assertEquals(0, resultFactory.createClass("in2.In2").getOutboundDependencies().size());
165        assertEquals(0, resultFactory.createClass("in1.In1").getInboundDependencies().size());
166        assertEquals(0, resultFactory.createClass("in1.In1").getOutboundDependencies().size());
167        assertEquals(0, resultFactory.createClass("base.Base").getInboundDependencies().size());
168        assertEquals(0, resultFactory.createClass("base.Base").getOutboundDependencies().size());
169        assertEquals(0, resultFactory.createClass("out1.Out1").getInboundDependencies().size());
170        assertEquals(0, resultFactory.createClass("out1.Out1").getOutboundDependencies().size());
171        assertEquals(0, resultFactory.createClass("out2.Out2").getInboundDependencies().size());
172        assertEquals(0, resultFactory.createClass("out2.Out2").getOutboundDependencies().size());
173 
174        assertEquals(0, resultFactory.createPackage("in2").getInboundDependencies().size());
175        assertEquals(0, resultFactory.createPackage("in2").getOutboundDependencies().size());
176        assertEquals(0, resultFactory.createPackage("in1").getInboundDependencies().size());
177        assertEquals(0, resultFactory.createPackage("in1").getOutboundDependencies().size());
178        assertEquals(0, resultFactory.createPackage("base").getInboundDependencies().size());
179        assertEquals(0, resultFactory.createPackage("base").getOutboundDependencies().size());
180        assertEquals(0, resultFactory.createPackage("out1").getInboundDependencies().size());
181        assertEquals(0, resultFactory.createPackage("out1").getOutboundDependencies().size());
182        assertEquals(0, resultFactory.createPackage("out2").getInboundDependencies().size());
183        assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
184    }
185 
186    public void testClassToClassFromClass() {
187        startCriteria.setMatchingClasses(true);
188        stopCriteria.setMatchingClasses(true);
189 
190        Logger.getLogger(getClass()).info("Start c2c test from class ...");
191        compute(Collections.singleton(base.getClassNode()));
192        Logger.getLogger(getClass()).info("Stop c2c test from class ...");
193 
194        assertEquals(0, resultFactory.getFeatures().size());
195 
196        assertEquals(5, resultFactory.getClasses().size());
197        assertTrue(resultFactory.getClasses().values().contains(in2.getClassNode()));
198        assertTrue(resultFactory.getClasses().values().contains(in1.getClassNode()));
199        assertTrue(resultFactory.getClasses().values().contains(base.getClassNode()));
200        assertTrue(resultFactory.getClasses().values().contains(out1.getClassNode()));
201        assertTrue(resultFactory.getClasses().values().contains(out2.getClassNode()));
202 
203        assertEquals(0, resultFactory.createClass("in2.In2").getInboundDependencies().size());
204        assertEquals(1, resultFactory.createClass("in2.In2").getOutboundDependencies().size());
205        assertEquals(1, resultFactory.createClass("in1.In1").getInboundDependencies().size());
206        assertEquals(1, resultFactory.createClass("in1.In1").getOutboundDependencies().size());
207        assertEquals(1, resultFactory.createClass("base.Base").getInboundDependencies().size());
208        assertEquals(1, resultFactory.createClass("base.Base").getOutboundDependencies().size());
209        assertEquals(1, resultFactory.createClass("out1.Out1").getInboundDependencies().size());
210        assertEquals(1, resultFactory.createClass("out1.Out1").getOutboundDependencies().size());
211        assertEquals(1, resultFactory.createClass("out2.Out2").getInboundDependencies().size());
212        assertEquals(0, resultFactory.createClass("out2.Out2").getOutboundDependencies().size());
213 
214        assertEquals(0, resultFactory.createPackage("in2").getInboundDependencies().size());
215        assertEquals(0, resultFactory.createPackage("in2").getOutboundDependencies().size());
216        assertEquals(0, resultFactory.createPackage("in1").getInboundDependencies().size());
217        assertEquals(0, resultFactory.createPackage("in1").getOutboundDependencies().size());
218        assertEquals(0, resultFactory.createPackage("base").getInboundDependencies().size());
219        assertEquals(0, resultFactory.createPackage("base").getOutboundDependencies().size());
220        assertEquals(0, resultFactory.createPackage("out1").getInboundDependencies().size());
221        assertEquals(0, resultFactory.createPackage("out1").getOutboundDependencies().size());
222        assertEquals(0, resultFactory.createPackage("out2").getInboundDependencies().size());
223        assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
224    }
225 
226    public void testClassToClassFromPackageList() {
227        startCriteria.setMatchingClasses(true);
228        stopCriteria.setMatchingClasses(true);
229 
230        Logger.getLogger(getClass()).info("Start c2c test from package list ...");
231        compute(factory.getPackages().values());
232        Logger.getLogger(getClass()).info("Stop c2c test from package list ...");
233 
234        assertEquals(0, resultFactory.getFeatures().size());
235 
236        assertEquals(5, resultFactory.getClasses().size());
237        assertTrue(resultFactory.getClasses().values().contains(in2.getClassNode()));
238        assertTrue(resultFactory.getClasses().values().contains(in1.getClassNode()));
239        assertTrue(resultFactory.getClasses().values().contains(base.getClassNode()));
240        assertTrue(resultFactory.getClasses().values().contains(out1.getClassNode()));
241        assertTrue(resultFactory.getClasses().values().contains(out2.getClassNode()));
242 
243        assertEquals(0, resultFactory.createClass("in2.In2").getInboundDependencies().size());
244        assertEquals(1, resultFactory.createClass("in2.In2").getOutboundDependencies().size());
245        assertEquals(1, resultFactory.createClass("in1.In1").getInboundDependencies().size());
246        assertEquals(1, resultFactory.createClass("in1.In1").getOutboundDependencies().size());
247        assertEquals(1, resultFactory.createClass("base.Base").getInboundDependencies().size());
248        assertEquals(1, resultFactory.createClass("base.Base").getOutboundDependencies().size());
249        assertEquals(1, resultFactory.createClass("out1.Out1").getInboundDependencies().size());
250        assertEquals(1, resultFactory.createClass("out1.Out1").getOutboundDependencies().size());
251        assertEquals(1, resultFactory.createClass("out2.Out2").getInboundDependencies().size());
252        assertEquals(0, resultFactory.createClass("out2.Out2").getOutboundDependencies().size());
253 
254        assertEquals(0, resultFactory.createPackage("in2").getInboundDependencies().size());
255        assertEquals(0, resultFactory.createPackage("in2").getOutboundDependencies().size());
256        assertEquals(0, resultFactory.createPackage("in1").getInboundDependencies().size());
257        assertEquals(0, resultFactory.createPackage("in1").getOutboundDependencies().size());
258        assertEquals(0, resultFactory.createPackage("base").getInboundDependencies().size());
259        assertEquals(0, resultFactory.createPackage("base").getOutboundDependencies().size());
260        assertEquals(0, resultFactory.createPackage("out1").getInboundDependencies().size());
261        assertEquals(0, resultFactory.createPackage("out1").getOutboundDependencies().size());
262        assertEquals(0, resultFactory.createPackage("out2").getInboundDependencies().size());
263        assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
264    }
265 
266    public void testPackageToPackageFromPackage() {
267        startCriteria.setMatchingPackages(true);
268        stopCriteria.setMatchingPackages(true);
269 
270        Logger.getLogger(getClass()).info("Start p2p test from package ...");
271        compute(Collections.singleton(base.getClassNode().getPackageNode()));
272        Logger.getLogger(getClass()).info("Stop p2p test from package ...");
273 
274        assertEquals(0, resultFactory.getFeatures().size());
275 
276        assertEquals(0, resultFactory.getClasses().size());
277 
278        assertEquals(5, resultFactory.getPackages().size());
279        assertTrue(resultFactory.getPackages().values().contains(in2.getClassNode().getPackageNode()));
280        assertTrue(resultFactory.getPackages().values().contains(in1.getClassNode().getPackageNode()));
281        assertTrue(resultFactory.getPackages().values().contains(base.getClassNode().getPackageNode()));
282        assertTrue(resultFactory.getPackages().values().contains(out1.getClassNode().getPackageNode()));
283        assertTrue(resultFactory.getPackages().values().contains(out2.getClassNode().getPackageNode()));
284 
285        assertEquals(0, resultFactory.createPackage("in2").getInboundDependencies().size());
286        assertEquals(1, resultFactory.createPackage("in2").getOutboundDependencies().size());
287        assertEquals(1, resultFactory.createPackage("in1").getInboundDependencies().size());
288        assertEquals(1, resultFactory.createPackage("in1").getOutboundDependencies().size());
289        assertEquals(1, resultFactory.createPackage("base").getInboundDependencies().size());
290        assertEquals(1, resultFactory.createPackage("base").getOutboundDependencies().size());
291        assertEquals(1, resultFactory.createPackage("out1").getInboundDependencies().size());
292        assertEquals(1, resultFactory.createPackage("out1").getOutboundDependencies().size());
293        assertEquals(1, resultFactory.createPackage("out2").getInboundDependencies().size());
294        assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
295    }
296 
297    public void testPackageToPackageFromPackageList() {
298        startCriteria.setMatchingPackages(true);
299        stopCriteria.setMatchingPackages(true);
300 
301        Logger.getLogger(getClass()).info("Start p2p test from package list ...");
302        compute(factory.getPackages().values());
303        Logger.getLogger(getClass()).info("Stop p2p test from package list ...");
304 
305        assertEquals(0, resultFactory.getFeatures().size());
306 
307        assertEquals(0, resultFactory.getClasses().size());
308 
309        assertEquals(5, resultFactory.getPackages().size());
310        assertTrue(resultFactory.getPackages().values().contains(in2.getClassNode().getPackageNode()));
311        assertTrue(resultFactory.getPackages().values().contains(in1.getClassNode().getPackageNode()));
312        assertTrue(resultFactory.getPackages().values().contains(base.getClassNode().getPackageNode()));
313        assertTrue(resultFactory.getPackages().values().contains(out1.getClassNode().getPackageNode()));
314        assertTrue(resultFactory.getPackages().values().contains(out2.getClassNode().getPackageNode()));
315 
316        assertEquals(0, resultFactory.createPackage("in2").getInboundDependencies().size());
317        assertEquals(1, resultFactory.createPackage("in2").getOutboundDependencies().size());
318        assertEquals(1, resultFactory.createPackage("in1").getInboundDependencies().size());
319        assertEquals(1, resultFactory.createPackage("in1").getOutboundDependencies().size());
320        assertEquals(1, resultFactory.createPackage("base").getInboundDependencies().size());
321        assertEquals(1, resultFactory.createPackage("base").getOutboundDependencies().size());
322        assertEquals(1, resultFactory.createPackage("out1").getInboundDependencies().size());
323        assertEquals(1, resultFactory.createPackage("out1").getOutboundDependencies().size());
324        assertEquals(1, resultFactory.createPackage("out2").getInboundDependencies().size());
325        assertEquals(0, resultFactory.createPackage("out2").getOutboundDependencies().size());
326    }
327 
328    private void compute(Collection<? extends Node> nodes) {
329        RegularExpressionSelectionCriteria localStartCriteria = new RegularExpressionSelectionCriteria();
330        localStartCriteria.setGlobalIncludes(startCriteria.getGlobalIncludes());
331        RegularExpressionSelectionCriteria localStopCriteria  = new RegularExpressionSelectionCriteria();
332        localStopCriteria.setGlobalIncludes(stopCriteria.getGlobalIncludes());
333 
334        TransitiveClosure closure = new TransitiveClosure(localStartCriteria, localStopCriteria);
335        closure.setMaximumInboundDepth(TransitiveClosure.UNBOUNDED_DEPTH);
336        closure.setMaximumOutboundDepth(TransitiveClosure.UNBOUNDED_DEPTH);
337        closure.traverseNodes(nodes);
338 
339        RegularExpressionSelectionCriteria localScopeCriteria  = new RegularExpressionSelectionCriteria();
340        localScopeCriteria.setMatchingPackages(startCriteria.isMatchingPackages());
341        localScopeCriteria.setMatchingClasses(startCriteria.isMatchingClasses());
342        localScopeCriteria.setMatchingFeatures(startCriteria.isMatchingFeatures());
343        localScopeCriteria.setGlobalIncludes("//");
344        RegularExpressionSelectionCriteria localFilterCriteria = new RegularExpressionSelectionCriteria();
345        localFilterCriteria.setMatchingPackages(stopCriteria.isMatchingPackages());
346        localFilterCriteria.setMatchingClasses(stopCriteria.isMatchingClasses());
347        localFilterCriteria.setMatchingFeatures(stopCriteria.isMatchingFeatures());
348        localFilterCriteria.setGlobalIncludes("//");
349 
350        GraphSummarizer summarizer = new GraphSummarizer(localScopeCriteria, localFilterCriteria);
351        summarizer.traverseNodes(closure.getFactory().getPackages().values());
352 
353        resultFactory = summarizer.getScopeFactory();
354    }
355}

[all classes][com.jeantessier.dependency]
EMMA 2.0.5312 (C) Vladimir Roubtsov