Coverage Report - com.jeantessier.dependency.TestLinkMaximizerSystematic
 
Classes in this File Line Coverage Branch Coverage Complexity
TestLinkMaximizerSystematic
100%
286/286
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 junit.framework.*;
 36   
 
 37  11 
 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  11 
         factory = new NodeFactory();
 50   
 
 51  11 
         a     = factory.createPackage("a");
 52  11 
         a_A   = factory.createClass("a.A");
 53  11 
         a_A_a = factory.createFeature("a.A.a()");
 54   
 
 55  11 
         b     = factory.createPackage("b");
 56  11 
         b_B   = factory.createClass("b.B");
 57  11 
         b_B_b = factory.createFeature("b.B.b()");
 58  11 
     }
 59   
 
 60   
     public void testPackagePackage() {
 61  1 
         a.addDependency(b);
 62   
 
 63  1 
         Visitor visitor = new LinkMaximizer();
 64  1 
         visitor.traverseNodes(factory.getPackages().values());
 65   
 
 66  1 
         assertEquals("a outbound",     1, a.getOutboundDependencies().size());
 67  1 
         assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b));
 68  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 69  1 
         assertEquals("a_A outbound",   0, a_A.getOutboundDependencies().size());
 70  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 71  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 72  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 73  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 74  1 
         assertEquals("b inbound",      1, b.getInboundDependencies().size());
 75  1 
         assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a));
 76  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 77  1 
         assertEquals("b_B inbound",    0, b_B.getInboundDependencies().size());
 78  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 79  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 80  1 
     }
 81   
 
 82   
     public void testPackageClass() {
 83  1 
         a.addDependency(b_B);
 84   
 
 85  1 
         Visitor visitor = new LinkMaximizer();
 86  1 
         visitor.traverseNodes(factory.getPackages().values());
 87   
 
 88  1 
         assertEquals("a outbound",     2, a.getOutboundDependencies().size());
 89  1 
         assertTrue("Missing a --> b",   a.getOutboundDependencies().contains(b));
 90  1 
         assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B));
 91  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 92  1 
         assertEquals("a_A outbound",   0, a_A.getOutboundDependencies().size());
 93  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 94  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 95  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 96  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 97  1 
         assertEquals("b inbound",      1, b.getInboundDependencies().size());
 98  1 
         assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a));
 99  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 100  1 
         assertEquals("b_B inbound",    1, b_B.getInboundDependencies().size());
 101  1 
         assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a));
 102  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 103  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 104  1 
     }
 105   
 
 106   
     public void testPackageFeature() {
 107  1 
         a.addDependency(b_B_b);
 108   
 
 109  1 
         Visitor visitor = new LinkMaximizer();
 110  1 
         visitor.traverseNodes(factory.getPackages().values());
 111   
 
 112  1 
         assertEquals("a outbound",     3, a.getOutboundDependencies().size());
 113  1 
         assertTrue("Missing a --> b",     a.getOutboundDependencies().contains(b));
 114  1 
         assertTrue("Missing a --> b.B",   a.getOutboundDependencies().contains(b_B));
 115  1 
         assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b));
 116  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 117  1 
         assertEquals("a_A outbound",   0, a_A.getOutboundDependencies().size());
 118  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 119  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 120  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 121  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 122  1 
         assertEquals("b inbound",      1, b.getInboundDependencies().size());
 123  1 
         assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a));
 124  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 125  1 
         assertEquals("b_B inbound",    1, b_B.getInboundDependencies().size());
 126  1 
         assertTrue("Missing b.B <-- a", b_B.getInboundDependencies().contains(a));
 127  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 128  1 
         assertEquals("b_B_b inbound",  1, b_B_b.getInboundDependencies().size());
 129  1 
         assertTrue("Missing b.B.b <-- a", b_B_b.getInboundDependencies().contains(a));
 130  1 
     }
 131   
 
 132   
     public void testClassPackage() {
 133  1 
         a_A.addDependency(b);
 134   
 
 135  1 
         Visitor visitor = new LinkMaximizer();
 136  1 
         visitor.traverseNodes(factory.getPackages().values());
 137   
 
 138  1 
         assertEquals("a outbound",     1, a.getOutboundDependencies().size());
 139  1 
         assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b));
 140  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 141  1 
         assertEquals("a_A outbound",   1, a_A.getOutboundDependencies().size());
 142  1 
         assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b));
 143  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 144  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 145  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 146  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 147  1 
         assertEquals("b inbound",      2, b.getInboundDependencies().size());
 148  1 
         assertTrue("Missing b <-- a", b.getInboundDependencies().contains(a));
 149  1 
         assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A));
 150  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 151  1 
         assertEquals("b_B inbound",    0, b_B.getInboundDependencies().size());
 152  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 153  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 154  1 
     }
 155   
 
 156   
     public void testClassClass() {
 157  1 
         a_A.addDependency(b_B);
 158   
 
 159  1 
         Visitor visitor = new LinkMaximizer();
 160  1 
         visitor.traverseNodes(factory.getPackages().values());
 161   
 
 162  1 
         assertEquals("a outbound",     2, a.getOutboundDependencies().size());
 163  1 
         assertTrue("Missing a --> b",   a.getOutboundDependencies().contains(b));
 164  1 
         assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B));
 165  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 166  1 
         assertEquals("a_A outbound",   2, a_A.getOutboundDependencies().size());
 167  1 
         assertTrue("Missing a.A --> b",   a_A.getOutboundDependencies().contains(b));
 168  1 
         assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B));
 169  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 170  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 171  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 172  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 173  1 
         assertEquals("b inbound",      2, b.getInboundDependencies().size());
 174  1 
         assertTrue("Missing b <-- a",   b.getInboundDependencies().contains(a));
 175  1 
         assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A));
 176  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 177  1 
         assertEquals("b_B inbound",    2, b_B.getInboundDependencies().size());
 178  1 
         assertTrue("Missing b.B <-- a",   b_B.getInboundDependencies().contains(a));
 179  1 
         assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A));
 180  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 181  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 182  1 
     }
 183   
 
 184   
     public void testClassClassSparse() {
 185  1 
         a.addDependency(b);
 186  1 
         a_A.addDependency(b_B);
 187   
 
 188  1 
         Visitor visitor = new LinkMaximizer();
 189  1 
         visitor.traverseNodes(factory.getPackages().values());
 190   
 
 191  1 
         assertEquals("a outbound",     2, a.getOutboundDependencies().size());
 192  1 
         assertTrue("Missing a --> b",   a.getOutboundDependencies().contains(b));
 193  1 
         assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B));
 194  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 195  1 
         assertEquals("a_A outbound",   2, a_A.getOutboundDependencies().size());
 196  1 
         assertTrue("Missing a.A --> b",   a_A.getOutboundDependencies().contains(b));
 197  1 
         assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B));
 198  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 199  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 200  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 201  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 202  1 
         assertEquals("b inbound",      2, b.getInboundDependencies().size());
 203  1 
         assertTrue("Missing b <-- a",   b.getInboundDependencies().contains(a));
 204  1 
         assertTrue("Missing b <-- a.A", b.getInboundDependencies().contains(a_A));
 205  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 206  1 
         assertEquals("b_B inbound",    2, b_B.getInboundDependencies().size());
 207  1 
         assertTrue("Missing b.B <-- a",   b_B.getInboundDependencies().contains(a));
 208  1 
         assertTrue("Missing b.B <-- a.A", b_B.getInboundDependencies().contains(a_A));
 209  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 210  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 211  1 
     }
 212   
 
 213   
     public void testClassFeature() {
 214  1 
         a_A.addDependency(b_B_b);
 215   
 
 216  1 
         Visitor visitor = new LinkMaximizer();
 217  1 
         visitor.traverseNodes(factory.getPackages().values());
 218   
 
 219  1 
         assertEquals("a outbound",     3, a.getOutboundDependencies().size());
 220  1 
         assertTrue("Missing a --> b",     a.getOutboundDependencies().contains(b));
 221  1 
         assertTrue("Missing a --> b.B",   a.getOutboundDependencies().contains(b_B));
 222  1 
         assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b));
 223  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 224  1 
         assertEquals("a_A outbound",   3, a_A.getOutboundDependencies().size());
 225  1 
         assertTrue("Missing a.A --> b",     a_A.getOutboundDependencies().contains(b));
 226  1 
         assertTrue("Missing a.A --> b.B",   a_A.getOutboundDependencies().contains(b_B));
 227  1 
         assertTrue("Missing a.A --> b.B.b", a_A.getOutboundDependencies().contains(b_B_b));
 228  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 229  1 
         assertEquals("a_A_a outbound", 0, a_A_a.getOutboundDependencies().size());
 230  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 231  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 232  1 
         assertEquals("b inbound",      2, b.getInboundDependencies().size());
 233  1 
         assertTrue("Missing b <-- a",   b.getInboundDependencies().contains(a));
 234  1 
         assertTrue("Missing b <-- a_A", b.getInboundDependencies().contains(a_A));
 235  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 236  1 
         assertEquals("b_B inbound",    2, b_B.getInboundDependencies().size());
 237  1 
         assertTrue("Missing b.B <-- a",   b_B.getInboundDependencies().contains(a));
 238  1 
         assertTrue("Missing b.B <-- a_A", b_B.getInboundDependencies().contains(a_A));
 239  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 240  1 
         assertEquals("b_B_b inbound",  2, b_B_b.getInboundDependencies().size());
 241  1 
         assertTrue("Missing b.B.b <-- a",   b_B_b.getInboundDependencies().contains(a));
 242  1 
         assertTrue("Missing b.B.b <-- a_A", b_B_b.getInboundDependencies().contains(a_A));
 243  1 
     }
 244   
 
 245   
     public void testFeaturePackage() {
 246  1 
         a_A_a.addDependency(b);
 247   
 
 248  1 
         Visitor visitor = new LinkMaximizer();
 249  1 
         visitor.traverseNodes(factory.getPackages().values());
 250   
 
 251  1 
         assertEquals("a outbound",     1, a.getOutboundDependencies().size());
 252  1 
         assertTrue("Missing a --> b", a.getOutboundDependencies().contains(b));
 253  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 254  1 
         assertEquals("a_A outbound",   1, a_A.getOutboundDependencies().size());
 255  1 
         assertTrue("Missing a.A --> b", a_A.getOutboundDependencies().contains(b));
 256  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 257  1 
         assertEquals("a_A_a outbound", 1, a_A_a.getOutboundDependencies().size());
 258  1 
         assertTrue("Missing a.A.a --> b", a_A_a.getOutboundDependencies().contains(b));
 259  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 260  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 261  1 
         assertEquals("b inbound",      3, b.getInboundDependencies().size());
 262  1 
         assertTrue("Missing b <-- a",     b.getInboundDependencies().contains(a));
 263  1 
         assertTrue("Missing b <-- a.A",   b.getInboundDependencies().contains(a_A));
 264  1 
         assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a));
 265  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 266  1 
         assertEquals("b_B inbound",    0, b_B.getInboundDependencies().size());
 267  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 268  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 269  1 
     }
 270   
 
 271   
     public void testFeatureClass() {
 272  1 
         a_A_a.addDependency(b_B);
 273   
 
 274  1 
         Visitor visitor = new LinkMaximizer();
 275  1 
         visitor.traverseNodes(factory.getPackages().values());
 276   
 
 277  1 
         assertEquals("a outbound",     2, a.getOutboundDependencies().size());
 278  1 
         assertTrue("Missing a --> b",   a.getOutboundDependencies().contains(b));
 279  1 
         assertTrue("Missing a --> b.B", a.getOutboundDependencies().contains(b_B));
 280  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 281  1 
         assertEquals("a_A outbound",   2, a_A.getOutboundDependencies().size());
 282  1 
         assertTrue("Missing a.A --> b",   a_A.getOutboundDependencies().contains(b));
 283  1 
         assertTrue("Missing a.A --> b.B", a_A.getOutboundDependencies().contains(b_B));
 284  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 285  1 
         assertEquals("a_A_a outbound", 2, a_A_a.getOutboundDependencies().size());
 286  1 
         assertTrue("Missing a.A.a --> b",   a_A_a.getOutboundDependencies().contains(b));
 287  1 
         assertTrue("Missing a.A.a --> b.B", a_A_a.getOutboundDependencies().contains(b_B));
 288  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 289  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 290  1 
         assertEquals("b inbound",      3, b.getInboundDependencies().size());
 291  1 
         assertTrue("Missing b <-- a",     b.getInboundDependencies().contains(a));
 292  1 
         assertTrue("Missing b <-- a.A",   b.getInboundDependencies().contains(a_A));
 293  1 
         assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a));
 294  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 295  1 
         assertEquals("b_B inbound",    3, b_B.getInboundDependencies().size());
 296  1 
         assertTrue("Missing b.B <-- a",     b_B.getInboundDependencies().contains(a));
 297  1 
         assertTrue("Missing b.B <-- a.A",   b_B.getInboundDependencies().contains(a_A));
 298  1 
         assertTrue("Missing b.B <-- a.A.a", b_B.getInboundDependencies().contains(a_A_a));
 299  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 300  1 
         assertEquals("b_B_b inbound",  0, b_B_b.getInboundDependencies().size());
 301  1 
     }
 302   
 
 303   
     public void testFeatureFeature() {
 304  1 
         a_A_a.addDependency(b_B_b);
 305   
 
 306  1 
         Visitor visitor = new LinkMaximizer();
 307  1 
         visitor.traverseNodes(factory.getPackages().values());
 308   
 
 309  1 
         assertEquals("a outbound",     3, a.getOutboundDependencies().size());
 310  1 
         assertTrue("Missing a --> b",     a.getOutboundDependencies().contains(b));
 311  1 
         assertTrue("Missing a --> b.B",   a.getOutboundDependencies().contains(b_B));
 312  1 
         assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b));
 313  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 314  1 
         assertEquals("a_A outbound",   3, a_A.getOutboundDependencies().size());
 315  1 
         assertTrue("Missing a.A --> b",     a_A.getOutboundDependencies().contains(b));
 316  1 
         assertTrue("Missing a.A --> b.B",   a_A.getOutboundDependencies().contains(b_B));
 317  1 
         assertTrue("Missing a.A --> b.B.b", a_A.getOutboundDependencies().contains(b_B_b));
 318  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 319  1 
         assertEquals("a_A_a outbound", 3, a_A_a.getOutboundDependencies().size());
 320  1 
         assertTrue("Missing a.A.a --> b",     a_A_a.getOutboundDependencies().contains(b));
 321  1 
         assertTrue("Missing a.A.a --> b.B",   a_A_a.getOutboundDependencies().contains(b_B));
 322  1 
         assertTrue("Missing a.A.a --> b.B.b", a_A_a.getOutboundDependencies().contains(b_B_b));
 323  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 324  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 325  1 
         assertEquals("b inbound",      3, b.getInboundDependencies().size());
 326  1 
         assertTrue("Missing b <-- a",     b.getInboundDependencies().contains(a));
 327  1 
         assertTrue("Missing b <-- a.A",   b.getInboundDependencies().contains(a_A));
 328  1 
         assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a));
 329  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 330  1 
         assertEquals("b_B inbound",    3, b_B.getInboundDependencies().size());
 331  1 
         assertTrue("Missing b.B <-- a",     b_B.getInboundDependencies().contains(a));
 332  1 
         assertTrue("Missing b.B <-- a.A",   b_B.getInboundDependencies().contains(a_A));
 333  1 
         assertTrue("Missing b.B <-- a.A.a", b_B.getInboundDependencies().contains(a_A_a));
 334  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 335  1 
         assertEquals("b_B_b inbound",  3, b_B_b.getInboundDependencies().size());
 336  1 
         assertTrue("Missing b.B.b <-- a",     b_B_b.getInboundDependencies().contains(a));
 337  1 
         assertTrue("Missing b.B.b <-- a.A",   b_B_b.getInboundDependencies().contains(a_A));
 338  1 
         assertTrue("Missing b.B.b <-- a.A.a", b_B_b.getInboundDependencies().contains(a_A_a));
 339  1 
     }
 340   
 
 341   
     public void testFeatureFeatureSparse() {
 342  1 
         a.addDependency(b);
 343  1 
         a_A.addDependency(b_B);
 344  1 
         a_A_a.addDependency(b_B_b);
 345   
 
 346  1 
         Visitor visitor = new LinkMaximizer();
 347  1 
         visitor.traverseNodes(factory.getPackages().values());
 348   
 
 349  1 
         assertEquals("a outbound",     3, a.getOutboundDependencies().size());
 350  1 
         assertTrue("Missing a --> b",     a.getOutboundDependencies().contains(b));
 351  1 
         assertTrue("Missing a --> b.B",   a.getOutboundDependencies().contains(b_B));
 352  1 
         assertTrue("Missing a --> b.B.b", a.getOutboundDependencies().contains(b_B_b));
 353  1 
         assertEquals("a inbound",      0, a.getInboundDependencies().size());
 354  1 
         assertEquals("a_A outbound",   3, a_A.getOutboundDependencies().size());
 355  1 
         assertTrue("Missing a.A --> b",     a_A.getOutboundDependencies().contains(b));
 356  1 
         assertTrue("Missing a.A --> b.B",   a_A.getOutboundDependencies().contains(b_B));
 357  1 
         assertTrue("Missing a.A --> b.B.b", a_A.getOutboundDependencies().contains(b_B_b));
 358  1 
         assertEquals("a_A inbound",    0, a_A.getInboundDependencies().size());
 359  1 
         assertEquals("a_A_a outbound", 3, a_A_a.getOutboundDependencies().size());
 360  1 
         assertTrue("Missing a.A.a --> b",     a_A_a.getOutboundDependencies().contains(b));
 361  1 
         assertTrue("Missing a.A.a --> b.B",   a_A_a.getOutboundDependencies().contains(b_B));
 362  1 
         assertTrue("Missing a.A.a --> b.B.b", a_A_a.getOutboundDependencies().contains(b_B_b));
 363  1 
         assertEquals("a_A_a inbound",  0, a_A_a.getInboundDependencies().size());
 364  1 
         assertEquals("b outbound",     0, b.getOutboundDependencies().size());
 365  1 
         assertEquals("b inbound",      3, b.getInboundDependencies().size());
 366  1 
         assertTrue("Missing b <-- a",     b.getInboundDependencies().contains(a));
 367  1 
         assertTrue("Missing b <-- a.A",   b.getInboundDependencies().contains(a_A));
 368  1 
         assertTrue("Missing b <-- a.A.a", b.getInboundDependencies().contains(a_A_a));
 369  1 
         assertEquals("b_B outbound",   0, b_B.getOutboundDependencies().size());
 370  1 
         assertEquals("b_B inbound",    3, b_B.getInboundDependencies().size());
 371  1 
         assertTrue("Missing b.B <-- a",     b_B.getInboundDependencies().contains(a));
 372  1 
         assertTrue("Missing b.B <-- a.A",   b_B.getInboundDependencies().contains(a_A));
 373  1 
         assertTrue("Missing b.B <-- a.A.a", b_B.getInboundDependencies().contains(a_A_a));
 374  1 
         assertEquals("b_B_b outbound", 0, b_B_b.getOutboundDependencies().size());
 375  1 
         assertEquals("b_B_b inbound",  3, b_B_b.getInboundDependencies().size());
 376  1 
         assertTrue("Missing b.B.b <-- a",     b_B_b.getInboundDependencies().contains(a));
 377  1 
         assertTrue("Missing b.B.b <-- a.A",   b_B_b.getInboundDependencies().contains(a_A));
 378  1 
         assertTrue("Missing b.B.b <-- a.A.a", b_B_b.getInboundDependencies().contains(a_A_a));
 379  1 
     }
 380   
 }
Report generated by Cobertura 1.9.3 on 11/29/10 3:12 PM.