EMMA Coverage Report (generated Mon Nov 29 14:43:38 PST 2010)
[all classes][com.jeantessier.diff]

COVERAGE SUMMARY FOR SOURCE FILE [TestAPIDifferenceStrategy.java]

nameclass, %method, %block, %line, %
TestAPIDifferenceStrategy.java100% (1/1)93%  (41/44)93%  (2183/2350)93%  (404/436)

COVERAGE BREAKDOWN BY CLASS AND METHOD

nameclass, %method, %block, %line, %
     
class TestAPIDifferenceStrategy100% (1/1)93%  (41/44)93%  (2183/2350)93%  (404/436)
testModifiedClass (): void 0%   (0/1)0%   (0/51)0%   (0/10)
testModifiedCodePackage (): void 0%   (0/1)0%   (0/65)0%   (0/12)
testModifiedInterface (): void 0%   (0/1)0%   (0/51)0%   (0/10)
TestAPIDifferenceStrategy (): void 100% (1/1)100% (3/3)100% (1/1)
setUp (): void 100% (1/1)100% (18/18)100% (4/4)
testDeprecatedConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testDeprecatedField (): void 100% (1/1)100% (55/55)100% (10/10)
testDeprecatedMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testModifiedCode (): void 100% (1/1)100% (57/57)100% (10/10)
testModifiedCodeConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testModifiedCodeMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testModifiedConstantValue (): void 100% (1/1)100% (57/57)100% (10/10)
testModifiedConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testModifiedDeclarationClass (): void 100% (1/1)100% (51/51)100% (10/10)
testModifiedDeclarationInterface (): void 100% (1/1)100% (51/51)100% (10/10)
testModifiedField (): void 100% (1/1)100% (55/55)100% (10/10)
testModifiedMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testModifiedPackage (): void 100% (1/1)100% (72/72)100% (13/13)
testModifiedValueField (): void 100% (1/1)100% (55/55)100% (10/10)
testNewClass (): void 100% (1/1)100% (51/51)100% (10/10)
testNewConstantValue (): void 100% (1/1)100% (52/52)100% (10/10)
testNewConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testNewField (): void 100% (1/1)100% (55/55)100% (10/10)
testNewInterface (): void 100% (1/1)100% (51/51)100% (10/10)
testNewMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testNewPackage (): void 100% (1/1)100% (58/58)100% (11/11)
testRemovedClass (): void 100% (1/1)100% (51/51)100% (10/10)
testRemovedConstantValue (): void 100% (1/1)100% (52/52)100% (10/10)
testRemovedConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testRemovedField (): void 100% (1/1)100% (55/55)100% (10/10)
testRemovedInterface (): void 100% (1/1)100% (51/51)100% (10/10)
testRemovedMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testRemovedPackage (): void 100% (1/1)100% (58/58)100% (11/11)
testUndeprecatedConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testUndeprecatedField (): void 100% (1/1)100% (55/55)100% (10/10)
testUndeprecatedMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testUnmodifiedClass (): void 100% (1/1)100% (51/51)100% (10/10)
testUnmodifiedCode (): void 100% (1/1)100% (57/57)100% (10/10)
testUnmodifiedConstantValue (): void 100% (1/1)100% (57/57)100% (10/10)
testUnmodifiedConstructor (): void 100% (1/1)100% (55/55)100% (10/10)
testUnmodifiedField (): void 100% (1/1)100% (55/55)100% (10/10)
testUnmodifiedInterface (): void 100% (1/1)100% (51/51)100% (10/10)
testUnmodifiedMethod (): void 100% (1/1)100% (55/55)100% (10/10)
testUnmodifiedPackage (): void 100% (1/1)100% (79/79)100% (14/14)

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 
33package com.jeantessier.diff;
34 
35import java.util.*;
36 
37import com.jeantessier.classreader.*;
38 
39public class TestAPIDifferenceStrategy extends TestDifferencesFactoryBase {
40    private MockDifferenceStrategy mockStrategy;
41    private APIDifferenceStrategy strategy;
42 
43    protected void setUp() throws Exception {
44        super.setUp();
45 
46        mockStrategy = new MockDifferenceStrategy(new NoDifferenceStrategy());
47        strategy = new APIDifferenceStrategy(mockStrategy);
48    }
49 
50    public void testUnmodifiedConstantValue() {
51        ConstantValue_attribute oldValue = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface").getField("unmodifiedField").getConstantValue();
52        ConstantValue_attribute newValue = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface").getField("unmodifiedField").getConstantValue();
53 
54        assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
55 
56        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
57        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
58        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
59        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
60        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
61        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
62    }
63 
64    public void testRemovedConstantValue() {
65        ConstantValue_attribute oldValue = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("removedField").getConstantValue();
66        ConstantValue_attribute newValue = null;
67 
68        assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
69 
70        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
71        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
72        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
73        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
74        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
75        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
76    }
77 
78    public void testModifiedConstantValue() {
79        ConstantValue_attribute oldValue = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField").getConstantValue();
80        ConstantValue_attribute newValue = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField").getConstantValue();
81 
82        assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
83 
84        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
85        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
86        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
87        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
88        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
89        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
90    }
91 
92    public void testNewConstantValue() {
93        ConstantValue_attribute oldValue = null;
94        ConstantValue_attribute newValue = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("newField").getConstantValue();
95 
96        assertFalse(strategy.isConstantValueDifferent(oldValue, newValue));
97 
98        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
99        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
100        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
101        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
102        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
103        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
104    }
105 
106    public void testUnmodifiedField() {
107        Field_info oldFeature = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getField("unmodifiedField");
108        Field_info newFeature = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getField("unmodifiedField");
109 
110        assertFalse(strategy.isFieldDifferent(oldFeature, newFeature));
111 
112        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
113        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
114        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
115        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
116        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
117        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
118    }
119 
120    public void testRemovedField() {
121        Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("removedField");
122        Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("removedField");
123 
124        assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
125 
126        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
127        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
128        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
129        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
130        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
131        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
132    }
133 
134    public void testModifiedField() {
135        Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
136        Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("modifiedField");
137 
138        assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
139 
140        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
141        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
142        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
143        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
144        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
145        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
146    }
147 
148    public void testModifiedValueField() {
149        Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField");
150        Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("modifiedValueField");
151 
152        assertFalse(strategy.isFieldDifferent(oldFeature, newFeature));
153 
154        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
155        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
156        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
157        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
158        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
159        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
160    }
161 
162    public void testDeprecatedField() {
163        Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("deprecatedField");
164        Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("deprecatedField");
165 
166        assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
167 
168        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
169        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
170        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
171        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
172        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
173        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
174    }
175 
176    public void testUndeprecatedField() {
177        Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("undeprecatedField");
178        Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface").getField("undeprecatedField");
179 
180        assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
181 
182        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
183        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
184        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
185        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
186        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
187        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
188    }
189 
190    public void testNewField() {
191        Field_info oldFeature = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getField("newField");
192        Field_info newFeature = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getField("newField");
193 
194        assertTrue(strategy.isFieldDifferent(oldFeature, newFeature));
195 
196        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
197        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
198        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
199        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
200        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
201        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
202    }
203 
204    public void testUnmodifiedCode() {
205        Code_attribute oldCode = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()").getCode();
206        Code_attribute newCode = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()").getCode();
207 
208        assertFalse(strategy.isCodeDifferent(oldCode, newCode));
209 
210        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
211        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
212        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
213        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
214        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
215        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
216    }
217 
218    public void testModifiedCode() {
219        Code_attribute oldCode = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
220        Code_attribute newCode = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()").getCode();
221 
222        assertFalse(strategy.isCodeDifferent(oldCode, newCode));
223 
224        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
225        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
226        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
227        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
228        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
229        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
230    }
231 
232    public void testUnmodifiedConstructor() {
233        Method_info oldMethod = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("UnmodifiedClass()");
234        Method_info newMethod = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("UnmodifiedClass()");
235 
236        assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
237 
238        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
239        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
240        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
241        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
242        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
243        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
244    }
245 
246    public void testRemovedConstructor() {
247        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass()");
248        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass()");
249 
250        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
251 
252        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
253        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
254        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
255        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
256        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
257        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
258    }
259 
260    public void testModifiedConstructor() {
261        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
262        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
263 
264        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
265 
266        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
267        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
268        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
269        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
270        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
271        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
272    }
273 
274    public void testModifiedCodeConstructor() {
275        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
276        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
277 
278        assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
279 
280        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
281        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
282        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
283        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
284        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
285        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
286    }
287 
288    public void testDeprecatedConstructor() {
289        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
290        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
291 
292        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
293 
294        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
295        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
296        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
297        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
298        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
299        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
300    }
301 
302    public void testUndeprecatedConstructor() {
303        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int)");
304        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int)");
305 
306        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
307 
308        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
309        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
310        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
311        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
312        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
313        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
314    }
315 
316    public void testNewConstructor() {
317        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int, int)");
318        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int, int, int)");
319 
320        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
321 
322        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
323        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
324        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
325        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
326        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
327        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
328    }
329 
330    public void testUnmodifiedMethod() {
331        Method_info oldMethod = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()");
332        Method_info newMethod = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass").getMethod("unmodifiedMethod()");
333 
334        assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
335 
336        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
337        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
338        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
339        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
340        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
341        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
342    }
343 
344    public void testRemovedMethod() {
345        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("removedMethod()");
346        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("removedMethod()");
347 
348        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
349 
350        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
351        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
352        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
353        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
354        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
355        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
356    }
357 
358    public void testModifiedMethod() {
359        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
360        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedMethod()");
361 
362        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
363 
364        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
365        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
366        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
367        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
368        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
369        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
370    }
371 
372    public void testModifiedCodeMethod() {
373        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
374        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("modifiedCodeMethod()");
375 
376        assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
377 
378        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
379        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
380        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
381        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
382        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
383        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
384    }
385 
386    public void testDeprecatedMethod() {
387        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("deprecatedMethod()");
388        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("deprecatedMethod()");
389 
390        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
391 
392        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
393        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
394        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
395        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
396        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
397        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
398    }
399 
400    public void testUndeprecatedMethod() {
401        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("undeprecatedMethod()");
402        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("undeprecatedMethod()");
403 
404        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
405 
406        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
407        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
408        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
409        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
410        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
411        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
412    }
413 
414    public void testNewMethod() {
415        Method_info oldMethod = getOldJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("newMethod()");
416        Method_info newMethod = getNewJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("newMethod()");
417 
418        assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
419 
420        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
421        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
422        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
423        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
424        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
425        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
426    }
427 
428    public void testUnmodifiedInterface() {
429        Classfile oldClass = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface");
430        Classfile newClass = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface");
431 
432        assertFalse(strategy.isClassDifferent(oldClass, newClass));
433 
434        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
435        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
436        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
437        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
438        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
439        assertEquals("code",     1, mockStrategy.getCodeDifferentCount());
440    }
441 
442    public void testRemovedInterface() {
443        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.RemovedInterface");
444        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.RemovedInterface");
445 
446        assertTrue(strategy.isClassDifferent(oldClass, newClass));
447 
448        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
449        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
450        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
451        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
452        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
453        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
454    }
455 
456    public void testModifiedDeclarationInterface() {
457        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedDeclarationInterface");
458        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedDeclarationInterface");
459 
460        assertTrue(strategy.isClassDifferent(oldClass, newClass));
461 
462        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
463        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
464        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
465        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
466        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
467        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
468    }
469 
470    public void testModifiedInterface() {
471        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedInterface");
472        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedInterface");
473 
474        assertTrue(strategy.isClassDifferent(oldClass, newClass));
475 
476        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
477        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
478        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
479        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
480        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
481        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
482    }
483 
484    public void testNewInterface() {
485        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.NewInterface");
486        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.NewInterface");
487 
488        assertTrue(strategy.isClassDifferent(oldClass, newClass));
489 
490        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
491        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
492        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
493        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
494        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
495        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
496    }
497 
498    public void testUnmodifiedClass() {
499        Classfile oldClass = getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass");
500        Classfile newClass = getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass");
501 
502        assertFalse(strategy.isClassDifferent(oldClass, newClass));
503 
504        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
505        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
506        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
507        assertEquals("constant", 1, mockStrategy.getConstantValueDifferentCount());
508        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
509        assertEquals("code",     2, mockStrategy.getCodeDifferentCount());
510    }
511 
512    public void testRemovedClass() {
513        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.RemovedClass");
514        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.RemovedClass");
515 
516        assertTrue(strategy.isClassDifferent(oldClass, newClass));
517 
518        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
519        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
520        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
521        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
522        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
523        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
524    }
525 
526    public void testModifiedDeclarationClass() {
527        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedDeclarationClass");
528        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedDeclarationClass");
529 
530        assertTrue(strategy.isClassDifferent(oldClass, newClass));
531 
532        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
533        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
534        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
535        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
536        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
537        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
538    }
539 
540    public void testModifiedClass() {
541        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.ModifiedClass");
542        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.ModifiedClass");
543 
544        assertTrue(strategy.isClassDifferent(oldClass, newClass));
545 
546        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
547        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
548        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
549        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
550        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
551        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
552    }
553 
554    public void testNewClass() {
555        Classfile oldClass = getOldJar().getClassfile("ModifiedPackage.NewClass");
556        Classfile newClass = getNewJar().getClassfile("ModifiedPackage.NewClass");
557 
558        assertTrue(strategy.isClassDifferent(oldClass, newClass));
559 
560        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
561        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
562        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
563        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
564        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
565        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
566    }
567 
568    public void testUnmodifiedPackage() {
569        Map oldPackage = new HashMap();
570        oldPackage.put("UnmodifiedPackage.UnmodifiedClass",     getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
571        oldPackage.put("UnmodifiedPackage.UnmodifiedInterface", getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface"));
572        Map newPackage = new HashMap();
573        newPackage.put("UnmodifiedPackage.UnmodifiedClass",     getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
574        newPackage.put("UnmodifiedPackage.UnmodifiedInterface", getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface"));
575 
576        assertFalse(strategy.isPackageDifferent(oldPackage, newPackage));
577 
578        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
579        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
580        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
581        assertEquals("constant", 2, mockStrategy.getConstantValueDifferentCount());
582        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
583        assertEquals("code",     3, mockStrategy.getCodeDifferentCount());
584    }
585 
586    public void testRemovedPackage() {
587        Map oldPackage = new HashMap();
588        oldPackage.put("RemovedPackage.RemovedClass", getOldJar().getClassfile("RemovedPackage.RemovedClass"));
589        Map newPackage = new HashMap();
590 
591        assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
592 
593        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
594        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
595        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
596        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
597        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
598        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
599    }
600 
601    public void testModifiedPackage() {
602        Map oldPackage = new HashMap();
603        oldPackage.put("UnmodifiedPackage.UnmodifiedClass",     getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
604        oldPackage.put("UnmodifiedPackage.UnmodifiedInterface", getOldJar().getClassfile("UnmodifiedPackage.UnmodifiedInterface"));
605        Map newPackage = new HashMap();
606        newPackage.put("UnmodifiedPackage.UnmodifiedClass",     getNewJar().getClassfile("UnmodifiedPackage.UnmodifiedClass"));
607 
608        assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
609 
610        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
611        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
612        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
613        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
614        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
615        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
616    }
617 
618    public void testModifiedCodePackage() {
619        Map oldPackage = new HashMap();
620        oldPackage.put("ModifiedPackage.ModifiedClass", getOldJar().getClassfile("ModifiedPackage.ModifiedClass"));
621        Map newPackage = new HashMap();
622        newPackage.put("ModifiedPackage.ModifiedClass", getNewJar().getClassfile("ModifiedPackage.ModifiedClass"));
623 
624        assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
625 
626        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
627        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
628        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
629        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
630        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
631        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
632    }
633 
634    public void testNewPackage() {
635        Map oldPackage = new HashMap();
636        Map newPackage = new HashMap();
637        newPackage.put("NewPackage.NewClass", getNewJar().getClassfile("NewPackage.NewClass"));
638 
639        assertTrue(strategy.isPackageDifferent(oldPackage, newPackage));
640 
641        assertEquals("package",  0, mockStrategy.getPackageDifferentCount());
642        assertEquals("class",    0, mockStrategy.getClassDifferentCount());
643        assertEquals("field",    0, mockStrategy.getFieldDifferentCount());
644        assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
645        assertEquals("method",   0, mockStrategy.getMethodDifferentCount());
646        assertEquals("code",     0, mockStrategy.getCodeDifferentCount());
647    }
648}

[all classes][com.jeantessier.diff]
EMMA 2.0.5312 (C) Vladimir Roubtsov