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