import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
private static String readProjectName(@NotNull String path) {
  final File file = new File(path);
  if (file.isDirectory()) {
    final File nameFile = new File(new File(path, Project.DIRECTORY_STORE_FOLDER), ProjectImpl.NAME_FILE);
    if (nameFile.exists()) {
      try {
        final BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(nameFile), CharsetToolkit.UTF8_CHARSET));
        try {
          String name = in.readLine();
          if (!StringUtil.isEmpty(name)) {
            return name.trim();
          }
        }
        finally {
          in.close();
        }
      }
      catch (IOException ignored) { }
    }
    return file.getName();
  }
  else {
    return FileUtilRt.getNameWithoutExtension(file.getName());
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
public void documentChanged(DocumentEvent event) {
  super.documentChanged(event);
  // optimisation: avoid documents piling up during batch processing
  if (FileDocumentManagerImpl.areTooManyDocumentsInTheQueue(myUncommittedDocuments)) {
    if (myUnitTestMode) {
      myStopTrackingDocuments = true;
      try {
        LOG.error("Too many uncommitted documents for " + myProject + ":\n" + StringUtil.join(myUncommittedDocuments, "\n") + 
                  "\n\n Project creation trace: " + myProject.getUserData(ProjectImpl.CREATION_TRACE));
      }
      finally {
        //noinspection TestOnlyProblems
        clearUncommittedDocuments();
      }
    }
    // must not commit during document save
    if (PomModelImpl.isAllowPsiModification()) {
      commitAllDocuments();
    }
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
public void loadProjectFromTemplate(@NotNull final ProjectImpl defaultProject) {
  final StateStorage stateStorage = getStateStorageManager().getFileStateStorage(DEFAULT_STATE_STORAGE);

  assert stateStorage instanceof XmlElementStorage;
  XmlElementStorage xmlElementStorage = (XmlElementStorage)stateStorage;

  defaultProject.save();
  final IProjectStore projectStore = defaultProject.getStateStore();
  assert projectStore instanceof DefaultProjectStoreImpl;
  DefaultProjectStoreImpl defaultProjectStore = (DefaultProjectStoreImpl)projectStore;
  final Element element = defaultProjectStore.getStateCopy();
  if (element != null) {
    xmlElementStorage.setDefaultState(element);
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@NotNull
@Override
public SaveSession save() throws IOException {
  final ProjectImpl.UnableToSaveProjectNotification[] notifications =
    NotificationsManager.getNotificationsManager().getNotificationsOfType(ProjectImpl.UnableToSaveProjectNotification.class, myProject);
  if (notifications.length > 0) throw new SaveCancelledException();

  final ReadonlyStatusHandler.OperationStatus operationStatus = ensureConfigFilesWritable();
  if (operationStatus == null) {
    throw new IOException();
  }
  else if (operationStatus.hasReadonlyFiles()) {
    ProjectImpl.dropUnableToSaveProjectNotification(myProject, operationStatus.getReadonlyFiles());
    throw new SaveCancelledException();
  }

  beforeSave();

  super.save();

  return this;
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
private static String readProjectName(String path) {
  final File file = new File(path);
  if (file.isDirectory()) {
    final File nameFile = new File(new File(path, Project.DIRECTORY_STORE_FOLDER), ProjectImpl.NAME_FILE);
    if (nameFile.exists()) {
      try {
        final BufferedReader in = new BufferedReader(new InputStreamReader(new FileInputStream(nameFile), "UTF-8"));
        try {
          final String name = in.readLine();
          if (name != null && name.length() > 0) return name.trim();
        }
        finally {
          in.close();
        }
      }
      catch (IOException ignored) { }
    }
    return file.getName();
  }
  else {
    return FileUtil.getNameWithoutExtension(file.getName());
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@RequiredWriteAction
public static synchronized void closeAndDeleteProject() {
  if (ourProject != null) {
    ApplicationManager.getApplication().assertWriteAccessAllowed();
    for (Sdk registeredSdk : ourRegisteredSdks) {
      SdkTable.getInstance().removeSdk(registeredSdk);
    }
    ((ProjectImpl)ourProject).setTemporarilyDisposed(false);
    final VirtualFile projFile = ((ProjectEx)ourProject).getStateStore().getProjectFile();
    final File projectFile = projFile == null ? null : VfsUtilCore.virtualToIoFile(projFile);
    if (!ourProject.isDisposed()) Disposer.dispose(ourProject);

    if (projectFile != null) {
      FileUtil.delete(projectFile);
    }
    ourProject = null;
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@TestOnly
public static void checkProjectLeak() throws Exception {
  Processor<Project> isReallyLeak = new Processor<Project>() {
    @Override
    public boolean process(Project project) {
      return !project.isDefault() && !((ProjectImpl)project).isLight();
    }
  };
  Collection<Object> roots = new ArrayList<Object>(Arrays.asList(ApplicationManager.getApplication(), Extensions.getRootArea()));
  ClassLoader classLoader = LeakHunter.class.getClassLoader();
  Vector<Class> allLoadedClasses = ReflectionUtil.getField(classLoader.getClass(), classLoader, Vector.class, "classes");
  roots.addAll(allLoadedClasses); // inspect static fields of all loaded classes
  checkLeak(roots, ProjectImpl.class, isReallyLeak);
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
public void testContextFileName() throws Exception {
  ProjectImpl project = (ProjectImpl)getProject();
  String name = project.getName();
  try {
    project.setProjectName("invalid | name");
    getContextManager().saveContext("foo", "bar");
  }
  finally {
    project.setProjectName(name);
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
/**
 * To support the custom language features, we need a ProjectImpl, and it's not desirable to
 * create one from scratch.<br>
 *
 * @return the current, non-default project, if one exists, else the default project.
 */
public static Project getProject() {
  Project project = (Project) DataManager.getInstance().getDataContext().getData("project");
  if (project != null && project instanceof ProjectImpl) {
    return project;
  }
  return ProjectManager.getInstance().getDefaultProject();
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
protected void readJdomExternalizables(final ModuleImpl module) {
  ApplicationManager.getApplication().runWriteAction(new Runnable() {
    @Override
    public void run() {
      final ProjectImpl project = (ProjectImpl)myProject;
      project.setOptimiseTestLoadSpeed(false);
      final ModuleRootManagerImpl moduleRootManager = (ModuleRootManagerImpl)ModuleRootManager.getInstance(module);
      module.getStateStore().initComponent(moduleRootManager, false);
      project.setOptimiseTestLoadSpeed(true);
    }
  });
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
protected void setUpProject() throws Exception {
  String projectPath = PathManagerEx.getTestDataPath() + "/model/model.ipr";
  myProject = ProjectManager.getInstance().loadAndOpenProject(projectPath);
  MutablePicoContainer container = (MutablePicoContainer)getProject().getPicoContainer();
  container.unregisterComponent(FileEditorManager.class.getName());
  ((ProjectImpl)getProject()).registerComponentImplementation(FileEditorManager.class, FileEditorManagerImpl.class);
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
public static synchronized void closeAndDeleteProject() {
  if (ourProject != null) {
    ApplicationManager.getApplication().assertWriteAccessAllowed();
    ((ProjectImpl)ourProject).setTemporarilyDisposed(false);
    final VirtualFile projFile = ((ProjectEx)ourProject).getStateStore().getProjectFile();
    final File projectFile = projFile == null ? null : VfsUtilCore.virtualToIoFile(projFile);
    if (!ourProject.isDisposed()) Disposer.dispose(ourProject);

    if (projectFile != null) {
      FileUtil.delete(projectFile);
    }
    ourProject = null;
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
public static String readProjectName(@Nonnull File file) {
  if (file.isDirectory()) {
    final File nameFile = new File(new File(file, Project.DIRECTORY_STORE_FOLDER), ProjectImpl.NAME_FILE);
    if (nameFile.exists()) {
      try {
        return FileUtil.loadFile(nameFile, true);
      }
      catch (IOException ignored) {
      }
    }
  }
  return file.getName();
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
public void loadProjectFromTemplate(@Nonnull ProjectImpl defaultProject) {
  defaultProject.save();

  Element element = ((DefaultProjectStoreImpl)defaultProject.getStateStore()).getStateCopy();
  if (element != null) {
    getDefaultFileStorage().setDefaultState(element);
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
protected final void doSave(@Nullable List<SaveSession> saveSessions, @Nonnull List<Pair<SaveSession, VirtualFile>> readonlyFiles) {
  ProjectImpl.UnableToSaveProjectNotification[] notifications =
          NotificationsManager.getNotificationsManager().getNotificationsOfType(ProjectImpl.UnableToSaveProjectNotification.class, myProject);
  if (notifications.length > 0) {
    throw new SaveCancelledException();
  }

  beforeSave(readonlyFiles);

  super.doSave(saveSessions, readonlyFiles);

  if (!readonlyFiles.isEmpty()) {
    ReadonlyStatusHandler.OperationStatus status;
    AccessToken token = ReadAction.start();
    try {
      status = ReadonlyStatusHandler.getInstance(myProject).ensureFilesWritable(getFilesList(readonlyFiles));
    }
    finally {
      token.finish();
    }

    if (status.hasReadonlyFiles()) {
      ProjectImpl.dropUnableToSaveProjectNotification(myProject, status.getReadonlyFiles());
      throw new SaveCancelledException();
    }
    else {
      List<Pair<SaveSession, VirtualFile>> oldList = new ArrayList<>(readonlyFiles);
      readonlyFiles.clear();
      for (Pair<SaveSession, VirtualFile> entry : oldList) {
        executeSave(entry.first, readonlyFiles);
      }

      if (!readonlyFiles.isEmpty()) {
        ProjectImpl.dropUnableToSaveProjectNotification(myProject, getFilesList(readonlyFiles));
        throw new SaveCancelledException();
      }
    }
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
public void documentChanged(DocumentEvent event) {
  super.documentChanged(event);
  // optimisation: avoid documents piling up during batch processing
  if (isUncommited(event.getDocument()) && FileDocumentManagerImpl.areTooManyDocumentsInTheQueue(myUncommittedDocuments)) {
    if (myUnitTestMode) {
      myStopTrackingDocuments = true;
      try {
        LOG.error("Too many uncommitted documents for " + myProject + "(" +myUncommittedDocuments.size()+")"+
                  ":\n" + StringUtil.join(myUncommittedDocuments, "\n") +
                  "\n\n Project creation trace: " + myProject.getUserData(ProjectImpl.CREATION_TRACE));
      }
      finally {
        //noinspection TestOnlyProblems
        clearUncommittedDocuments();
      }
    }
    // must not commit during document save
    if (PomModelImpl.isAllowPsiModification()
        // it can happen that document(forUseInNonAWTThread=true) outside write action caused this
        && ApplicationManager.getApplication().isWriteAccessAllowed()) {
      // commit one document to avoid OOME
      for (Document document : myUncommittedDocuments) {
        if (document != event.getDocument()) {
          doCommitWithoutReparse(document);
          break;
        }
      }
    }
  }
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
protected void setUpProject() throws Exception {
  String projectPath = "/model/model.ipr";
  myProject = ProjectManager.getInstance().loadAndOpenProject(projectPath);
  MutablePicoContainer container = (MutablePicoContainer)getProject().getPicoContainer();
  container.unregisterComponent(FileEditorManager.class.getName());
  ((ProjectImpl)getProject()).registerComponentImplementation(FileEditorManager.class, FileEditorManagerImpl.class);
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
protected void setUpProject() throws Exception {
  String projectPath = PathManagerEx.getTestDataPath() + "/model/model.ipr";
  myProject = ProjectManager.getInstance().loadAndOpenProject(projectPath);
  ((ProjectImpl)getProject()).registerComponentImplementation(FileEditorManager.class, FileEditorManagerImpl.class);
}
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
@Override
  public void projectOpened() {
    //myFocusWatcher.install(myWindows.getComponent ());
    getMainSplitters().startListeningFocus();

    MessageBusConnection connection = myProject.getMessageBus().connect(myProject);

    final FileStatusManager fileStatusManager = FileStatusManager.getInstance(myProject);
    if (fileStatusManager != null) {
      /**
       * Updates tabs colors
       */
      final MyFileStatusListener myFileStatusListener = new MyFileStatusListener();
      fileStatusManager.addFileStatusListener(myFileStatusListener, myProject);
    }
    connection.subscribe(FileTypeManager.TOPIC, new MyFileTypeListener());
    connection.subscribe(ProjectTopics.PROJECT_ROOTS, new MyRootsListener());

    /**
     * Updates tabs names
     */
    final MyVirtualFileListener myVirtualFileListener = new MyVirtualFileListener();
    VirtualFileManager.getInstance().addVirtualFileListener(myVirtualFileListener, myProject);
    /**
     * Extends/cuts number of opened tabs. Also updates location of tabs.
     */
    final MyUISettingsListener myUISettingsListener = new MyUISettingsListener();
    UISettings.getInstance().addUISettingsListener(myUISettingsListener, myProject);

    StartupManager.getInstance(myProject).registerPostStartupActivity(new DumbAwareRunnable() {
      @Override
      public void run() {
        if (myProject.isDisposed()) return;
        setTabsMode(UISettings.getInstance().EDITOR_TAB_PLACEMENT != UISettings.TABS_NONE);

        ToolWindowManager.getInstance(myProject).invokeLater(new Runnable() {
          @Override
          public void run() {
            CommandProcessor.getInstance().executeCommand(myProject, new Runnable() {
              @Override
              public void run() {

                ApplicationManager.getApplication().invokeLater(new Runnable() {
                  @Override
                  public void run() {
                    long currentTime = System.nanoTime();
                    Long startTime = myProject.getUserData(ProjectImpl.CREATION_TIME);
                    if (startTime != null) {
                      LOG.info("Project opening took " + (currentTime - startTime.longValue()) / 1000000 + " ms");
                      PluginManagerCore.dumpPluginClassStatistics();
                    }
                  }
                }, myProject.getDisposed());
// group 1
              }
            }, "", null);
          }
        });
      }
    });
  }
 

import com.intellij.openapi.project.impl.ProjectImpl; //导入依赖的package包/类
public void testOnBreakpointListChangedSetsErrorMessageAndUpdatesBreakpointPresentation()
    throws Exception {
  // override the default XBreakpointManager implementation with mock to use Mockito.verify()
  XBreakpointManager breakpointManager = mock(XBreakpointManager.class);
  XDebuggerManager debuggerManager = mock(XDebuggerManager.class);
  when(debuggerManager.getBreakpointManager()).thenReturn(breakpointManager);
  ((ProjectImpl) getProject()).registerComponentInstance(XDebuggerManager.class, debuggerManager);

  ArrayList<Breakpoint> breakpoints = new ArrayList<Breakpoint>();
  Breakpoint breakpoint = new Breakpoint();
  breakpoint
      .setId("breakpointId")
      .setIsFinalState(Boolean.TRUE)
      .setStatus(new StatusMessage().setIsError(Boolean.TRUE));
  breakpoints.add(breakpoint);
  CloudDebugProcessState processState = mock(CloudDebugProcessState.class);
  when(processState.getCurrentServerBreakpointList())
      .thenReturn(ContainerUtil.immutableList(breakpoints));

  XLineBreakpointImpl xLineBreakpointImpl = mock(XLineBreakpointImpl.class);
  CloudLineBreakpoint cloudLineBreakpoint =
      mockCloudLineBreakpoint("mock error message", xLineBreakpointImpl);
  when(xLineBreakpointImpl.getUserData(com.intellij.debugger.ui.breakpoints.Breakpoint.DATA_KEY))
      .thenReturn(cloudLineBreakpoint);
  CloudBreakpointHandler breakpointHandler = mock(CloudBreakpointHandler.class);
  when(breakpointHandler.getEnabledXBreakpoint(breakpoint)).thenReturn(xLineBreakpointImpl);

  process.setBreakpointHandler(breakpointHandler);
  process.initialize(processState);

  process.onBreakpointListChanged(mock(CloudDebugProcessState.class));

  verify(cloudLineBreakpoint).setErrorMessage(eq("General error"));
  verify(cloudLineBreakpoint).getXBreakpoint();
  verify(cloudLineBreakpoint).getSetIcon(Matchers.anyBoolean());
  verify(cloudLineBreakpoint).getErrorMessage();
  verify(breakpointManager)
      .updateBreakpointPresentation(
          same(xLineBreakpointImpl), any(Icon.class), eq("General error"));

  process.getStateController().stopBackgroundListening();
}