001: /*
002: * Copyright (c) 2001-2007, Jean Tessier
003: * All rights reserved.
004: *
005: * Redistribution and use in source and binary forms, with or without
006: * modification, are permitted provided that the following conditions
007: * are met:
008: *
009: * * Redistributions of source code must retain the above copyright
010: * notice, this list of conditions and the following disclaimer.
011: *
012: * * Redistributions in binary form must reproduce the above copyright
013: * notice, this list of conditions and the following disclaimer in the
014: * documentation and/or other materials provided with the distribution.
015: *
016: * * Neither the name of Jean Tessier nor the names of his contributors
017: * may be used to endorse or promote products derived from this software
018: * without specific prior written permission.
019: *
020: * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
021: * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
022: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
023: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
024: * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
025: * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
026: * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
027: * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
028: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
029: * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
030: * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
031: */
032:
033: package com.jeantessier.diff;
034:
035: import java.io.*;
036:
037: import com.jeantessier.classreader.*;
038:
039: public class TestDifferencesFactory extends TestDifferencesFactoryBase {
040: private ProjectDifferences projectDifferences;
041:
042: protected void setUp() throws Exception {
043: super .setUp();
044:
045: DifferencesFactory factory = new DifferencesFactory();
046: projectDifferences = (ProjectDifferences) factory
047: .createProjectDifferences("test", "old",
048: getOldPackages(), "new", getNewPackages());
049: }
050:
051: public void testEmptyJars() throws IOException {
052: DifferencesFactory factory = new DifferencesFactory();
053: ProjectDifferences emptyDifferences = (ProjectDifferences) factory
054: .createProjectDifferences("test", "old",
055: new PackageMapper(), "new", new PackageMapper());
056:
057: assertEquals("name", "test", emptyDifferences.getName());
058: assertEquals("old version", "old", emptyDifferences
059: .getOldVersion());
060: assertEquals("new version", "new", emptyDifferences
061: .getNewVersion());
062:
063: assertEquals("NbPackageDifferences: "
064: + projectDifferences.getPackageDifferences(), 3,
065: projectDifferences.getPackageDifferences().size());
066: }
067:
068: public void testModifiedPackage() {
069: String name = "ModifiedPackage";
070: PackageDifferences differences = (PackageDifferences) find(
071: name, projectDifferences.getPackageDifferences());
072: assertNotNull(name, differences);
073:
074: assertEquals(name, differences.getName());
075: assertEquals(name + ".ClassDifferences: "
076: + differences.getClassDifferences(), 13, differences
077: .getClassDifferences().size());
078: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
079: assertTrue(name + ".IsModified()", differences.isModified());
080: assertTrue(name + ".IsNew()", !differences.isNew());
081: }
082:
083: public void testNewPackage() {
084: String name = "NewPackage";
085: PackageDifferences differences = (PackageDifferences) find(
086: name, projectDifferences.getPackageDifferences());
087: assertNotNull(name, differences);
088:
089: assertEquals(name, differences.getName());
090: assertEquals(name + ".ClassDifferences: "
091: + differences.getClassDifferences(), 0, differences
092: .getClassDifferences().size());
093: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
094: assertTrue(name + ".IsModified()", !differences.isModified());
095: assertTrue(name + ".IsNew()", differences.isNew());
096: }
097:
098: public void testRemovedPackage() {
099: String name = "RemovedPackage";
100: PackageDifferences differences = (PackageDifferences) find(
101: name, projectDifferences.getPackageDifferences());
102: assertNotNull(name, differences);
103:
104: assertEquals(name, differences.getName());
105: assertEquals(name + ".ClassDifferences: "
106: + differences.getClassDifferences(), 0, differences
107: .getClassDifferences().size());
108: assertTrue(name + ".IsRemoved()", differences.isRemoved());
109: assertTrue(name + ".IsModified()", !differences.isModified());
110: assertTrue(name + ".IsNew()", !differences.isNew());
111: }
112:
113: public void testDeprecatedClass() {
114: String packageName = "ModifiedPackage";
115: PackageDifferences packageDifferences = (PackageDifferences) find(
116: packageName, projectDifferences.getPackageDifferences());
117:
118: String name = packageName + ".DeprecatedClass";
119: DeprecatableDifferences deprecatableDifferences = (DeprecatableDifferences) find(
120: name, packageDifferences.getClassDifferences());
121: ClassDifferences differences = (ClassDifferences) deprecatableDifferences
122: .getComponent();
123: assertNotNull(name, differences);
124:
125: assertTrue(name + ".NewDeprecation()", deprecatableDifferences
126: .isNewDeprecation());
127: assertTrue(name + ".RemovedDeprecation()",
128: !deprecatableDifferences.isRemovedDeprecation());
129:
130: assertEquals(name, differences.getName());
131: assertEquals(name + ".FeatureDifferences", 0, differences
132: .getFeatureDifferences().size());
133: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
134: assertTrue(name + ".IsModified()", !differences.isModified());
135: assertTrue(name + ".IsNew()", !differences.isNew());
136: }
137:
138: public void testModifiedClass() {
139: String packageName = "ModifiedPackage";
140: PackageDifferences packageDifferences = (PackageDifferences) find(
141: packageName, projectDifferences.getPackageDifferences());
142:
143: String name = packageName + ".ModifiedClass";
144: ClassDifferences differences = (ClassDifferences) find(name,
145: packageDifferences.getClassDifferences());
146: assertNotNull(name, differences);
147:
148: assertEquals(name, differences.getName());
149: assertEquals(name + ".FeatureDifferences", 17, differences
150: .getFeatureDifferences().size());
151: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
152: assertTrue(name + ".IsModified()", differences.isModified());
153: assertTrue(name + ".IsNew()", !differences.isNew());
154: }
155:
156: public void testModifiedInterface() {
157: String packageName = "ModifiedPackage";
158: PackageDifferences packageDifferences = (PackageDifferences) find(
159: packageName, projectDifferences.getPackageDifferences());
160:
161: String name = packageName + ".ModifiedInterface";
162: ClassDifferences differences = (ClassDifferences) find(name,
163: packageDifferences.getClassDifferences());
164: assertNotNull(name, differences);
165:
166: assertEquals(name, differences.getName());
167: assertEquals(name + ".FeatureDifferences", 11, differences
168: .getFeatureDifferences().size());
169: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
170: assertTrue(name + ".IsModified()", differences.isModified());
171: assertTrue(name + ".IsNew()", !differences.isNew());
172: }
173:
174: public void testNewClass() {
175: String packageName = "ModifiedPackage";
176: PackageDifferences packageDifferences = (PackageDifferences) find(
177: packageName, projectDifferences.getPackageDifferences());
178:
179: String name = packageName + ".NewClass";
180: ClassDifferences differences = (ClassDifferences) find(name,
181: packageDifferences.getClassDifferences());
182: assertNotNull(name, differences);
183:
184: assertEquals(name, differences.getName());
185: assertEquals(name + ".FeatureDifferences", 0, differences
186: .getFeatureDifferences().size());
187: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
188: assertTrue(name + ".IsModified()", !differences.isModified());
189: assertTrue(name + ".IsNew()", differences.isNew());
190: }
191:
192: public void testNewInterface() {
193: String packageName = "ModifiedPackage";
194: PackageDifferences packageDifferences = (PackageDifferences) find(
195: packageName, projectDifferences.getPackageDifferences());
196:
197: String name = packageName + ".NewInterface";
198: ClassDifferences differences = (ClassDifferences) find(name,
199: packageDifferences.getClassDifferences());
200: assertNotNull(name, differences);
201:
202: assertEquals(name, differences.getName());
203: assertEquals(name + ".FeatureDifferences", 0, differences
204: .getFeatureDifferences().size());
205: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
206: assertTrue(name + ".IsModified()", !differences.isModified());
207: assertTrue(name + ".IsNew()", differences.isNew());
208: }
209:
210: public void testRemovedClass() {
211: String packageName = "ModifiedPackage";
212: PackageDifferences packageDifferences = (PackageDifferences) find(
213: packageName, projectDifferences.getPackageDifferences());
214:
215: String name = packageName + ".RemovedClass";
216: ClassDifferences differences = (ClassDifferences) find(name,
217: packageDifferences.getClassDifferences());
218: assertNotNull(name, differences);
219:
220: assertEquals(name, differences.getName());
221: assertEquals(name + ".FeatureDifferences", 0, differences
222: .getFeatureDifferences().size());
223: assertTrue(name + ".IsRemoved()", differences.isRemoved());
224: assertTrue(name + ".IsModified()", !differences.isModified());
225: assertTrue(name + ".IsNew()", !differences.isNew());
226: }
227:
228: public void testRemovedInterface() {
229: String packageName = "ModifiedPackage";
230: PackageDifferences packageDifferences = (PackageDifferences) find(
231: packageName, projectDifferences.getPackageDifferences());
232:
233: String name = packageName + ".RemovedInterface";
234: ClassDifferences differences = (ClassDifferences) find(name,
235: packageDifferences.getClassDifferences());
236: assertNotNull(name, differences);
237:
238: assertEquals(name, differences.getName());
239: assertEquals(name + ".FeatureDifferences", 0, differences
240: .getFeatureDifferences().size());
241: assertTrue(name + ".IsRemoved()", differences.isRemoved());
242: assertTrue(name + ".IsModified()", !differences.isModified());
243: assertTrue(name + ".IsNew()", !differences.isNew());
244: }
245:
246: public void testUndeprecatedClass() {
247: String packageName = "ModifiedPackage";
248: PackageDifferences packageDifferences = (PackageDifferences) find(
249: packageName, projectDifferences.getPackageDifferences());
250:
251: String name = packageName + ".UndeprecatedClass";
252: DeprecatableDifferences deprecatableDifferences = (DeprecatableDifferences) find(
253: name, packageDifferences.getClassDifferences());
254: ClassDifferences differences = (ClassDifferences) deprecatableDifferences
255: .getComponent();
256: assertNotNull(name, differences);
257:
258: assertTrue(name + ".NewDeprecation()", !deprecatableDifferences
259: .isNewDeprecation());
260: assertTrue(name + ".RemovedDeprecation()",
261: deprecatableDifferences.isRemovedDeprecation());
262:
263: assertEquals(name, differences.getName());
264: assertEquals(name + ".FeatureDifferences", 0, differences
265: .getFeatureDifferences().size());
266: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
267: assertTrue(name + ".IsModified()", !differences.isModified());
268: assertTrue(name + ".IsNew()", !differences.isNew());
269: }
270:
271: public void testModifiedClassModifiedField() {
272: String packageName = "ModifiedPackage";
273: PackageDifferences packageDifferences = (PackageDifferences) find(
274: packageName, projectDifferences.getPackageDifferences());
275:
276: String className = packageName + ".ModifiedClass";
277: ClassDifferences classDifferences = (ClassDifferences) find(
278: className, packageDifferences.getClassDifferences());
279:
280: String name = className + ".modifiedField";
281: FieldDifferences differences = (FieldDifferences) find(name,
282: classDifferences.getFeatureDifferences());
283: assertNotNull(name, differences);
284:
285: assertEquals(name, differences.getName());
286: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
287: assertTrue(name + ".IsModified()", differences.isModified());
288: assertTrue(name + ".IsNew()", !differences.isNew());
289: }
290:
291: public void testModifiedClassNewField() {
292: String packageName = "ModifiedPackage";
293: PackageDifferences packageDifferences = (PackageDifferences) find(
294: packageName, projectDifferences.getPackageDifferences());
295:
296: String className = packageName + ".ModifiedClass";
297: ClassDifferences classDifferences = (ClassDifferences) find(
298: className, packageDifferences.getClassDifferences());
299:
300: String name = className + ".newField";
301: FieldDifferences differences = (FieldDifferences) find(name,
302: classDifferences.getFeatureDifferences());
303: assertNotNull(name, differences);
304:
305: assertEquals(name, differences.getName());
306: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
307: assertTrue(name + ".IsModified()", !differences.isModified());
308: assertTrue(name + ".IsNew()", differences.isNew());
309: }
310:
311: public void testModifiedClassRemovedField() {
312: String packageName = "ModifiedPackage";
313: PackageDifferences packageDifferences = (PackageDifferences) find(
314: packageName, projectDifferences.getPackageDifferences());
315:
316: String className = packageName + ".ModifiedClass";
317: ClassDifferences classDifferences = (ClassDifferences) find(
318: className, packageDifferences.getClassDifferences());
319:
320: String name = className + ".removedField";
321: FieldDifferences differences = (FieldDifferences) find(name,
322: classDifferences.getFeatureDifferences());
323: assertNotNull(name, differences);
324:
325: assertEquals(name, differences.getName());
326: assertTrue(name + ".IsRemoved()", differences.isRemoved());
327: assertTrue(name + ".IsModified()", !differences.isModified());
328: assertTrue(name + ".IsNew()", !differences.isNew());
329: }
330:
331: public void testModifiedClassModifiedConstructor() {
332: String packageName = "ModifiedPackage";
333: PackageDifferences packageDifferences = (PackageDifferences) find(
334: packageName, projectDifferences.getPackageDifferences());
335:
336: String className = packageName + ".ModifiedClass";
337: ClassDifferences classDifferences = (ClassDifferences) find(
338: className, packageDifferences.getClassDifferences());
339:
340: String name = className + ".ModifiedClass(int, int, int)";
341: ConstructorDifferences differences = (ConstructorDifferences) find(
342: name, classDifferences.getFeatureDifferences());
343: assertNotNull(name + " not in "
344: + classDifferences.getFeatureDifferences(), differences);
345:
346: assertEquals(name, differences.getName());
347: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
348: assertTrue(name + ".IsModified()", differences.isModified());
349: assertTrue(name + ".IsNew()", !differences.isNew());
350: }
351:
352: public void testModifiedClassModifiedCodeConstructor() {
353: String packageName = "ModifiedPackage";
354: PackageDifferences packageDifferences = (PackageDifferences) find(
355: packageName, projectDifferences.getPackageDifferences());
356:
357: String className = packageName + ".ModifiedClass";
358: ClassDifferences classDifferences = (ClassDifferences) find(
359: className, packageDifferences.getClassDifferences());
360:
361: String name = className + ".ModifiedClass(float)";
362: ConstructorDifferences differences = (ConstructorDifferences) find(
363: name, classDifferences.getFeatureDifferences());
364: assertNotNull(name + " not in "
365: + classDifferences.getFeatureDifferences(), differences);
366:
367: assertEquals(name, differences.getName());
368: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
369: assertTrue(name + ".IsModified()", differences.isModified());
370: assertTrue(name + ".IsNew()", !differences.isNew());
371: }
372:
373: public void testModifiedClassNewConstructor() {
374: String packageName = "ModifiedPackage";
375: PackageDifferences packageDifferences = (PackageDifferences) find(
376: packageName, projectDifferences.getPackageDifferences());
377:
378: String className = packageName + ".ModifiedClass";
379: ClassDifferences classDifferences = (ClassDifferences) find(
380: className, packageDifferences.getClassDifferences());
381:
382: String name = className
383: + ".ModifiedClass(int, int, int, int, int, int)";
384: ConstructorDifferences differences = (ConstructorDifferences) find(
385: name, classDifferences.getFeatureDifferences());
386: assertNotNull(name + " not in "
387: + classDifferences.getFeatureDifferences(), differences);
388:
389: assertEquals(name, differences.getName());
390: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
391: assertTrue(name + ".IsModified()", !differences.isModified());
392: assertTrue(name + ".IsNew()", differences.isNew());
393: }
394:
395: public void testModifiedClassRemovedConstructor() {
396: String packageName = "ModifiedPackage";
397: PackageDifferences packageDifferences = (PackageDifferences) find(
398: packageName, projectDifferences.getPackageDifferences());
399:
400: String className = packageName + ".ModifiedClass";
401: ClassDifferences classDifferences = (ClassDifferences) find(
402: className, packageDifferences.getClassDifferences());
403:
404: String name = className + ".ModifiedClass()";
405: ConstructorDifferences differences = (ConstructorDifferences) find(
406: name, classDifferences.getFeatureDifferences());
407: assertNotNull(name + " not in "
408: + classDifferences.getFeatureDifferences(), differences);
409:
410: assertEquals(name, differences.getName());
411: assertTrue(name + ".IsRemoved()", differences.isRemoved());
412: assertTrue(name + ".IsModified()", !differences.isModified());
413: assertTrue(name + ".IsNew()", !differences.isNew());
414: }
415:
416: public void testModifiedClassModifiedMethod() {
417: String packageName = "ModifiedPackage";
418: PackageDifferences packageDifferences = (PackageDifferences) find(
419: packageName, projectDifferences.getPackageDifferences());
420:
421: String className = packageName + ".ModifiedClass";
422: ClassDifferences classDifferences = (ClassDifferences) find(
423: className, packageDifferences.getClassDifferences());
424:
425: String name = className + ".modifiedMethod()";
426: MethodDifferences differences = (MethodDifferences) find(name,
427: classDifferences.getFeatureDifferences());
428: assertNotNull(name, differences);
429:
430: assertEquals(name, differences.getName());
431: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
432: assertTrue(name + ".IsModified()", differences.isModified());
433: assertTrue(name + ".IsNew()", !differences.isNew());
434: }
435:
436: public void testModifiedClassModifiedCodeMethod() {
437: String packageName = "ModifiedPackage";
438: PackageDifferences packageDifferences = (PackageDifferences) find(
439: packageName, projectDifferences.getPackageDifferences());
440:
441: String className = packageName + ".ModifiedClass";
442: ClassDifferences classDifferences = (ClassDifferences) find(
443: className, packageDifferences.getClassDifferences());
444:
445: String name = className + ".modifiedCodeMethod()";
446: MethodDifferences differences = (MethodDifferences) find(name,
447: classDifferences.getFeatureDifferences());
448: assertNotNull(name, differences);
449:
450: assertEquals(name, differences.getName());
451: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
452: assertTrue(name + ".IsModified()", differences.isModified());
453: assertTrue(name + ".IsNew()", !differences.isNew());
454: }
455:
456: public void testModifiedClassNewMethod() {
457: String packageName = "ModifiedPackage";
458: PackageDifferences packageDifferences = (PackageDifferences) find(
459: packageName, projectDifferences.getPackageDifferences());
460:
461: String className = packageName + ".ModifiedClass";
462: ClassDifferences classDifferences = (ClassDifferences) find(
463: className, packageDifferences.getClassDifferences());
464:
465: String name = className + ".newMethod()";
466: MethodDifferences differences = (MethodDifferences) find(name,
467: classDifferences.getFeatureDifferences());
468: assertNotNull(name, differences);
469:
470: assertEquals(name, differences.getName());
471: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
472: assertTrue(name + ".IsModified()", !differences.isModified());
473: assertTrue(name + ".IsNew()", differences.isNew());
474: }
475:
476: public void testModifiedClassRemovedMethod() {
477: String packageName = "ModifiedPackage";
478: PackageDifferences packageDifferences = (PackageDifferences) find(
479: packageName, projectDifferences.getPackageDifferences());
480:
481: String className = packageName + ".ModifiedClass";
482: ClassDifferences classDifferences = (ClassDifferences) find(
483: className, packageDifferences.getClassDifferences());
484:
485: String name = className + ".removedMethod()";
486: MethodDifferences differences = (MethodDifferences) find(name,
487: classDifferences.getFeatureDifferences());
488: assertNotNull(name, differences);
489:
490: assertEquals(name, differences.getName());
491: assertTrue(name + ".IsRemoved()", differences.isRemoved());
492: assertTrue(name + ".IsModified()", !differences.isModified());
493: assertTrue(name + ".IsNew()", !differences.isNew());
494: }
495:
496: public void testModifiedInterfaceModifiedField() {
497: String packageName = "ModifiedPackage";
498: PackageDifferences packageDifferences = (PackageDifferences) find(
499: packageName, projectDifferences.getPackageDifferences());
500:
501: String className = packageName + ".ModifiedInterface";
502: ClassDifferences classDifferences = (ClassDifferences) find(
503: className, packageDifferences.getClassDifferences());
504:
505: String name = className + ".modifiedField";
506: FieldDifferences differences = (FieldDifferences) find(name,
507: classDifferences.getFeatureDifferences());
508: assertNotNull(name, differences);
509:
510: assertEquals(name, differences.getName());
511: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
512: assertTrue(name + ".IsModified()", differences.isModified());
513: assertTrue(name + ".IsNew()", !differences.isNew());
514: }
515:
516: public void testModifiedInterfaceNewField() {
517: String packageName = "ModifiedPackage";
518: PackageDifferences packageDifferences = (PackageDifferences) find(
519: packageName, projectDifferences.getPackageDifferences());
520:
521: String className = packageName + ".ModifiedInterface";
522: ClassDifferences classDifferences = (ClassDifferences) find(
523: className, packageDifferences.getClassDifferences());
524:
525: String name = className + ".newField";
526: FieldDifferences differences = (FieldDifferences) find(name,
527: classDifferences.getFeatureDifferences());
528: assertNotNull(name, differences);
529:
530: assertEquals(name, differences.getName());
531: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
532: assertTrue(name + ".IsModified()", !differences.isModified());
533: assertTrue(name + ".IsNew()", differences.isNew());
534: }
535:
536: public void testModifiedInterfaceRemovedField() {
537: String packageName = "ModifiedPackage";
538: PackageDifferences packageDifferences = (PackageDifferences) find(
539: packageName, projectDifferences.getPackageDifferences());
540:
541: String className = packageName + ".ModifiedInterface";
542: ClassDifferences classDifferences = (ClassDifferences) find(
543: className, packageDifferences.getClassDifferences());
544:
545: String name = className + ".removedField";
546: FieldDifferences differences = (FieldDifferences) find(name,
547: classDifferences.getFeatureDifferences());
548: assertNotNull(name, differences);
549:
550: assertEquals(name, differences.getName());
551: assertTrue(name + ".IsRemoved()", differences.isRemoved());
552: assertTrue(name + ".IsModified()", !differences.isModified());
553: assertTrue(name + ".IsNew()", !differences.isNew());
554: }
555:
556: public void testModifiedInterfaceModifiedMethod() {
557: String packageName = "ModifiedPackage";
558: PackageDifferences packageDifferences = (PackageDifferences) find(
559: packageName, projectDifferences.getPackageDifferences());
560:
561: String className = packageName + ".ModifiedInterface";
562: ClassDifferences classDifferences = (ClassDifferences) find(
563: className, packageDifferences.getClassDifferences());
564:
565: String name = className + ".modifiedMethod()";
566: FeatureDifferences differences = (FeatureDifferences) find(
567: name, classDifferences.getFeatureDifferences());
568: assertNotNull(name, differences);
569:
570: assertEquals(name, differences.getName());
571: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
572: assertTrue(name + ".IsModified()", differences.isModified());
573: assertTrue(name + ".IsNew()", !differences.isNew());
574: }
575:
576: public void testModifiedInterfaceNewMethod() {
577: String packageName = "ModifiedPackage";
578: PackageDifferences packageDifferences = (PackageDifferences) find(
579: packageName, projectDifferences.getPackageDifferences());
580:
581: String className = packageName + ".ModifiedInterface";
582: ClassDifferences classDifferences = (ClassDifferences) find(
583: className, packageDifferences.getClassDifferences());
584:
585: String name = className + ".newMethod()";
586: FeatureDifferences differences = (FeatureDifferences) find(
587: name, classDifferences.getFeatureDifferences());
588: assertNotNull(name, differences);
589:
590: assertEquals(name, differences.getName());
591: assertTrue(name + ".IsRemoved()", !differences.isRemoved());
592: assertTrue(name + ".IsModified()", !differences.isModified());
593: assertTrue(name + ".IsNew()", differences.isNew());
594: }
595:
596: public void testModifiedInterfaceRemovedMethod() {
597: String packageName = "ModifiedPackage";
598: PackageDifferences packageDifferences = (PackageDifferences) find(
599: packageName, projectDifferences.getPackageDifferences());
600:
601: String className = packageName + ".ModifiedInterface";
602: ClassDifferences classDifferences = (ClassDifferences) find(
603: className, packageDifferences.getClassDifferences());
604:
605: String name = className + ".removedMethod()";
606: FeatureDifferences differences = (FeatureDifferences) find(
607: name, classDifferences.getFeatureDifferences());
608: assertNotNull(name, differences);
609:
610: assertEquals(name, differences.getName());
611: assertTrue(name + ".IsRemoved()", differences.isRemoved());
612: assertTrue(name + ".IsModified()", !differences.isModified());
613: assertTrue(name + ".IsNew()", !differences.isNew());
614: }
615: }
|