import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@SuppressWarnings("UnusedDeclaration")
public void _testContentChanged_reloadChangedDocumentOnSave() throws Exception {
  final MockVirtualFile file = new MockVirtualFile("test.txt", "test\rtest") {
    @Override
    public void refresh(boolean asynchronous, boolean recursive, Runnable postRunnable) {
      long oldStamp = getModificationStamp();
      setModificationStamp(LocalTimeCounter.currentTime());
      myDocumentManager.contentsChanged(new VirtualFileEvent(null, this, null, oldStamp, getModificationStamp()));
    }
  };
  Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  document.insertString(0, "zzz");
  file.setContent(null, "xxx", false);

  myReloadFromDisk = Boolean.TRUE;
  myDocumentManager.saveAllDocuments();
  long fileStamp = file.getModificationStamp();

  assertEquals("xxx", document.getText());
  assertEquals(file.getModificationStamp(), document.getModificationStamp());
  assertEquals(file.getModificationStamp(), fileStamp);
  assertEquals(0, myDocumentManager.getUnsavedDocuments().length);
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
MockJavaPsiFacade(
    Project project, PsiManager psiManager, ImmutableCollection<String> classNames) {
  super(project, psiManager, null, null);
  ImmutableMap.Builder<String, PsiClass> classesBuilder = ImmutableMap.builder();
  ImmutableMap.Builder<String, Long> timestampsBuilder = ImmutableMap.builder();
  for (String className : classNames) {
    VirtualFile virtualFile =
        new MockVirtualFile("/src/" + className.replace('.', '/') + ".java");
    PsiFile psiFile = mock(PsiFile.class);
    when(psiFile.getVirtualFile()).thenReturn(virtualFile);
    PsiClass psiClass = mock(PsiClass.class);
    when(psiClass.getContainingFile()).thenReturn(psiFile);
    classesBuilder.put(className, psiClass);
    timestampsBuilder.put(className, virtualFile.getTimeStamp());
  }
  classes = classesBuilder.build();
  timestamps = timestampsBuilder.build();
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@Test
public void testBasics() {
    SlingProject slingProject = new SlingProject4IntelliJ(module);
    VirtualFile virtualFile = new MockVirtualFile("test");
    SlingResource slingResource = new SlingResource4IntelliJ(slingProject, virtualFile);

    assertThat("Sling Resource Name is wrong", slingResource.getName(), equalTo("test"));
    assertThat("Sling Resource Project is undefined", slingResource.getProject(), notNullValue());
    assertThat("No Modification Stored expected", Util.getModificationStamp(virtualFile), equalTo(-1L));
    assertThat("Resource isn't marked as changed", slingResource.isModified(), is(Boolean.TRUE));
    assertThat("Resource isn't a file", slingResource.isFile(), is(Boolean.TRUE));
    assertThat("Resource is a folder but should be file", slingResource.isFolder(), is(Boolean.FALSE));
    LOGGER.info("Resource Path: '{}'", slingResource.getLocalPath());
    LOGGER.info("Sync Directory: '{}'", slingProject.getSyncDirectory());
    SlingResource slingResourceChild = new SlingResource4IntelliJ(slingProject, "/a/b/c.txt");
    assertThat("Obtained Resource doesn't match", slingResource.getResourceFromPath("/a/b/c.txt"), equalTo(slingResourceChild));
    //AS TODO: Test Load Filter (should be the same as for Sling Project
    SlingResource slingResourceEqual = new SlingResource4IntelliJ(slingProject, virtualFile);
    assertThat("Sling Resource must be equal even if not identical", slingResource, equalTo(slingResourceEqual));
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@Test
public void testGetChildrenWithViewNode() throws Exception {
    //given
    SharedViewTreeNode sharedViewTreeNodeRoot = getSharedViewTreeNodeViewNode();

    //and
    SharedViewGroupNode sharedViewGroupNode = new SharedViewGroupNode(mockProject, sharedViewTreeNodeRoot, ViewSettings.DEFAULT);

    //and
    MockVirtualFile mockVirtualFile = new MockVirtualFile(false, "any_file.anything");
    mockVirtualFileManager.addFileByUrl("file://" + getClass().getClassLoader().getResource(".").getPath() + File.separator + "any_file.anything", mockVirtualFile);

    //and
    MockPsiFile mockPsiFile = new MockPsiFile(mockVirtualFile);
    mockPsiManager.addFile(mockVirtualFile, mockPsiFile);

    //when
    Collection<? extends AbstractTreeNode> children = sharedViewGroupNode.getChildren();

    //then
    assertThat(children.size(), is(1));
    assertThat(((ArrayList) children).get(0) instanceof PsiFileNode, is(true));
    assertThat(((PsiFileNode) ((ArrayList) children).get(0)).getValue().getVirtualFile(), is((VirtualFile) mockVirtualFile));
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testGetUnsavedDocuments_afterSaveDocumentWithProblems() throws Exception {
  final VirtualFile file = new MockVirtualFile("test.txt", "test") {
    @Override
    @NotNull
    public OutputStream getOutputStream(Object requestor, long newModificationStamp, long newTimeStamp) throws IOException {
      throw new IOException("");
    }
  };

  Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  document.insertString(0, "xxx");

  myDocumentManager.saveDocument(document);

  assertNotNull(myDocumentManager.myExceptionOnSave);

  final Document[] unsavedDocuments = myDocumentManager.getUnsavedDocuments();
  assertEquals(1, unsavedDocuments.length);
  assertSame(document, unsavedDocuments[0]);
  assertTrue(Arrays.equals("test".getBytes("UTF-8"), file.contentsToByteArray()));
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testContentChanged_ignoreEventsFromSelfOnSave() throws Exception {
  final VirtualFile file = new MockVirtualFile("test.txt", "test\rtest") {
    @NotNull
    @Override
    public OutputStream getOutputStream(final Object requestor, final long newModificationStamp, long newTimeStamp) throws IOException {
      final VirtualFile self = this;
      return new ByteArrayOutputStream() {
        @Override
        public void close() throws IOException {
          super.close();
          long oldStamp = getModificationStamp();
          setModificationStamp(newModificationStamp);
          setText(toString());
          myDocumentManager.contentsChanged(new VirtualFileEvent(requestor, self, null, oldStamp, getModificationStamp()));
        }
      };
    }
  };
  Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  document.insertString(0, "xxx");
  final long stamp = document.getModificationStamp();

  myDocumentManager.saveAllDocuments();
  assertEquals(stamp, document.getModificationStamp());
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testContentChanged_reloadChangedDocument() throws Exception {
  final MockVirtualFile file = new MockVirtualFile("test.txt", "test\rtest");
  file.setListener(myDocumentManager);
  Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  document.insertString(0, "zzz");

  myDocumentManager.myReloadFromDisk = Boolean.TRUE;
  try {
    file.setContent(null, "xxx", true);

    assertEquals("xxx", document.getText());
    assertEquals(file.getModificationStamp(), document.getModificationStamp());
    assertEquals(0, myDocumentManager.getUnsavedDocuments().length);
  }
  finally {
    myDocumentManager.myReloadFromDisk = null;
  }
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testContentChanged_DoNotReloadChangedDocument() throws Exception {
  final MockVirtualFile file = newTextFile();
  file.setListener(myDocumentManager);
  Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  document.insertString(0, "old ");

  myDocumentManager.myReloadFromDisk = Boolean.FALSE;
  try {
    long oldDocumentStamp = document.getModificationStamp();

    file.setContent(null, "xxx", true);

    assertEquals("old test", document.getText());
    assertEquals(oldDocumentStamp, document.getModificationStamp());
  }
  finally {
    myDocumentManager.myReloadFromDisk = null;
  }
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testSaveDocument_DoNotSaveIfModStampEqualsToFile() throws Exception {
  final VirtualFile file = new MockVirtualFile("test.txt", "test") {
    @NotNull
    @Override
    public OutputStream getOutputStream(Object requestor, long newModificationStamp, long newTimeStamp) throws IOException {
      fail();
      throw new IOException();
    }
  };
  DocumentEx document = (DocumentEx)myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  document.insertString(0, "zzz");
  document.setModificationStamp(file.getModificationStamp());

  myDocumentManager.saveDocument(document);
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@DataProvider
public static Object[][] dataProviderDirsToFileFromProjectRoot() {
    final MockVirtualFile javaFile = new MockVirtualFile(true, "MyJavaFile.java");
    javaFile.setParent(getVFDirectoryWithModule());

    final MockVirtualFile projectFile = new MockVirtualFile(true, "projectFile.txt");
    projectFile.setParent(projectDirectory);

    final MockVirtualFile withoutModule = new MockVirtualFile(true, "MyJava2File.java");
    withoutModule.setParent(getVFDirectoryWithoutModule());


    return new Object[][]{
            {Paths.get(WITH_MODULE_RELATIVE_PATH), javaFile},
            {Paths.get(""), projectFile},
            {Paths.get(WITHOUT_MODULE_RELATIVE_PATH), withoutModule},
    };
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testGetUnsavedDocuments_afterSaveDocumentWithProblems() throws Exception {
  try {
    final VirtualFile file = new MockVirtualFile("test.txt", "test") {
      @Override
      @NotNull
      public OutputStream getOutputStream(Object requestor, long newModificationStamp, long newTimeStamp) throws IOException {
        throw new IOException("");
      }
    };

    final Document document = myDocumentManager.getDocument(file);
    assertNotNull(file.toString(), document);
    WriteCommandAction.runWriteCommandAction(getProject(), new Runnable() {
      @Override
      public void run() {
        document.insertString(0, "xxx");
      }
    });


    try {
      myDocumentManager.saveDocument(document);
      fail("must throw IOException");
    }
    catch (RuntimeException e) {
      assertTrue(e.getCause() instanceof IOException);
    }

    final Document[] unsavedDocuments = myDocumentManager.getUnsavedDocuments();
    assertEquals(1, unsavedDocuments.length);
    assertSame(document, unsavedDocuments[0]);
    assertEquals("test", new String(file.contentsToByteArray(), CharsetToolkit.UTF8_CHARSET));
  }
  finally {
    myDocumentManager.dropAllUnsavedDocuments();
  }
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testRememberSeparators() throws Exception {
  final VirtualFile file = new MockVirtualFile("test.txt", "test\rtest");
  final Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  WriteCommandAction.runWriteCommandAction(myProject, new Runnable() {
    @Override
    public void run() {
      document.insertString(0, "xxx ");
    }
  });

  myDocumentManager.saveAllDocuments();
  assertEquals("xxx test\rtest", new String(file.contentsToByteArray(), CharsetToolkit.UTF8_CHARSET));
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testContentChanged_ignoreEventsFromSelfOnSave() throws Exception {
  final VirtualFile file = new MockVirtualFile("test.txt", "test\rtest") {
    @NotNull
    @Override
    public OutputStream getOutputStream(final Object requestor, final long newModificationStamp, long newTimeStamp) throws IOException {
      final VirtualFile self = this;
      return new ByteArrayOutputStream() {
        @Override
        public void close() throws IOException {
          super.close();
          long oldStamp = getModificationStamp();
          setModificationStamp(newModificationStamp);
          setText(toString());
          myDocumentManager.contentsChanged(new VirtualFileEvent(requestor, self, null, oldStamp, getModificationStamp()));
        }
      };
    }
  };
  final Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  WriteCommandAction.runWriteCommandAction(myProject, new Runnable() {
    @Override
    public void run() {
      document.insertString(0, "xxx");
    }
  });

  final long stamp = document.getModificationStamp();

  myDocumentManager.saveAllDocuments();
  assertEquals(stamp, document.getModificationStamp());
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
public void testContentChanged_doNotReloadChangedDocumentOnSave() throws Exception {
  final MockVirtualFile file =
  new MockVirtualFile("test.txt", "test") {
    @Override
    public void refresh(boolean asynchronous, boolean recursive, Runnable postRunnable) {
      long oldStamp = getModificationStamp();
      setModificationStamp(LocalTimeCounter.currentTime());
      myDocumentManager.contentsChanged(new VirtualFileEvent(null, this, null, oldStamp, getModificationStamp()));
    }
  };

  myReloadFromDisk = Boolean.FALSE;
  final Document document = myDocumentManager.getDocument(file);
  assertNotNull(file.toString(), document);
  WriteCommandAction.runWriteCommandAction(myProject, new Runnable() {
    @Override
    public void run() {
      document.insertString(0, "old ");
    }
  });

  long documentStamp = document.getModificationStamp();

  file.setContent(null, "xxx", false);

  myDocumentManager.saveAllDocuments();

  assertEquals("old test", document.getText());
  assertEquals(file.getModificationStamp(), document.getModificationStamp());
  assertEquals("old test", new String(file.contentsToByteArray(), CharsetToolkit.UTF8_CHARSET));
  assertEquals(documentStamp, document.getModificationStamp());
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
private static MockVirtualFile dir(@NonNls @NotNull String name, MockVirtualFile... children) {
  final MockVirtualFile root = new MockVirtualFile(true, name);
  for (MockVirtualFile child : children) {
    root.addChild(child);
  }
  return root;
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
private static void link(@NonNls @NotNull String targetPath, @NotNull @NonNls String linkPath) {
  final VirtualFile target = myRoot.findFileByRelativePath(targetPath);
  assertNotNull(targetPath, target);
  final int pos = linkPath.lastIndexOf('/');
  final VirtualFile linkParent = myRoot.findFileByRelativePath(linkPath.substring(0, pos));
  assertNotNull(linkPath, linkParent);
  ((MockVirtualFile)linkParent).addChild(new MockVirtualLink(linkPath.substring(pos + 1), target));
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@Before
public void setup() {
    String artifactId = "myArtifact";
    String groupId = "myGroupId";
    ServerConfiguration serverConfiguration = new ServerConfiguration();
    module = new ServerConfiguration.Module( serverConfiguration, groupId + "." + artifactId, true, 0 );
    VirtualFile syncFolder = new MockVirtualFile(true, "baseDir");
    Project mockProject = new MockProject()
        .setBaseDir(syncFolder);
    UnifiedModule mockUnifiedModule = new MockUnifiedModule()
        .setSymbolicName(groupId + "." + artifactId)
        .setContentDirectoryPaths(Arrays.asList("/baseDir/" + JCR_ROOT_FOLDER_NAME));
    module.rebind(mockProject, mockUnifiedModule);
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
private MockVirtualFile createSharedViewsFolderVirtualFile() {
    MockVirtualFileWithPath sharedviewsFolder = new MockVirtualFileWithPath(true, "sharedviews");
    MockVirtualFileWithPath sharedViewsFile = new MockVirtualFileWithPath("sharedViews.view");
    sharedViewsFile.setPath(getClass().getClassLoader().getResource("resources/sharedviews/sharedViews.view").getPath());
    sharedviewsFolder.addChild(sharedViewsFile);

    MockVirtualFileWithPath subFolder = new MockVirtualFileWithPath(true, "subfolder");
    MockVirtualFileWithPath subFolderFile = new MockVirtualFileWithPath("subFolderFile.view");
    subFolderFile.setPath(getClass().getClassLoader().getResource("resources/sharedviews/subfolder/subFolderFile.view").getPath());
    subFolder.addChild(subFolderFile);
    sharedviewsFolder.addChild(subFolder);

    return sharedviewsFolder;
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@Test
public void createSuitableFilePattern_withInvalidFilename_doesNotMatch() {
  // unaccepted file name pattern, although correct content.
  MockVirtualFile invalidNameFile = new MockVirtualFile("myApp.yaml");
  FileContent wrongFile =
      new FileContentImpl(
          invalidNameFile, VALID_APP_ENGINE_FLEX_YAML_CONTENT, System.currentTimeMillis());

  assertThat(pattern.accepts(wrongFile)).isFalse();
}
 

import com.intellij.mock.MockVirtualFile; //导入依赖的package包/类
@Test
public void createSuitableFilePattern_appYml_withInvalidContent_doesNotMatch() {
  MockVirtualFile invalidYamlFile = new MockVirtualFile("app.yml");
  FileContent invalidYamlFileContent =
      new FileContentImpl(
          invalidYamlFile, NOT_APP_ENGINE_FLEX_YAML_CONTENT, System.currentTimeMillis());

  assertThat(pattern.accepts(invalidYamlFileContent)).isFalse();
}