KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > refactoring > java > RefactoringTestCase


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */

19
20
21
22 package org.netbeans.modules.refactoring.java;
23
24 import java.io.File JavaDoc;
25 import java.io.IOException JavaDoc;
26 import java.util.Arrays JavaDoc;
27 import java.util.Collection JavaDoc;
28 import java.util.LinkedList JavaDoc;
29 import java.util.List JavaDoc;
30 import java.util.Map JavaDoc;
31 import java.util.TreeMap JavaDoc;
32 import org.netbeans.junit.diff.LineDiff;
33 import org.netbeans.modules.refactoring.api.AbstractRefactoring;
34 import org.netbeans.modules.refactoring.api.Problem;
35 import org.netbeans.modules.refactoring.api.RefactoringElement;
36 import org.netbeans.modules.refactoring.api.RefactoringSession;
37 import org.openide.filesystems.FileObject;
38 import org.openide.filesystems.FileUtil;
39
40 /**
41  *
42  * @author Jiri Prox
43  */

44 public abstract class RefactoringTestCase extends LogTestCase{
45     
46     public interface ParameterSetter {
47         
48         void setParameters();
49     }
50     
51     /**
52      * Map of files involved in refactoring. Files are stored as Strings as FQN + extension.
53      */

54     private Map JavaDoc<String JavaDoc,LinkedList JavaDoc<String JavaDoc>> refactoredFiles;
55     
56     /**
57      * List of source files (and folders) in project before performing refactoring. Names stored as FQN + extension
58      */

59     private List JavaDoc<String JavaDoc> projectSources;
60     
61     /** Creates a new instance of DummyTest
62      * @param name Name of current test
63      */

64     public RefactoringTestCase(String JavaDoc name) {
65         super(name);
66     }
67     
68     protected void addRefactoringElement(RefactoringElement element) {
69         FileObject fo = element.getParentFile();
70         String JavaDoc relPath = getRelativeFileName(fo);
71         if(!refactoredFiles.keySet().contains(relPath)) { //new file
72
try {
73                 File JavaDoc fBackUp = new File JavaDoc(getWorkDir(),getRelativeFileName(fo));
74                 File JavaDoc oFile = FileUtil.toFile(fo);
75                 copyFile(oFile, fBackUp);
76             } catch (IOException JavaDoc ioe) {
77                 fail(ioe.getMessage());
78             }
79             refactoredFiles.put(relPath, new LinkedList JavaDoc<String JavaDoc>());
80         }
81         List JavaDoc<String JavaDoc> list = refactoredFiles.get(relPath);
82         list.add(element.getDisplayText());
83     }
84     
85     protected void dumpRefactoredFiles() {
86         for (String JavaDoc fileName: refactoredFiles.keySet()) {
87             ref(fileName);
88             ref("--------------------");
89             for(String JavaDoc text : refactoredFiles.get(fileName)) {
90                 ref(text);
91             }
92             ref("--------------------");
93             try {
94                 File JavaDoc actualFile = new File JavaDoc(classPathWorkDir,fqn2FilePath(fileName));
95                 File JavaDoc backupedFile = new File JavaDoc(getWorkDir(),fileName);
96                 log("Original file:");
97                 log(backupedFile);
98                 if(!actualFile.exists()) {
99                     ref("File was deleted");
100                 } else {
101                     log("Actual file:");
102                     log(actualFile);
103                     File JavaDoc diff = File.createTempFile("refactoring", null);
104                     LineDiff ldiff = new LineDiff();
105                     ldiff.diff(actualFile,backupedFile, diff);
106                     ref(diff);
107                     diff.delete();
108                 }
109                 ref("\n");
110             } catch (IOException JavaDoc ioe) {
111                 fail(ioe.getMessage());
112             }
113         }
114     }
115     
116     /**
117      * Compares two list of sources and dumps a new files
118      * @param originalSources Original projects sources
119      * @param currentSources New projects sources
120      */

121     protected void dumpNewFiles(List JavaDoc<String JavaDoc> originalSources,List JavaDoc<String JavaDoc> currentSources) {
122         log("Original sources: "+originalSources);
123         log("Current sources: "+currentSources);
124         for (String JavaDoc fileName : currentSources) {
125             if(!originalSources.contains(fileName)) {
126                 File JavaDoc file = new File JavaDoc(classPathWorkDir,fqn2FilePath(fileName));
127                 ref(fileName);
128                 ref("--------------------");
129                 if(file.isDirectory()) ref("Directory created");
130                 else ref(file);
131                 ref("\n");
132             }
133         }
134     }
135     
136     private void dumpDir(File JavaDoc dir, List JavaDoc<String JavaDoc> result) {
137         File JavaDoc[] files = dir.listFiles();
138         Arrays.sort(files);
139         for (int i = 0; i < files.length; i++) {
140             File JavaDoc file = files[i];
141             if(file.getName().startsWith(".")) continue; // skipping hidden files
142
result.add(getRelativeFileName(FileUtil.toFileObject(file)));
143             if(file.isDirectory()) dumpDir(file, result);
144         }
145     }
146     
147     
148     private List JavaDoc<String JavaDoc> getProjectSources() {
149         List JavaDoc<String JavaDoc> list = new LinkedList JavaDoc<String JavaDoc>();
150         dumpDir(classPathWorkDir, list);
151         return list;
152     }
153     
154     
155     
156     private String JavaDoc fqn2FilePath(String JavaDoc pkg) {
157         if(pkg.endsWith(".java")) {
158             String JavaDoc cutExtension = pkg.substring(0, pkg.length()-5);
159             return cutExtension.replace('.', '/')+".java";
160         } else {
161             return pkg.replace('.', '/');
162         }
163     }
164     
165     public boolean perform(AbstractRefactoring absRefactoring, ParameterSetter parameterSetter) {
166         refactoredFiles = new TreeMap JavaDoc<String JavaDoc, LinkedList JavaDoc<String JavaDoc>>();
167         projectSources = getProjectSources();
168         Problem problem = absRefactoring.preCheck();
169         boolean fatal = false;
170         while(problem!=null) {
171             ref.print(problem.getMessage());
172             if(problem.isFatal()) fatal = true;
173             problem = problem.getNext();
174         }
175         if(fatal) return false;
176         parameterSetter.setParameters();
177         problem = absRefactoring.fastCheckParameters();
178         while(problem!=null) {
179             ref.print(problem.getMessage());
180             if(problem.isFatal()) fatal = true;
181             problem = problem.getNext();
182         }
183         if(fatal) return false;
184         problem = absRefactoring.checkParameters();
185         while(problem!=null) {
186             ref.print(problem.getMessage());
187             if(problem.isFatal()) fatal = true;
188             problem = problem.getNext();
189         }
190         if(fatal) return false;
191         RefactoringSession rs = RefactoringSession.create("Session");
192         absRefactoring.prepare(rs);
193         Collection JavaDoc<RefactoringElement> elems = rs.getRefactoringElements();
194         for (RefactoringElement refactoringElement : elems) {
195             addRefactoringElement(refactoringElement);
196         }
197         rs.doRefactoring(true);
198         dumpRefactoredFiles();
199         dumpNewFiles(projectSources, getProjectSources());
200         return true;
201     }
202     
203 }
204
Popular Tags