Java PlatformTestCase类代码示例

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
@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();
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
@Override
protected Module doCreateRealModule(String moduleName) {
  if (useExternalCompiler()) {
    //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(Result<Module> result) throws Throwable {
        Module module = ModuleManager.getInstance(myProject)
          .newModule(FileUtil.toSystemIndependentName(moduleFile.getAbsolutePath()), getModuleType().getId());
        module.getModuleFile();
        result.setResult(module);
      }
    }.execute().getResultObject();
  }
  return super.doCreateRealModule(moduleName);
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
  PlatformTestCase.initPlatformLangPrefix();
  super.setUp();
  myModule = context.mock(Module.class, "myModule");
  context.checking(new Expectations() {{
    allowing(myModule).getName(); will(returnValue("my-module"));
  }});
  myManager = new ModuleRunConfigurationManager(myModule, new MyRunManagerImpl());

  mySettings = createSettings("my-module-run", new MyModuleBasedConfiguration("my-module-run-config", getProject(), myModule));
  final List<? extends RunnerAndConfigurationSettings> configs = ContainerUtil.newArrayList(
    createSettings("other-run", context.mock(RunConfiguration.class, "other-run-run-config")),
    createSettings("other-module-run", new MyModuleBasedConfiguration("other-module-run-config", getProject(), getModule())),
    mySettings
  );
  myConfigurations = Collections.unmodifiableCollection(configs);
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
protected void doTest(final PerformAction performAction, final String testName) throws Exception {
  String path = getTestDataPath() + getTestRoot() + testName;

  String pathBefore = path + "/before";
  final VirtualFile rootDir = PsiTestUtil.createTestProjectStructure(myProject, myModule, pathBefore, PlatformTestCase.myFilesToDelete, false);
  prepareProject(rootDir);
  PsiDocumentManager.getInstance(myProject).commitAllDocuments();

  String pathAfter = path + "/after";
  final VirtualFile rootAfter = LocalFileSystem.getInstance().findFileByPath(pathAfter.replace(File.separatorChar, '/'));

  performAction.performAction(rootDir, rootAfter);
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    public void run() {
      myProject.getComponent(PostprocessReformattingAspect.class).doPostponedFormatting();
    }
  });

  FileDocumentManager.getInstance().saveAllDocuments();

  if (myDoCompare) {
    PlatformTestUtil.assertDirectoriesEqual(rootAfter, rootDir);
  }
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
public static synchronized IdeaTestApplication getInstance(@Nullable final String configPath) {
  if (ourInstance == null) {
    PlatformTestCase.doAutodetectPlatformPrefix();
    new IdeaTestApplication();
    PluginManagerCore.getPlugins();
    ApplicationManagerEx.getApplicationEx().load(configPath);
  }
  return (IdeaTestApplication)ourInstance;
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
public void testPreserveCustomTemplates() throws Exception {
  myTemplateManager.addTemplate("foo", "txt");
  myTemplateManager.setTemplates(FileTemplateManager.DEFAULT_TEMPLATES_CATEGORY, Arrays.asList(myTemplateManager.getAllTemplates()));
  assertNotNull(myTemplateManager.getTemplate("foo.txt"));

  File foo = PlatformTestCase.createTempDir("foo");
  final Project project = ProjectManager.getInstance().createProject("foo", foo.getPath());;
  try {
    assertNotNull(project);
    assertNotNull(FileTemplateManager.getInstance(project).getTemplate("foo.txt"));
  }
  finally {
    closeProject(project);
  }
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
public void testSurviveOnProjectReopen() throws Exception {
  File foo = PlatformTestCase.createTempDir("foo");
  Project reloaded = null;
  final Project project = ProjectManager.getInstance().createProject("foo", foo.getPath());;
  try {
    assertNotNull(project);
    FileTemplateManager manager = FileTemplateManager.getInstance(project);
    manager.setCurrentScheme(manager.getProjectScheme());
    FileTemplate template = manager.getTemplate(TEST_TEMPLATE_TXT);
    assertEquals(HI_THERE, template.getText());
    String newText = "good bye";
    template.setText(newText);
    assertEquals(newText, manager.getTemplate(TEST_TEMPLATE_TXT).getText());

    PlatformTestUtil.saveProject(project);
    closeProject(project);

    reloaded = ProjectManager.getInstance().loadAndOpenProject(foo.getPath());
    assertNotNull(reloaded);
    manager = FileTemplateManager.getInstance(reloaded);
    assertEquals(manager.getProjectScheme(), manager.getCurrentScheme());
    //manager.setCurrentScheme(FileTemplatesScheme.DEFAULT);
    //manager.setCurrentScheme(manager.getProjectScheme()); // enforce reloading
    assertEquals(newText, manager.getTemplate(TEST_TEMPLATE_TXT).getText());
  }
  finally {
    closeProject(project);
    closeProject(reloaded);
  }
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
public void setUp() throws Exception {
    myTestRoot = new File(FileUtil.getTempDirectory(), "testRoot");
    PlatformTestCase.myFilesToDelete.add(myTestRoot);
    checkTestRootIsEmpty(myTestRoot);

    EdtTestUtil.runInEdtAndWait(() -> super.setUp());
    myTestRootFile = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(myTestRoot);
    this.refresh();

    myTestStartedIndicator = enableDebugLogging();

    myProjectRoot = myProject.getBaseDir();
    myProjectPath = myProjectRoot.getPath();

    changeListManager = (ChangeListManagerImpl) ChangeListManager.getInstance(myProject);

    myGitSettings = GitVcsSettings.getInstance(myProject);
    myGitSettings.getAppSettings().setPathToGit("git");

    myDialogManager = ServiceManager.getService(DialogManager.class);
    myVcsNotifier = ServiceManager.getService(myProject, VcsNotifier.class);

    myGitRepositoryManager = GitUtil.getRepositoryManager(myProject);
    myGit = ServiceManager.getService(Git.class);
    myVcs = GitVcs.getInstance(myProject);
    myVcs.doActivate();

    addSilently();
    removeSilently();
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
private void setUpProject() throws Exception {
  new WriteCommandAction.Simple(null) {
    @Override
    protected void run() throws Throwable {
      File projectFile = FileUtil.createTempFile(myName+"_", PROJECT_FILE_SUFFIX);
      FileUtil.delete(projectFile);
      myFilesToDelete.add(projectFile);

      LocalFileSystem.getInstance().refreshAndFindFileByIoFile(projectFile);
      ByteArrayOutputStream buffer = new ByteArrayOutputStream();
      new Throwable(projectFile.getPath()).printStackTrace(new PrintStream(buffer));
      myProject = PlatformTestCase.createProject(projectFile, buffer.toString());

      for (ModuleFixtureBuilder moduleFixtureBuilder: myModuleFixtureBuilders) {
        moduleFixtureBuilder.getFixture().setUp();
      }

      StartupManagerImpl sm = (StartupManagerImpl)StartupManager.getInstance(myProject);
      sm.runStartupActivities();
      sm.startCacheUpdate();
      sm.runPostStartupActivities();

      ProjectManagerEx.getInstanceEx().openTestProject(myProject);
      LightPlatformTestCase.clearUncommittedDocuments(myProject);
    }
  }.execute().throwException();
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
private void setUpProject() throws Exception {
  new WriteCommandAction.Simple(null) {
    @Override
    protected void run() throws Throwable {
      File projectDir = FileUtil.createTempDirectory(myName + "_", "project");
      FileUtil.delete(projectDir);
      myFilesToDelete.add(projectDir);

      LocalFileSystem.getInstance().refreshAndFindFileByIoFile(projectDir);
      ByteArrayOutputStream buffer = new ByteArrayOutputStream();
      new Throwable(projectDir.getPath()).printStackTrace(new PrintStream(buffer));
      myProject = PlatformTestCase.createProject(projectDir, buffer.toString());

      for (ModuleFixtureBuilder moduleFixtureBuilder : myModuleFixtureBuilders) {
        moduleFixtureBuilder.getFixture().setUp();
      }

      StartupManagerImpl sm = (StartupManagerImpl)StartupManager.getInstance(myProject);
      sm.runStartupActivities();
      sm.startCacheUpdate();
      sm.runPostStartupActivities();

      ProjectManagerEx.getInstanceEx().openTestProject(myProject);
      LightPlatformTestCase.clearUncommittedDocuments(myProject);
    }
  }.execute().throwException();
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
public void setFileText(@NotNull final VirtualFile file, @NotNull final String text) throws IOException {
  PlatformTestCase.setFileText(file, text);
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
public static void setBinaryContent(final VirtualFile file, final byte[] content) {
  PlatformTestCase.setBinaryContent(file, content);
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
@Override
protected void tearDown() throws Exception {
  try {
    if (myFixture != null) {
      try {
        if (CAN_SYNC_PROJECTS) {
          Project project = myFixture.getProject();
          // Since we don't really open the project, but we manually register listeners in the gradle importer
          // by explicitly calling AndroidGradleProjectComponent#configureGradleProject, we need to counteract
          // that here, otherwise the testsuite will leak
          if (Projects.isGradleProject(project)) {
            AndroidGradleProjectComponent projectComponent = ServiceManager.getService(project, AndroidGradleProjectComponent.class);
            projectComponent.projectClosed();
          }
        }
      }
      finally {
        myFixture.tearDown();
        myFixture = null;
      }
    }

    if (CAN_SYNC_PROJECTS) {
      GradleProjectImporter.ourSkipSetupFromTest = false;
    }

    ProjectManagerEx projectManager = ProjectManagerEx.getInstanceEx();
    Project[] openProjects = projectManager.getOpenProjects();
    if (openProjects.length > 0) {
      PlatformTestCase.closeAndDisposeProjectAndCheckThatNoOpenProjects(openProjects[0]);
    }
  }
  finally {
    try {
      assertEquals(0, ProjectManager.getInstance().getOpenProjects().length);
    }
    finally {
      super.tearDown();
    }

    // In case other test cases rely on the builtin (incomplete) SDK, restore
    if (ourPreviousSdkData != null) {
      setSdkData(ourPreviousSdkData);
      ourPreviousSdkData = null;
    }
  }
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
private static void initPlatformPrefix() {
  PlatformTestCase.autodetectPlatformPrefix();
}
 

import com.intellij.testFramework.PlatformTestCase; //导入依赖的package包/类
@SuppressWarnings("JUnitTestCaseWithNonTrivialConstructors")
protected SpellcheckerInspectionTestCase() {
  PlatformTestCase.initPlatformLangPrefix();
}