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 | 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 | } |