plugins/groovy/test/org/jetbrains/plugins/groovy/lang/GroovyCompilerTestCase.java

   1 package org.jetbrains.plugins.groovy.lang;
   2
   3 import com.intellij.compiler.CompilerManagerImpl;
   4 import com.intellij.execution.ExecutionException;
   5 import com.intellij.execution.Executor;
   6 import com.intellij.execution.application.ApplicationConfiguration;
   7 import com.intellij.execution.application.ApplicationConfigurationType;
   8 import com.intellij.execution.configurations.RunnerSettings;
   9 import com.intellij.execution.executors.DefaultRunExecutor;
  10 import com.intellij.execution.impl.DefaultJavaProgramRunner;
  11 import com.intellij.execution.process.ProcessAdapter;
  12 import com.intellij.execution.process.ProcessEvent;
  13 import com.intellij.execution.process.ProcessHandler;
  14 import com.intellij.execution.process.ProcessOutputTypes;
  15 import com.intellij.execution.runners.ExecutionEnvironment;
  16 import com.intellij.execution.runners.ProgramRunner;
  17 import com.intellij.execution.ui.RunContentDescriptor;
  18 import com.intellij.ide.DataManager;
  19 import com.intellij.openapi.application.ApplicationManager;
  20 import com.intellij.openapi.application.ModalityState;
  21 import com.intellij.openapi.application.PathManager;
  22 import com.intellij.openapi.application.Result;
  23 import com.intellij.openapi.command.WriteCommandAction;
  24 import com.intellij.openapi.compiler.*;
  25 import com.intellij.openapi.module.ModifiableModuleModel;
  26 import com.intellij.openapi.module.Module;
  27 import com.intellij.openapi.module.ModuleManager;
  28 import com.intellij.openapi.module.StdModuleTypes;
  29 import com.intellij.openapi.roots.*;
  30 import com.intellij.openapi.util.JDOMExternalizable;
  31 import com.intellij.openapi.util.Key;
  32 import com.intellij.openapi.util.text.StringUtil;
  33 import com.intellij.openapi.vfs.VfsUtil;
  34 import com.intellij.openapi.vfs.VirtualFile;
  35 import com.intellij.psi.PsiFile;
  36 import com.intellij.testFramework.PsiTestUtil;
  37 import com.intellij.testFramework.builders.JavaModuleFixtureBuilder;
  38 import com.intellij.testFramework.fixtures.JavaCodeInsightFixtureTestCase;
  39 import com.intellij.testFramework.fixtures.TempDirTestFixture;
  40 import com.intellij.testFramework.fixtures.impl.TempDirTestFixtureImpl;
  41 import com.intellij.util.ObjectUtils;
  42 import com.intellij.util.concurrency.Semaphore;
  43 import org.jetbrains.plugins.groovy.compiler.GroovyCompilerLoader;
  44 import org.jetbrains.plugins.groovy.config.GroovyConfigUtils;
  45 import org.jetbrains.plugins.groovy.util.GroovyUtils;
  46
  47 import java.io.File;
  48 import java.io.IOException;
  49 import java.util.ArrayList;
  50 import java.util.List;
  51
  52 /**
  53  * @author peter
  54  */
  55 public abstract class GroovyCompilerTestCase extends JavaCodeInsightFixtureTestCase {
  56   private TempDirTestFixture myMainOutput;
  57
  58   @Override
  59   protected void setUp() throws Exception {
  60     myMainOutput = new TempDirTestFixtureImpl();
  61     myMainOutput.setUp();
  62     super.setUp();
  63     getProject().getComponent(GroovyCompilerLoader.class).projectOpened();
  64     CompilerManagerImpl.testSetup();
  65
  66     CompilerProjectExtension.getInstance(getProject()).setCompilerOutputUrl(myMainOutput.findOrCreateDir("out").getUrl());
  67
  68     addGroovyLibrary(myModule);
  69   }
  70
  71   @Override
  72   protected void tuneFixture(JavaModuleFixtureBuilder moduleBuilder) throws Exception {
  73     moduleBuilder.setMockJdkLevel(JavaModuleFixtureBuilder.MockJdkLevel.jdk15);
  74     super.tuneFixture(moduleBuilder);
  75   }
  76
  77   protected static void addGroovyLibrary(final Module to) {
  78     final String root = PathManager.getHomePath() + "/community/lib/";
  79     final File[] groovyJars = GroovyUtils.getFilesInDirectoryByPattern(root, GroovyConfigUtils.GROOVY_ALL_JAR_PATTERN);
  80     assert groovyJars.length == 1;
  81     PsiTestUtil.addLibrary(to, "groovy", root, groovyJars[0].getName());
  82   }
  83
  84   @Override
  85   protected void tearDown() throws Exception {
  86     myMainOutput.tearDown();
  87     myMainOutput = null;
  88     super.tearDown();
  89   }
  90
  91   protected void setupTestSources() {
  92     new WriteCommandAction(getProject()) {
  93       protected void run(Result result) throws Throwable {
  94         final ModuleRootManager rootManager = ModuleRootManager.getInstance(myModule);
  95         final ModifiableRootModel rootModel = rootManager.getModifiableModel();
  96         final ContentEntry entry = rootModel.getContentEntries()[0];
  97         entry.removeSourceFolder(entry.getSourceFolders()[0]);
  98         entry.addSourceFolder(myFixture.getTempDirFixture().findOrCreateDir("src"), false);
  99         entry.addSourceFolder(myFixture.getTempDirFixture().findOrCreateDir("tests"), true);
 100         rootModel.commit();
 101       }
 102     }.execute();
 103   }
 104
 105   protected Module addDependentModule() {
 106     Module dep = new WriteCommandAction<Module>(getProject()) {
 107       @Override
 108       protected void run(Result<Module> result) throws Throwable {
 109         final ModifiableModuleModel moduleModel = ModuleManager.getInstance(getProject()).getModifiableModel();
 110         moduleModel.newModule("dependent/dependent.iml", StdModuleTypes.JAVA);
 111         moduleModel.commit();
 112
 113         final Module dep = ModuleManager.getInstance(getProject()).findModuleByName("dependent");
 114         final ModifiableRootModel model = ModuleRootManager.getInstance(dep).getModifiableModel();
 115         model.addModuleOrderEntry(myModule);
 116         final VirtualFile depRoot = myFixture.getTempDirFixture().getFile("dependent");
 117         final ContentEntry entry = model.addContentEntry(depRoot);
 118         entry.addSourceFolder(depRoot, false);
 119         model.setSdk(ModuleRootManager.getInstance(myModule).getSdk());
 120
 121         //model.getModuleExtension(CompilerModuleExtension.class).inheritCompilerOutputPath(true);
 122
 123         model.commit();
 124         result.setResult(dep);
 125       }
 126     }.execute().getResultObject();
 127     return dep;
 128   }
 129
 130   protected void deleteClassFile(final String className) throws IOException {
 131     new WriteCommandAction(getProject()) {
 132       protected void run(Result result) throws Throwable {
 133         final CompilerModuleExtension extension = ModuleRootManager.getInstance(myModule).getModuleExtension(CompilerModuleExtension.class);
 134         //noinspection ConstantConditions
 135         extension.getCompilerOutputPath().findChild(className + ".class").delete(this);
 136       }
 137     }.execute();
 138   }
 139
 140   protected static void touch(VirtualFile file) throws IOException {
 141     file.setBinaryContent(file.contentsToByteArray(), file.getModificationStamp() + 1, file.getTimeStamp() + 1);
 142   }
 143
 144   protected static void setFileText(final PsiFile file, final String barText) throws IOException {
 145     Runnable runnable = new Runnable() {
 146       public void run() {
 147         try {
 148           VfsUtil.saveText(ObjectUtils.assertNotNull(file.getVirtualFile()), barText);
 149         }
 150         catch (IOException e) {
 151           throw new RuntimeException(e);
 152         }
 153       }
 154     };
 155     ApplicationManager.getApplication().invokeAndWait(runnable, ModalityState.NON_MODAL);
 156
 157   }
 158
 159   protected void setFileName(final PsiFile bar, final String name) {
 160     new WriteCommandAction(getProject()) {
 161       protected void run(Result result) throws Throwable {
 162         bar.setName(name);
 163       }
 164     }.execute();
 165   }
 166
 167   protected List<String> make() {
 168     final Semaphore semaphore = new Semaphore();
 169     semaphore.down();
 170     final ErrorReportingCallback callback = new ErrorReportingCallback(semaphore);
 171     CompilerManager.getInstance(getProject()).make(callback);
 172     semaphore.waitFor();
 173     callback.throwException();
 174     return callback.getMessages();
 175   }
 176
 177   protected void assertOutput(String className, String output) throws ExecutionException {
 178     assertOutput(className, output, myModule);
 179   }
 180
 181   protected void assertOutput(String className, String output, final Module module) throws ExecutionException {
 182     final ApplicationConfiguration configuration =
 183       new ApplicationConfiguration("app", getProject(), ApplicationConfigurationType.getInstance());
 184     configuration.setModule(module);
 185     configuration.setMainClassName(className);
 186     final DefaultRunExecutor extension = Executor.EXECUTOR_EXTENSION_NAME.findExtension(DefaultRunExecutor.class);
 187     final ExecutionEnvironment environment = new ExecutionEnvironment(configuration, new RunnerSettings<JDOMExternalizable>(null, null),null, DataManager
 188       .getInstance().getDataContext());
 189     final DefaultJavaProgramRunner runner = ProgramRunner.PROGRAM_RUNNER_EP.findExtension(DefaultJavaProgramRunner.class);
 190     final StringBuffer sb = new StringBuffer();
 191     final Semaphore semaphore = new Semaphore();
 192     semaphore.down();
 193     runner.execute(extension, environment, new ProgramRunner.Callback() {
 194       public void processStarted(RunContentDescriptor descriptor) {
 195         final ProcessHandler handler = descriptor.getProcessHandler();
 196
 197         assert handler != null;
 198         handler.addProcessListener(new ProcessAdapter() {
 199           public void onTextAvailable(ProcessEvent event, Key outputType) {
 200             if (ProcessOutputTypes.SYSTEM != outputType) {
 201               sb.append(event.getText());
 202             }
 203           }
 204
 205           @Override
 206           public void processTerminated(ProcessEvent event) {
 207             semaphore.up();
 208           }
 209         });
 210       }
 211     });
 212     semaphore.waitFor();
 213     assertEquals(output.trim(), StringUtil.convertLineSeparators(sb.toString().trim()));
 214   }
 215
 216   private static class ErrorReportingCallback implements CompileStatusNotification {
 217     private final Semaphore mySemaphore;
 218     private Throwable myError;
 219     private List<String> myMessages = new ArrayList<String>();
 220
 221     public ErrorReportingCallback(Semaphore semaphore) {
 222       mySemaphore = semaphore;
 223     }
 224
 225     public void finished(boolean aborted, int errors, int warnings, final CompileContext compileContext) {
 226       try {
 227         assertFalse("Code did not compile!", aborted);
 228         for (CompilerMessageCategory category : CompilerMessageCategory.values()) {
 229           for (CompilerMessage message : compileContext.getMessages(category)) {
 230             final String msg = message.getMessage();
 231             if (category != CompilerMessageCategory.INFORMATION || !msg.startsWith("Compilation completed successfully")) {
 232               myMessages.add(category + ": " + msg);
 233             }
 234           }
 235         }
 236         if (errors > 0) {
 237           fail("Compiler errors occurred! " + StringUtil.join(myMessages, "\n"));
 238         }
 239       }
 240       catch (Throwable t) {
 241         myError = t;
 242       }
 243       finally {
 244         mySemaphore.up();
 245       }
 246     }
 247
 248     void throwException() {
 249       if (myError != null) {
 250         throw new RuntimeException(myError);
 251       }
 252     }
 253
 254     public List<String> getMessages() {
 255       return myMessages;
 256     }
 257   }
 258 }