Java 类com.intellij.openapi.application.WriteAction 实例源码

@Override
public void projectOpened() {
    try {
        WriteAction.run(new ThrowableRunnable<Throwable>() {
            @Override
            public void run() throws Throwable {
                String ignoredFiles = FileTypeManager.getInstance().getIgnoredFilesList();
                if (ignoredFiles.length() == 0) {
                    ignoredFiles = "*.dso";
                } else {
                    ignoredFiles = ignoredFiles + ";*.dso";
                }
                FileTypeManager.getInstance().setIgnoredFilesList(ignoredFiles);
            }
        });
    } catch (Throwable ignored) {

    }
}

private void moveMavenModulesToGroup(
    final Project project,
    final List<Module> mavenModules,
    final String[] rootGroup
) {
    AccessToken token = null;
    final ModifiableModuleModel modifiableModuleModel;
    try {
        token = ApplicationManager.getApplication().acquireReadActionLock();
        modifiableModuleModel = ModuleManager.getInstance(project).getModifiableModel();

        for (Module module : mavenModules) {
            module.setOption(HybrisConstants.DESCRIPTOR_TYPE, HybrisModuleDescriptorType.MAVEN.name());
            final String[] groupPath = modifiableModuleModel.getModuleGroupPath(module);
            modifiableModuleModel.setModuleGroupPath(module, ArrayUtils.addAll(rootGroup, groupPath));
        }
    } finally {
        if (token != null) {
            token.finish();
        }
    }
    ApplicationManager.getApplication().invokeAndWait(() -> WriteAction.run(modifiableModuleModel::commit));
}

private static Sdk addDetectedSdk(@NotNull Sdk sdk, @NotNull Project project) {
  final ProjectSdksModel model = PyConfigurableInterpreterList.getInstance(project).getModel();
  final String name = sdk.getName();
  VirtualFile sdkHome = WriteAction.compute(() -> LocalFileSystem.getInstance().refreshAndFindFileByPath(name));
  sdk = SdkConfigurationUtil.createAndAddSDK(sdkHome.getPath(), PythonSdkType.getInstance());
  if (sdk != null) {
    PythonSdkUpdater.updateOrShowError(sdk, null, project, null);
  }

  model.addSdk(sdk);
  try {
    model.apply();
  }
  catch (ConfigurationException exception) {
    LOG.error("Error adding detected python interpreter " + exception.getMessage());
  }
  return sdk;
}

protected Module loadModule(@NotNull String modulePath) {
  String normalizedPath = FileUtil.toSystemIndependentName(modulePath);
  LocalFileSystem.getInstance().refreshAndFindFileByPath(normalizedPath);

  ModuleManager moduleManager = ModuleManager.getInstance(myProject);
  Module module;
  AccessToken token = WriteAction.start();
  try {
    module = moduleManager.loadModule(normalizedPath);
  }
  catch (Exception e) {
    LOG.error(e);
    return null;
  }
  finally {
    token.finish();
  }

  myModulesToDispose.add(module);
  return module;
}

@Override
public void updateProjectStructure(@NotNull final Module module) {
  if (!MvcModuleStructureUtil.isEnabledStructureUpdate()) return;

  final VirtualFile root = findAppRoot(module);
  if (root == null) return;

  AccessToken token = WriteAction.start();
  try {
    MvcModuleStructureUtil.updateModuleStructure(module, createProjectStructure(module, false), root);

    if (hasSupport(module)) {
      MvcModuleStructureUtil.updateAuxiliaryPluginsModuleRoots(module, this);
      MvcModuleStructureUtil.updateGlobalPluginModule(module.getProject(), this);
    }
  }
  finally {
    token.finish();
  }

  final Project project = module.getProject();
  ChangeListManager.getInstance(project).addFilesToIgnore(IgnoredBeanFactory.ignoreUnderDirectory(getUserHomeGriffon(), project));
}

@NotNull
protected PsiFile createFile(@NotNull final Module module, @NotNull final VirtualFile vDir, @NotNull final String fileName, @NotNull final String text) throws IOException {
  return new WriteAction<PsiFile>() {
    @Override
    protected void run(@NotNull Result<PsiFile> result) throws Throwable {
      if (!ModuleRootManager.getInstance(module).getFileIndex().isInSourceContent(vDir)) {
        addSourceContentToRoots(module, vDir);
      }

      final VirtualFile vFile = vDir.createChildData(vDir, fileName);
      VfsUtil.saveText(vFile, text);
      assertNotNull(vFile);
      final PsiFile file = myPsiManager.findFile(vFile);
      assertNotNull(file);
      result.setResult(file);
    }
  }.execute().getResultObject();
}

private void downloadJar(String jarUrl, String jarName) {
  final Project project = myModule.getProject();
  final String dirPath = PropertiesComponent.getInstance(project).getValue("findjar.last.used.dir");
  VirtualFile toSelect = dirPath == null ? null : LocalFileSystem.getInstance().findFileByIoFile(new File(dirPath));
  final VirtualFile file = FileChooser.chooseFile(FileChooserDescriptorFactory.createSingleFolderDescriptor(), project, toSelect);
  if (file != null) {
    PropertiesComponent.getInstance(project).setValue("findjar.last.used.dir", file.getPath());
    final DownloadableFileService downloader = DownloadableFileService.getInstance();
    final DownloadableFileDescription description = downloader.createFileDescription(jarUrl, jarName);
    final List<VirtualFile> jars =
      downloader.createDownloader(Arrays.asList(description), jarName)
                .downloadFilesWithProgress(file.getPath(), project, myEditorComponent);
    if (jars != null && jars.size() == 1) {
      AccessToken token = WriteAction.start();
      try {
        OrderEntryFix.addJarToRoots(jars.get(0).getPresentableUrl(), myModule, myRef);
      }
      finally {
        token.finish();
      }
    }
  }
}

@Nullable
public static Library createLibrary(@Nullable final LibraryType type, @NotNull final JComponent parentComponent,
                                    @NotNull final Project project, @NotNull final LibrariesModifiableModel modifiableModel) {
  final NewLibraryConfiguration configuration = createNewLibraryConfiguration(type, parentComponent, project);
  if (configuration == null) return null;
  final LibraryType<?> libraryType = configuration.getLibraryType();
  final Library library = modifiableModel.createLibrary(
    LibraryEditingUtil.suggestNewLibraryName(modifiableModel, configuration.getDefaultLibraryName()),
    libraryType != null ? libraryType.getKind() : null);

  final NewLibraryEditor editor = new NewLibraryEditor(libraryType, configuration.getProperties());
  configuration.addRoots(editor);
  final Library.ModifiableModel model = library.getModifiableModel();
  editor.applyTo((LibraryEx.ModifiableModelEx)model);
  AccessToken token = WriteAction.start();
  try {
    model.commit();
  }
  finally {
    token.finish();
  }
  return library;
}

@Override
public void apply() throws ConfigurationException {
  myPackagingEditorContext.saveEditorSettings();
  checkForEmptyAndDuplicatedNames("Artifact", CommonBundle.getErrorTitle(), ArtifactConfigurableBase.class);
  super.apply();

  myPackagingEditorContext.getManifestFilesInfo().saveManifestFiles();
  final ModifiableArtifactModel modifiableModel = myPackagingEditorContext.getActualModifiableModel();
  if (modifiableModel != null) {
    new WriteAction() {
      @Override
      protected void run(@NotNull final Result result) {
        modifiableModel.commit();
      }
    }.execute();
    myPackagingEditorContext.resetModifiableModel();
  }


  reset(); // TODO: fix to not reset on apply!
}

protected void doOKAction() {
  if (myAddSupportPanel.hasSelectedFrameworks()) {
    if (!myAddSupportPanel.downloadLibraries()) {
      int answer = Messages.showYesNoDialog(myAddSupportPanel.getMainPanel(),
                                            ProjectBundle.message("warning.message.some.required.libraries.wasn.t.downloaded"),
                                            CommonBundle.getWarningTitle(), Messages.getWarningIcon());
      if (answer != Messages.YES) {
        return;
      }
    }

    DumbService.allowStartingDumbModeInside(DumbModePermission.MAY_START_BACKGROUND, new Runnable() {
      @Override
      public void run() {
        new WriteAction() {
          protected void run(@NotNull final Result result) {
            ModifiableRootModel model = ModuleRootManager.getInstance(myModule).getModifiableModel();
            myAddSupportPanel.addSupport(myModule, model);
            model.commit();
          }
        }.execute();
      }
    });
  }
  super.doOKAction();
}

static Library addProjectLibrary(final Project project, final @Nullable Module module, final String name, final DependencyScope scope,
                                 final VirtualFile[] jars) {
  return new WriteAction<Library>() {
    @Override
    protected void run(@NotNull final Result<Library> result) {
      final Library library = LibraryTablesRegistrar.getInstance().getLibraryTable(project).createLibrary(name);
      final Library.ModifiableModel libraryModel = library.getModifiableModel();
      for (VirtualFile jar : jars) {
        libraryModel.addRoot(jar, OrderRootType.CLASSES);
      }
      libraryModel.commit();
      if (module != null) {
        ModuleRootModificationUtil.addDependency(module, library, scope, false);
      }
      result.setResult(library);
    }
  }.execute().getResultObject();
}

protected void copyToProject(String relativePath) {
  File dir = PathManagerEx.findFileUnderProjectHome(relativePath, getClass());
  final File target = new File(FileUtil.toSystemDependentName(getProjectBasePath()));
  try {
    FileUtil.copyDir(dir, target);
  }
  catch (IOException e) {
    throw new RuntimeException(e);
  }
  new WriteAction() {
    @Override
    protected void run(@NotNull final Result result) {
      VirtualFile virtualDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(target);
      assertNotNull(target.getAbsolutePath() + " not found", virtualDir);
      virtualDir.refresh(false, true);
    }
  }.execute();
}

protected Module addModule(final String moduleName, final @Nullable VirtualFile sourceRoot, final @Nullable VirtualFile testRoot) {
  return new WriteAction<Module>() {
    @Override
    protected void run(@NotNull final Result<Module> result) {
      final Module module = createModule(moduleName);
      if (sourceRoot != null) {
        PsiTestUtil.addSourceContentToRoots(module, sourceRoot, false);
      }
      if (testRoot != null) {
        PsiTestUtil.addSourceContentToRoots(module, testRoot, true);
      }
      ModuleRootModificationUtil.setModuleSdk(module, getTestProjectJdk());
      result.setResult(module);
    }
  }.execute().getResultObject();
}

@Override
protected Module doCreateRealModule(String moduleName) {
  //todo[nik] reuse code from PlatformTestCase
  final VirtualFile baseDir = myProject.getBaseDir();
  Assert.assertNotNull(baseDir);
  final File moduleFile = new File(baseDir.getPath().replace('/', File.separatorChar), moduleName + ModuleFileType.DOT_DEFAULT_EXTENSION);
  PlatformTestCase.myFilesToDelete.add(moduleFile);
  return new WriteAction<Module>() {
    @Override
    protected void run(@NotNull Result<Module> result) throws Throwable {
      Module module = ModuleManager.getInstance(myProject)
        .newModule(FileUtil.toSystemIndependentName(moduleFile.getAbsolutePath()), getModuleType().getId());
      module.getModuleFile();
      result.setResult(module);
    }
  }.execute().getResultObject();
}

@Override
public void loadState(final Element element) {
  try {
    if (myFirstLoad) {
      myModel.readExternal(element);
    }
    else {
      LibraryModel model = new LibraryModel(myModel);
      AccessToken token = WriteAction.start();
      try {
        model.readExternal(element);
        commit(model);
      }
      finally {
        token.finish();
      }
    }

    myFirstLoad = false;
  }
  catch (InvalidDataException e) {
    throw new RuntimeException(e);
  }
}

protected VirtualFile createConfigFile(final VirtualFile dir, String config) throws IOException {
  final String configFileName = getExternalSystemConfigFileName();
  VirtualFile f = dir.findChild(configFileName);
  if (f == null) {
    f = new WriteAction<VirtualFile>() {
      @Override
      protected void run(@NotNull Result<VirtualFile> result) throws Throwable {
        VirtualFile res = dir.createChildData(null, configFileName);
        result.setResult(res);
      }
    }.execute().getResultObject();
    myAllConfigs.add(f);
  }
  setFileContent(f, config, true);
  return f;
}

@Override
public ActionCallback perform(List<LibraryOrderEntry> orderEntriesContainingFile) {
  ApplicationManager.getApplication().assertIsDispatchThread();

  ActionCallback callback = new ActionCallback();
  callback.setDone();

  if (!mySrcFile.isValid()) return callback;

  if (myLibrary != getLibraryFromOrderEntriesList(orderEntriesContainingFile)) return callback;

  AccessToken accessToken = WriteAction.start();
  try {
    addSourceFile(mySrcFile, myLibrary);
  }
  finally {
    accessToken.finish();
  }

  return callback;
}

public void testDoNotFilterButCopyBigFiles() throws Exception {
  assertEquals(FileTypeManager.getInstance().getFileTypeByFileName("file.xyz"), FileTypes.UNKNOWN);

  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      createProjectSubFile("resources/file.xyz").setBinaryContent(new byte[1024 * 1024 * 20]);
    }
  }.execute().throwException();

  importProject("<groupId>test</groupId>" +
                "<artifactId>project</artifactId>" +
                "<version>1</version>" +

                "<build>" +
                "  <resources>" +
                "    <resource>" +
                "      <directory>resources</directory>" +
                "      <filtering>true</filtering>" +
                "    </resource>" +
                "  </resources>" +
                "</build>");
  compileModules("project");

  assertNotNull(myProjectPom.getParent().findFileByRelativePath("target/classes/file.xyz"));
}

protected static Module doCreateRealModuleIn(String moduleName, final Project project, final ModuleType moduleType) {
  final VirtualFile baseDir = project.getBaseDir();
  assertNotNull(baseDir);
  final File moduleFile = new File(FileUtil.toSystemDependentName(baseDir.getPath()), moduleName + ModuleFileType.DOT_DEFAULT_EXTENSION);
  FileUtil.createIfDoesntExist(moduleFile);
  myFilesToDelete.add(moduleFile);
  return new WriteAction<Module>() {
    @Override
    protected void run(@NotNull Result<Module> result) throws Throwable {
      VirtualFile virtualFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(moduleFile);
      assertNotNull(virtualFile);
      Module module = ModuleManager.getInstance(project).newModule(virtualFile.getPath(), moduleType.getId());
      module.getModuleFile();
      result.setResult(module);
    }
  }.execute().getResultObject();
}

private PsiFile createFile(final Module module, final VirtualFile vDir, final String fileName, final String text) {
  return new WriteAction<PsiFile>() {
    @Override
    protected void run(@NotNull Result<PsiFile> result) throws Throwable {
      if (!ModuleRootManager.getInstance(module).getFileIndex().isInSourceContent(vDir)) {
        PsiTestUtil.addSourceContentToRoots(module, vDir);
      }

      final VirtualFile vFile = vDir.createChildData(vDir, fileName);
      VfsUtil.saveText(vFile, text);
      PsiDocumentManager.getInstance(myProject).commitAllDocuments();
      final PsiFile file = PsiManager.getInstance(myProject).findFile(vFile);
      assert (file != null);
      result.setResult(file);
    }
  }.execute().getResultObject();
}

public void testClearingInfoForDeletedFiles() throws Exception {
  final VirtualFile nonProjectFile1 = createNonProjectFile();
  final VirtualFile nonProjectFile2 = createNonProjectFile();

  typeAndCheck(nonProjectFile1, false);
  typeAndCheck(nonProjectFile2, false);

  assertNotNull(NonProjectFileWritingAccessProvider.getAccessStatus(getProject(), nonProjectFile1));
  assertNotNull(NonProjectFileWritingAccessProvider.getAccessStatus(getProject(), nonProjectFile2));

  new WriteAction<Object>() {
    @Override
    protected void run(@NotNull Result<Object> result) throws Throwable {
      nonProjectFile1.delete(this);
    }
  }.execute();

  assertNull(NonProjectFileWritingAccessProvider.getAccessStatus(getProject(), nonProjectFile1));
  assertNotNull(NonProjectFileWritingAccessProvider.getAccessStatus(getProject(), nonProjectFile2));
}

public void testCaseInsensitiveRename() throws IOException {
  File file = createTempFile("file.txt", "");
  File home = file.getParentFile();
  assertOrderedEquals(Collections.singletonList("file.txt"), home.list());

  final VirtualFile vFile = myFS.refreshAndFindFileByIoFile(file);
  assertNotNull(vFile);
  new WriteAction<Void>() {
    @Override
    protected void run(@NotNull Result<Void> result) throws Throwable {
      vFile.rename(LocalFileSystemTest.class, "FILE.txt");
    }
  }.execute();
  assertEquals("FILE.txt", vFile.getName());
  assertOrderedEquals(Collections.singletonList("FILE.txt"), home.list());
}

public void testInvalidFileName() {
  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      VirtualFile tempDir = myFS.refreshAndFindFileByIoFile(createTempDirectory());
      assertNotNull(tempDir);
      try {
        tempDir.createChildData(this, "a/b");
        fail("invalid file name should have been rejected");
      }
      catch (IOException e) {
        assertEquals(VfsBundle.message("file.invalid.name.error", "a/b"), e.getMessage());
      }
    }
  }.execute();
}

public void testDuplicateViaRename() {
  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      VirtualFile tempDir = myFS.refreshAndFindFileByIoFile(createTempDirectory());
      assertNotNull(tempDir);

      VirtualFile file1 = tempDir.createChildData(this, "a.txt");
      FileUtil.delete(VfsUtilCore.virtualToIoFile(file1));

      VirtualFile file2 = tempDir.createChildData(this, "b.txt");
      try {
        file2.rename(this, "a.txt");
        fail("duplicate file name should have been rejected");
      }
      catch (IOException e) {
        assertEquals(VfsBundle.message("vfs.target.already.exists.error", file1.getPath()), e.getMessage());
      }
    }
  }.execute();
}

public void testUnknownProblemWithEmptyFile() throws Exception {
  createProjectPom("");
  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      myProjectPom.setBinaryContent(new byte[0]);
    }
  }.execute().throwException();

  importProject();

  assertModules("project");

  MavenProject root = getRootProjects().get(0);
  assertProblems(root, "'pom.xml' has syntax errors");
}

public void testExternalExecutor() throws Exception {
  if (!hasMavenInstallation()) return;

  VfsUtil.saveText(createProjectSubFile("src/main/java/A.java"), "public class A {}");
  PsiDocumentManager.getInstance(myProject).commitAllDocuments();

  new WriteAction<Object>() {
    @Override
    protected void run(@NotNull Result<Object> objectResult) throws Throwable {
      createProjectPom("<groupId>test</groupId>" +
                       "<artifactId>project</artifactId>" +
                       "<version>1</version>");
    }
  }.execute();

  assertFalse(new File(getProjectPath(), "target").exists());

  execute(new MavenRunnerParameters(true, getProjectPath(), Arrays.asList("compile"), Collections.<String>emptyList()));

  assertTrue(new File(getProjectPath(), "target").exists());
}

public void testMoveFile() throws Exception {
  new WriteAction<Object>() {
    @Override
    protected void run(@NotNull Result<Object> result) throws Throwable {
      final VirtualFile dir1 = getProject().getBaseDir().createChildDirectory(this, "dir1");
      final VirtualFile dir2 = getProject().getBaseDir().createChildDirectory(this, "dir2");
      VirtualFile child = dir1.createChildData(this, "child");

      long outOfCodeBlockCount = myTracker.getOutOfCodeBlockModificationCount();
      child.move(this, dir2);
      assertFalse(myTracker.getOutOfCodeBlockModificationCount() == outOfCodeBlockCount);

      outOfCodeBlockCount = myTracker.getOutOfCodeBlockModificationCount();
      child.move(this, dir1);
      assertFalse(myTracker.getOutOfCodeBlockModificationCount() == outOfCodeBlockCount);
    }
  }.execute();
}

public void testMoveDir() throws Exception {
  new WriteAction<Object>() {
    @Override
    protected void run(@NotNull Result<Object> result) throws Throwable {
      final VirtualFile dir1 = getProject().getBaseDir().createChildDirectory(this, "dir1");
      final VirtualFile dir2 = getProject().getBaseDir().createChildDirectory(this, "dir2");
      VirtualFile child = dir1.createChildDirectory(this, "child");

      long outOfCodeBlockCount = myTracker.getOutOfCodeBlockModificationCount();
      child.move(this, dir2);
      assertFalse(myTracker.getOutOfCodeBlockModificationCount() == outOfCodeBlockCount);

      outOfCodeBlockCount = myTracker.getOutOfCodeBlockModificationCount();
      child.move(this, dir1);
      assertFalse(myTracker.getOutOfCodeBlockModificationCount() == outOfCodeBlockCount);
    }
  }.execute();
}

public static <T extends XBreakpointType> XBreakpoint addBreakpoint(@NotNull final Project project,
                                                                    @NotNull final Class<T> exceptionType,
                                                                    @NotNull final XBreakpointProperties properties) {
  final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  XBreakpointType[] types = XBreakpointUtil.getBreakpointTypes();
  final Ref<XBreakpoint> breakpoint = Ref.create(null);
  for (XBreakpointType type : types) {
    if (exceptionType.isInstance(type)) {
      final T breakpointType = exceptionType.cast(type);
      new WriteAction() {
        @Override
        protected void run(@NotNull Result result) throws Throwable {
          breakpoint.set(breakpointManager.addBreakpoint(breakpointType, properties));
        }
      }.execute();
      break;
    }
  }
  return breakpoint.get();
}

public static void setBreakpointCondition(Project project, int line, final String condition) {
  XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  for (XBreakpoint breakpoint : getBreakpoints(breakpointManager)) {
    if (breakpoint instanceof XLineBreakpoint) {
      final XLineBreakpoint lineBreakpoint = (XLineBreakpoint)breakpoint;

      if (lineBreakpoint.getLine() == line) {
        new WriteAction() {
          @Override
          protected void run(@NotNull Result result) throws Throwable {
            lineBreakpoint.setCondition(condition);
          }
        }.execute();
      }
    }
  }
}

public static void setBreakpointLogExpression(Project project, int line, final String logExpression) {
  XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager();
  for (XBreakpoint breakpoint : getBreakpoints(breakpointManager)) {
    if (breakpoint instanceof XLineBreakpoint) {
      final XLineBreakpoint lineBreakpoint = (XLineBreakpoint)breakpoint;

      if (lineBreakpoint.getLine() == line) {
        new WriteAction() {
          @Override
          protected void run(@NotNull Result result) throws Throwable {
            lineBreakpoint.setLogExpression(logExpression);
            lineBreakpoint.setLogMessage(true);
          }
        }.execute();
      }
    }
  }
}

@Override
protected void setStateImpl(final Project project, final Editor editor, final TextEditorState state) {
  super.setStateImpl(project, editor, state);
  // Folding
  final CodeFoldingState foldState = state.getFoldingState();
  if (project != null && foldState != null) {
    new WriteAction() {
      @Override
      protected void run(@NotNull Result result) throws Throwable {
        PsiDocumentManager.getInstance(project).commitDocument(editor.getDocument());
        editor.getFoldingModel().runBatchFoldingOperation(
          new Runnable() {
            @Override
            public void run() {
              CodeFoldingManager.getInstance(project).restoreFoldingState(editor, foldState);
            }
          }
        );
      }
    }.execute();
  }
}

@Override
public void actionPerformed(AnActionEvent e) {
  final VirtualFile[] files = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY);
  final Project project = getEventProject(e);
  if (files == null || project == null) return;

  try {
    final ModifiableModuleModel model = ModuleManager.getInstance(project).getModifiableModel();
    for (VirtualFile file : files) {
      model.loadModule(file.getPath());
    }

    AccessToken token = WriteAction.start();
    try {
      model.commit();
    }
    finally {
      token.finish();
    }
  }
  catch (Exception ex) {
    LOG.info(ex);
    Messages.showErrorDialog(project, "Cannot import module: " + ex.getMessage(), CommonBundle.getErrorTitle());
  }
}

@Override
protected void setUp() throws Exception {
  super.setUp();
  final IdeaTestFixtureFactory factory = IdeaTestFixtureFactory.getFixtureFactory();

  myTestFixture = createFixture(factory);

  myTestFixture.setTestDataPath(getTestDataBasePath() + getTestDataPath());

  Class<? extends LocalInspectionTool>[] inspectionClasses = new DefaultInspectionProvider().getInspectionClasses();
  if (getName().contains("Inspection")) {
    inspectionClasses = ArrayUtil.mergeArrays(inspectionClasses, ApplicationLoader.getInspectionClasses());
  }

  myTestFixture.setUp();

  myTestFixture.enableInspections(inspectionClasses);

  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      ResourceUtil.copyFiles(HighlightingTestBase.this);
      init();
    }
  }.execute().throwException();
}

@Override
public void setUp() throws Exception {
  myJdkHome = IdeaTestUtil.requireRealJdkHome();
  super.setUp();
  assumeThat(gradleVersion, versionMatcherRule.getMatcher());
  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      Sdk oldJdk = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
      if (oldJdk != null) {
        ProjectJdkTable.getInstance().removeJdk(oldJdk);
      }
      VirtualFile jdkHomeDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(new File(myJdkHome));
      Sdk jdk = SdkConfigurationUtil.setupSdk(new Sdk[0], jdkHomeDir, JavaSdk.getInstance(), true, null, GRADLE_JDK_NAME);
      assertNotNull("Cannot create JDK for " + myJdkHome, jdk);
      ProjectJdkTable.getInstance().addJdk(jdk);
    }
  }.execute();
  myProjectSettings = new GradleProjectSettings();
  GradleSettings.getInstance(myProject).setGradleVmOptions("-Xmx64m -XX:MaxPermSize=64m");
  System.setProperty(ExternalSystemExecutionSettings.REMOTE_PROCESS_IDLE_TTL_IN_MS_KEY, String.valueOf(GRADLE_DAEMON_TTL_MS));
  configureWrapper();
}

@Override
public void tearDown() throws Exception {
  if (myJdkHome == null) {
    //super.setUp() wasn't called
    return;
  }

  try {
    new WriteAction() {
      @Override
      protected void run(@NotNull Result result) throws Throwable {
        Sdk old = ProjectJdkTable.getInstance().findJdk(GRADLE_JDK_NAME);
        if (old != null) {
          SdkConfigurationUtil.removeSdk(old);
        }
      }
    }.execute();
    Messages.setTestDialog(TestDialog.DEFAULT);
    FileUtil.delete(BuildManager.getInstance().getBuildSystemDirectory());
  }
  finally {
    super.tearDown();
  }
}

private static Library addProjectLibrary(final Module module, final String name, final List<String> jarDirectories, final VirtualFile[] sources) {
  return new WriteAction<Library>() {
    protected void run(@NotNull final Result<Library> result) {
      final LibraryTable libraryTable = LibraryTablesRegistrar.getInstance().getLibraryTable(module.getProject());
      Library library = libraryTable.getLibraryByName(name);
      if (library == null) {
        library = libraryTable.createLibrary(name);
        final Library.ModifiableModel model = library.getModifiableModel();
        for (String path : jarDirectories) {
          String url = VfsUtilCore.pathToUrl(path);
          VirtualFileManager.getInstance().refreshAndFindFileByUrl(url);
          model.addJarDirectory(url, false);
        }
        for (VirtualFile sourceRoot : sources) {
          model.addRoot(sourceRoot, OrderRootType.SOURCES);
        }
        model.commit();
      }
      result.setResult(library);
    }
  }.execute().getResultObject();
}

private static Module doLoadModule(@NotNull String path, @NotNull Project project) throws IOException, JDOMException, InvalidDataException {
  Module module;
  AccessToken token = WriteAction.start();
  try {
    module = ModuleManager.getInstance(project).newModule(path + '/' + EclipseProjectFinder.findProjectName(path) + IdeaXml.IML_EXT, StdModuleTypes.JAVA.getId());
  }
  finally {
    token.finish();
  }

  replaceRoot(path, EclipseXml.DOT_CLASSPATH_EXT, project);

  ModifiableRootModel rootModel = ModuleRootManager.getInstance(module).getModifiableModel();
  new EclipseClasspathConverter(module).readClasspath(rootModel);
  token = WriteAction.start();
  try {
    rootModel.commit();
  }
  finally {
    token.finish();
  }
  return module;
}

@Override
public void moduleRenamed(@NotNull Module module, @NotNull String oldName, @NotNull String newName) {
  try {
    CachedXmlDocumentSet fileSet = getFileCache(module);
    VirtualFile root = LocalFileSystem.getInstance().findFileByPath(ModuleUtilCore.getModuleDirPath(module));
    VirtualFile source = root == null ? null : root.findChild(oldName + EclipseXml.IDEA_SETTINGS_POSTFIX);
    if (source != null && source.isValid()) {
      AccessToken token = WriteAction.start();
      try {
        source.rename(this, newName + EclipseXml.IDEA_SETTINGS_POSTFIX);
      }
      finally {
        token.finish();
      }
    }

    DotProjectFileHelper.saveDotProjectFile(module, fileSet.getParent(EclipseXml.PROJECT_FILE));
    fileSet.unregister(oldName + EclipseXml.IDEA_SETTINGS_POSTFIX);
    fileSet.register(newName + EclipseXml.IDEA_SETTINGS_POSTFIX, ModuleUtilCore.getModuleDirPath(module));
  }
  catch (IOException e) {
    EclipseClasspathWriter.LOG.warn(e);
  }
}

public void setFileText(final PsiFile file, final String text) throws IOException {
  new WriteAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      final VirtualFile virtualFile = file.getVirtualFile();
      VfsUtil.saveText(ObjectUtils.assertNotNull(virtualFile), text);
    }
  }.execute().throwException();
  touch(file.getVirtualFile());
}