Coverage Report - com.jeantessier.diff.TestDifferencesFactory
 
Classes in this File Line Coverage Branch Coverage Complexity
TestDifferencesFactory
100%
337/337
50%
60/120
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.diff;
 34  
 
 35  
 import java.io.*;
 36  
 
 37  
 import com.jeantessier.classreader.*;
 38  
 
 39  29
 public class TestDifferencesFactory extends TestDifferencesFactoryBase {
 40  
     private ProjectDifferences projectDifferences;
 41  
 
 42  
     protected void setUp() throws Exception {
 43  29
         super.setUp();
 44  
 
 45  29
         DifferencesFactory factory = new DifferencesFactory();
 46  29
         projectDifferences = (ProjectDifferences) factory.createProjectDifferences("test", "old", getOldPackages(), "new", getNewPackages());
 47  29
     }
 48  
 
 49  
     public void testEmptyJars() throws IOException {
 50  1
         DifferencesFactory factory = new DifferencesFactory();
 51  1
         ProjectDifferences emptyDifferences = (ProjectDifferences) factory.createProjectDifferences("test", "old", new PackageMapper(), "new", new PackageMapper());
 52  
 
 53  1
         assertEquals("name",        "test", emptyDifferences.getName());
 54  1
         assertEquals("old version", "old",  emptyDifferences.getOldVersion());
 55  1
         assertEquals("new version", "new",  emptyDifferences.getNewVersion());
 56  
 
 57  1
         assertEquals("NbPackageDifferences: " + projectDifferences.getPackageDifferences(), 3, projectDifferences.getPackageDifferences().size());
 58  1
     }
 59  
 
 60  
     public void testModifiedPackage() {
 61  1
         String name = "ModifiedPackage";
 62  1
         PackageDifferences differences = (PackageDifferences) find(name, projectDifferences.getPackageDifferences());
 63  1
         assertNotNull(name, differences);
 64  
 
 65  1
         assertEquals(name, differences.getName());
 66  1
         assertEquals(name + ".ClassDifferences: " + differences.getClassDifferences(), 13, differences.getClassDifferences().size());
 67  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 68  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 69  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 70  1
     }
 71  
 
 72  
     public void testNewPackage() {
 73  1
         String name = "NewPackage";
 74  1
         PackageDifferences differences = (PackageDifferences) find(name, projectDifferences.getPackageDifferences());
 75  1
         assertNotNull(name, differences);
 76  
 
 77  1
         assertEquals(name, differences.getName());
 78  1
         assertEquals(name + ".ClassDifferences: " + differences.getClassDifferences(), 0, differences.getClassDifferences().size());
 79  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 80  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 81  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 82  1
     }
 83  
 
 84  
     public void testRemovedPackage() {
 85  1
         String name = "RemovedPackage";
 86  1
         PackageDifferences differences = (PackageDifferences) find(name, projectDifferences.getPackageDifferences());
 87  1
         assertNotNull(name, differences);
 88  
 
 89  1
         assertEquals(name, differences.getName());
 90  1
         assertEquals(name + ".ClassDifferences: " + differences.getClassDifferences(), 0, differences.getClassDifferences().size());
 91  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 92  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 93  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 94  1
     }
 95  
 
 96  
     public void testDeprecatedClass() {
 97  1
         String packageName = "ModifiedPackage";
 98  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 99  
 
 100  1
         String name = packageName + ".DeprecatedClass";
 101  1
         DeprecatableDifferences deprecatableDifferences = (DeprecatableDifferences) find(name, packageDifferences.getClassDifferences());
 102  1
         ClassDifferences differences = (ClassDifferences) deprecatableDifferences.getComponent();
 103  1
         assertNotNull(name, differences);
 104  
 
 105  1
         assertTrue(name + ".NewDeprecation()",        deprecatableDifferences.isNewDeprecation());
 106  1
         assertTrue(name + ".RemovedDeprecation()",   !deprecatableDifferences.isRemovedDeprecation());
 107  
 
 108  1
         assertEquals(name, differences.getName());
 109  1
         assertEquals(name + ".FeatureDifferences", 0, differences.getFeatureDifferences().size());
 110  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 111  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 112  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 113  1
     }
 114  
 
 115  
     public void testModifiedClass() {
 116  1
         String packageName = "ModifiedPackage";
 117  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 118  
 
 119  1
         String name = packageName + ".ModifiedClass";
 120  1
         ClassDifferences differences = (ClassDifferences) find(name, packageDifferences.getClassDifferences());
 121  1
         assertNotNull(name, differences);
 122  
 
 123  1
         assertEquals(name, differences.getName());
 124  1
         assertEquals(name + ".FeatureDifferences", 35, differences.getFeatureDifferences().size());
 125  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 126  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 127  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 128  1
     }
 129  
 
 130  
     public void testModifiedInterface() {
 131  1
         String packageName = "ModifiedPackage";
 132  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 133  
 
 134  1
         String name = packageName + ".ModifiedInterface";
 135  1
         ClassDifferences differences = (ClassDifferences) find(name, packageDifferences.getClassDifferences());
 136  1
         assertNotNull(name, differences);
 137  
 
 138  1
         assertEquals(name, differences.getName());
 139  1
         assertEquals(name + ".FeatureDifferences", 11, differences.getFeatureDifferences().size());
 140  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 141  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 142  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 143  1
     }
 144  
 
 145  
     public void testNewClass() {
 146  1
         String packageName = "ModifiedPackage";
 147  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 148  
 
 149  1
         String name = packageName + ".NewClass";
 150  1
         ClassDifferences differences = (ClassDifferences) find(name, packageDifferences.getClassDifferences());
 151  1
         assertNotNull(name, differences);
 152  
 
 153  1
         assertEquals(name, differences.getName());
 154  1
         assertEquals(name + ".FeatureDifferences", 0, differences.getFeatureDifferences().size());
 155  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 156  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 157  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 158  1
     }
 159  
 
 160  
     public void testNewInterface() {
 161  1
         String packageName = "ModifiedPackage";
 162  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 163  
 
 164  1
         String name = packageName + ".NewInterface";
 165  1
         ClassDifferences differences = (ClassDifferences) find(name, packageDifferences.getClassDifferences());
 166  1
         assertNotNull(name, differences);
 167  
 
 168  1
         assertEquals(name, differences.getName());
 169  1
         assertEquals(name + ".FeatureDifferences", 0, differences.getFeatureDifferences().size());
 170  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 171  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 172  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 173  1
     }
 174  
 
 175  
     public void testRemovedClass() {
 176  1
         String packageName = "ModifiedPackage";
 177  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 178  
 
 179  1
         String name = packageName + ".RemovedClass";
 180  1
         ClassDifferences differences = (ClassDifferences) find(name, packageDifferences.getClassDifferences());
 181  1
         assertNotNull(name, differences);
 182  
 
 183  1
         assertEquals(name, differences.getName());
 184  1
         assertEquals(name + ".FeatureDifferences", 0, differences.getFeatureDifferences().size());
 185  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 186  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 187  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 188  1
     }
 189  
 
 190  
     public void testRemovedInterface() {
 191  1
         String packageName = "ModifiedPackage";
 192  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 193  
 
 194  1
         String name = packageName + ".RemovedInterface";
 195  1
         ClassDifferences differences = (ClassDifferences) find(name, packageDifferences.getClassDifferences());
 196  1
         assertNotNull(name, differences);
 197  
 
 198  1
         assertEquals(name, differences.getName());
 199  1
         assertEquals(name + ".FeatureDifferences", 0, differences.getFeatureDifferences().size());
 200  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 201  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 202  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 203  1
     }
 204  
 
 205  
     public void testUndeprecatedClass() {
 206  1
         String packageName = "ModifiedPackage";
 207  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 208  
 
 209  1
         String name = packageName + ".UndeprecatedClass";
 210  1
         DeprecatableDifferences deprecatableDifferences = (DeprecatableDifferences) find(name, packageDifferences.getClassDifferences());
 211  1
         ClassDifferences differences = (ClassDifferences) deprecatableDifferences.getComponent();
 212  1
         assertNotNull(name, differences);
 213  
 
 214  1
         assertTrue(name + ".NewDeprecation()",       !deprecatableDifferences.isNewDeprecation());
 215  1
         assertTrue(name + ".RemovedDeprecation()",    deprecatableDifferences.isRemovedDeprecation());
 216  
 
 217  1
         assertEquals(name, differences.getName());
 218  1
         assertEquals(name + ".FeatureDifferences", 0, differences.getFeatureDifferences().size());
 219  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 220  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 221  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 222  1
     }
 223  
 
 224  
     public void testModifiedClassModifiedField() {
 225  1
         String packageName = "ModifiedPackage";
 226  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 227  
 
 228  1
         String className = packageName + ".ModifiedClass";
 229  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 230  
 
 231  1
         String name = className + ".modifiedField";
 232  1
         FieldDifferences differences = (FieldDifferences) find(name, classDifferences.getFeatureDifferences());
 233  1
         assertNotNull(name, differences);
 234  
 
 235  1
         assertEquals(name, differences.getName());
 236  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 237  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 238  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 239  1
     }
 240  
     
 241  
     public void testModifiedClassNewField() {
 242  1
         String packageName = "ModifiedPackage";
 243  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 244  
 
 245  1
         String className = packageName + ".ModifiedClass";
 246  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 247  
 
 248  1
         String name = className + ".newField";
 249  1
         FieldDifferences differences = (FieldDifferences) find(name, classDifferences.getFeatureDifferences());
 250  1
         assertNotNull(name, differences);
 251  
 
 252  1
         assertEquals(name, differences.getName());
 253  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 254  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 255  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 256  1
     }
 257  
     
 258  
     public void testModifiedClassRemovedField() {
 259  1
         String packageName = "ModifiedPackage";
 260  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 261  
 
 262  1
         String className = packageName + ".ModifiedClass";
 263  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 264  
 
 265  1
         String name = className + ".removedField";
 266  1
         FieldDifferences differences = (FieldDifferences) find(name, classDifferences.getFeatureDifferences());
 267  1
         assertNotNull(name, differences);
 268  
 
 269  1
         assertEquals(name, differences.getName());
 270  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 271  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 272  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 273  1
     }
 274  
     
 275  
     public void testModifiedClassModifiedConstructor() {
 276  1
         String packageName = "ModifiedPackage";
 277  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 278  
 
 279  1
         String className = packageName + ".ModifiedClass";
 280  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 281  
 
 282  1
         String name = className + ".ModifiedClass(int, int, int)";
 283  1
         ConstructorDifferences differences = (ConstructorDifferences) find(name, classDifferences.getFeatureDifferences());
 284  1
         assertNotNull(name + " not in " + classDifferences.getFeatureDifferences(), differences);
 285  
 
 286  1
         assertEquals(name, differences.getName());
 287  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 288  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 289  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 290  1
     }
 291  
 
 292  
     public void testModifiedClassModifiedCodeConstructor() {
 293  1
         String packageName = "ModifiedPackage";
 294  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 295  
 
 296  1
         String className = packageName + ".ModifiedClass";
 297  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 298  
 
 299  1
         String name = className + ".ModifiedClass(float)";
 300  1
         ConstructorDifferences differences = (ConstructorDifferences) find(name, classDifferences.getFeatureDifferences());
 301  1
         assertNotNull(name + " not in " + classDifferences.getFeatureDifferences(), differences);
 302  
 
 303  1
         assertEquals(name, differences.getName());
 304  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 305  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 306  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 307  1
     }
 308  
 
 309  
     public void testModifiedClassNewConstructor() {
 310  1
         String packageName = "ModifiedPackage";
 311  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 312  
 
 313  1
         String className = packageName + ".ModifiedClass";
 314  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 315  
 
 316  1
         String name = className + ".ModifiedClass(int, int, int, int, int, int)";
 317  1
         ConstructorDifferences differences = (ConstructorDifferences) find(name, classDifferences.getFeatureDifferences());
 318  1
         assertNotNull(name + " not in " + classDifferences.getFeatureDifferences(), differences);
 319  
 
 320  1
         assertEquals(name, differences.getName());
 321  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 322  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 323  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 324  1
     }
 325  
     
 326  
     public void testModifiedClassRemovedConstructor() {
 327  1
         String packageName = "ModifiedPackage";
 328  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 329  
 
 330  1
         String className = packageName + ".ModifiedClass";
 331  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 332  
 
 333  1
         String name = className + ".ModifiedClass()";
 334  1
         ConstructorDifferences differences = (ConstructorDifferences) find(name, classDifferences.getFeatureDifferences());
 335  1
         assertNotNull(name + " not in " + classDifferences.getFeatureDifferences(), differences);
 336  
 
 337  1
         assertEquals(name, differences.getName());
 338  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 339  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 340  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 341  1
     }
 342  
     
 343  
     public void testModifiedClassModifiedMethod() {
 344  1
         String packageName = "ModifiedPackage";
 345  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 346  
 
 347  1
         String className = packageName + ".ModifiedClass";
 348  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 349  
 
 350  1
         String name = className + ".modifiedMethod()";
 351  1
         MethodDifferences differences = (MethodDifferences) find(name, classDifferences.getFeatureDifferences());
 352  1
         assertNotNull(name, differences);
 353  
 
 354  1
         assertEquals(name, differences.getName());
 355  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 356  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 357  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 358  1
     }
 359  
 
 360  
     public void testModifiedClassModifiedCodeMethod() {
 361  1
         String packageName = "ModifiedPackage";
 362  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 363  
 
 364  1
         String className = packageName + ".ModifiedClass";
 365  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 366  
 
 367  1
         String name = className + ".modifiedCodeMethod()";
 368  1
         MethodDifferences differences = (MethodDifferences) find(name, classDifferences.getFeatureDifferences());
 369  1
         assertNotNull(name, differences);
 370  
 
 371  1
         assertEquals(name, differences.getName());
 372  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 373  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 374  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 375  1
     }
 376  
 
 377  
     public void testModifiedClassNewMethod() {
 378  1
         String packageName = "ModifiedPackage";
 379  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 380  
 
 381  1
         String className = packageName + ".ModifiedClass";
 382  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 383  
 
 384  1
         String name = className + ".newMethod()";
 385  1
         MethodDifferences differences = (MethodDifferences) find(name, classDifferences.getFeatureDifferences());
 386  1
         assertNotNull(name, differences);
 387  
 
 388  1
         assertEquals(name, differences.getName());
 389  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 390  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 391  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 392  1
     }
 393  
     
 394  
     public void testModifiedClassRemovedMethod() {
 395  1
         String packageName = "ModifiedPackage";
 396  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 397  
 
 398  1
         String className = packageName + ".ModifiedClass";
 399  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 400  
 
 401  1
         String name = className + ".removedMethod()";
 402  1
         MethodDifferences differences = (MethodDifferences) find(name, classDifferences.getFeatureDifferences());
 403  1
         assertNotNull(name, differences);
 404  
 
 405  1
         assertEquals(name, differences.getName());
 406  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 407  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 408  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 409  1
     }
 410  
     
 411  
     public void testModifiedInterfaceModifiedField() {
 412  1
         String packageName = "ModifiedPackage";
 413  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 414  
 
 415  1
         String className = packageName + ".ModifiedInterface";
 416  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 417  
 
 418  1
         String name = className + ".modifiedField";
 419  1
         FieldDifferences differences = (FieldDifferences) find(name, classDifferences.getFeatureDifferences());
 420  1
         assertNotNull(name, differences);
 421  
 
 422  1
         assertEquals(name, differences.getName());
 423  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 424  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 425  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 426  1
     }
 427  
     
 428  
     public void testModifiedInterfaceNewField() {
 429  1
         String packageName = "ModifiedPackage";
 430  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 431  
 
 432  1
         String className = packageName + ".ModifiedInterface";
 433  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 434  
 
 435  1
         String name = className + ".newField";
 436  1
         FieldDifferences differences = (FieldDifferences) find(name, classDifferences.getFeatureDifferences());
 437  1
         assertNotNull(name, differences);
 438  
 
 439  1
         assertEquals(name, differences.getName());
 440  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 441  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 442  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 443  1
     }
 444  
     
 445  
     public void testModifiedInterfaceRemovedField() {
 446  1
         String packageName = "ModifiedPackage";
 447  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 448  
 
 449  1
         String className = packageName + ".ModifiedInterface";
 450  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 451  
 
 452  1
         String name = className + ".removedField";
 453  1
         FieldDifferences differences = (FieldDifferences) find(name, classDifferences.getFeatureDifferences());
 454  1
         assertNotNull(name, differences);
 455  
 
 456  1
         assertEquals(name, differences.getName());
 457  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 458  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 459  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 460  1
     }
 461  
     
 462  
     public void testModifiedInterfaceModifiedMethod() {
 463  1
         String packageName = "ModifiedPackage";
 464  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 465  
 
 466  1
         String className = packageName + ".ModifiedInterface";
 467  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 468  
 
 469  1
         String name = className + ".modifiedMethod()";
 470  1
         FeatureDifferences differences = (FeatureDifferences) find(name, classDifferences.getFeatureDifferences());
 471  1
         assertNotNull(name, differences);
 472  
 
 473  1
         assertEquals(name, differences.getName());
 474  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 475  1
         assertTrue(name + ".IsModified()",  differences.isModified());
 476  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 477  1
     }
 478  
     
 479  
     public void testModifiedInterfaceNewMethod() {
 480  1
         String packageName = "ModifiedPackage";
 481  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 482  
 
 483  1
         String className = packageName + ".ModifiedInterface";
 484  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 485  
 
 486  1
         String name = className + ".newMethod()";
 487  1
         FeatureDifferences differences = (FeatureDifferences) find(name, classDifferences.getFeatureDifferences());
 488  1
         assertNotNull(name, differences);
 489  
 
 490  1
         assertEquals(name, differences.getName());
 491  1
         assertTrue(name + ".IsRemoved()",  !differences.isRemoved());
 492  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 493  1
         assertTrue(name + ".IsNew()",       differences.isNew());
 494  1
     }
 495  
     
 496  
     public void testModifiedInterfaceRemovedMethod() {
 497  1
         String packageName = "ModifiedPackage";
 498  1
         PackageDifferences packageDifferences = (PackageDifferences) find(packageName, projectDifferences.getPackageDifferences());
 499  
 
 500  1
         String className = packageName + ".ModifiedInterface";
 501  1
         ClassDifferences classDifferences = (ClassDifferences) find(className, packageDifferences.getClassDifferences());
 502  
 
 503  1
         String name = className + ".removedMethod()";
 504  1
         FeatureDifferences differences = (FeatureDifferences) find(name, classDifferences.getFeatureDifferences());
 505  1
         assertNotNull(name, differences);
 506  
 
 507  1
         assertEquals(name, differences.getName());
 508  1
         assertTrue(name + ".IsRemoved()",   differences.isRemoved());
 509  1
         assertTrue(name + ".IsModified()", !differences.isModified());
 510  1
         assertTrue(name + ".IsNew()",      !differences.isNew());
 511  1
     }
 512  
 }