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 }