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

COVERAGE SUMMARY FOR SOURCE FILE [TestTransitiveClosureWithTestClass.java]

nameclass, %method, %block, %line, %
TestTransitiveClosureWithTestClass.java100% (1/1)100% (9/9)99%  (1245/1256)100% (160.7/161)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class TestTransitiveClosureWithTestClass100% (1/1)100% (9/9)99%  (1245/1256)100% (160.7/161)
testCopyAllNodesOnly (): void 100% (1/1)99%  (220/223)100% (24.9/25)
testCopyFeatureNodesOnly (): void 100% (1/1)99%  (228/231)100% (26.9/27)
testCopyClassNodesOnly (): void 100% (1/1)99%  (169/171)100% (21.9/22)
testCompleteClosure (): void 100% (1/1)99%  (325/328)100% (21.9/22)
TestTransitiveClosureWithTestClass (): void 100% (1/1)100% (3/3)100% (1/1)
compute (Collection): void 100% (1/1)100% (88/88)100% (20/20)
setUp (): void 100% (1/1)100% (125/125)100% (24/24)
testCopyNothing (): void 100% (1/1)100% (34/34)100% (8/8)
testCopyPackageNodesOnly (): void 100% (1/1)100% (53/53)100% (12/12)

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 
39public 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}

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