Coverage Report - com.jeantessier.diff.TestListBasedDifferenceStrategy
 
Classes in this File Line Coverage Branch Coverage Complexity
TestListBasedDifferenceStrategy
97%
266/272
N/A
N/A
1.125
 
 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 com.jeantessier.classreader.*;
 39   
 
 40  23 
 public class TestListBasedDifferenceStrategy extends TestDifferencesFactoryBase {
 41   
     private MockDifferenceStrategy mockStrategy;
 42   
 
 43   
     protected void setUp() throws Exception {
 44  23 
         super.setUp();
 45   
 
 46  23 
         mockStrategy = new MockDifferenceStrategy(new CodeDifferenceStrategy());
 47  23 
     }
 48   
 
 49   
     public void testNullFile() throws IOException {
 50   
         try {
 51  1 
             new ListBasedDifferenceStrategy(mockStrategy, (BufferedReader) null);
 52  0 
             fail("Created validator with null");
 53  1 
         } catch (NullPointerException ex) {
 54   
             // Expected
 55  0 
         }
 56  1 
     }
 57   
 
 58   
     public void testMissingFile1() {
 59   
         try {
 60  1 
             new ListBasedDifferenceStrategy(mockStrategy, "no such file");
 61  0 
             fail("Created validator with missing file");
 62  1 
         } catch (IOException ex) {
 63   
             // Expected
 64  0 
         }
 65  1 
     }
 66   
 
 67   
     public void testMissingFile2() {
 68  1 
         File file = new File("no such file");
 69  1 
         assertFalse("File exists", file.exists());
 70   
 
 71   
         try {
 72  1 
             new ListBasedDifferenceStrategy(mockStrategy, file);
 73  0 
             fail("Created validator with missing file");
 74  1 
         } catch (IOException ex) {
 75   
             // Expected
 76  0 
         }
 77  1 
     }
 78   
 
 79   
     public void testIsPackageDifferentNotInList() throws IOException {
 80  1 
         Map oldPackage = new HashMap();
 81  1 
         oldPackage.put("ModifiedPackage.ModifiedClass", getOldJar().getClassfile("ModifiedPackage.ModifiedClass"));
 82  1 
         Map newPackage = new HashMap();
 83  1 
         newPackage.put("ModifiedPackage.ModifiedClass", getNewJar().getClassfile("ModifiedPackage.ModifiedClass"));
 84   
 
 85  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 86  1 
         strategy.isPackageDifferent(oldPackage, newPackage);
 87   
 
 88  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 89  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 90  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 91  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 92  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 93  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 94  1 
     }
 95   
 
 96   
     public void testIsClassDifferentNotInList() throws IOException {
 97  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedClass");
 98  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedClass");
 99   
 
 100  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 101  1 
         strategy.isClassDifferent(oldClass, newClass);
 102   
 
 103  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 104  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 105  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 106  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 107  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 108  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 109  1 
     }
 110   
 
 111   
     public void testIsFieldDifferentNotInList() throws IOException {
 112  1 
         Field_info oldField = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 113  1 
         Field_info newField = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 114   
 
 115  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 116  1 
         strategy.isFieldDifferent(oldField, newField);
 117   
 
 118  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 119  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 120  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 121  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 122  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 123  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 124  1 
     }
 125   
 
 126   
     public void testIsMethodDifferentNotInList() throws IOException {
 127  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 128  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 129   
 
 130  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 131  1 
         strategy.isMethodDifferent(oldMethod, newMethod);
 132   
 
 133  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 134  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 135  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 136  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 137  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 138  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 139  1 
     }
 140   
 
 141   
     public void testIsCodeMethodDifferentNotInList() throws IOException {
 142  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 143  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 144   
 
 145  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 146  1 
         strategy.isMethodDifferent(oldMethod, newMethod);
 147   
 
 148  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 149  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 150  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 151  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 152  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 153  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 154  1 
     }
 155   
 
 156   
     public void testIsCodeDifferentNotInList() throws IOException {
 157  1 
         Code_attribute oldCode = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 158  1 
         Code_attribute newCode = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 159   
 
 160  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 161  1 
         strategy.isCodeDifferent(oldCode, newCode);
 162   
 
 163  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 164  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 165  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 166  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 167  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 168  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 169  1 
     }
 170   
 
 171   
     public void testIsPackageDifferentInList() throws IOException {
 172  1 
         Map oldPackage = new HashMap();
 173  1 
         oldPackage.put("ModifiedPackage.ModifiedClass", getOldJar().getClassfile("ModifiedPackage.ModifiedClass"));
 174  1 
         Map newPackage = new HashMap();
 175  1 
         newPackage.put("ModifiedPackage.ModifiedClass", getNewJar().getClassfile("ModifiedPackage.ModifiedClass"));
 176   
 
 177  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage")));
 178  1 
         strategy.isPackageDifferent(oldPackage, newPackage);
 179   
 
 180  1 
         assertEquals("package",  1, mockStrategy.getPackageDifferentCount());
 181  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 182  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 183  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 184  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 185  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 186  1 
     }
 187   
 
 188   
     public void testIsClassDifferentInList() throws IOException {
 189  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedClass");
 190  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedClass");
 191   
 
 192  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass")));
 193  1 
         strategy.isClassDifferent(oldClass, newClass);
 194   
 
 195  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 196  1 
         assertEquals("class",    1, mockStrategy.getClassDifferentCount());
 197  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 198  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 199  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 200  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 201  1 
     }
 202   
 
 203   
     public void testIsFieldDifferentInList() throws IOException {
 204  1 
         Field_info oldField = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 205  1 
         Field_info newField = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 206   
 
 207  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedField")));
 208  1 
         strategy.isFieldDifferent(oldField, newField);
 209   
 
 210  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 211  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 212  1 
         assertEquals("field",    1, mockStrategy.getFieldDifferentCount());
 213  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 214  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 215  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 216  1 
     }
 217   
 
 218   
     public void testIsMethodDifferentInList() throws IOException {
 219  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 220  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 221   
 
 222  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedMethod()")));
 223  1 
         strategy.isMethodDifferent(oldMethod, newMethod);
 224   
 
 225  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 226  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 227  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 228  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 229  1 
         assertEquals("method",   1, mockStrategy.getMethodDifferentCount());
 230  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 231  1 
     }
 232   
 
 233   
     public void testIsCodeMethodDifferentInList() throws IOException {
 234  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 235  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 236   
 
 237  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedCodeMethod()")));
 238  1 
         strategy.isMethodDifferent(oldMethod, newMethod);
 239   
 
 240  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 241  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 242  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 243  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 244  1 
         assertEquals("method",   1, mockStrategy.getMethodDifferentCount());
 245  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 246  1 
     }
 247   
 
 248   
     public void testIsCodeDifferentInList() throws IOException {
 249  1 
         Code_attribute oldCode = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 250  1 
         Code_attribute newCode = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 251   
 
 252  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedCodeMethod()")));
 253  1 
         strategy.isCodeDifferent(oldCode, newCode);
 254   
 
 255  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 256  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 257  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 258  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 259  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 260  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 261  1 
     }
 262   
 
 263   
     public void testIsPackageDifferentInListWithSuffix() throws IOException {
 264  1 
         Map oldPackage = new HashMap();
 265  1 
         oldPackage.put("ModifiedPackage.ModifiedClass", getOldJar().getClassfile("ModifiedPackage.ModifiedClass"));
 266  1 
         Map newPackage = new HashMap();
 267  1 
         newPackage.put("ModifiedPackage.ModifiedClass", getNewJar().getClassfile("ModifiedPackage.ModifiedClass"));
 268   
 
 269  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage [P]")));
 270  1 
         strategy.isPackageDifferent(oldPackage, newPackage);
 271   
 
 272  1 
         assertEquals("package",  1, mockStrategy.getPackageDifferentCount());
 273  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 274  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 275  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 276  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 277  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 278  1 
     }
 279   
 
 280   
     public void testIsClassDifferentInListWithSuffix() throws IOException {
 281  1 
         Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedClass");
 282  1 
         Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedClass");
 283   
 
 284  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass [C]")));
 285  1 
         strategy.isClassDifferent(oldClass, newClass);
 286   
 
 287  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 288  1 
         assertEquals("class",    1, mockStrategy.getClassDifferentCount());
 289  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 290  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 291  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 292  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 293  1 
     }
 294   
 
 295   
     public void testIsFieldDifferentInListWithSuffix() throws IOException {
 296  1 
         Field_info oldField = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 297  1 
         Field_info newField = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
 298   
 
 299  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedField [F]")));
 300  1 
         strategy.isFieldDifferent(oldField, newField);
 301   
 
 302  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 303  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 304  1 
         assertEquals("field",    1, mockStrategy.getFieldDifferentCount());
 305  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 306  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 307  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 308  1 
     }
 309   
 
 310   
     public void testIsMethodDifferentInListWithSuffix() throws IOException {
 311  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 312  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
 313   
 
 314  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedMethod() [F]")));
 315  1 
         strategy.isMethodDifferent(oldMethod, newMethod);
 316   
 
 317  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 318  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 319  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 320  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 321  1 
         assertEquals("method",   1, mockStrategy.getMethodDifferentCount());
 322  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 323  1 
     }
 324   
 
 325   
     public void testIsCodeMethodDifferentInListWithSuffix() throws IOException {
 326  1 
         Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 327  1 
         Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
 328   
 
 329  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedCodeMethod() [F]")));
 330  1 
         strategy.isMethodDifferent(oldMethod, newMethod);
 331   
 
 332  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 333  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 334  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 335  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 336  1 
         assertEquals("method",   1, mockStrategy.getMethodDifferentCount());
 337  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 338  1 
     }
 339   
 
 340   
     public void testIsCodeDifferentInListWithSuffix() throws IOException {
 341  1 
         Code_attribute oldCode = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 342  1 
         Code_attribute newCode = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
 343   
 
 344  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("ModifiedPackage.ModifiedClass.modifiedCodeMethod() [F]")));
 345  1 
         strategy.isCodeDifferent(oldCode, newCode);
 346   
 
 347  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 348  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 349  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 350  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 351  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 352  1 
         assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
 353  1 
     }
 354   
 
 355   
     public void testIsConstantValueDifferent() throws IOException {
 356  1 
         ConstantValue_attribute oldConstantValue = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField").getConstantValue();
 357  1 
         ConstantValue_attribute newConstantValue = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField").getConstantValue();
 358   
 
 359  1 
         DifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 360  1 
         strategy.isConstantValueDifferent(oldConstantValue, newConstantValue);
 361   
 
 362  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 363  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 364  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 365  1 
         assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
 366  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 367  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 368  1 
     }
 369   
 
 370   
     public void testMerge() throws IOException {
 371  1 
         Map oldPackage1 = new HashMap();
 372  1 
         oldPackage1.put("ModifiedPackage.ModifiedClass", getOldJar().getClassfile("ModifiedPackage.ModifiedClass"));
 373  1 
         Map newPackage1 = new HashMap();
 374  1 
         newPackage1.put("ModifiedPackage.ModifiedClass", getNewJar().getClassfile("ModifiedPackage.ModifiedClass"));
 375   
 
 376  1 
         Map oldPackage2 = new HashMap();
 377  1 
         oldPackage2.put("UnmodifiedPackage.UnmodifiedClass", getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
 378  1 
         Map newPackage2 = new HashMap();
 379  1 
         newPackage2.put("UnmodifiedPackage.UnmodifiedClass", getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
 380   
 
 381  1 
         ListBasedDifferenceStrategy strategy = new ListBasedDifferenceStrategy(mockStrategy, new BufferedReader(new StringReader("")));
 382   
 
 383  1 
         strategy.isPackageDifferent(oldPackage1, newPackage1);
 384  1 
         strategy.isPackageDifferent(oldPackage2, newPackage2);
 385  1 
         assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
 386  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 387  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 388  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 389  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 390  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 391   
 
 392  1 
         strategy.load(new BufferedReader(new StringReader("ModifiedPackage")));
 393   
 
 394  1 
         strategy.isPackageDifferent(oldPackage1, newPackage1);
 395  1 
         strategy.isPackageDifferent(oldPackage2, newPackage2);
 396  1 
         assertEquals("package",  1, mockStrategy.getPackageDifferentCount());
 397  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 398  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 399  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 400  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 401  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 402   
 
 403  1 
         strategy.load(new BufferedReader(new StringReader("UnmodifiedPackage")));
 404   
 
 405  1 
         strategy.isPackageDifferent(oldPackage1, newPackage1);
 406  1 
         strategy.isPackageDifferent(oldPackage2, newPackage2);
 407  1 
         assertEquals("package",  3, mockStrategy.getPackageDifferentCount());
 408  1 
         assertEquals("class",    0, mockStrategy.getClassDifferentCount());
 409  1 
         assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
 410  1 
         assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
 411  1 
         assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
 412  1 
         assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
 413  1 
     }
 414   
 }
Report generated by Cobertura 1.9.3 on 11/29/10 3:12 PM.