Continue setting up tests (compiler server).
[idea/community.git] / jps / jps-builders / testSrc / org / jetbrains / ether / IncrementalTestCase.java
1 /*
2  * Copyright 2000-2012 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.jetbrains.ether;
17
18 import com.intellij.openapi.diagnostic.Logger;
19 import com.intellij.openapi.util.SystemInfo;
20 import com.intellij.openapi.util.io.FileUtil;
21 import junit.framework.TestCase;
22 import junitx.framework.FileAssert;
23 import org.apache.log4j.Level;
24 import org.apache.log4j.PropertyConfigurator;
25 import org.jetbrains.annotations.NonNls;
26 import org.jetbrains.annotations.Nullable;
27 import org.jetbrains.jps.Project;
28 import org.jetbrains.jps.api.CanceledStatus;
29 import org.jetbrains.jps.idea.IdeaProjectLoader;
30 import org.jetbrains.jps.incremental.AllProjectScope;
31 import org.jetbrains.jps.incremental.BuilderRegistry;
32 import org.jetbrains.jps.incremental.FSState;
33 import org.jetbrains.jps.incremental.IncProjectBuilder;
34 import org.jetbrains.jps.incremental.storage.BuildDataManager;
35 import org.jetbrains.jps.incremental.storage.ProjectTimestamps;
36 import org.jetbrains.jps.server.ProjectDescriptor;
37
38 import java.io.*;
39 import java.util.Properties;
40
41 /**
42  * Created by IntelliJ IDEA.
43  * User: db
44  * Date: 26.07.11
45  * Time: 0:34
46  * To change this template use File | Settings | File Templates.
47  */
48 public abstract class IncrementalTestCase extends TestCase {
49   private static class RootStripper {
50     private String root;
51
52     void setRoot(final String root) {
53       this.root = root;
54     }
55
56     String strip(final String s) {
57       if (s.startsWith(root)) {
58         return s.substring(root.length());
59       }
60
61       return s;
62     }
63   }
64
65   static {
66     Logger.setFactory(new Logger.Factory() {
67       @Override
68       public Logger getLoggerInstance(String category) {
69         final org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(category);
70
71         final boolean affectedLogger = category.equals("#org.jetbrains.jps.incremental.java.JavaBuilder") ||
72                                        category.equals("#org.jetbrains.jps.incremental.IncProjectBuilder");
73
74         return new Logger() {
75           @Override
76           public boolean isDebugEnabled() {
77             return affectedLogger;
78           }
79
80           @Override
81           public void debug(@NonNls String message) {
82           }
83
84           @Override
85           public void debug(@Nullable Throwable t) {
86           }
87
88           @Override
89           public void debug(@NonNls String message, @Nullable Throwable t) {
90           }
91
92           @Override
93           public void error(@NonNls String message, @Nullable Throwable t, @NonNls String... details) {
94           }
95
96           @Override
97           public void info(@NonNls String message) {
98             if (affectedLogger) {
99               logger.info(stripper.strip(message));
100             }
101           }
102
103           @Override
104           public void info(@NonNls String message, @Nullable Throwable t) {
105           }
106
107           @Override
108           public void warn(@NonNls String message, @Nullable Throwable t) {
109           }
110
111           @Override
112           public void setLevel(Level level) {
113           }
114         };
115       }
116     });
117   }
118
119   private static RootStripper stripper = new RootStripper();
120
121   private final String groupName;
122   private final String tempDir = FileUtil.toSystemDependentName(new File(System.getProperty("java.io.tmpdir")).getCanonicalPath());
123
124   private String baseDir;
125   private String workDir;
126
127   protected IncrementalTestCase(final String name) throws Exception {
128     super(name);
129     groupName = name;
130   }
131
132   @Override
133   protected void setUp() throws Exception {
134     super.setUp();
135
136     baseDir = "jps/testData" + File.separator + "incremental" + File.separator;
137
138     for (int i = 0; ; i++) {
139       final File tmp = new File(tempDir + File.separator + "__temp__" + i);
140       if (tmp.mkdir()) {
141         workDir = tmp.getPath() + File.separator;
142         break;
143       }
144     }
145
146     FileUtil.copyDir(new File(getBaseDir()), new File(getWorkDir()));
147   }
148
149   @Override
150   protected void tearDown() throws Exception {
151     super.tearDown();
152     //delete(new File(workDir));
153   }
154
155   private String getProjectName() {
156     final String name = getName();
157
158     assert (name.startsWith("test"));
159
160     return Character.toLowerCase(name.charAt("test".length())) + name.substring("test".length() + 1);
161   }
162
163   private String getDir(final String prefix) {
164     return prefix + groupName + File.separator + getProjectName();
165   }
166
167   private String getBaseDir() {
168     return getDir(baseDir);
169   }
170
171   private String getWorkDir() {
172     return getDir(workDir);
173   }
174
175   private static void delete(final File file) throws Exception {
176     if (file.isDirectory()) {
177       final File[] files = file.listFiles();
178
179       if (files != null) {
180         for (File f : files) {
181           delete(f);
182         }
183       }
184     }
185
186     if (!file.delete()) throw new IOException("could not delete file or directory " + file.getPath());
187   }
188
189   private static void copy(final File input, final File output) throws Exception {
190     if (input.isDirectory()) {
191       if (output.mkdirs()) {
192         final File[] files = input.listFiles();
193
194         if (files != null) {
195           for (File f : files) {
196             copy(f, new File(output.getPath() + File.separator + f.getName()));
197           }
198         }
199       }
200       else {
201         throw new IOException("unable to create directory " + output.getPath());
202       }
203     }
204     else if (input.isFile()) {
205       final FileReader in = new FileReader(input);
206       final FileWriter out = new FileWriter(output);
207
208       try {
209         int c;
210         while ((c = in.read()) != -1) out.write(c);
211       }
212       finally {
213         in.close();
214         out.close();
215       }
216     }
217   }
218
219   private void modify() throws Exception {
220     final File dir = new File(getBaseDir());
221     final File[] files = dir.listFiles(new FileFilter() {
222       public boolean accept(final File pathname) {
223         final String name = pathname.getName();
224
225         return name.endsWith(".java.new") || name.endsWith(".java.remove");
226       }
227     });
228
229     for (File input : files) {
230       final String name = input.getName();
231
232       final boolean copy = name.endsWith(".java.new");
233       final String postfix = name.substring(0, name.length() - (copy ? ".new" : ".remove").length());
234       final int pathSep = postfix.indexOf("$");
235       final String basename = pathSep == -1 ? postfix : postfix.substring(pathSep + 1);
236       final String path =
237         getWorkDir() + File.separator + (pathSep == -1 ? "src" : postfix.substring(0, pathSep).replace('-', File.separatorChar));
238       final File output = new File(path + File.separator + basename);
239
240       if (copy) {
241         copy(input, output);
242       }
243       else {
244         output.delete();
245       }
246     }
247   }
248
249   private void initLoggers() {
250     final Properties properties = new Properties();
251
252     properties.setProperty("log4j.rootCategory", "INFO, A1");
253     properties.setProperty("log4j.appender.A1", "org.apache.log4j.FileAppender");
254     properties.setProperty("log4j.appender.A1.file", getWorkDir() + ".log");
255     properties.setProperty("log4j.appender.A1.layout", "org.apache.log4j.PatternLayout");
256     properties.setProperty("log4j.appender.A1.layout.ConversionPattern", "%m%n");
257
258     PropertyConfigurator.configure(properties);
259   }
260
261   public void doTest() throws Exception {
262     stripper.setRoot(FileUtil.toSystemIndependentName(getWorkDir() + File.separator));
263
264     initLoggers();
265
266     final String projectPath = getWorkDir() + File.separator + ".idea";
267     final String projectName = getProjectName();
268     final Project project = new Project();
269
270     IdeaProjectLoader.loadFromPath(project, projectPath, "");
271
272     final ProjectDescriptor projectDescriptor =
273       new ProjectDescriptor(projectPath, project, new FSState(true), new ProjectTimestamps(projectName),
274                             new BuildDataManager(projectName, true));
275     final IncProjectBuilder builder = new IncProjectBuilder(projectDescriptor, BuilderRegistry.getInstance(), CanceledStatus.NULL);
276
277     builder.build(new AllProjectScope(project, true), false, true);
278
279     if (SystemInfo.isUnix) {
280       Thread.sleep(1000);
281     }
282
283     modify();
284
285     builder.build(new AllProjectScope(project, false), true, false);
286
287     projectDescriptor.release();
288
289     FileAssert.assertEquals(new File(getBaseDir() + ".log"), new File(getWorkDir() + ".log"));
290   }
291 }