Clover coverage report - Dependency Finder
Coverage timestamp: Mon Nov 29 2010 15:00:50 PST
file stats: LOC: 1,363   Methods: 94
NCLOC: 1,030   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
TestIncompatibleDifferenceStrategyWithPublishedAPI.java 75% 100% 100% 99.8%
coverage coverage
 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    import java.util.*;
 37   
 38    import junit.framework.*;
 39   
 40    import com.jeantessier.classreader.*;
 41   
 42    public class TestIncompatibleDifferenceStrategyWithPublishedAPI extends TestCase {
 43    public static final String OLD_PUBLISHED_CLASSPATH = "tests" + File.separator + "JarJarDiff" + File.separator + "oldpublished";
 44    public static final String NEW_PUBLISHED_CLASSPATH = "tests" + File.separator + "JarJarDiff" + File.separator + "newpublished";
 45   
 46    private static PackageMapper oldPublishedPackages;
 47    private static PackageMapper newPublishedPackages;
 48   
 49    private static ClassfileLoader oldPublishedJar;
 50    private static ClassfileLoader newPublishedJar;
 51   
 52  1 public static PackageMapper getOldPublishedPackages() {
 53  1 if (oldPublishedPackages == null) {
 54  1 oldPublishedPackages = new PackageMapper();
 55    }
 56   
 57  1 return oldPublishedPackages;
 58    }
 59   
 60  1 public static PackageMapper getNewPublishedPackages() {
 61  1 if (newPublishedPackages == null) {
 62  1 newPublishedPackages = new PackageMapper();
 63    }
 64   
 65  1 return newPublishedPackages;
 66    }
 67   
 68  89 public static ClassfileLoader getOldPublishedJar() {
 69  89 if (oldPublishedJar == null) {
 70  1 oldPublishedJar = new AggregatingClassfileLoader();
 71  1 oldPublishedJar.addLoadListener(getOldPublishedPackages());
 72  1 oldPublishedJar.load(Collections.singleton(OLD_PUBLISHED_CLASSPATH));
 73    }
 74   
 75  89 return oldPublishedJar;
 76    }
 77   
 78  89 public static ClassfileLoader getNewPublishedJar() {
 79  89 if (newPublishedJar == null) {
 80  1 newPublishedJar = new AggregatingClassfileLoader();
 81  1 newPublishedJar.addLoadListener(getNewPublishedPackages());
 82  1 newPublishedJar.load(Collections.singleton(NEW_PUBLISHED_CLASSPATH));
 83    }
 84   
 85  89 return newPublishedJar;
 86    }
 87   
 88    private MockDifferenceStrategy mockStrategy;
 89    private IncompatibleDifferenceStrategy strategy;
 90   
 91  89 protected void setUp() throws Exception {
 92  89 super.setUp();
 93   
 94  89 mockStrategy = new MockDifferenceStrategy(new NoDifferenceStrategy());
 95  89 strategy = new IncompatibleDifferenceStrategy(mockStrategy);
 96    }
 97   
 98    /*
 99    * Classes
 100    */
 101   
 102  1 public void testPublicToPublicClass() {
 103  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PublicToPublicClass");
 104  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PublicToPublicClass");
 105   
 106  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 107   
 108  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 109  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 110  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 111  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 112  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 113  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 114    }
 115   
 116  1 public void testPublicToPackageClass() {
 117  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PublicToPackageClass");
 118  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PublicToPackageClass");
 119   
 120  1 assertTrue(strategy.isClassDifferent(oldClass, newClass));
 121   
 122  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 123  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 124  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 125  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 126  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 127  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 128    }
 129   
 130  1 public void testPackageToPublicClass() {
 131  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PackageToPublicClass");
 132  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PackageToPublicClass");
 133   
 134  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 135   
 136  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 137  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 138  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 139  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 140  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 141  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 142    }
 143   
 144  1 public void testPackageToPackageClass() {
 145  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PackageToPackageClass");
 146  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PackageToPackageClass");
 147   
 148  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 149   
 150  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 151  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 152  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 153  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 154  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 155  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 156    }
 157   
 158  1 public void testClassToClassClass() {
 159  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ClassToClassClass");
 160  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ClassToClassClass");
 161   
 162  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 163   
 164  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 165  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 166  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 167  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 168  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 169  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 170    }
 171   
 172  1 public void testClassToInterfaceClass() {
 173  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ClassToInterfaceClass");
 174  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ClassToInterfaceClass");
 175   
 176  1 assertTrue(strategy.isClassDifferent(oldClass, newClass));
 177   
 178  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 179  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 180  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 181  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 182  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 183  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 184    }
 185   
 186  1 public void testInterfaceToClassClass() {
 187  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.InterfaceToClassClass");
 188  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.InterfaceToClassClass");
 189   
 190  1 assertTrue(strategy.isClassDifferent(oldClass, newClass));
 191   
 192  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 193  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 194  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 195  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 196  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 197  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 198    }
 199   
 200  1 public void testInterfaceToInterfaceClass() {
 201  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.InterfaceToInterfaceClass");
 202  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.InterfaceToInterfaceClass");
 203   
 204  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 205   
 206  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 207  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 208  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 209  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 210  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 211  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 212    }
 213   
 214  1 public void testConcreteToConcreteClass() {
 215  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ConcreteToConcreteClass");
 216  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ConcreteToConcreteClass");
 217   
 218  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 219   
 220  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 221  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 222  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 223  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 224  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 225  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 226    }
 227   
 228  1 public void testConcreteToAbstractClass() {
 229  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ConcreteToAbstractClass");
 230  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ConcreteToAbstractClass");
 231   
 232  1 assertTrue(strategy.isClassDifferent(oldClass, newClass));
 233   
 234  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 235  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 236  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 237  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 238  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 239  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 240    }
 241   
 242  1 public void testAbstractToConcreteClass() {
 243  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.AbstractToConcreteClass");
 244  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.AbstractToConcreteClass");
 245   
 246  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 247   
 248  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 249  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 250  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 251  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 252  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 253  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 254    }
 255   
 256  1 public void testAbstractToAbstractClass() {
 257  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.AbstractToAbstractClass");
 258  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.AbstractToAbstractClass");
 259   
 260  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 261   
 262  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 263  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 264  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 265  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 266  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 267  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 268    }
 269   
 270  1 public void testNonFinalToNonFinalClass() {
 271  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.NonFinalToNonFinalClass");
 272  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.NonFinalToNonFinalClass");
 273   
 274  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 275   
 276  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 277  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 278  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 279  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 280  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 281  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 282    }
 283   
 284  1 public void testNonFinalToFinalClass() {
 285  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.NonFinalToFinalClass");
 286  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.NonFinalToFinalClass");
 287   
 288  1 assertTrue(strategy.isClassDifferent(oldClass, newClass));
 289   
 290  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 291  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 292  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 293  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 294  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 295  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 296    }
 297   
 298  1 public void testFinalToNonFinalClass() {
 299  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.FinalToNonFinalClass");
 300  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.FinalToNonFinalClass");
 301   
 302  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 303   
 304  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 305  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 306  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 307  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 308  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 309  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 310    }
 311   
 312  1 public void testFinalToFinalClass() {
 313  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.FinalToFinalClass");
 314  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.FinalToFinalClass");
 315   
 316  1 assertFalse(strategy.isClassDifferent(oldClass, newClass));
 317   
 318  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 319  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 320  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 321  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 322  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 323  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 324    }
 325   
 326    /*
 327    * Fields
 328    */
 329   
 330  1 public void testPrivateToPrivateField() {
 331  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPrivateField");
 332  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPrivateField");
 333   
 334  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 335   
 336  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 337  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 338  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 339  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 340  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 341  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 342    }
 343   
 344  1 public void testPrivateToProtectedField() {
 345  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToProtectedField");
 346  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToProtectedField");
 347   
 348  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 349   
 350  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 351  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 352  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 353  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 354  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 355  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 356    }
 357   
 358  1 public void testPrivateToPackageField() {
 359  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPackagedField");
 360  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPackageField");
 361   
 362  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 363   
 364  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 365  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 366  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 367  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 368  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 369  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 370    }
 371   
 372  1 public void testPrivateToPublicField() {
 373  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPublicField");
 374  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPublicField");
 375   
 376  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 377   
 378  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 379  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 380  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 381  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 382  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 383  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 384    }
 385   
 386  1 public void testProtectedToPrivateField() {
 387  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPrivateField");
 388  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPrivateField");
 389   
 390  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 391   
 392  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 393  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 394  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 395  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 396  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 397  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 398    }
 399   
 400  1 public void testProtectedToProtectedField() {
 401  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToProtectedField");
 402  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToProtectedField");
 403   
 404  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 405   
 406  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 407  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 408  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 409  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 410  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 411  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 412    }
 413   
 414  1 public void testProtectedToPackageField() {
 415  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPackageField");
 416  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPackageField");
 417   
 418  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 419   
 420  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 421  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 422  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 423  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 424  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 425  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 426    }
 427   
 428  1 public void testProtectedToPublicField() {
 429  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPublicField");
 430  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPublicField");
 431   
 432  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 433   
 434  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 435  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 436  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 437  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 438  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 439  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 440    }
 441   
 442  1 public void testPackageToPrivateField() {
 443  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPrivateField");
 444  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPrivateField");
 445   
 446  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 447   
 448  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 449  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 450  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 451  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 452  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 453  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 454    }
 455   
 456  1 public void testPackageToProtectedField() {
 457  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToProtectedField");
 458  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToProtectedField");
 459   
 460  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 461   
 462  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 463  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 464  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 465  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 466  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 467  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 468    }
 469   
 470  1 public void testPackageToPackageField() {
 471  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPackagedField");
 472  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPackageField");
 473   
 474  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 475   
 476  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 477  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 478  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 479  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 480  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 481  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 482    }
 483   
 484  1 public void testPackageToPublicField() {
 485  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPublicField");
 486  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPublicField");
 487   
 488  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 489   
 490  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 491  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 492  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 493  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 494  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 495  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 496    }
 497   
 498  1 public void testPublicToPrivateField() {
 499  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPrivateField");
 500  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPrivateField");
 501   
 502  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 503   
 504  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 505  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 506  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 507  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 508  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 509  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 510    }
 511   
 512  1 public void testPublicToProtectedField() {
 513  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToProtectedField");
 514  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToProtectedField");
 515   
 516  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 517   
 518  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 519  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 520  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 521  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 522  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 523  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 524    }
 525   
 526  1 public void testPublicToPackageField() {
 527  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPackageField");
 528  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPackageField");
 529   
 530  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 531   
 532  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 533  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 534  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 535  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 536  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 537  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 538    }
 539   
 540  1 public void testPublicToPublicField() {
 541  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPublicField");
 542  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPublicField");
 543   
 544  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 545   
 546  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 547  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 548  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 549  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 550  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 551  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 552    }
 553   
 554  1 public void testNonFinalToNonFinalField() {
 555  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToNonFinalField");
 556  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToNonFinalField");
 557   
 558  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 559   
 560  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 561  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 562  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 563  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 564  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 565  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 566    }
 567   
 568  1 public void testNonFinalToFinalField() {
 569  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToFinalField");
 570  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToFinalField");
 571   
 572  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 573   
 574  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 575  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 576  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 577  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 578  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 579  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 580    }
 581   
 582  1 public void testFinalToNonFinalField() {
 583  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToNonFinalField");
 584  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToNonFinalField");
 585   
 586  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 587   
 588  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 589  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 590  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 591  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 592  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 593  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 594    }
 595   
 596  1 public void testFinalToFinalField() {
 597  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToFinalField");
 598  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToFinalField");
 599   
 600  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 601   
 602  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 603  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 604  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 605  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 606  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 607  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 608    }
 609   
 610  1 public void testTypeToSameTypeField() {
 611  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToSameTypeField");
 612  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToSameTypeField");
 613   
 614  1 assertFalse(strategy.isFieldDifferent(oldField, newField));
 615   
 616  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 617  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 618  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 619  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 620  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 621  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 622    }
 623   
 624  1 public void testTypeToDifferentTypeField() {
 625  1 Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToDifferentTypeField");
 626  1 Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToDifferentTypeField");
 627   
 628  1 assertTrue(strategy.isFieldDifferent(oldField, newField));
 629   
 630  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 631  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 632  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 633  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 634  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 635  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 636    }
 637   
 638    /*
 639    * Constructors
 640    */
 641   
 642  1 public void testPrivateToPrivateConstructor() {
 643  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
 644  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
 645   
 646  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 647   
 648  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 649  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 650  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 651  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 652  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 653  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 654    }
 655   
 656  1 public void testPrivateToProtectedConstructor() {
 657  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long");
 658  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long)");
 659   
 660  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 661   
 662  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 663  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 664  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 665  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 666  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 667  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 668    }
 669   
 670  1 public void testPrivateToPackageConstructor() {
 671  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
 672  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
 673   
 674  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 675   
 676  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 677  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 678  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 679  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 680  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 681  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 682    }
 683   
 684  1 public void testPrivateToPublicConstructor() {
 685  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double)");
 686  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double)");
 687   
 688  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 689   
 690  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 691  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 692  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 693  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 694  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 695  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 696    }
 697   
 698  1 public void testProtectedToPrivateConstructor() {
 699  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int)");
 700  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int)");
 701   
 702  1 assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
 703   
 704  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 705  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 706  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 707  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 708  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 709  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 710    }
 711   
 712  1 public void testProtectedToProtectedConstructor() {
 713  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long)");
 714  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long)");
 715   
 716  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 717   
 718  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 719  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 720  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 721  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 722  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 723  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 724    }
 725   
 726  1 public void testProtectedToPackageConstructor() {
 727  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float)");
 728  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float)");
 729   
 730  1 assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
 731   
 732  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 733  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 734  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 735  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 736  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 737  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 738    }
 739   
 740  1 public void testProtectedToPublicConstructor() {
 741  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double)");
 742  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double)");
 743   
 744  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 745   
 746  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 747  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 748  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 749  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 750  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 751  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 752    }
 753   
 754  1 public void testPackageToPrivateConstructor() {
 755  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
 756  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
 757   
 758  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 759   
 760  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 761  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 762  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 763  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 764  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 765  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 766    }
 767   
 768  1 public void testPackageToProtectedConstructor() {
 769  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long)");
 770  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long)");
 771   
 772  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 773   
 774  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 775  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 776  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 777  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 778  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 779  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 780    }
 781   
 782  1 public void testPackageToPackageConstructor() {
 783  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float)");
 784  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float)");
 785   
 786  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 787   
 788  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 789  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 790  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 791  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 792  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 793  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 794    }
 795   
 796  1 public void testPackageToPublicConstructor() {
 797  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double)");
 798  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double)");
 799   
 800  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 801   
 802  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 803  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 804  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 805  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 806  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 807  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 808    }
 809   
 810  1 public void testPublicToPrivateConstructor() {
 811  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int)");
 812  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int)");
 813   
 814  1 assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
 815   
 816  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 817  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 818  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 819  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 820  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 821  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 822    }
 823   
 824  1 public void testPublicToProtectedConstructor() {
 825  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long, long)");
 826  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long, long)");
 827   
 828  1 assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
 829   
 830  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 831  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 832  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 833  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 834  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 835  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 836    }
 837   
 838  1 public void testPublicToPackageConstructor() {
 839  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float, float)");
 840  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float, float)");
 841   
 842  1 assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
 843   
 844  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 845  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 846  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 847  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 848  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 849  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 850    }
 851   
 852  1 public void testPublicToPublicConstructor() {
 853  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double, double)");
 854  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double, double)");
 855   
 856  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 857   
 858  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 859  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 860  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 861  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 862  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 863  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 864    }
 865   
 866  1 public void testThrowsToSameThrowsConstructor() {
 867  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object)");
 868  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object)");
 869   
 870  1 assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
 871   
 872  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 873  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 874  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 875  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 876  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 877  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 878    }
 879   
 880  1 public void testThrowsToDifferentThrowsConstructor() {
 881  1 Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object, java.lang.Object)");
 882  1 Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object, java.lang.Object)");
 883   
 884  1 assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
 885   
 886  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 887  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 888  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 889  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 890  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 891  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 892    }
 893   
 894    /*
 895    * Methods
 896    */
 897   
 898  1 public void testPrivateToPrivateMethod() {
 899  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPrivateMethod()");
 900  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPrivateMethod()");
 901   
 902  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 903   
 904  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 905  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 906  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 907  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 908  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 909  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 910    }
 911   
 912  1 public void testPrivateToProtectedMethod() {
 913  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToProtectedMethod()");
 914  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToProtectedMethod()");
 915   
 916  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 917   
 918  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 919  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 920  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 921  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 922  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 923  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 924    }
 925   
 926  1 public void testPrivateToPackageMethod() {
 927  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPackagedMethod()");
 928  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPackageMethod()");
 929   
 930  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 931   
 932  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 933  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 934  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 935  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 936  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 937  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 938    }
 939   
 940  1 public void testPrivateToPublicMethod() {
 941  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPublicMethod()");
 942  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPublicMethod()");
 943   
 944  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 945   
 946  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 947  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 948  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 949  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 950  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 951  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 952    }
 953   
 954  1 public void testProtectedToPrivateMethod() {
 955  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPrivateMethod()");
 956  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPrivateMethod()");
 957   
 958  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 959   
 960  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 961  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 962  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 963  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 964  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 965  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 966    }
 967   
 968  1 public void testProtectedToProtectedMethod() {
 969  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToProtectedMethod()");
 970  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToProtectedMethod()");
 971   
 972  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 973   
 974  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 975  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 976  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 977  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 978  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 979  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 980    }
 981   
 982  1 public void testProtectedToPackageMethod() {
 983  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPackageMethod()");
 984  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPackageMethod()");
 985   
 986  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 987   
 988  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 989  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 990  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 991  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 992  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 993  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 994    }
 995   
 996  1 public void testProtectedToPublicMethod() {
 997  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPublicMethod()");
 998  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPublicMethod()");
 999   
 1000  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1001   
 1002  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1003  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1004  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1005  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1006  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1007  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1008    }
 1009   
 1010  1 public void testPackageToPrivateMethod() {
 1011  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPrivateMethod()");
 1012  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPrivateMethod()");
 1013   
 1014  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1015   
 1016  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1017  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1018  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1019  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1020  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1021  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1022    }
 1023   
 1024  1 public void testPackageToProtectedMethod() {
 1025  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToProtectedMethod()");
 1026  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToProtectedMethod()");
 1027   
 1028  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1029   
 1030  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1031  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1032  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1033  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1034  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1035  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1036    }
 1037   
 1038  1 public void testPackageToPackageMethod() {
 1039  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPackagedMethod()");
 1040  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPackageMethod()");
 1041   
 1042  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1043   
 1044  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1045  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1046  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1047  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1048  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1049  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1050    }
 1051   
 1052  1 public void testPackageToPublicMethod() {
 1053  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPublicMethod()");
 1054  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPublicMethod()");
 1055   
 1056  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1057   
 1058  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1059  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1060  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1061  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1062  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1063  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1064    }
 1065   
 1066  1 public void testPublicToPrivateMethod() {
 1067  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPrivateMethod()");
 1068  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPrivateMethod()");
 1069   
 1070  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1071   
 1072  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1073  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1074  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1075  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1076  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1077  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1078    }
 1079   
 1080  1 public void testPublicToProtectedMethod() {
 1081  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToProtectedMethod()");
 1082  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToProtectedMethod()");
 1083   
 1084  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1085   
 1086  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1087  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1088  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1089  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1090  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1091  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1092    }
 1093   
 1094  1 public void testPublicToPackageMethod() {
 1095  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPackageMethod()");
 1096  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPackageMethod()");
 1097   
 1098  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1099   
 1100  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1101  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1102  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1103  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1104  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1105  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1106    }
 1107   
 1108  1 public void testPublicToPublicMethod() {
 1109  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPublicMethod()");
 1110  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPublicMethod()");
 1111   
 1112  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1113   
 1114  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1115  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1116  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1117  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1118  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1119  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1120    }
 1121   
 1122  1 public void testConcreteToConcreteMethod() {
 1123  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToConcreteMethod()");
 1124  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToConcreteMethod()");
 1125   
 1126  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1127   
 1128  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1129  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1130  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1131  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1132  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1133  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1134    }
 1135   
 1136  1 public void testConcreteToAbstractMethod() {
 1137  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToAbstractMethod()");
 1138  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToAbstractMethod()");
 1139   
 1140  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1141   
 1142  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1143  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1144  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1145  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1146  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1147  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1148    }
 1149   
 1150  1 public void testAbstractToConcreteMethod() {
 1151  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToConcreteMethod()");
 1152  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToConcreteMethod()");
 1153   
 1154  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1155   
 1156  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1157  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1158  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1159  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1160  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1161  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1162    }
 1163   
 1164  1 public void testAbstractToAbstractMethod() {
 1165  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToAbstractMethod()");
 1166  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToAbstractMethod()");
 1167   
 1168  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1169   
 1170  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1171  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1172  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1173  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1174  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1175  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1176    }
 1177   
 1178  1 public void testNonStaticToNonStaticMethod() {
 1179  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToNonStaticMethod()");
 1180  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToNonStaticMethod()");
 1181   
 1182  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1183   
 1184  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1185  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1186  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1187  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1188  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1189  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1190    }
 1191   
 1192  1 public void testNonStaticToStaticMethod() {
 1193  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToStaticMethod()");
 1194  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToStaticMethod()");
 1195   
 1196  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1197   
 1198  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1199  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1200  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1201  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1202  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1203  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1204    }
 1205   
 1206  1 public void testStaticToNonStaticMethod() {
 1207  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToNonStaticMethod()");
 1208  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToNonStaticMethod()");
 1209   
 1210  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1211   
 1212  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1213  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1214  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1215  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1216  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1217  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1218    }
 1219   
 1220  1 public void testStaticToStaticMethod() {
 1221  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToStaticMethod()");
 1222  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToStaticMethod()");
 1223   
 1224  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1225   
 1226  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1227  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1228  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1229  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1230  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1231  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1232    }
 1233   
 1234  1 public void testNonFinalToNonFinalMethod() {
 1235  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToNonFinalMethod()");
 1236  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToNonFinalMethod()");
 1237   
 1238  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1239   
 1240  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1241  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1242  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1243  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1244  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1245  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1246    }
 1247   
 1248  1 public void testNonFinalToFinalMethod() {
 1249  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToFinalMethod()");
 1250  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToFinalMethod()");
 1251   
 1252  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1253   
 1254  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1255  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1256  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1257  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1258  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1259  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1260    }
 1261   
 1262  1 public void testFinalToNonFinalMethod() {
 1263  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToNonFinalMethod()");
 1264  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToNonFinalMethod()");
 1265   
 1266  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1267   
 1268  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1269  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1270  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1271  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1272  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1273  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1274    }
 1275   
 1276  1 public void testFinalToFinalMethod() {
 1277  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToFinalMethod()");
 1278  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToFinalMethod()");
 1279   
 1280  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1281   
 1282  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1283  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1284  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1285  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1286  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1287  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1288    }
 1289   
 1290  1 public void testReturnTypeToSameReturnTypeMethod() {
 1291  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToSameReturnTypeMethod()");
 1292  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToSameReturnTypeMethod()");
 1293   
 1294  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1295   
 1296  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1297  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1298  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1299  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1300  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1301  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1302    }
 1303   
 1304  1 public void testReturnTypeToDifferentReturnTypeMethod() {
 1305  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToDifferentReturnTypeMethod()");
 1306  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToDifferentReturnTypeMethod()");
 1307   
 1308  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1309   
 1310  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1311  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1312  1 assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
 1313  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1314  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1315  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1316    }
 1317   
 1318  1 public void testThrowsToSameThrowsMethod() {
 1319  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToSameThrowsMethod()");
 1320  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToSameThrowsMethod()");
 1321   
 1322  1 assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 1323   
 1324  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1325  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1326  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 1327  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1328  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1329  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1330    }
 1331   
 1332  1 public void testThrowsToDifferentThrowsMethod() {
 1333  1 Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToDifferentThrowsMethod()");
 1334  1 Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToDifferentThrowsMethod()");
 1335   
 1336  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1337   
 1338  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1339  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1340  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 1341  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1342  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1343  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1344    }
 1345   
 1346  1 public void testCompatibleClassWithIncompatibleMethod() {
 1347  1 Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.CompatibleClass");
 1348  1 Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.CompatibleClass");
 1349   
 1350  1 Method_info oldMethod = oldClass.getMethod("incompatibleMethod()");
 1351  1 Method_info newMethod = newClass.getMethod("incompatibleMethod()");
 1352   
 1353  1 assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 1354  1 assertTrue(strategy.isClassDifferent(oldClass, newClass));
 1355   
 1356  1 assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
 1357  1 assertEquals("class", 0, mockStrategy.getClassDifferentCount());
 1358  1 assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
 1359  1 assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 1360  1 assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
 1361  1 assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
 1362    }
 1363    }