001: package org.acm.seguin.refactor.type;
002:
003: import java.io.File;
004: import org.acm.seguin.io.FileCopy;
005: import org.acm.seguin.junit.FileCompare;
006: import org.acm.seguin.junit.DirSourceTestCase;
007: import org.acm.seguin.refactor.RefactoringException;
008:
009: /**
010: * Runs the unit tests for repackaging and renaming types
011: *
012: *@author Chris Seguin
013: */
014: public class TestRepackage extends DirSourceTestCase {
015: private File checkDir;
016:
017: /**
018: * Constructor for the TestRepackage object
019: *
020: *@param name Description of Parameter
021: */
022: public TestRepackage(String name) {
023: super (name);
024: }
025:
026: /**
027: * The first unit test
028: *
029: *@exception RefactoringException Description of Exception
030: */
031: public void test01() throws RefactoringException {
032: // First Step
033: MoveClass moveClass = new MoveClass();
034: moveClass.setDirectory(root);
035: moveClass.setDestinationPackage("test");
036: moveClass.add("TestClass.java");
037: moveClass.run();
038:
039: checkRelevantFiles("step1");
040:
041: // The second step
042: moveClass = new MoveClass();
043: moveClass.setDirectory(root + "\\test");
044: moveClass.setDestinationPackage("experiment");
045: moveClass.add("TestClass.java");
046: moveClass.run();
047:
048: (new File(root + "\\test")).delete();
049:
050: checkRelevantFiles("step2");
051:
052: // The third step
053: moveClass = new MoveClass();
054: moveClass.setDirectory(root + "\\experiment");
055: moveClass.setDestinationPackage("");
056: moveClass.add("TestClass.java");
057: moveClass.run();
058:
059: (new File(root + "\\experiment")).delete();
060:
061: checkRelevantFiles("step3");
062: RenameClassRefactoring renameClass = new RenameClassRefactoring();
063: renameClass.setDirectory(root + "\\ren");
064: renameClass.setOldClassName("NoOutsideReferences");
065: renameClass.setNewClassName("LocalizedObject");
066: renameClass.run();
067:
068: // Copy the files
069: checkRelevantFiles("step4");
070:
071: // The fifth step
072: renameClass = new RenameClassRefactoring();
073: renameClass.setDirectory(root + "\\ren");
074: renameClass.setOldClassName("SimpleRename");
075: renameClass.setNewClassName("TestState");
076: renameClass.run();
077:
078: // Copy the files
079: checkRelevantFiles("step5");
080:
081: // The sixth step
082: renameClass = new RenameClassRefactoring();
083: renameClass.setDirectory(root + "\\ren");
084: renameClass.setOldClassName("SimpleNameConflict");
085: renameClass.setNewClassName("AccessClassVar");
086: renameClass.run();
087:
088: checkRelevantFiles("step6");
089:
090: // The seventh step
091: renameClass = new RenameClassRefactoring();
092: renameClass.setDirectory(root + "\\ren");
093: renameClass.setOldClassName("ComplexNameConflict");
094: renameClass.setNewClassName("Associate");
095: renameClass.run();
096:
097: checkRelevantFiles("step7");
098:
099: (new File(root + "\\ren\\LocalizedObject.java")).delete();
100: (new File(root + "\\ren\\TestState.java")).delete();
101: (new File(root + "\\ren\\AccessClassVar.java")).delete();
102: (new File(root + "\\ren\\Associate.java")).delete();
103:
104: }
105:
106: /**
107: * A unit test for JUnit
108: *
109: *@exception RefactoringException Description of Exception
110: */
111: public void test2() throws RefactoringException {
112: File source = new File(clean);
113: File orig = new File(root + "\\src");
114: File dest = new File(root + "\\dest");
115: checkDir = new File(check + "\\ut1\\step22");
116: source.mkdirs();
117: (new FileCopy(new File(source, "src_MovingClass.java"),
118: new File(orig, "MovingClass.java"), false)).run();
119: (new FileCopy(new File(source, "src_HoldingClass.java"),
120: new File(orig, "HoldingClass.java"), false)).run();
121:
122: MoveClass moveClass = new MoveClass();
123: moveClass.setDirectory(root + "\\src");
124: moveClass.setDestinationPackage("dest");
125: moveClass.add("MovingClass.java");
126: moveClass.run();
127:
128: FileCompare.assertEquals("Comparing file MovingClass",
129: new File(checkDir, "MovingClass.java"), new File(dest,
130: "MovingClass.java"));
131:
132: (new File(dest, "MovingClass.java")).delete();
133: (new File(orig, "HoldingClass.java")).delete();
134: }
135:
136: /**
137: * The JUnit setup method
138: */
139: protected void setUp() {
140: // Setup
141: (new FileCopy(new File(clean + "\\TestClass.java"), new File(
142: root + "\\TestClass.java"), false)).run();
143: (new FileCopy(new File(clean + "\\AssociateTwo.java"),
144: new File(root + "\\AssociateTwo.java"), false)).run();
145: (new FileCopy(new File(clean + "\\Nonassociate.java"),
146: new File(root + "\\Nonassociate.java"), false)).run();
147: (new FileCopy(new File(clean + "\\Associate.java"), new File(
148: root + "\\imp\\Associate.java"), false)).run();
149: (new FileCopy(new File(clean + "\\AccessClassVar.java"),
150: new File(root + "\\imp\\AccessClassVar.java"), false))
151: .run();
152: (new FileCopy(new File(clean + "\\AssociateThree.java"),
153: new File(root + "\\imp\\AssociateThree.java"), false))
154: .run();
155: (new FileCopy(new File(clean + "\\AssociateFour.java"),
156: new File(root + "\\imp\\AssociateFour.java"), false))
157: .run();
158: (new FileCopy(new File(clean + "\\TypeChecker.java"), new File(
159: root + "\\imp\\TypeChecker.java"), false)).run();
160: (new FileCopy(new File(clean + "\\Factory.java"), new File(root
161: + "\\imp\\Factory.java"), false)).run();
162: (new FileCopy(new File(clean + "\\ClassAccess.java"), new File(
163: root + "\\imp\\ClassAccess.java"), false)).run();
164: (new FileCopy(new File(clean + "\\AllocTest.java"), new File(
165: root + "\\direct\\AllocTest.java"), false)).run();
166: (new FileCopy(new File(clean + "\\StaticField.java"), new File(
167: root + "\\direct\\StaticField.java"), false)).run();
168: (new FileCopy(new File(clean + "\\StaticMethod.java"),
169: new File(root + "\\direct\\StaticMethod.java"), false))
170: .run();
171: (new FileCopy(new File(clean + "\\OtherType1.java"), new File(
172: root + "\\direct\\OtherType1.java"), false)).run();
173: (new FileCopy(new File(clean + "\\OtherType2.java"), new File(
174: root + "\\direct\\OtherType2.java"), false)).run();
175: (new FileCopy(new File(clean + "\\NoOutsideReferences.java"),
176: new File(root + "\\ren\\NoOutsideReferences.java"),
177: false)).run();
178: (new FileCopy(new File(clean + "\\SimpleRename.java"),
179: new File(root + "\\ren\\SimpleRename.java"), false))
180: .run();
181: (new FileCopy(new File(clean + "\\SimpleNameConflict.java"),
182: new File(root + "\\ren\\SimpleNameConflict.java"),
183: false)).run();
184: (new FileCopy(new File(clean + "\\ComplexNameConflict.java"),
185: new File(root + "\\ren\\ComplexNameConflict.java"),
186: false)).run();
187: }
188:
189: /**
190: * The teardown method for JUnit
191: */
192: protected void tearDown() {
193: }
194:
195: /**
196: * Gets the FirstRename attribute of the TestRepackage object
197: *
198: *@param step Description of Parameter
199: *@return The FirstRename value
200: */
201: private String getFirstRename(String step) {
202: String index = step.substring(4);
203: int indexValue = 0;
204: try {
205: indexValue = Integer.parseInt(index);
206: } catch (NumberFormatException nfe) {
207: }
208:
209: if (indexValue >= 4) {
210: return "LocalizedObject";
211: } else {
212: return "NoOutsideReferences";
213: }
214: }
215:
216: /**
217: * Gets the SecondRename attribute of the TestRepackage object
218: *
219: *@param step Description of Parameter
220: *@return The SecondRename value
221: */
222: private String getSecondRename(String step) {
223: String index = step.substring(4);
224: int indexValue = 0;
225: try {
226: indexValue = Integer.parseInt(index);
227: } catch (NumberFormatException nfe) {
228: }
229:
230: if (indexValue >= 5) {
231: return "TestState";
232: } else {
233: return "SimpleRename";
234: }
235: }
236:
237: /**
238: * Gets the ThirdRename attribute of the TestRepackage object
239: *
240: *@param step Description of Parameter
241: *@param dest Description of Parameter
242: *@return The ThirdRename value
243: */
244: private String getThirdRename(String step, boolean dest) {
245: String index = step.substring(4);
246: int indexValue = 0;
247: try {
248: indexValue = Integer.parseInt(index);
249: } catch (NumberFormatException nfe) {
250: }
251:
252: if (indexValue >= 6) {
253: if (dest) {
254: return "AccessClassVar_ren";
255: }
256: return "AccessClassVar";
257: } else {
258: return "SimpleNameConflict";
259: }
260: }
261:
262: /**
263: * Gets the FourthRename attribute of the TestRepackage object
264: *
265: *@param step Description of Parameter
266: *@param dest Description of Parameter
267: *@return The FourthRename value
268: */
269: private String getFourthRename(String step, boolean dest) {
270: String index = step.substring(4);
271: int indexValue = 0;
272: try {
273: indexValue = Integer.parseInt(index);
274: } catch (NumberFormatException nfe) {
275: }
276:
277: if (indexValue >= 7) {
278: if (dest) {
279: return "Associate_ren";
280: }
281: return "Associate";
282: } else {
283: return "ComplexNameConflict";
284: }
285: }
286:
287: /**
288: * Gets the TestClassDir attribute of the TestRepackage object
289: *
290: *@param step Description of Parameter
291: *@return The TestClassDir value
292: */
293: private String getTestClassDir(String step) {
294: if (step.equals("step1")) {
295: return "\\test";
296: } else if (step.equals("step2")) {
297: return "\\experiment";
298: }
299:
300: return "";
301: }
302:
303: /**
304: * Description of the Method
305: *
306: *@param step Description of Parameter
307: */
308: private void checkRelevantFiles(String step) {
309: String check = this .check + "\\ut1\\" + step;
310:
311: // COPY Files
312: FileCompare.assertEquals("Comparing file TestClass in " + step,
313: new File(check + "\\TestClass.java"), new File(root
314: + getTestClassDir(step) + "\\TestClass.java"));
315: FileCompare.assertEquals("Comparing file Associate in " + step,
316: new File(check + "\\Associate.java"), new File(root
317: + "\\imp\\Associate.java"));
318: FileCompare.assertEquals("Comparing file AssociateTwo in "
319: + step, new File(check + "\\AssociateTwo.java"),
320: new File(root + "\\AssociateTwo.java"));
321: FileCompare.assertEquals("Comparing file AccessClassVar in "
322: + step, new File(check + "\\AccessClassVar.java"),
323: new File(root + "\\imp\\AccessClassVar.java"));
324: FileCompare.assertEquals("Comparing file TypeChecker in "
325: + step, new File(check + "\\TypeChecker.java"),
326: new File(root + "\\imp\\TypeChecker.java"));
327: FileCompare.assertEquals("Comparing file ClassAccess in "
328: + step, new File(check + "\\ClassAccess.java"),
329: new File(root + "\\imp\\ClassAccess.java"));
330: FileCompare.assertEquals("Comparing file Factory in " + step,
331: new File(check + "\\Factory.java"), new File(root
332: + "\\imp\\Factory.java"));
333: FileCompare.assertEquals("Comparing file AllocTest in " + step,
334: new File(check + "\\AllocTest.java"), new File(root
335: + "\\direct\\AllocTest.java"));
336: FileCompare.assertEquals("Comparing file StaticField in "
337: + step, new File(check + "\\StaticField.java"),
338: new File(root + "\\direct\\StaticField.java"));
339: FileCompare.assertEquals("Comparing file StaticMethod in "
340: + step, new File(check + "\\StaticMethod.java"),
341: new File(root + "\\direct\\StaticMethod.java"));
342: FileCompare.assertEquals(
343: "Comparing file OtherType1 in " + step, new File(check
344: + "\\OtherType1.java"), new File(root
345: + "\\direct\\OtherType1.java"));
346: FileCompare.assertEquals(
347: "Comparing file OtherType2 in " + step, new File(check
348: + "\\OtherType2.java"), new File(root
349: + "\\direct\\OtherType2.java"));
350: FileCompare.assertEquals("Comparing file "
351: + getFirstRename(step) + " in " + step, new File(check
352: + "\\" + getFirstRename(step) + ".java"), new File(root
353: + "\\ren\\" + getFirstRename(step) + ".java"));
354: FileCompare.assertEquals("Comparing file "
355: + getSecondRename(step) + " in " + step, new File(check
356: + "\\" + getSecondRename(step) + ".java"), new File(
357: root + "\\ren\\" + getSecondRename(step) + ".java"));
358: FileCompare.assertEquals("Comparing file "
359: + getThirdRename(step, false) + " in " + step,
360: new File(check + "\\" + getThirdRename(step, true)
361: + ".java"), new File(root + "\\ren\\"
362: + getThirdRename(step, false) + ".java"));
363: FileCompare.assertEquals("Comparing file "
364: + getFourthRename(step, false) + " in " + step,
365: new File(check + "\\" + getFourthRename(step, true)
366: + ".java"), new File(root + "\\ren\\"
367: + getFourthRename(step, false) + ".java"));
368: }
369: }
|