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