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