1 |
| |
2 |
| |
3 |
| |
4 |
| |
5 |
| |
6 |
| |
7 |
| |
8 |
| |
9 |
| |
10 |
| |
11 |
| |
12 |
| |
13 |
| |
14 |
| |
15 |
| |
16 |
| |
17 |
| |
18 |
| |
19 |
| |
20 |
| |
21 |
| |
22 |
| |
23 |
| |
24 |
| |
25 |
| |
26 |
| |
27 |
| |
28 |
| |
29 |
| |
30 |
| |
31 |
| |
32 |
| |
33 |
| package com.jeantessier.diff; |
34 |
| |
35 |
| import java.io.*; |
36 |
| import java.util.*; |
37 |
| |
38 |
| import junit.framework.*; |
39 |
| |
40 |
| import com.jeantessier.classreader.*; |
41 |
| |
42 |
| public class TestIncompatibleDifferenceStrategyWithPublishedAPI extends TestCase { |
43 |
| public static final String OLD_PUBLISHED_CLASSPATH = "tests" + File.separator + "JarJarDiff" + File.separator + "oldpublished"; |
44 |
| public static final String NEW_PUBLISHED_CLASSPATH = "tests" + File.separator + "JarJarDiff" + File.separator + "newpublished"; |
45 |
| |
46 |
| private static PackageMapper oldPublishedPackages; |
47 |
| private static PackageMapper newPublishedPackages; |
48 |
| |
49 |
| private static ClassfileLoader oldPublishedJar; |
50 |
| private static ClassfileLoader newPublishedJar; |
51 |
| |
52 |
1
| public static PackageMapper getOldPublishedPackages() {
|
53 |
1
| if (oldPublishedPackages == null) {
|
54 |
1
| oldPublishedPackages = new PackageMapper();
|
55 |
| } |
56 |
| |
57 |
1
| return oldPublishedPackages;
|
58 |
| } |
59 |
| |
60 |
1
| public static PackageMapper getNewPublishedPackages() {
|
61 |
1
| if (newPublishedPackages == null) {
|
62 |
1
| newPublishedPackages = new PackageMapper();
|
63 |
| } |
64 |
| |
65 |
1
| return newPublishedPackages;
|
66 |
| } |
67 |
| |
68 |
89
| public static ClassfileLoader getOldPublishedJar() {
|
69 |
89
| if (oldPublishedJar == null) {
|
70 |
1
| oldPublishedJar = new AggregatingClassfileLoader();
|
71 |
1
| oldPublishedJar.addLoadListener(getOldPublishedPackages());
|
72 |
1
| oldPublishedJar.load(Collections.singleton(OLD_PUBLISHED_CLASSPATH));
|
73 |
| } |
74 |
| |
75 |
89
| return oldPublishedJar;
|
76 |
| } |
77 |
| |
78 |
89
| public static ClassfileLoader getNewPublishedJar() {
|
79 |
89
| if (newPublishedJar == null) {
|
80 |
1
| newPublishedJar = new AggregatingClassfileLoader();
|
81 |
1
| newPublishedJar.addLoadListener(getNewPublishedPackages());
|
82 |
1
| newPublishedJar.load(Collections.singleton(NEW_PUBLISHED_CLASSPATH));
|
83 |
| } |
84 |
| |
85 |
89
| return newPublishedJar;
|
86 |
| } |
87 |
| |
88 |
| private MockDifferenceStrategy mockStrategy; |
89 |
| private IncompatibleDifferenceStrategy strategy; |
90 |
| |
91 |
89
| protected void setUp() throws Exception {
|
92 |
89
| super.setUp();
|
93 |
| |
94 |
89
| mockStrategy = new MockDifferenceStrategy(new NoDifferenceStrategy());
|
95 |
89
| strategy = new IncompatibleDifferenceStrategy(mockStrategy);
|
96 |
| } |
97 |
| |
98 |
| |
99 |
| |
100 |
| |
101 |
| |
102 |
1
| public void testPublicToPublicClass() {
|
103 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PublicToPublicClass");
|
104 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PublicToPublicClass");
|
105 |
| |
106 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
107 |
| |
108 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
109 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
110 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
111 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
112 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
113 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
114 |
| } |
115 |
| |
116 |
1
| public void testPublicToPackageClass() {
|
117 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PublicToPackageClass");
|
118 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PublicToPackageClass");
|
119 |
| |
120 |
1
| assertTrue(strategy.isClassDifferent(oldClass, newClass));
|
121 |
| |
122 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
123 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
124 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
125 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
126 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
127 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
128 |
| } |
129 |
| |
130 |
1
| public void testPackageToPublicClass() {
|
131 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PackageToPublicClass");
|
132 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PackageToPublicClass");
|
133 |
| |
134 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
135 |
| |
136 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
137 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
138 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
139 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
140 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
141 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
142 |
| } |
143 |
| |
144 |
1
| public void testPackageToPackageClass() {
|
145 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.PackageToPackageClass");
|
146 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.PackageToPackageClass");
|
147 |
| |
148 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
149 |
| |
150 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
151 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
152 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
153 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
154 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
155 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
156 |
| } |
157 |
| |
158 |
1
| public void testClassToClassClass() {
|
159 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ClassToClassClass");
|
160 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ClassToClassClass");
|
161 |
| |
162 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
163 |
| |
164 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
165 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
166 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
167 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
168 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
169 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
170 |
| } |
171 |
| |
172 |
1
| public void testClassToInterfaceClass() {
|
173 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ClassToInterfaceClass");
|
174 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ClassToInterfaceClass");
|
175 |
| |
176 |
1
| assertTrue(strategy.isClassDifferent(oldClass, newClass));
|
177 |
| |
178 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
179 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
180 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
181 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
182 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
183 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
184 |
| } |
185 |
| |
186 |
1
| public void testInterfaceToClassClass() {
|
187 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.InterfaceToClassClass");
|
188 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.InterfaceToClassClass");
|
189 |
| |
190 |
1
| assertTrue(strategy.isClassDifferent(oldClass, newClass));
|
191 |
| |
192 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
193 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
194 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
195 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
196 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
197 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
198 |
| } |
199 |
| |
200 |
1
| public void testInterfaceToInterfaceClass() {
|
201 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.InterfaceToInterfaceClass");
|
202 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.InterfaceToInterfaceClass");
|
203 |
| |
204 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
205 |
| |
206 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
207 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
208 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
209 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
210 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
211 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
212 |
| } |
213 |
| |
214 |
1
| public void testConcreteToConcreteClass() {
|
215 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ConcreteToConcreteClass");
|
216 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ConcreteToConcreteClass");
|
217 |
| |
218 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
219 |
| |
220 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
221 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
222 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
223 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
224 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
225 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
226 |
| } |
227 |
| |
228 |
1
| public void testConcreteToAbstractClass() {
|
229 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.ConcreteToAbstractClass");
|
230 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.ConcreteToAbstractClass");
|
231 |
| |
232 |
1
| assertTrue(strategy.isClassDifferent(oldClass, newClass));
|
233 |
| |
234 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
235 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
236 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
237 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
238 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
239 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
240 |
| } |
241 |
| |
242 |
1
| public void testAbstractToConcreteClass() {
|
243 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.AbstractToConcreteClass");
|
244 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.AbstractToConcreteClass");
|
245 |
| |
246 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
247 |
| |
248 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
249 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
250 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
251 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
252 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
253 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
254 |
| } |
255 |
| |
256 |
1
| public void testAbstractToAbstractClass() {
|
257 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.AbstractToAbstractClass");
|
258 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.AbstractToAbstractClass");
|
259 |
| |
260 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
261 |
| |
262 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
263 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
264 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
265 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
266 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
267 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
268 |
| } |
269 |
| |
270 |
1
| public void testNonFinalToNonFinalClass() {
|
271 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.NonFinalToNonFinalClass");
|
272 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.NonFinalToNonFinalClass");
|
273 |
| |
274 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
275 |
| |
276 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
277 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
278 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
279 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
280 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
281 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
282 |
| } |
283 |
| |
284 |
1
| public void testNonFinalToFinalClass() {
|
285 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.NonFinalToFinalClass");
|
286 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.NonFinalToFinalClass");
|
287 |
| |
288 |
1
| assertTrue(strategy.isClassDifferent(oldClass, newClass));
|
289 |
| |
290 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
291 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
292 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
293 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
294 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
295 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
296 |
| } |
297 |
| |
298 |
1
| public void testFinalToNonFinalClass() {
|
299 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.FinalToNonFinalClass");
|
300 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.FinalToNonFinalClass");
|
301 |
| |
302 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
303 |
| |
304 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
305 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
306 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
307 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
308 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
309 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
310 |
| } |
311 |
| |
312 |
1
| public void testFinalToFinalClass() {
|
313 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.FinalToFinalClass");
|
314 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.FinalToFinalClass");
|
315 |
| |
316 |
1
| assertFalse(strategy.isClassDifferent(oldClass, newClass));
|
317 |
| |
318 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
319 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
320 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
321 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
322 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
323 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
324 |
| } |
325 |
| |
326 |
| |
327 |
| |
328 |
| |
329 |
| |
330 |
1
| public void testPrivateToPrivateField() {
|
331 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPrivateField");
|
332 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPrivateField");
|
333 |
| |
334 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
335 |
| |
336 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
337 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
338 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
339 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
340 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
341 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
342 |
| } |
343 |
| |
344 |
1
| public void testPrivateToProtectedField() {
|
345 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToProtectedField");
|
346 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToProtectedField");
|
347 |
| |
348 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
349 |
| |
350 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
351 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
352 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
353 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
354 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
355 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
356 |
| } |
357 |
| |
358 |
1
| public void testPrivateToPackageField() {
|
359 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPackagedField");
|
360 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPackageField");
|
361 |
| |
362 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
363 |
| |
364 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
365 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
366 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
367 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
368 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
369 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
370 |
| } |
371 |
| |
372 |
1
| public void testPrivateToPublicField() {
|
373 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPublicField");
|
374 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("privateToPublicField");
|
375 |
| |
376 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
377 |
| |
378 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
379 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
380 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
381 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
382 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
383 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
384 |
| } |
385 |
| |
386 |
1
| public void testProtectedToPrivateField() {
|
387 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPrivateField");
|
388 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPrivateField");
|
389 |
| |
390 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
391 |
| |
392 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
393 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
394 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
395 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
396 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
397 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
398 |
| } |
399 |
| |
400 |
1
| public void testProtectedToProtectedField() {
|
401 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToProtectedField");
|
402 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToProtectedField");
|
403 |
| |
404 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
405 |
| |
406 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
407 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
408 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
409 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
410 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
411 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
412 |
| } |
413 |
| |
414 |
1
| public void testProtectedToPackageField() {
|
415 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPackageField");
|
416 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPackageField");
|
417 |
| |
418 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
419 |
| |
420 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
421 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
422 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
423 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
424 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
425 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
426 |
| } |
427 |
| |
428 |
1
| public void testProtectedToPublicField() {
|
429 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPublicField");
|
430 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("protectedToPublicField");
|
431 |
| |
432 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
433 |
| |
434 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
435 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
436 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
437 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
438 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
439 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
440 |
| } |
441 |
| |
442 |
1
| public void testPackageToPrivateField() {
|
443 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPrivateField");
|
444 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPrivateField");
|
445 |
| |
446 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
447 |
| |
448 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
449 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
450 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
451 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
452 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
453 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
454 |
| } |
455 |
| |
456 |
1
| public void testPackageToProtectedField() {
|
457 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToProtectedField");
|
458 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToProtectedField");
|
459 |
| |
460 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
461 |
| |
462 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
463 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
464 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
465 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
466 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
467 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
468 |
| } |
469 |
| |
470 |
1
| public void testPackageToPackageField() {
|
471 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPackagedField");
|
472 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPackageField");
|
473 |
| |
474 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
475 |
| |
476 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
477 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
478 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
479 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
480 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
481 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
482 |
| } |
483 |
| |
484 |
1
| public void testPackageToPublicField() {
|
485 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPublicField");
|
486 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("packageToPublicField");
|
487 |
| |
488 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
489 |
| |
490 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
491 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
492 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
493 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
494 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
495 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
496 |
| } |
497 |
| |
498 |
1
| public void testPublicToPrivateField() {
|
499 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPrivateField");
|
500 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPrivateField");
|
501 |
| |
502 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
503 |
| |
504 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
505 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
506 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
507 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
508 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
509 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
510 |
| } |
511 |
| |
512 |
1
| public void testPublicToProtectedField() {
|
513 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToProtectedField");
|
514 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToProtectedField");
|
515 |
| |
516 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
517 |
| |
518 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
519 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
520 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
521 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
522 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
523 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
524 |
| } |
525 |
| |
526 |
1
| public void testPublicToPackageField() {
|
527 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPackageField");
|
528 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPackageField");
|
529 |
| |
530 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
531 |
| |
532 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
533 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
534 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
535 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
536 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
537 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
538 |
| } |
539 |
| |
540 |
1
| public void testPublicToPublicField() {
|
541 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPublicField");
|
542 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("publicToPublicField");
|
543 |
| |
544 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
545 |
| |
546 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
547 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
548 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
549 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
550 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
551 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
552 |
| } |
553 |
| |
554 |
1
| public void testNonFinalToNonFinalField() {
|
555 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToNonFinalField");
|
556 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToNonFinalField");
|
557 |
| |
558 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
559 |
| |
560 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
561 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
562 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
563 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
564 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
565 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
566 |
| } |
567 |
| |
568 |
1
| public void testNonFinalToFinalField() {
|
569 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToFinalField");
|
570 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("nonFinalToFinalField");
|
571 |
| |
572 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
573 |
| |
574 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
575 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
576 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
577 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
578 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
579 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
580 |
| } |
581 |
| |
582 |
1
| public void testFinalToNonFinalField() {
|
583 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToNonFinalField");
|
584 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToNonFinalField");
|
585 |
| |
586 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
587 |
| |
588 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
589 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
590 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
591 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
592 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
593 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
594 |
| } |
595 |
| |
596 |
1
| public void testFinalToFinalField() {
|
597 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToFinalField");
|
598 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("finalToFinalField");
|
599 |
| |
600 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
601 |
| |
602 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
603 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
604 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
605 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
606 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
607 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
608 |
| } |
609 |
| |
610 |
1
| public void testTypeToSameTypeField() {
|
611 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToSameTypeField");
|
612 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToSameTypeField");
|
613 |
| |
614 |
1
| assertFalse(strategy.isFieldDifferent(oldField, newField));
|
615 |
| |
616 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
617 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
618 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
619 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
620 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
621 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
622 |
| } |
623 |
| |
624 |
1
| public void testTypeToDifferentTypeField() {
|
625 |
1
| Field_info oldField = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToDifferentTypeField");
|
626 |
1
| Field_info newField = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getField("typeToDifferentTypeField");
|
627 |
| |
628 |
1
| assertTrue(strategy.isFieldDifferent(oldField, newField));
|
629 |
| |
630 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
631 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
632 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
633 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
634 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
635 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
636 |
| } |
637 |
| |
638 |
| |
639 |
| |
640 |
| |
641 |
| |
642 |
1
| public void testPrivateToPrivateConstructor() {
|
643 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
|
644 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int)");
|
645 |
| |
646 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
647 |
| |
648 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
649 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
650 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
651 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
652 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
653 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
654 |
| } |
655 |
| |
656 |
1
| public void testPrivateToProtectedConstructor() {
|
657 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long");
|
658 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long)");
|
659 |
| |
660 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
661 |
| |
662 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
663 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
664 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
665 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
666 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
667 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
668 |
| } |
669 |
| |
670 |
1
| public void testPrivateToPackageConstructor() {
|
671 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
|
672 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float)");
|
673 |
| |
674 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
675 |
| |
676 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
677 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
678 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
679 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
680 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
681 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
682 |
| } |
683 |
| |
684 |
1
| public void testPrivateToPublicConstructor() {
|
685 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double)");
|
686 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double)");
|
687 |
| |
688 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
689 |
| |
690 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
691 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
692 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
693 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
694 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
695 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
696 |
| } |
697 |
| |
698 |
1
| public void testProtectedToPrivateConstructor() {
|
699 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int)");
|
700 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int)");
|
701 |
| |
702 |
1
| assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
703 |
| |
704 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
705 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
706 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
707 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
708 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
709 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
710 |
| } |
711 |
| |
712 |
1
| public void testProtectedToProtectedConstructor() {
|
713 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long)");
|
714 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long)");
|
715 |
| |
716 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
717 |
| |
718 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
719 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
720 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
721 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
722 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
723 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
724 |
| } |
725 |
| |
726 |
1
| public void testProtectedToPackageConstructor() {
|
727 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float)");
|
728 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float)");
|
729 |
| |
730 |
1
| assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
731 |
| |
732 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
733 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
734 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
735 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
736 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
737 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
738 |
| } |
739 |
| |
740 |
1
| public void testProtectedToPublicConstructor() {
|
741 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double)");
|
742 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double)");
|
743 |
| |
744 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
745 |
| |
746 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
747 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
748 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
749 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
750 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
751 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
752 |
| } |
753 |
| |
754 |
1
| public void testPackageToPrivateConstructor() {
|
755 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
|
756 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int)");
|
757 |
| |
758 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
759 |
| |
760 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
761 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
762 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
763 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
764 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
765 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
766 |
| } |
767 |
| |
768 |
1
| public void testPackageToProtectedConstructor() {
|
769 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long)");
|
770 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long)");
|
771 |
| |
772 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
773 |
| |
774 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
775 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
776 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
777 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
778 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
779 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
780 |
| } |
781 |
| |
782 |
1
| public void testPackageToPackageConstructor() {
|
783 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float)");
|
784 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float)");
|
785 |
| |
786 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
787 |
| |
788 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
789 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
790 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
791 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
792 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
793 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
794 |
| } |
795 |
| |
796 |
1
| public void testPackageToPublicConstructor() {
|
797 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double)");
|
798 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double)");
|
799 |
| |
800 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
801 |
| |
802 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
803 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
804 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
805 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
806 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
807 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
808 |
| } |
809 |
| |
810 |
1
| public void testPublicToPrivateConstructor() {
|
811 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int)");
|
812 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(int, int, int, int)");
|
813 |
| |
814 |
1
| assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
815 |
| |
816 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
817 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
818 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
819 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
820 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
821 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
822 |
| } |
823 |
| |
824 |
1
| public void testPublicToProtectedConstructor() {
|
825 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long, long)");
|
826 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(long, long, long, long)");
|
827 |
| |
828 |
1
| assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
829 |
| |
830 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
831 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
832 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
833 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
834 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
835 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
836 |
| } |
837 |
| |
838 |
1
| public void testPublicToPackageConstructor() {
|
839 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float, float)");
|
840 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(float, float, float, float)");
|
841 |
| |
842 |
1
| assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
843 |
| |
844 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
845 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
846 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
847 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
848 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
849 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
850 |
| } |
851 |
| |
852 |
1
| public void testPublicToPublicConstructor() {
|
853 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double, double)");
|
854 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(double, double, double, double)");
|
855 |
| |
856 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
857 |
| |
858 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
859 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
860 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
861 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
862 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
863 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
864 |
| } |
865 |
| |
866 |
1
| public void testThrowsToSameThrowsConstructor() {
|
867 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object)");
|
868 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object)");
|
869 |
| |
870 |
1
| assertFalse(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
871 |
| |
872 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
873 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
874 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
875 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
876 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
877 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
878 |
| } |
879 |
| |
880 |
1
| public void testThrowsToDifferentThrowsConstructor() {
|
881 |
1
| Method_info oldConstructor = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object, java.lang.Object)");
|
882 |
1
| Method_info newConstructor = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("ModifiedClass(java.lang.Object, java.lang.Object)");
|
883 |
| |
884 |
1
| assertTrue(strategy.isMethodDifferent(oldConstructor, newConstructor));
|
885 |
| |
886 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
887 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
888 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
889 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
890 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
891 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
892 |
| } |
893 |
| |
894 |
| |
895 |
| |
896 |
| |
897 |
| |
898 |
1
| public void testPrivateToPrivateMethod() {
|
899 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPrivateMethod()");
|
900 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPrivateMethod()");
|
901 |
| |
902 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
903 |
| |
904 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
905 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
906 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
907 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
908 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
909 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
910 |
| } |
911 |
| |
912 |
1
| public void testPrivateToProtectedMethod() {
|
913 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToProtectedMethod()");
|
914 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToProtectedMethod()");
|
915 |
| |
916 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
917 |
| |
918 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
919 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
920 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
921 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
922 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
923 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
924 |
| } |
925 |
| |
926 |
1
| public void testPrivateToPackageMethod() {
|
927 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPackagedMethod()");
|
928 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPackageMethod()");
|
929 |
| |
930 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
931 |
| |
932 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
933 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
934 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
935 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
936 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
937 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
938 |
| } |
939 |
| |
940 |
1
| public void testPrivateToPublicMethod() {
|
941 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPublicMethod()");
|
942 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("privateToPublicMethod()");
|
943 |
| |
944 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
945 |
| |
946 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
947 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
948 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
949 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
950 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
951 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
952 |
| } |
953 |
| |
954 |
1
| public void testProtectedToPrivateMethod() {
|
955 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPrivateMethod()");
|
956 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPrivateMethod()");
|
957 |
| |
958 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
959 |
| |
960 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
961 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
962 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
963 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
964 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
965 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
966 |
| } |
967 |
| |
968 |
1
| public void testProtectedToProtectedMethod() {
|
969 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToProtectedMethod()");
|
970 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToProtectedMethod()");
|
971 |
| |
972 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
973 |
| |
974 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
975 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
976 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
977 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
978 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
979 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
980 |
| } |
981 |
| |
982 |
1
| public void testProtectedToPackageMethod() {
|
983 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPackageMethod()");
|
984 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPackageMethod()");
|
985 |
| |
986 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
987 |
| |
988 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
989 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
990 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
991 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
992 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
993 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
994 |
| } |
995 |
| |
996 |
1
| public void testProtectedToPublicMethod() {
|
997 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPublicMethod()");
|
998 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("protectedToPublicMethod()");
|
999 |
| |
1000 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1001 |
| |
1002 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1003 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1004 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1005 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1006 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1007 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1008 |
| } |
1009 |
| |
1010 |
1
| public void testPackageToPrivateMethod() {
|
1011 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPrivateMethod()");
|
1012 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPrivateMethod()");
|
1013 |
| |
1014 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1015 |
| |
1016 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1017 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1018 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1019 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1020 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1021 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1022 |
| } |
1023 |
| |
1024 |
1
| public void testPackageToProtectedMethod() {
|
1025 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToProtectedMethod()");
|
1026 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToProtectedMethod()");
|
1027 |
| |
1028 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1029 |
| |
1030 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1031 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1032 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1033 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1034 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1035 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1036 |
| } |
1037 |
| |
1038 |
1
| public void testPackageToPackageMethod() {
|
1039 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPackagedMethod()");
|
1040 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPackageMethod()");
|
1041 |
| |
1042 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1043 |
| |
1044 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1045 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1046 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1047 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1048 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1049 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1050 |
| } |
1051 |
| |
1052 |
1
| public void testPackageToPublicMethod() {
|
1053 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPublicMethod()");
|
1054 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("packageToPublicMethod()");
|
1055 |
| |
1056 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1057 |
| |
1058 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1059 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1060 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1061 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1062 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1063 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1064 |
| } |
1065 |
| |
1066 |
1
| public void testPublicToPrivateMethod() {
|
1067 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPrivateMethod()");
|
1068 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPrivateMethod()");
|
1069 |
| |
1070 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1071 |
| |
1072 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1073 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1074 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1075 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1076 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1077 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1078 |
| } |
1079 |
| |
1080 |
1
| public void testPublicToProtectedMethod() {
|
1081 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToProtectedMethod()");
|
1082 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToProtectedMethod()");
|
1083 |
| |
1084 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1085 |
| |
1086 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1087 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1088 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1089 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1090 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1091 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1092 |
| } |
1093 |
| |
1094 |
1
| public void testPublicToPackageMethod() {
|
1095 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPackageMethod()");
|
1096 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPackageMethod()");
|
1097 |
| |
1098 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1099 |
| |
1100 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1101 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1102 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1103 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1104 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1105 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1106 |
| } |
1107 |
| |
1108 |
1
| public void testPublicToPublicMethod() {
|
1109 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPublicMethod()");
|
1110 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("publicToPublicMethod()");
|
1111 |
| |
1112 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1113 |
| |
1114 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1115 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1116 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1117 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1118 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1119 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1120 |
| } |
1121 |
| |
1122 |
1
| public void testConcreteToConcreteMethod() {
|
1123 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToConcreteMethod()");
|
1124 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToConcreteMethod()");
|
1125 |
| |
1126 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1127 |
| |
1128 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1129 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1130 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1131 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1132 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1133 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1134 |
| } |
1135 |
| |
1136 |
1
| public void testConcreteToAbstractMethod() {
|
1137 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToAbstractMethod()");
|
1138 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("concreteToAbstractMethod()");
|
1139 |
| |
1140 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1141 |
| |
1142 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1143 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1144 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1145 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1146 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1147 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1148 |
| } |
1149 |
| |
1150 |
1
| public void testAbstractToConcreteMethod() {
|
1151 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToConcreteMethod()");
|
1152 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToConcreteMethod()");
|
1153 |
| |
1154 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1155 |
| |
1156 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1157 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1158 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1159 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1160 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1161 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1162 |
| } |
1163 |
| |
1164 |
1
| public void testAbstractToAbstractMethod() {
|
1165 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToAbstractMethod()");
|
1166 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("abstractToAbstractMethod()");
|
1167 |
| |
1168 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1169 |
| |
1170 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1171 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1172 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1173 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1174 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1175 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1176 |
| } |
1177 |
| |
1178 |
1
| public void testNonStaticToNonStaticMethod() {
|
1179 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToNonStaticMethod()");
|
1180 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToNonStaticMethod()");
|
1181 |
| |
1182 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1183 |
| |
1184 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1185 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1186 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1187 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1188 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1189 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1190 |
| } |
1191 |
| |
1192 |
1
| public void testNonStaticToStaticMethod() {
|
1193 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToStaticMethod()");
|
1194 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonStaticToStaticMethod()");
|
1195 |
| |
1196 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1197 |
| |
1198 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1199 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1200 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1201 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1202 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1203 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1204 |
| } |
1205 |
| |
1206 |
1
| public void testStaticToNonStaticMethod() {
|
1207 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToNonStaticMethod()");
|
1208 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToNonStaticMethod()");
|
1209 |
| |
1210 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1211 |
| |
1212 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1213 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1214 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1215 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1216 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1217 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1218 |
| } |
1219 |
| |
1220 |
1
| public void testStaticToStaticMethod() {
|
1221 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToStaticMethod()");
|
1222 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("staticToStaticMethod()");
|
1223 |
| |
1224 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1225 |
| |
1226 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1227 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1228 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1229 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1230 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1231 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1232 |
| } |
1233 |
| |
1234 |
1
| public void testNonFinalToNonFinalMethod() {
|
1235 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToNonFinalMethod()");
|
1236 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToNonFinalMethod()");
|
1237 |
| |
1238 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1239 |
| |
1240 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1241 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1242 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1243 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1244 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1245 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1246 |
| } |
1247 |
| |
1248 |
1
| public void testNonFinalToFinalMethod() {
|
1249 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToFinalMethod()");
|
1250 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("nonFinalToFinalMethod()");
|
1251 |
| |
1252 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1253 |
| |
1254 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1255 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1256 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1257 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1258 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1259 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1260 |
| } |
1261 |
| |
1262 |
1
| public void testFinalToNonFinalMethod() {
|
1263 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToNonFinalMethod()");
|
1264 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToNonFinalMethod()");
|
1265 |
| |
1266 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1267 |
| |
1268 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1269 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1270 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1271 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1272 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1273 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1274 |
| } |
1275 |
| |
1276 |
1
| public void testFinalToFinalMethod() {
|
1277 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToFinalMethod()");
|
1278 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("finalToFinalMethod()");
|
1279 |
| |
1280 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1281 |
| |
1282 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1283 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1284 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1285 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1286 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1287 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1288 |
| } |
1289 |
| |
1290 |
1
| public void testReturnTypeToSameReturnTypeMethod() {
|
1291 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToSameReturnTypeMethod()");
|
1292 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToSameReturnTypeMethod()");
|
1293 |
| |
1294 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1295 |
| |
1296 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1297 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1298 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1299 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1300 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1301 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1302 |
| } |
1303 |
| |
1304 |
1
| public void testReturnTypeToDifferentReturnTypeMethod() {
|
1305 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToDifferentReturnTypeMethod()");
|
1306 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("returnTypeToDifferentReturnTypeMethod()");
|
1307 |
| |
1308 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1309 |
| |
1310 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1311 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1312 |
1
| assertEquals("field", 0, mockStrategy.getFieldDifferentCount());
|
1313 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1314 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1315 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1316 |
| } |
1317 |
| |
1318 |
1
| public void testThrowsToSameThrowsMethod() {
|
1319 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToSameThrowsMethod()");
|
1320 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToSameThrowsMethod()");
|
1321 |
| |
1322 |
1
| assertFalse(strategy.isMethodDifferent(oldMethod, newMethod));
|
1323 |
| |
1324 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1325 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1326 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
1327 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1328 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1329 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1330 |
| } |
1331 |
| |
1332 |
1
| public void testThrowsToDifferentThrowsMethod() {
|
1333 |
1
| Method_info oldMethod = getOldPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToDifferentThrowsMethod()");
|
1334 |
1
| Method_info newMethod = getNewPublishedJar().getClassfile("ModifiedPackage.ModifiedClass").getMethod("throwsToDifferentThrowsMethod()");
|
1335 |
| |
1336 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1337 |
| |
1338 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1339 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1340 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
1341 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1342 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1343 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1344 |
| } |
1345 |
| |
1346 |
1
| public void testCompatibleClassWithIncompatibleMethod() {
|
1347 |
1
| Classfile oldClass = getOldPublishedJar().getClassfile("ModifiedPackage.CompatibleClass");
|
1348 |
1
| Classfile newClass = getNewPublishedJar().getClassfile("ModifiedPackage.CompatibleClass");
|
1349 |
| |
1350 |
1
| Method_info oldMethod = oldClass.getMethod("incompatibleMethod()");
|
1351 |
1
| Method_info newMethod = newClass.getMethod("incompatibleMethod()");
|
1352 |
| |
1353 |
1
| assertTrue(strategy.isMethodDifferent(oldMethod, newMethod));
|
1354 |
1
| assertTrue(strategy.isClassDifferent(oldClass, newClass));
|
1355 |
| |
1356 |
1
| assertEquals("package", 0, mockStrategy.getPackageDifferentCount());
|
1357 |
1
| assertEquals("class", 0, mockStrategy.getClassDifferentCount());
|
1358 |
1
| assertEquals("field", 0, mockStrategy.getMethodDifferentCount());
|
1359 |
1
| assertEquals("constant", 0, mockStrategy.getConstantValueDifferentCount());
|
1360 |
1
| assertEquals("method", 0, mockStrategy.getMethodDifferentCount());
|
1361 |
1
| assertEquals("code", 0, mockStrategy.getCodeDifferentCount());
|
1362 |
| } |
1363 |
| } |