001: package org.acm.seguin.refactor.type;
002:
003: import java.io.File;
004: import org.acm.seguin.summary.SummaryTraversal;
005: import org.acm.seguin.io.FileCopy;
006: import net.sourceforge.jrefactory.ast.ASTName;
007: import net.sourceforge.jrefactory.ast.ASTUnmodifiedClassDeclaration;
008: import net.sourceforge.jrefactory.ast.ASTClassDeclaration;
009: import net.sourceforge.jrefactory.ast.ASTTypeDeclaration;
010: import net.sourceforge.jrefactory.ast.ASTPackageDeclaration;
011: import net.sourceforge.jrefactory.ast.ASTCompilationUnit;
012: import org.acm.seguin.summary.TypeSummary;
013: import org.acm.seguin.summary.PackageSummary;
014: import org.acm.seguin.summary.query.GetTypeSummary;
015: import org.acm.seguin.junit.FileCompare;
016: import org.acm.seguin.junit.DirSourceTestCase;
017: import org.acm.seguin.refactor.RefactoringException;
018:
019: /**
020: * Unit test for creating a class or adding a parent class
021: *
022: *@author Chris Seguin
023: */
024: public class TestAddAbstractParent extends DirSourceTestCase {
025: /**
026: * Constructor for the TestAddAbstractParent object
027: *
028: *@param name Description of Parameter
029: */
030: public TestAddAbstractParent(String name) {
031: super (name);
032: }
033:
034: /**
035: * A unit test for JUnit
036: *
037: *@exception RefactoringException Description of Exception
038: */
039: public void test01() throws RefactoringException {
040: AddAbstractParent aap = new AddAbstractParent();
041: aap.addChildClass("abstracter", "NormalClass");
042: aap.setParentName("ParentClass");
043:
044: aap.run();
045:
046: File destDir = new File(root + "\\abstracter");
047: File checkDir = new File(check + "\\ut1\\step10");
048: FileCompare.assertEquals("Normal class in error", new File(
049: checkDir, "NormalClass.java"), new File(destDir,
050: "NormalClass.java"));
051: FileCompare.assertEquals("Parent class in error", new File(
052: checkDir, "ParentClass.java"), new File(destDir,
053: "ParentClass.java"));
054:
055: (new File(destDir, "ParentClass.java")).delete();
056: }
057:
058: /**
059: * A unit test for JUnit
060: *
061: *@exception RefactoringException Description of Exception
062: */
063: public void test02() throws RefactoringException {
064: AddAbstractParent aap = new AddAbstractParent();
065: aap.addChildClass("abstracter", "GrandParentClass");
066: aap.setParentName("GreatGrandParentClass");
067:
068: aap.run();
069:
070: File destDir = new File(root + "\\abstracter");
071: File checkDir = new File(check + "\\ut1\\step11");
072: FileCompare.assertEquals("Grand Parent class in error",
073: new File(checkDir, "GrandParentClass.java"), new File(
074: destDir, "GrandParentClass.java"));
075: FileCompare.assertEquals("Great Grand Parent class in error",
076: new File(checkDir, "GreatGrandParentClass.java"),
077: new File(destDir, "GreatGrandParentClass.java"));
078:
079: (new File(destDir, "GreatGrandParentClass.java")).delete();
080: }
081:
082: /**
083: * A unit test for JUnit
084: */
085: public void test03() {
086: CreateClass aap = new CreateClass();
087: aap.setPackageName("abstracter");
088: String parent = "Parent";
089:
090: ASTName grandparent = new ASTName(0);
091: grandparent.addNamePart("GrandParent");
092:
093: ASTUnmodifiedClassDeclaration ucd = aap.createClassBody(parent,
094: grandparent);
095: ASTCompilationUnit rootNode = new ASTCompilationUnit(0);
096: rootNode.jjtAddChild(ucd, 0);
097: aap.print(parent, rootNode);
098:
099: File destDir = new File(root + "\\abstracter");
100: File checkDir = new File(check + "\\ut1\\step12");
101: FileCompare.assertEquals("Normal class in error", new File(
102: checkDir, "AParent.java"), new File(destDir,
103: "Parent.java"));
104:
105: (new File(destDir, "Parent.java")).delete();
106: }
107:
108: /**
109: * A unit test for JUnit
110: */
111: public void test04() {
112: String parent = "Parent";
113: CreateClass aap = new CreateClass(null, parent, true);
114: aap.setPackageName("abstracter");
115:
116: ASTName grandparent = new ASTName(0);
117: grandparent.addNamePart("GrandParent");
118:
119: ASTClassDeclaration ucd = aap.createModifiedClass(grandparent);
120: ASTCompilationUnit rootNode = new ASTCompilationUnit(0);
121: rootNode.jjtAddChild(ucd, 0);
122: aap.print(parent, rootNode);
123:
124: File destDir = new File(root + "\\abstracter");
125: File checkDir = new File(check + "\\ut1\\step12");
126: FileCompare.assertEquals("Normal class in error", new File(
127: checkDir, "BParent.java"), new File(destDir,
128: "Parent.java"));
129:
130: (new File(destDir, "Parent.java")).delete();
131: }
132:
133: /**
134: * A unit test for JUnit
135: */
136: public void test05() {
137: String parent = "Parent";
138: CreateClass aap = new CreateClass(null, parent, true);
139: aap.setPackageName("abstracter");
140:
141: ASTName grandparent = new ASTName(0);
142: grandparent.addNamePart("GrandParent");
143:
144: ASTTypeDeclaration ucd = aap.createTypeDeclaration(grandparent);
145: ASTCompilationUnit rootNode = new ASTCompilationUnit(0);
146: rootNode.jjtAddChild(ucd, 0);
147: aap.print(parent, rootNode);
148:
149: File destDir = new File(root + "\\abstracter");
150: File checkDir = new File(check + "\\ut1\\step12");
151: FileCompare.assertEquals("Normal class in error", new File(
152: checkDir, "CParent.java"), new File(destDir,
153: "Parent.java"));
154:
155: (new File(destDir, "Parent.java")).delete();
156: }
157:
158: /**
159: * A unit test for JUnit
160: */
161: public void test06() {
162: String parent = "Parent";
163:
164: ASTName grandparent = new ASTName(0);
165: grandparent.addNamePart("GrandParent");
166:
167: ASTCompilationUnit rootNode = new ASTCompilationUnit(0);
168:
169: TypeSummary typeSummary = GetTypeSummary.query(PackageSummary
170: .getPackageSummary("abstracter"), "NormalClass");
171: CreateClass aap = new CreateClass(typeSummary, "Parent", true);
172: boolean result = aap.addImportStatement(null, grandparent,
173: rootNode, 0);
174: assertTrue("Not incremented", result);
175: }
176:
177: /**
178: * A unit test for JUnit
179: */
180: public void test08() {
181: String parent = "Parent";
182:
183: TypeSummary typeSummary = GetTypeSummary.query(PackageSummary
184: .getPackageSummary("abstracter"), "NormalClass");
185: CreateClass aap = new CreateClass(typeSummary, parent, true);
186: aap.setPackageName("abstracter");
187:
188: ASTPackageDeclaration ucd = aap.createPackageDeclaration();
189: ASTCompilationUnit rootNode = new ASTCompilationUnit(0);
190: rootNode.jjtAddChild(ucd, 0);
191: aap.print("Package", rootNode);
192:
193: File destDir = new File(root + "\\abstracter");
194: File checkDir = new File(check + "\\ut1\\step12");
195: FileCompare.assertEquals("Normal class in error", new File(
196: checkDir, "EParent.java"), new File(destDir,
197: "Package.java"));
198:
199: (new File(destDir, "Package.java")).delete();
200: }
201:
202: /**
203: * A unit test for JUnit
204: */
205: public void test09() {
206: AddAbstractParent aap = new AddAbstractParent();
207: aap.addChildClass("abstracter", "NameConflict");
208: aap.setParentName("Associate");
209:
210: boolean exceptionThrown = false;
211: try {
212: aap.run();
213: } catch (RefactoringException re) {
214: exceptionThrown = true;
215: }
216:
217: assertTrue("Did not complain about the name conflicts",
218: exceptionThrown);
219: }
220:
221: /**
222: * A unit test for JUnit
223: *
224: *@exception RefactoringException Description of Exception
225: */
226: public void test10() throws RefactoringException {
227: AddAbstractParent aap = new AddAbstractParent();
228: aap.addChildClass("abstracter", "NameConflictClass");
229: aap.setParentName("Associate");
230:
231: aap.run();
232:
233: File destDir = new File(root + "\\abstracter");
234: File checkDir = new File(check + "\\ut1\\step13");
235: File impDir = new File(root + "\\imp");
236:
237: FileCompare.assertEquals("NameConflictClass class in error",
238: new File(checkDir, "NameConflictClass.java"), new File(
239: destDir, "NameConflictClass.java"));
240:
241: FileCompare.assertEquals("Associate class in error", new File(
242: checkDir, "Associate.java"), new File(destDir,
243: "Associate.java"));
244:
245: FileCompare.assertEquals("TypeChecker class in error",
246: new File(checkDir, "TypeChecker.java"), new File(
247: impDir, "TypeChecker.java"));
248:
249: (new File(destDir, "Associate.java")).delete();
250: }
251:
252: /**
253: * A unit test for JUnit
254: *
255: *@exception RefactoringException Description of Exception
256: */
257: public void test11() throws RefactoringException {
258: AddAbstractParent aap = new AddAbstractParent();
259: aap.addChildClass("abstracter", "ChildOne");
260: aap.addChildClass("abstracter", "ChildTwo");
261: aap.setParentName("StepParentClass");
262:
263: aap.run();
264:
265: File destDir = new File(root + "\\abstracter");
266: File checkDir = new File(check + "\\ut1\\step14");
267:
268: FileCompare.assertEquals("ChildOne class in error", new File(
269: checkDir, "ChildOne.java"), new File(destDir,
270: "ChildOne.java"));
271:
272: FileCompare.assertEquals("ChildTwo class in error", new File(
273: checkDir, "ChildTwo.java"), new File(destDir,
274: "ChildTwo.java"));
275:
276: FileCompare.assertEquals("StepParentClass class in error",
277: new File(checkDir, "StepParentClass.java"), new File(
278: destDir, "StepParentClass.java"));
279:
280: (new File(destDir, "StepParentClass.java")).delete();
281: }
282:
283: /**
284: * A unit test for JUnit
285: *
286: *@exception RefactoringException Description of Exception
287: */
288: public void test12() throws RefactoringException {
289: AddAbstractParent aap = new AddAbstractParent();
290: aap.addChildClass("abstracter", "ChildThree");
291: aap.addChildClass("abstracter", "ChildFour");
292: aap.setParentName("StepParentTwoClass");
293:
294: aap.run();
295:
296: File destDir = new File(root + "\\abstracter");
297: File checkDir = new File(check + "\\ut1\\step15");
298:
299: FileCompare.assertEquals("ChildThree class in error", new File(
300: checkDir, "ChildThree.java"), new File(destDir,
301: "ChildThree.java"));
302:
303: FileCompare.assertEquals("ChildFour class in error", new File(
304: checkDir, "ChildFour.java"), new File(destDir,
305: "ChildFour.java"));
306:
307: FileCompare.assertEquals("StepParentTwoClass class in error",
308: new File(checkDir, "StepParentTwoClass.java"),
309: new File(destDir, "StepParentTwoClass.java"));
310:
311: (new File(destDir, "StepParentTwoClass.java")).delete();
312: }
313:
314: /**
315: * A unit test for JUnit
316: */
317: public void test13() {
318: AddAbstractParent aap = new AddAbstractParent();
319: aap.addChildClass("abstracter", "NameConflict");
320: aap.addChildClass("imp", "Associate");
321: aap.setParentName("ValidParentClass");
322:
323: boolean exceptionThrown = false;
324: try {
325: aap.run();
326: } catch (RefactoringException re) {
327: exceptionThrown = true;
328: }
329:
330: assertTrue("Did not complain about the name conflicts",
331: exceptionThrown);
332: }
333:
334: /**
335: * A unit test for JUnit
336: */
337: public void test14() {
338: AddAbstractParent aap = new AddAbstractParent();
339: aap.addChildClass("abstracter", "NameConflict");
340: aap.setParentName("NormalClass");
341:
342: boolean exceptionThrown = false;
343: try {
344: aap.run();
345: } catch (RefactoringException re) {
346: exceptionThrown = true;
347: }
348:
349: assertTrue("Did not complain about the name conflicts",
350: exceptionThrown);
351: }
352:
353: /**
354: * A unit test for JUnit
355: *
356: *@exception RefactoringException Description of Exception
357: */
358: public void test15() throws RefactoringException {
359: String parent = "SampleChild";
360:
361: TypeSummary typeSummary = GetTypeSummary.query(PackageSummary
362: .getPackageSummary("abstracter"), "NormalClass");
363: CreateClass cc = new CreateClass(typeSummary, parent, false);
364: cc.setAbstract(false);
365: cc.run();
366:
367: File destDir = new File(root + "\\abstracter");
368: File checkDir = new File(check + "\\ut1\\step12");
369:
370: FileCompare.assertEquals("Normal class in error", new File(
371: checkDir, "AChild.java"), new File(destDir,
372: "SampleChild.java"));
373:
374: (new File(destDir, "SampleChild.java")).delete();
375: }
376:
377: /**
378: * A unit test for JUnit
379: *
380: *@exception RefactoringException Description of Exception
381: */
382: public void test16() throws RefactoringException {
383: File cleanDir = new File(clean);
384: File destDir = new File(root + "\\abstracter");
385: File impDir = new File(root + "\\imp");
386:
387: (new FileCopy(new File(cleanDir, "ExtraParentClass.java"),
388: new File(impDir, "ExtraParentClass.java"), false))
389: .run();
390:
391: (new FileCopy(new File(cleanDir, "ExtraNormalClass.java"),
392: new File(destDir, "ExtraNormalClass.java"), false))
393: .run();
394:
395: (new SummaryTraversal(root)).run();
396:
397: AddAbstractParent aap = new AddAbstractParent();
398: aap.addChildClass("abstracter", "ExtraNormalClass");
399: aap.setParentName("ExtraLocalParent");
400:
401: aap.run();
402:
403: File checkDir = new File(check + "\\ut1\\step21");
404:
405: FileCompare.assertEquals("ExtraParentClass in error", new File(
406: checkDir, "ExtraParentClass.java"), new File(impDir,
407: "ExtraParentClass.java"));
408:
409: FileCompare.assertEquals("ExtraNormalClass in error", new File(
410: checkDir, "ExtraNormalClass.java"), new File(destDir,
411: "ExtraNormalClass.java"));
412:
413: FileCompare.assertEquals("ExtraLocalParent in error", new File(
414: checkDir, "ExtraLocalParent.java"), new File(destDir,
415: "ExtraLocalParent.java"));
416:
417: (new File(impDir, "ExtraParentClass.java")).delete();
418: (new File(destDir, "ExtraNormalClass.java")).delete();
419: (new File(destDir, "ExtraLocalParent.java")).delete();
420: }
421:
422: /**
423: * The JUnit setup method
424: */
425: protected void setUp() {
426: File cleanDir = new File(clean);
427: File destDir = new File(root + "\\abstracter");
428: File impDir = new File(root + "\\imp");
429:
430: (new FileCopy(new File(cleanDir, "GrandParentClass.java"),
431: new File(destDir, "GrandParentClass.java"), false))
432: .run();
433:
434: (new FileCopy(new File(cleanDir, "NormalClass.java"), new File(
435: destDir, "NormalClass.java"), false)).run();
436:
437: (new FileCopy(new File(cleanDir, "TypeChecker.java"), new File(
438: impDir, "TypeChecker.java"), false)).run();
439:
440: (new FileCopy(new File(cleanDir, "NameConflict.java"),
441: new File(destDir, "NameConflict.java"), false)).run();
442:
443: (new FileCopy(new File(cleanDir, "NameConflictClass.java"),
444: new File(destDir, "NameConflictClass.java"), false))
445: .run();
446:
447: (new FileCopy(new File(cleanDir, "ChildOne.java"), new File(
448: destDir, "ChildOne.java"), false)).run();
449:
450: (new FileCopy(new File(cleanDir, "ChildTwo.java"), new File(
451: destDir, "ChildTwo.java"), false)).run();
452:
453: (new FileCopy(new File(cleanDir, "ChildThree.java"), new File(
454: destDir, "ChildThree.java"), false)).run();
455:
456: (new FileCopy(new File(cleanDir, "ChildFour.java"), new File(
457: destDir, "ChildFour.java"), false)).run();
458:
459: (new SummaryTraversal(root)).run();
460: }
461:
462: /**
463: * The teardown method for JUnit
464: */
465: protected void tearDown() {
466: File destDir = new File(root + "\\abstracter");
467: File problemChild = new File(destDir, "Associate.java");
468: if (problemChild.exists()) {
469: problemChild.delete();
470: }
471:
472: File impDir = new File(root + "\\imp");
473:
474: (new File(destDir, "GrandParentClass.java")).delete();
475: (new File(destDir, "NormalClass.java")).delete();
476: (new File(impDir, "TypeChecker.java")).delete();
477: (new File(destDir, "NameConflict.java")).delete();
478: (new File(destDir, "NameConflictClass.java")).delete();
479: (new File(destDir, "ChildOne.java")).delete();
480: (new File(destDir, "ChildTwo.java")).delete();
481: (new File(destDir, "ChildThree.java")).delete();
482: (new File(destDir, "ChildFour.java")).delete();
483: }
484: }
|