Coverage Report - com.jeantessier.diff.TestAPIDifferenceStrategy
 
Classes in this File Line Coverage Branch Coverage Complexity
TestAPIDifferenceStrategy
97%
427/436
N/A
N/A
1
 
 1   
 /*
 2   
  *  Copyright (c) 2001-2009, Jean Tessier
 3   
  *  All rights reserved.
 4   
  *
 5   
  *  Redistribution and use in source and binary forms, with or without
 6   
  *  modification, are permitted provided that the following conditions
 7   
  *  are met:
 8   
  *
 9   
  *      * Redistributions of source code must retain the above copyright
 10   
  *        notice, this list of conditions and the following disclaimer.
 11   
  *
 12   
  *      * Redistributions in binary form must reproduce the above copyright
 13   
  *        notice, this list of conditions and the following disclaimer in the
 14   
  *        documentation and/or other materials provided with the distribution.
 15   
  *
 16   
  *      * Neither the name of Jean Tessier nor the names of his contributors
 17   
  *        may be used to endorse or promote products derived from this software
 18   
  *        without specific prior written permission.
 19   
  *
 20   
  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 21   
  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 22   
  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 23   
  *  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR
 24   
  *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 25   
  *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 26   
  *  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 27   
  *  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 28   
  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 29   
  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 30   
  *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 31   
  */
 32   
 
 33   
 package com.jeantessier.diff;
 34   
 
 35   
 import java.util.*;
 36   
 
 37   
 import com.jeantessier.classreader.*;
 38   
 
 39  42 
 public class TestAPIDifferenceStrategy extends TestDifferencesFactoryBase {
 40   
     private MockDifferenceStrategy mockStrategy;
 41   
     private APIDifferenceStrategy strategy;
 42   
 
 43   
     protected void setUp() throws Exception {
 44  42 
         super.setUp();
 45   
 
 46  42 
         mockStrategy = new MockDifferenceStrategy(new NoDifferenceStrategy());
 47  42 
         strategy = new APIDifferenceStrategy(mockStrategy);
 48  42 
     }
 49   
 
 50   
     public void testUnmodifiedConstantValue() {
 51  1 
         ConstantValue_attribute oldValue = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface").getField("unmodifiedField").getConstantValue();
 52  1 
         ConstantValue_attribute newValue = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface").getField("unmodifiedField").getConstantValue();
 53   
 
 54  1 
         assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
 55   
 
 56  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 57  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 58  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 59  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 60  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 61  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 62  1 
     }
 63   
 
 64   
     public void testRemovedConstantValue() {
 65  1 
         ConstantValue_attribute oldValue = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("removedField").getConstantValue();
 66  1 
         ConstantValue_attribute newValue = null;
 67   
 
 68  1 
         assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
 69   
 
 70  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 71  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 72  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 73  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 74  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 75  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 76  1 
     }
 77   
 
 78   
     public void testModifiedConstantValue() {
 79  1 
         ConstantValue_attribute oldValue = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField").getConstantValue();
 80  1 
         ConstantValue_attribute newValue = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField").getConstantValue();
 81   
 
 82  1 
         assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
 83   
 
 84  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 85  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 86  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 87  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 88  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 89  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 90  1 
     }
 91   
 
 92   
     public void testNewConstantValue() {
 93  1 
         ConstantValue_attribute oldValue = null;
 94  1 
         ConstantValue_attribute newValue = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("newField").getConstantValue();
 95   
 
 96  1 
         assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
 97   
 
 98  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 99  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 100  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 101  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 102  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 103  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 104  1 
     }
 105   
 
 106   
     public void testUnmodifiedField() {
 107  1 
         Field_info oldFeature = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getField("unmodifiedField");
 108  1 
         Field_info newFeature = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getField("unmodifiedField");
 109   
 
 110  1 
         assertFalse(strategy.isFieldDifferent(oldFeature, newFeature));
 111   
 
 112  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 113  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 114  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 115  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 116  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 117  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 118  1 
     }
 119   
 
 120   
     public void testRemovedField() {
 121  1 
         Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("removedField");
 122  1 
         Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("removedField");
 123   
 
 124  1 
         assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
 125   
 
 126  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 127  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 128  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 129  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 130  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 131  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 132  1 
     }
 133   
 
 134   
     public void testModifiedField() {
 135  1 
         Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 136  1 
         Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 137   
 
 138  1 
         assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
 139   
 
 140  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 141  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 142  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 143  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 144  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 145  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 146  1 
     }
 147   
 
 148   
     public void testModifiedValueField() {
 149  1 
         Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField");
 150  1 
         Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField");
 151   
 
 152  1 
         assertFalse(strategy.isFieldDifferent(oldFeature, newFeature));
 153   
 
 154  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 155  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 156  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 157  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 158  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 159  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 160  1 
     }
 161   
 
 162   
     public void testDeprecatedField() {
 163  1 
         Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("deprecatedField");
 164  1 
         Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("deprecatedField");
 165   
 
 166  1 
         assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
 167   
 
 168  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 169  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 170  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 171  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 172  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 173  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 174  1 
     }
 175   
 
 176   
     public void testUndeprecatedField() {
 177  1 
         Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("undeprecatedField");
 178  1 
         Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("undeprecatedField");
 179   
 
 180  1 
         assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
 181   
 
 182  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 183  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 184  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 185  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 186  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 187  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 188  1 
     }
 189   
 
 190   
     public void testNewField() {
 191  1 
         Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("newField");
 192  1 
         Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("newField");
 193   
 
 194  1 
         assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
 195   
 
 196  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 197  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 198  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 199  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 200  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 201  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 202  1 
     }
 203   
 
 204   
     public void testUnmodifiedCode() {
 205  1 
         Code_attribute oldCode = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()").getCode();
 206  1 
         Code_attribute newCode = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()").getCode();
 207   
 
 208  1 
         assertFalse(strategy.isCodeDifferent(oldCode, newCode));
 209   
 
 210  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 211  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 212  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 213  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 214  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 215  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 216  1 
     }
 217   
 
 218   
     public void testModifiedCode() {
 219  1 
         Code_attribute oldCode = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 220  1 
         Code_attribute newCode = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 221   
 
 222  1 
         assertFalse(strategy.isCodeDifferent(oldCode, newCode));
 223   
 
 224  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 225  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 226  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 227  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 228  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 229  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 230  1 
     }
 231   
 
 232   
     public void testUnmodifiedConstructor() {
 233  1 
         Method_info oldMethod = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("UnmodifiedClass()");
 234  1 
         Method_info newMethod = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("UnmodifiedClass()");
 235   
 
 236  1 
         assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 237   
 
 238  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 239  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 240  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 241  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 242  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 243  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 244  1 
     }
 245   
 
 246   
     public void testRemovedConstructor() {
 247  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass()");
 248  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass()");
 249   
 
 250  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 251   
 
 252  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 253  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 254  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 255  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 256  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 257  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 258  1 
     }
 259   
 
 260   
     public void testModifiedConstructor() {
 261  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
 262  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
 263   
 
 264  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 265   
 
 266  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 267  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 268  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 269  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 270  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 271  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 272  1 
     }
 273   
 
 274   
     public void testModifiedCodeConstructor() {
 275  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
 276  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
 277   
 
 278  1 
         assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 279   
 
 280  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 281  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 282  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 283  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 284  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 285  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 286  1 
     }
 287   
 
 288   
     public void testDeprecatedConstructor() {
 289  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
 290  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
 291   
 
 292  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 293   
 
 294  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 295  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 296  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 297  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 298  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 299  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 300  1 
     }
 301   
 
 302   
     public void testUndeprecatedConstructor() {
 303  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int)");
 304  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int)");
 305   
 
 306  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 307   
 
 308  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 309  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 310  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 311  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 312  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 313  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 314  1 
     }
 315   
 
 316   
     public void testNewConstructor() {
 317  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int, int)");
 318  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int, int)");
 319   
 
 320  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 321   
 
 322  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 323  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 324  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 325  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 326  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 327  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 328  1 
     }
 329   
 
 330   
     public void testUnmodifiedMethod() {
 331  1 
         Method_info oldMethod = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()");
 332  1 
         Method_info newMethod = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()");
 333   
 
 334  1 
         assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 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",     1, mockStrategy.getCodeDifferentCount());
 342  1 
     }
 343   
 
 344   
     public void testRemovedMethod() {
 345  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("removedMethod()");
 346  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("removedMethod()");
 347   
 
 348  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 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  1 
     }
 357   
 
 358   
     public void testModifiedMethod() {
 359  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 360  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 361   
 
 362  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 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  1 
     }
 371   
 
 372   
     public void testModifiedCodeMethod() {
 373  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 374  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 375   
 
 376  1 
         assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
 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",     1, mockStrategy.getCodeDifferentCount());
 384  1 
     }
 385   
 
 386   
     public void testDeprecatedMethod() {
 387  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("deprecatedMethod()");
 388  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("deprecatedMethod()");
 389   
 
 390  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 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  1 
     }
 399   
 
 400   
     public void testUndeprecatedMethod() {
 401  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("undeprecatedMethod()");
 402  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("undeprecatedMethod()");
 403   
 
 404  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 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  1 
     }
 413   
 
 414   
     public void testNewMethod() {
 415  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("newMethod()");
 416  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("newMethod()");
 417   
 
 418  1 
         assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
 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  1 
     }
 427   
 
 428   
     public void testUnmodifiedInterface() {
 429  1 
         Classfile oldClass = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface");
 430  1 
         Classfile newClass = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface");
 431   
 
 432  1 
         assertFalse(strategy.isClassDifferent(oldClass, newClass));
 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", 1, mockStrategy.getConstantValueDifferentCount());
 438  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 439  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 440  1 
     }
 441   
 
 442   
     public void testRemovedInterface() {
 443  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.RemovedInterface");
 444  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.RemovedInterface");
 445   
 
 446  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  1 
     }
 455   
 
 456   
     public void testModifiedDeclarationInterface() {
 457  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedDeclarationInterface");
 458  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedDeclarationInterface");
 459   
 
 460  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  1 
     }
 469   
 
 470   
     public void testModifiedInterface() {
 471  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface");
 472  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface");
 473   
 
 474  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  0 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 481  0 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 482  0 
     }
 483   
 
 484   
     public void testNewInterface() {
 485  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.NewInterface");
 486  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.NewInterface");
 487   
 
 488  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  1 
     }
 497   
 
 498   
     public void testUnmodifiedClass() {
 499  1 
         Classfile oldClass = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass");
 500  1 
         Classfile newClass = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass");
 501   
 
 502  1 
         assertFalse(strategy.isClassDifferent(oldClass, newClass));
 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", 1, mockStrategy.getConstantValueDifferentCount());
 508  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 509  1 
         assertEquals("code",     2, mockStrategy.getCodeDifferentCount());
 510  1 
     }
 511   
 
 512   
     public void testRemovedClass() {
 513  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.RemovedClass");
 514  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.RemovedClass");
 515   
 
 516  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  1 
     }
 525   
 
 526   
     public void testModifiedDeclarationClass() {
 527  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedDeclarationClass");
 528  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedDeclarationClass");
 529   
 
 530  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  1 
     }
 539   
 
 540   
     public void testModifiedClass() {
 541  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedClass");
 542  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedClass");
 543   
 
 544  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  0 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 551  0 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 552  0 
     }
 553   
 
 554   
     public void testNewClass() {
 555  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.NewClass");
 556  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.NewClass");
 557   
 
 558  1 
         assertTrue(strategy.isClassDifferent(oldClass, newClass));
 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  1 
     }
 567   
 
 568   
     public void testUnmodifiedPackage() {
 569  1 
         Map oldPackage = new HashMap();
 570  1 
         oldPackage.put("UnmodifiedPackage.UnmodifiedClass",     getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
 571  1 
         oldPackage.put("UnmodifiedPackage.UnmodifiedInterface", getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface"));
 572  1 
         Map newPackage = new HashMap();
 573  1 
         newPackage.put("UnmodifiedPackage.UnmodifiedClass",     getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
 574  1 
         newPackage.put("UnmodifiedPackage.UnmodifiedInterface", getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface"));
 575   
 
 576  1 
         assertFalse(strategy.isPackageDifferent(oldPackage, newPackage));
 577   
 
 578  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 579  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 580  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 581  1 
         assertEquals("constant", 2, mockStrategy.getConstantValueDifferentCount());
 582  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 583  1 
         assertEquals("code",     3, mockStrategy.getCodeDifferentCount());
 584  1 
     }
 585   
 
 586   
     public void testRemovedPackage() {
 587  1 
         Map oldPackage = new HashMap();
 588  1 
         oldPackage.put("RemovedPackage.RemovedClass", getOldJar().getClassfile("RemovedPackage.RemovedClass"));
 589  1 
         Map newPackage = new HashMap();
 590   
 
 591  1 
         assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
 592   
 
 593  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 594  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 595  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 596  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 597  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 598  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 599  1 
     }
 600   
 
 601   
     public void testModifiedPackage() {
 602  1 
         Map oldPackage = new HashMap();
 603  1 
         oldPackage.put("UnmodifiedPackage.UnmodifiedClass",     getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
 604  1 
         oldPackage.put("UnmodifiedPackage.UnmodifiedInterface", getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface"));
 605  1 
         Map newPackage = new HashMap();
 606  1 
         newPackage.put("UnmodifiedPackage.UnmodifiedClass",     getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
 607   
 
 608  1 
         assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
 609   
 
 610  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 611  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 612  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 613  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 614  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 615  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 616  1 
     }
 617   
 
 618   
     public void testModifiedCodePackage() {
 619  1 
         Map oldPackage = new HashMap();
 620  1 
         oldPackage.put("ModifiedPackage.ModifiedClass", getOldJar().getClassfile("ModifiedPackage.ModifiedClass"));
 621  1 
         Map newPackage = new HashMap();
 622  1 
         newPackage.put("ModifiedPackage.ModifiedClass", getNewJar().getClassfile("ModifiedPackage.ModifiedClass"));
 623   
 
 624  1 
         assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
 625   
 
 626  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 627  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 628  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 629  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 630  0 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 631  0 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 632  0 
     }
 633   
 
 634   
     public void testNewPackage() {
 635  1 
         Map oldPackage = new HashMap();
 636  1 
         Map newPackage = new HashMap();
 637  1 
         newPackage.put("NewPackage.NewClass", getNewJar().getClassfile("NewPackage.NewClass"));
 638   
 
 639  1 
         assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
 640   
 
 641  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 642  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 643  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 644  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 645  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 646  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 647  1 
     }
 648   
 }
Report generated by Cobertura 1.9.3 on 11/29/10 3:12 PM.