Clover coverage report - Dependency Finder
Coverage timestamp: Mon Nov 29 2010 15:00:50 PST
Overview   Package   File
    FRAMES   NO FRAMES  
file stats: LOC: 648   Methods: 43
NCLOC: 485   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
TestAPIDifferenceStrategy.java - 98.5% 100% 98.6%
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.util.*;
 36   
 37    import com.jeantessier.classreader.*;
 38   
 39    public class TestAPIDifferenceStrategy extends TestDifferencesFactoryBase {
 40    private MockDifferenceStrategy mockStrategy;
 41    private APIDifferenceStrategy strategy;
 42   
 43  42 protected void setUp() throws Exception {
 44  42 super.setUp();
 45   
 46  42 mockStrategy = new MockDifferenceStrategy(new NoDifferenceStrategy());
 47  42 strategy = new APIDifferenceStrategy(mockStrategy);
 48    }
 49   
 50  1 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    }
 63   
 64  1 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    }
 77   
 78  1 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    }
 91   
 92  1 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    }
 105   
 106  1 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    }
 119   
 120  1 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    }
 133   
 134  1 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    }
 147   
 148  1 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    }
 161   
 162  1 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    }
 175   
 176  1 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    }
 189   
 190  1 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    }
 203   
 204  1 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    }
 217   
 218  1 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    }
 231   
 232  1 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    }
 245   
 246  1 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    }
 259   
 260  1 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    }
 273   
 274  1 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    }
 287   
 288  1 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    }
 301   
 302  1 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    }
 315   
 316  1 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    }
 329   
 330  1 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    }
 343   
 344  1 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    }
 357   
 358  1 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    }
 371   
 372  1 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    }
 385   
 386  1 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    }
 399   
 400  1 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    }
 413   
 414  1 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    }
 427   
 428  1 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    }
 441   
 442  1 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    }
 455   
 456  1 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    }
 469   
 470  1 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    }
 483   
 484  1 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    }
 497   
 498  1 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    }
 511   
 512  1 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    }
 525   
 526  1 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    }
 539   
 540  1 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    }
 553   
 554  1 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    }
 567   
 568  1 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    }
 585   
 586  1 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    }
 600   
 601  1 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    }
 617   
 618  1 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    }
 633   
 634  1 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    }
 648    }
 
CloverReport generated by Clover Code Coverage v1.3.13
Mon Nov 29 2010 15:00:54 PST.		   Open Source License registered to the Dependency Finder Project. This license of Clover is provided to support the development of Dependency Finder only.