diff --git a/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtFileSystemTest.java b/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtFileSystemTest.java index d28b5a304b38..436d43f0035d 100644 --- a/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtFileSystemTest.java +++ b/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtFileSystemTest.java @@ -2,6 +2,8 @@ package com.intellij.java.openapi.vfs; import com.intellij.JavaTestUtil; +import com.intellij.openapi.Disposable; +import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.SystemInfo; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.CharsetToolkit; @@ -10,14 +12,16 @@ import com.intellij.openapi.vfs.VirtualFile; import com.intellij.openapi.vfs.VirtualFileManager; import com.intellij.openapi.vfs.jrt.JrtFileSystem; import com.intellij.openapi.vfs.newvfs.events.VFileEvent; +import com.intellij.openapi.vfs.pointers.VirtualFilePointer; +import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager; import com.intellij.testFramework.VfsTestUtil; import com.intellij.testFramework.fixtures.BareTestFixtureTestCase; import com.intellij.testFramework.rules.TempDirectory; +import org.junit.After; import org.junit.Before; import org.junit.Rule; import org.junit.Test; -import java.io.File; import java.io.IOException; import java.nio.ByteBuffer; import java.nio.file.Files; @@ -33,6 +37,7 @@ import static org.assertj.core.api.Assertions.assertThat; public class JrtFileSystemTest extends BareTestFixtureTestCase { @Rule public TempDirectory myTempDir = new TempDirectory(); + private final Disposable myDisposable = Disposer.newDisposable(); private Path myTestData; private Path myTempPath; private VirtualFile myRoot; @@ -40,26 +45,26 @@ public class JrtFileSystemTest extends BareTestFixtureTestCase { @Before public void setUp() throws IOException { myTestData = Paths.get(JavaTestUtil.getJavaTestDataPath(), "jrt"); - File jrtDir = myTempDir.newFolder("jrt"); - myTempPath = jrtDir.toPath(); - myRoot = setupJrtFileSystem(jrtDir); + myTempPath = myTempDir.newFolder("jrt").toPath(); + + setupJrtFileSystem(); + myRoot = findRoot(myTempPath.toString()); + assertThat(myRoot).isNotNull(); + assertThat(JrtFileSystem.isRoot(myRoot)).isTrue(); } - public static VirtualFile setupJrtFileSystem(File jrtDir) throws IOException { - Path jrtPath = jrtDir.toPath(); + @After + public void tearDown() { + Disposer.dispose(myDisposable); + } - Files.write(jrtPath.resolve("release"), "JAVA_VERSION=9\n".getBytes(CharsetToolkit.UTF8_CHARSET)); - Path lib = Files.createDirectory(jrtPath.resolve("lib")); - - Path testData = Paths.get(JavaTestUtil.getJavaTestDataPath(), "jrt"); - Files.copy(testData.resolve("jrt-fs.jar"), lib.resolve("jrt-fs.jar")); - Files.copy(testData.resolve("image1"), lib.resolve("modules")); - LocalFileSystem.getInstance().refreshAndFindFileByIoFile(jrtDir.getParentFile()); - - VirtualFile root = findRoot(jrtPath.toString()); - assertThat(root).isNotNull(); - assertThat(JrtFileSystem.isRoot(root)).isTrue(); - return root; + private void setupJrtFileSystem() throws IOException { + Files.createDirectories(myTempPath); + Files.write(myTempPath.resolve("release"), "JAVA_VERSION=9\n".getBytes(CharsetToolkit.UTF8_CHARSET)); + Path lib = Files.createDirectory(myTempPath.resolve("lib")); + Files.copy(myTestData.resolve("jrt-fs.jar"), lib.resolve("jrt-fs.jar")); + Files.copy(myTestData.resolve("image1"), lib.resolve("modules")); + LocalFileSystem.getInstance().refreshAndFindFileByPath(myTempPath.toString()); } @Test @@ -105,6 +110,31 @@ public class JrtFileSystemTest extends BareTestFixtureTestCase { } } + @Test + public void filePointers() throws IOException { + VirtualFile vTemp = LocalFileSystem.getInstance().refreshAndFindFileByPath(myTempPath.toString()); + assertThat(vTemp).isNotNull(); + VirtualFilePointerManager manager = VirtualFilePointerManager.getInstance(); + VirtualFilePointer[] pointers = {manager.create(vTemp, myDisposable, null), manager.create(myRoot, myDisposable, null)}; + assertPointers(pointers, true); + + if (SystemInfo.isUnix) { + VirtualFile testRoot = vTemp.getParent(); + + assertThat(FileUtil.delete(myTempPath.toFile())).isTrue(); + testRoot.refresh(false, true); + assertPointers(pointers, false); + + setupJrtFileSystem(); + testRoot.refresh(false, true); + assertPointers(pointers, true); + + assertThat(FileUtil.delete(myTempPath.toFile())).isTrue(); + testRoot.refresh(false, true); + assertPointers(pointers, false); + } + } + private static VirtualFile findRoot(String path) { String url = VirtualFileManager.constructUrl(JrtFileSystem.PROTOCOL, path + JrtFileSystem.SEPARATOR); return VirtualFileManager.getInstance().findFileByUrl(url); @@ -113,4 +143,9 @@ public class JrtFileSystemTest extends BareTestFixtureTestCase { private static List childNames(VirtualFile dir) { return Stream.of(dir.getChildren()).map(VirtualFile::getName).collect(Collectors.toList()); } + + private static void assertPointers(VirtualFilePointer[] pointers, boolean valid) { + assertThat(pointers).allMatch(p -> p.isValid() == valid); + assertThat(pointers).allMatch(p -> p.getFile() == null || p.getFile().isValid()); + } } \ No newline at end of file diff --git a/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtVirtualFilePointerTest.java b/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtVirtualFilePointerTest.java deleted file mode 100644 index 4b50f05cf497..000000000000 --- a/java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtVirtualFilePointerTest.java +++ /dev/null @@ -1,117 +0,0 @@ -// Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE file. -package com.intellij.java.openapi.vfs; - -import com.intellij.openapi.Disposable; -import com.intellij.openapi.util.Disposer; -import com.intellij.openapi.util.SystemInfo; -import com.intellij.openapi.util.io.FileUtil; -import com.intellij.openapi.vfs.LocalFileSystem; -import com.intellij.openapi.vfs.VirtualFile; -import com.intellij.openapi.vfs.VirtualFileManager; -import com.intellij.openapi.vfs.impl.VirtualFilePointerManagerImpl; -import com.intellij.openapi.vfs.jrt.JrtFileSystem; -import com.intellij.openapi.vfs.pointers.VirtualFilePointer; -import com.intellij.openapi.vfs.pointers.VirtualFilePointerListener; -import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager; -import com.intellij.testFramework.PlatformTestUtil; -import com.intellij.testFramework.fixtures.LightPlatformCodeInsightFixtureTestCase; -import com.intellij.util.ui.UIUtil; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; - -import java.io.File; -import java.io.IOException; - -import static com.intellij.openapi.vfs.impl.VirtualFilePointerTest.*; -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assume.assumeTrue; - -/** - * @author yole - */ -public class JrtVirtualFilePointerTest extends LightPlatformCodeInsightFixtureTestCase { - - private VirtualFilePointerManagerImpl myVirtualFilePointerManager; - private Disposable myDisposable; - - public void setUp() throws Exception { - super.setUp(); - myVirtualFilePointerManager = (VirtualFilePointerManagerImpl)VirtualFilePointerManager.getInstance(); - myDisposable = Disposer.newDisposable(); - } - - public void tearDown() throws Exception { - try { - Disposer.dispose(myDisposable); - } - finally { - super.tearDown(); - } - } - - public void testJrt() throws Exception { - assumeTrue(SystemInfo.isUnix); - final File tempDir = FileUtil.createTempDirectory("jrt", ""); - LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDir); - JrtFileSystemTest.setupJrtFileSystem(tempDir); - - VirtualFile vTemp = PlatformTestUtil.notNull(refreshAndFindFile(tempDir)); - assertThat(vTemp.isValid()).isTrue(); - - final VirtualFilePointer[] pointersToWatch = new VirtualFilePointer[2]; - final VirtualFilePointerListener listener = new VirtualFilePointerListener() { - @Override - public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) { - verifyPointersInCorrectState(pointersToWatch); - } - - @Override - public void validityChanged(@NotNull VirtualFilePointer[] pointers) { - verifyPointersInCorrectState(pointersToWatch); - } - }; - final VirtualFilePointer jrtParentPointer = createPointerByFile(tempDir, listener); - final String jrtUrl = VirtualFileManager.constructUrl(JrtFileSystem.PROTOCOL, tempDir + JrtFileSystem.SEPARATOR); - final VirtualFilePointer jrtPointer = myVirtualFilePointerManager.create(jrtUrl, myDisposable, listener); - pointersToWatch[0] = jrtParentPointer; - pointersToWatch[1] = jrtPointer; - assertThat(jrtParentPointer.isValid()).isTrue(); - assertThat(jrtPointer.isValid()).isTrue(); - - assertThat(FileUtil.delete(tempDir)).isTrue(); - refreshVFS(); - - verifyPointersInCorrectState(pointersToWatch); - assertThat(jrtParentPointer.isValid()).isFalse(); - assertThat(jrtPointer.isValid()).isFalse(); - UIUtil.dispatchAllInvocationEvents(); - - FileUtil.createDirectory(tempDir); - LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDir); - JrtFileSystemTest.setupJrtFileSystem(tempDir); - - refreshVFS(); - verifyPointersInCorrectState(pointersToWatch); - assertThat(jrtParentPointer.isValid()).isTrue(); - assertThat(jrtPointer.isValid()).isTrue(); - UIUtil.dispatchAllInvocationEvents(); - - assertThat(FileUtil.delete(tempDir)).isTrue(); - refreshVFS(); - UIUtil.dispatchAllInvocationEvents(); - - verifyPointersInCorrectState(pointersToWatch); - assertThat(jrtParentPointer.isValid()).isFalse(); - assertThat(jrtPointer.isValid()).isFalse(); - UIUtil.dispatchAllInvocationEvents(); - } - - @NotNull - private VirtualFilePointer createPointerByFile(@NotNull File file, @Nullable VirtualFilePointerListener fileListener) throws IOException { - final String url = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, file.getCanonicalPath().replace(File.separatorChar, '/')); - final VirtualFile vFile = refreshAndFind(url); - return vFile == null - ? myVirtualFilePointerManager.create(url, myDisposable, fileListener) - : myVirtualFilePointerManager.create(vFile, myDisposable, fileListener); - } -} diff --git a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java index 799d8a0c90a3..a303051d1c39 100644 --- a/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java +++ b/platform/platform-tests/testSrc/com/intellij/openapi/vfs/impl/VirtualFilePointerTest.java @@ -7,171 +7,151 @@ import com.intellij.mock.MockVirtualFile; import com.intellij.openapi.Disposable; import com.intellij.openapi.application.ApplicationManager; import com.intellij.openapi.application.ReadAction; +import com.intellij.openapi.application.WriteAction; import com.intellij.openapi.application.ex.PathManagerEx; -import com.intellij.openapi.command.WriteCommandAction; -import com.intellij.openapi.roots.ModuleRootManager; -import com.intellij.openapi.roots.OrderRootType; -import com.intellij.openapi.roots.ProjectRootManager; -import com.intellij.openapi.roots.impl.OrderEntryUtil; -import com.intellij.openapi.roots.libraries.Library; -import com.intellij.openapi.roots.libraries.LibraryTable; -import com.intellij.openapi.roots.libraries.LibraryUtil; -import com.intellij.openapi.util.Computable; import com.intellij.openapi.util.Disposer; import com.intellij.openapi.util.io.FileUtil; import com.intellij.openapi.vfs.*; -import com.intellij.openapi.vfs.ex.temp.TempFileSystem; import com.intellij.openapi.vfs.newvfs.ManagingFS; -import com.intellij.openapi.vfs.newvfs.events.VFileCreateEvent; -import com.intellij.openapi.vfs.newvfs.events.VFileEvent; import com.intellij.openapi.vfs.pointers.VirtualFilePointer; import com.intellij.openapi.vfs.pointers.VirtualFilePointerListener; import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager; -import com.intellij.testFramework.*; -import com.intellij.util.ArrayUtil; +import com.intellij.testFramework.LightVirtualFile; +import com.intellij.testFramework.PlatformTestUtil; +import com.intellij.testFramework.Timings; +import com.intellij.testFramework.VfsTestUtil; +import com.intellij.testFramework.fixtures.BareTestFixtureTestCase; +import com.intellij.testFramework.rules.TempDirectory; import com.intellij.util.ConcurrencyUtil; +import com.intellij.util.ExceptionUtil; import com.intellij.util.IncorrectOperationException; import com.intellij.util.TimeoutUtil; import com.intellij.util.containers.ContainerUtil; import com.intellij.util.ui.UIUtil; -import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; import java.io.File; import java.io.IOException; import java.util.ArrayList; import java.util.Collection; import java.util.List; +import java.util.Locale; import java.util.concurrent.CountDownLatch; -import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; -import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicReference; import java.util.stream.Collectors; import java.util.stream.IntStream; -/** - * @author dsl - */ -public class VirtualFilePointerTest extends PlatformTestCase { - private VirtualFilePointerManagerImpl myVirtualFilePointerManager; - private int numberOfPointersBefore; - private final Disposable disposable = Disposer.newDisposable(); - private int numberOfListenersBefore; +import static com.intellij.openapi.util.io.FileUtil.toSystemIndependentName; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.*; - @Override - protected void setUp() throws Exception { - super.setUp(); +/** + * @author dsl + */ +public class VirtualFilePointerTest extends BareTestFixtureTestCase { + @Rule public TempDirectory myTempDir = new TempDirectory(); + + private final Disposable disposable = Disposer.newDisposable(); + private VirtualFilePointerManagerImpl myVirtualFilePointerManager; + private int numberOfPointersBefore, numberOfListenersBefore; + + @Before + public void setUp() { myVirtualFilePointerManager = (VirtualFilePointerManagerImpl)VirtualFilePointerManager.getInstance(); numberOfPointersBefore = myVirtualFilePointerManager.numberOfPointers(); numberOfListenersBefore = myVirtualFilePointerManager.numberOfListeners(); } - @Override - protected void tearDown() throws Exception { + @After + public void tearDown() { Disposer.dispose(disposable); - try { - assertEquals(numberOfPointersBefore, myVirtualFilePointerManager.numberOfPointers()); // check there is no leak - assertEquals(numberOfListenersBefore, myVirtualFilePointerManager.numberOfListeners()); // check there is no leak - } - finally { - myVirtualFilePointerManager = null; - super.tearDown(); - } + int nPointers = myVirtualFilePointerManager.numberOfPointers(), nListeners = myVirtualFilePointerManager.numberOfListeners(); + myVirtualFilePointerManager = null; + assertEquals(numberOfPointersBefore, nPointers); + assertEquals(numberOfListenersBefore, nListeners); } private static class LoggingListener implements VirtualFilePointerListener { - private final List myLog = new ArrayList<>(); + private final List log = new ArrayList<>(); @Override public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) { verifyPointersInCorrectState(pointers); - myLog.add(buildMessage("before", pointers)); - } - - private static String buildMessage(@NonNls final String startMsg, VirtualFilePointer[] pointers) { - StringBuilder buffer = new StringBuilder(startMsg); - buffer.append(":"); - for (int i = 0; i < pointers.length; i++) { - VirtualFilePointer pointer = pointers[i]; - final String s = Boolean.toString(pointer.isValid()); - if (i > 0) buffer.append(":"); - buffer.append(s); - } - return buffer.toString(); + log.add(buildMessage("before", pointers)); } @Override public void validityChanged(@NotNull VirtualFilePointer[] pointers) { verifyPointersInCorrectState(pointers); - myLog.add(buildMessage("after", pointers)); + log.add(buildMessage("after", pointers)); } - public List getLog() { - return myLog; + private static String buildMessage(String startMsg, VirtualFilePointer[] pointers) { + StringBuilder buffer = new StringBuilder(); + buffer.append(startMsg).append(':'); + for (int i = 0; i < pointers.length; i++) { + if (i > 0) buffer.append(':'); + buffer.append(pointers[i].isValid()); + } + return buffer.toString(); } } - public void testDelete() throws Exception { - File tempDirectory = createTempDirectory(); - final File fileToDelete = new File(tempDirectory, "toDelete.txt"); - assertTrue(fileToDelete.createNewFile()); - final LoggingListener fileToDeleteListener = new LoggingListener(); - final VirtualFilePointer fileToDeletePointer = createPointerByFile(fileToDelete, fileToDeleteListener); + @Test + public void testDelete() throws IOException { + File fileToDelete = myTempDir.newFile("toDelete.txt"); + LoggingListener fileToDeleteListener = new LoggingListener(); + VirtualFilePointer fileToDeletePointer = createPointerByFile(fileToDelete, fileToDeleteListener); assertTrue(fileToDeletePointer.isValid()); VfsTestUtil.deleteFile(getVirtualFile(fileToDelete)); assertFalse(fileToDeletePointer.isValid()); - assertEquals("[before:true, after:false]", fileToDeleteListener.getLog().toString()); + assertEquals("[before:true, after:false]", fileToDeleteListener.log.toString()); } - public void testCreate() throws Exception { - final File tempDirectory = createTempDirectory(); - final File fileToCreate = new File(tempDirectory, "toCreate.txt"); - final LoggingListener fileToCreateListener = new LoggingListener(); - final VirtualFilePointer fileToCreatePointer = createPointerByFile(fileToCreate, fileToCreateListener); + @Test + public void testCreate() throws IOException { + File fileToCreate = new File(myTempDir.getRoot(), "toCreate.txt"); + LoggingListener fileToCreateListener = new LoggingListener(); + VirtualFilePointer fileToCreatePointer = createPointerByFile(fileToCreate, fileToCreateListener); assertFalse(fileToCreatePointer.isValid()); assertTrue(fileToCreate.createNewFile()); - ApplicationManager.getApplication().runWriteAction(() -> { - VirtualFileManager.getInstance().syncRefresh(); - final VirtualFile virtualFile = getVirtualFile(tempDirectory); - virtualFile.refresh(false, true); - }); + getVirtualFile(myTempDir.getRoot()).refresh(false, true); assertTrue(fileToCreatePointer.isValid()); - assertEquals("[before:false, after:true]", fileToCreateListener.getLog().toString()); - try { - String expectedUrl = VirtualFileManager - .constructUrl(LocalFileSystem.PROTOCOL, fileToCreate.getCanonicalPath().replace(File.separatorChar, '/')); - assertEquals(expectedUrl.toUpperCase(), fileToCreatePointer.getUrl().toUpperCase()); - } - catch (IOException e) { - fail(); - } + assertEquals("[before:false, after:true]", fileToCreateListener.log.toString()); + String expectedUrl = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, toSystemIndependentName(fileToCreate.getPath())); + assertEquals(expectedUrl.toUpperCase(Locale.US), fileToCreatePointer.getUrl().toUpperCase(Locale.US)); } + @Test public void testUrlsHavingOnlyStartingSlashInCommon() { VirtualFilePointer p1 = myVirtualFilePointerManager.create("file:///a/p1", disposable, null); VirtualFilePointer p2 = myVirtualFilePointerManager.create("file:///b/p2", disposable, null); - final LightVirtualFile root = new LightVirtualFile("/"); + LightVirtualFile root = new LightVirtualFile("/"); LightVirtualFile a = createLightFile(root, "a"); LightVirtualFile b = createLightFile(root, "b"); - assertSameElements(myVirtualFilePointerManager.getPointersUnder(a, "p1"), p1); - assertSameElements(myVirtualFilePointerManager.getPointersUnder(b, "p2"), p2); + assertThat(myVirtualFilePointerManager.getPointersUnder(a, "p1")).containsExactly(p1); + assertThat(myVirtualFilePointerManager.getPointersUnder(b, "p2")).containsExactly(p2); } + @Test public void testUrlsHavingOnlyStartingSlashInCommonAndInvalidUrlBetweenThem() { VirtualFilePointer p1 = myVirtualFilePointerManager.create("file:///a/p1", disposable, null); myVirtualFilePointerManager.create("file://invalid/path", disposable, null); VirtualFilePointer p2 = myVirtualFilePointerManager.create("file:///b/p2", disposable, null); - final LightVirtualFile root = new LightVirtualFile("/"); + LightVirtualFile root = new LightVirtualFile("/"); LightVirtualFile a = createLightFile(root, "a"); LightVirtualFile b = createLightFile(root, "b"); - assertSameElements(myVirtualFilePointerManager.getPointersUnder(a, "p1"), p1); - assertSameElements(myVirtualFilePointerManager.getPointersUnder(b, "p2"), p2); + assertThat(myVirtualFilePointerManager.getPointersUnder(a, "p1")).containsExactly(p1); + assertThat(myVirtualFilePointerManager.getPointersUnder(b, "p2")).containsExactly(p2); } - @NotNull - private static LightVirtualFile createLightFile(final LightVirtualFile parent, final String name) { + private static LightVirtualFile createLightFile(LightVirtualFile parent, String name) { return new LightVirtualFile(name) { @Override public VirtualFile getParent() { @@ -180,27 +160,29 @@ public class VirtualFilePointerTest extends PlatformTestCase { }; } - public void testPathNormalization() throws Exception { + @Test + public void testPathNormalization() throws IOException { checkFileName("///", ""); } - public void testPathNormalization2() throws Exception { + + @Test + public void testPathNormalization2() throws IOException { checkFileName("\\\\", "/"); } - public void testPathNormalization3() throws Exception { + + @Test + public void testPathNormalization3() throws IOException { checkFileName("//", "/////"); } private void checkFileName(String prefix, String suffix) throws IOException { - final File tempDirectory = createTempDirectory(); - - final VirtualFile temp = getVirtualFile(tempDirectory); + VirtualFile temp = getVirtualFile(myTempDir.getRoot()); String name = "toCreate.txt"; - final VirtualFilePointer fileToCreatePointer = createPointerByFile(new File(tempDirectory.getPath() + prefix + name +suffix), null); + VirtualFilePointer fileToCreatePointer = createPointerByFile(new File(myTempDir.getRoot() + prefix + name + suffix), null); assertFalse(fileToCreatePointer.isValid()); assertNull(fileToCreatePointer.getFile()); - VirtualFile child = createChildData(temp, name); - + VirtualFile child = WriteAction.computeAndWait(() -> temp.createChildData(null, name)); assertTrue(fileToCreatePointer.isValid()); assertEquals(child, fileToCreatePointer.getFile()); @@ -209,251 +191,169 @@ public class VirtualFilePointerTest extends PlatformTestCase { assertNull(fileToCreatePointer.getFile()); } - public void testMovePointedFile() throws Exception { - File tempDirectory = createTempDirectory(); - final File moveTarget = new File(tempDirectory, "moveTarget"); - assertTrue(moveTarget.mkdir()); - final File fileToMove = new File(tempDirectory, "toMove.txt"); - assertTrue(fileToMove.createNewFile()); + @Test + public void testMovePointedFile() throws IOException { + File moveTarget = myTempDir.newFolder("moveTarget"); + File fileToMove = myTempDir.newFile("toMove.txt"); - final LoggingListener fileToMoveListener = new LoggingListener(); - final VirtualFilePointer fileToMovePointer = createPointerByFile(fileToMove, fileToMoveListener); + LoggingListener fileToMoveListener = new LoggingListener(); + VirtualFilePointer fileToMovePointer = createPointerByFile(fileToMove, fileToMoveListener); assertTrue(fileToMovePointer.isValid()); - ApplicationManager.getApplication().runWriteAction(() -> { - final VirtualFile virtualFile = getVirtualFile(fileToMove); - assertTrue(virtualFile.isValid()); - final VirtualFile target = getVirtualFile(moveTarget); - assertTrue(target.isValid()); - try { - virtualFile.move(null, target); - } - catch (IOException e) { - fail(); - } - }); + doMove(fileToMove, moveTarget); assertTrue(fileToMovePointer.isValid()); - assertEquals("[before:true, after:true]", fileToMoveListener.getLog().toString()); + assertEquals("[before:true, after:true]", fileToMoveListener.log.toString()); } - public void testMoveFileUnderExistingPointer() throws Exception { - File tempDirectory = createTempDirectory(); - final File moveTarget = new File(tempDirectory, "moveTarget"); - assertTrue(moveTarget.mkdir()); - final File fileToMove = new File(tempDirectory, "toMove.txt"); - assertTrue(fileToMove.createNewFile()); + @Test + public void testMoveFileUnderExistingPointer() throws IOException { + File moveTarget = myTempDir.newFolder("moveTarget"); + File fileToMove = myTempDir.newFile("toMove.txt"); - final LoggingListener listener = new LoggingListener(); - final VirtualFilePointer fileToMoveTargetPointer = createPointerByFile(new File(moveTarget, fileToMove.getName()), listener); + LoggingListener listener = new LoggingListener(); + VirtualFilePointer fileToMoveTargetPointer = createPointerByFile(new File(moveTarget, fileToMove.getName()), listener); assertFalse(fileToMoveTargetPointer.isValid()); - ApplicationManager.getApplication().runWriteAction(() -> { - final VirtualFile virtualFile = getVirtualFile(fileToMove); - assertTrue(virtualFile.isValid()); - final VirtualFile target = getVirtualFile(moveTarget); - assertTrue(target.isValid()); - try { - virtualFile.move(null, target); - } - catch (IOException e) { - fail(); - } - }); + doMove(fileToMove, moveTarget); assertTrue(fileToMoveTargetPointer.isValid()); - assertEquals("[before:false, after:true]", listener.getLog().toString()); + assertEquals("[before:false, after:true]", listener.log.toString()); } - public void testMoveSrcDirUnderNewRootShouldGenerateRootsChanged() throws Exception { - File tempDirectory = createTempDirectory(); - final File moveTarget = new File(tempDirectory, "moveTarget"); - assertTrue(moveTarget.mkdir()); - final File dirToMove = new File(tempDirectory, "dirToMove"); - assertTrue(dirToMove.mkdir()); + @Test + public void testMoveSrcDirUnderNewRootShouldGenerateRootsChanged() throws IOException { + File moveTarget = myTempDir.newFolder("moveTarget"); + File dirToMove = myTempDir.newFolder("dirToMove"); - final LoggingListener listener = new LoggingListener(); - final VirtualFilePointer dirToMovePointer = createPointerByFile(dirToMove, listener); + LoggingListener listener = new LoggingListener(); + VirtualFilePointer dirToMovePointer = createPointerByFile(dirToMove, listener); assertTrue(dirToMovePointer.isValid()); - ApplicationManager.getApplication().runWriteAction(() -> { - final VirtualFile virtualFile = getVirtualFile(dirToMove); - assertTrue(virtualFile.isValid()); - final VirtualFile target = getVirtualFile(moveTarget); - assertTrue(target.isValid()); - try { - virtualFile.move(null, target); - } - catch (IOException e) { - fail(); - } - }); + doMove(dirToMove, moveTarget); assertTrue(dirToMovePointer.isValid()); - assertEquals("[before:true, after:true]", listener.getLog().toString()); + assertEquals("[before:true, after:true]", listener.log.toString()); } - public void testMovePointedFileUnderAnotherPointer() throws Exception { - File tempDirectory = createTempDirectory(); - final File moveTarget = new File(tempDirectory, "moveTarget"); - assertTrue(moveTarget.mkdir()); - final File fileToMove = new File(tempDirectory, "toMove.txt"); - assertTrue(fileToMove.createNewFile()); + @Test + public void testMovePointedFileUnderAnotherPointer() throws IOException { + File moveTarget = myTempDir.newFolder("moveTarget"); + File fileToMove = myTempDir.newFile("toMove.txt"); - final LoggingListener listener = new LoggingListener(); - final LoggingListener targetListener = new LoggingListener(); + LoggingListener listener = new LoggingListener(); + LoggingListener targetListener = new LoggingListener(); - final VirtualFilePointer fileToMovePointer = createPointerByFile(fileToMove, listener); - final VirtualFilePointer fileToMoveTargetPointer = createPointerByFile(new File(moveTarget, fileToMove.getName()), targetListener); + VirtualFilePointer fileToMovePointer = createPointerByFile(fileToMove, listener); + VirtualFilePointer fileToMoveTargetPointer = createPointerByFile(new File(moveTarget, fileToMove.getName()), targetListener); assertFalse(fileToMoveTargetPointer.isValid()); - ApplicationManager.getApplication().runWriteAction(() -> { - final VirtualFile virtualFile = getVirtualFile(fileToMove); - assertTrue(virtualFile.isValid()); - final VirtualFile target = getVirtualFile(moveTarget); - assertTrue(target.isValid()); - try { - virtualFile.move(null, target); - } - catch (IOException e) { - fail(); - } - }); + doMove(fileToMove, moveTarget); assertTrue(fileToMovePointer.isValid()); assertTrue(fileToMoveTargetPointer.isValid()); - assertEquals("[before:true, after:true]", listener.getLog().toString()); - assertEquals("[before:false, after:true]", targetListener.getLog().toString()); + assertEquals("[before:true, after:true]", listener.log.toString()); + assertEquals("[before:false, after:true]", targetListener.log.toString()); } + private void doMove(File fileToMove, File moveTarget) throws IOException { + VirtualFile virtualFile = getVirtualFile(fileToMove); + assertTrue(virtualFile.isValid()); + VirtualFile target = getVirtualFile(moveTarget); + assertTrue(target.isValid()); + WriteAction.runAndWait(() -> virtualFile.move(this, target)); + } + + @Test public void testRenamingPointedFile() throws IOException { - final File tempDir = createTempDirectory(); - final File file = new File(tempDir, "f1"); - assertTrue(file.createNewFile()); - - final LoggingListener listener = new LoggingListener(); + File file = myTempDir.newFile("f1"); + LoggingListener listener = new LoggingListener(); VirtualFilePointer pointer = createPointerByFile(file, listener); assertTrue(pointer.isValid()); - rename(getVirtualFile(file), "f2"); + WriteAction.runAndWait(() -> getVirtualFile(file).rename(this, "f2")); assertTrue(pointer.isValid()); - assertEquals("[]", listener.getLog().toString()); + assertEquals("[]", listener.log.toString()); } + @Test public void testRenamingFileUnderTheExistingPointer() throws IOException { - final File tempDir = createTempDirectory(); - final File file = new File(tempDir, "f1"); - assertTrue(file.createNewFile()); - - final LoggingListener listener = new LoggingListener(); + File file = myTempDir.newFile("f1"); + LoggingListener listener = new LoggingListener(); VirtualFilePointer pointer = createPointerByFile(new File(file.getParent(), "f2"), listener); assertFalse(pointer.isValid()); - rename(getVirtualFile(file), "f2"); + WriteAction.runAndWait(() -> getVirtualFile(file).rename(this, "f2")); assertTrue(pointer.isValid()); - assertEquals("[before:false, after:true]", listener.getLog().toString()); + assertEquals("[before:false, after:true]", listener.log.toString()); } + @Test public void testTwoPointersBecomeOneAfterFileRenamedUnderTheOtherName() throws IOException { - final File tempDir = createTempDirectory(); - final File f1 = new File(tempDir, "f1"); - boolean created = f1.createNewFile(); - assertTrue(created); - - final String url1 = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, f1.getCanonicalPath().replace(File.separatorChar, '/')); - final VirtualFile vFile1 = refreshAndFind(url1); - - final LoggingListener listener1 = new LoggingListener(); + File f1 = myTempDir.newFile("f1"); + VirtualFile vFile1 = getVirtualFile(f1); + String url1 = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, toSystemIndependentName(f1.getPath())); + LoggingListener listener1 = new LoggingListener(); VirtualFilePointer pointer1 = myVirtualFilePointerManager.create(url1, disposable, listener1); assertTrue(pointer1.isValid()); - String url2 = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, tempDir.getCanonicalPath().replace(File.separatorChar, '/')+"/f2"); - final LoggingListener listener2 = new LoggingListener(); + + String url2 = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, toSystemIndependentName(f1.getParent()) + "/f2"); + LoggingListener listener2 = new LoggingListener(); VirtualFilePointer pointer2 = myVirtualFilePointerManager.create(url2, disposable, listener2); assertFalse(pointer2.isValid()); - rename(vFile1, "f2"); + WriteAction.runAndWait(() -> vFile1.rename(this, "f2")); assertTrue(pointer1.isValid()); assertTrue(pointer2.isValid()); - - assertEquals("[]", listener1.getLog().toString()); - assertEquals("[before:false, after:true]", listener2.getLog().toString()); + assertEquals("[]", listener1.log.toString()); + assertEquals("[before:false, after:true]", listener2.log.toString()); } - public void testCreate1() throws Exception { - final File tempDirectory = createTempDirectory(); - final File fileToCreate = new File(tempDirectory, "toCreate1.txt"); - final LoggingListener fileToCreateListener = new LoggingListener(); - final VirtualFilePointer fileToCreatePointer = createPointerByFile(fileToCreate, fileToCreateListener); + @Test + public void testCreate1() throws IOException { + File fileToCreate = new File(myTempDir.getRoot(), "toCreate1.txt"); + LoggingListener fileToCreateListener = new LoggingListener(); + VirtualFilePointer fileToCreatePointer = createPointerByFile(fileToCreate, fileToCreateListener); assertFalse(fileToCreatePointer.isValid()); assertTrue(fileToCreate.createNewFile()); - final Runnable postRunnable = () -> { - assertTrue(fileToCreatePointer.isValid()); - assertEquals("[before:false, after:true]", fileToCreateListener.getLog().toString()); - try { - String expectedUrl = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, fileToCreate.getCanonicalPath().replace(File.separatorChar, '/')); - assertEquals(expectedUrl.toUpperCase(), fileToCreatePointer.getUrl().toUpperCase()); - } catch (IOException e) { - fail(); - } - }; - ApplicationManager.getApplication().runWriteAction(() -> { - VirtualFileManager.getInstance().syncRefresh(); - final VirtualFile virtualFile = getVirtualFile(tempDirectory); - virtualFile.refresh(false, true); - }); - postRunnable.run(); + getVirtualFile(myTempDir.getRoot()).refresh(false, true); + assertTrue(fileToCreatePointer.isValid()); + assertEquals("[before:false, after:true]", fileToCreateListener.log.toString()); + String expectedUrl = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, toSystemIndependentName(fileToCreate.getPath())); + assertThat(expectedUrl).isEqualToIgnoringCase(fileToCreatePointer.getUrl()); } - public void testMultipleNotifications() throws Exception { - final File tempDir = createTempDirectory(); - final File file_f1 = new File(tempDir, "f1"); - final File file_f2 = new File(tempDir, "f2"); - final LoggingListener listener = new LoggingListener(); - final VirtualFilePointer pointer_f1 = createPointerByFile(file_f1, listener); - final VirtualFilePointer pointer_f2 = createPointerByFile(file_f2, listener); - assertFalse(pointer_f1.isValid()); - assertFalse(pointer_f2.isValid()); - assertTrue(file_f1.createNewFile()); - assertTrue(file_f2.createNewFile()); - ApplicationManager.getApplication().runWriteAction(() -> LocalFileSystem.getInstance().refresh(false)); - assertEquals("[before:false:false, after:true:true]", listener.getLog().toString()); + @Test + public void testMultipleNotifications() throws IOException { + File file1 = new File(myTempDir.getRoot(), "f1"); + File file2 = new File(myTempDir.getRoot(), "f2"); + LoggingListener listener = new LoggingListener(); + VirtualFilePointer pointer1 = createPointerByFile(file1, listener); + VirtualFilePointer pointer2 = createPointerByFile(file2, listener); + assertFalse(pointer1.isValid()); + assertFalse(pointer2.isValid()); + assertTrue(file1.createNewFile()); + assertTrue(file2.createNewFile()); + getVirtualFile(myTempDir.getRoot()).refresh(false, true); + assertEquals("[before:false:false, after:true:true]", listener.log.toString()); } - public void testJars() throws Exception { - final File tempDir = createTempDirectory(); - VirtualFile vTemp = PlatformTestUtil.notNull(refreshAndFindFile(tempDir)); - assertTrue(vTemp.isValid()); - - final File jarParent = new File(tempDir, "jarParent"); - assertTrue(jarParent.mkdir()); - final File jar = new File(jarParent, "x.jar"); - final File originalJar = new File(PathManagerEx.getTestDataPath() + "/psi/generics22/collect-2.2.jar"); + @Test + public void testJars() throws IOException { + VirtualFile vTemp = getVirtualFile(myTempDir.getRoot()); + File jarParent = myTempDir.newFolder("jarParent"); + File jar = new File(jarParent, "x.jar"); + File originalJar = new File(PathManagerEx.getTestDataPath() + "/psi/generics22/collect-2.2.jar"); FileUtil.copy(originalJar, jar); + getVirtualFile(jar); // Make sure we receive events when jar changes - LocalFileSystem.getInstance().refreshAndFindFileByIoFile(jar); // Make sure we receive events when jar changes - - final VirtualFilePointer[] pointersToWatch = new VirtualFilePointer[2]; - final VirtualFilePointerListener listener = new VirtualFilePointerListener() { - @Override - public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) { - verifyPointersInCorrectState(pointersToWatch); - } - - @Override - public void validityChanged(@NotNull VirtualFilePointer[] pointers) { - verifyPointersInCorrectState(pointersToWatch); - } - }; - final VirtualFilePointer jarParentPointer = createPointerByFile(jarParent, listener); - final String pathInJar = jar.getPath().replace(File.separatorChar, '/') + JarFileSystem.JAR_SEPARATOR; - final String jarUrl = VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, pathInJar); - final VirtualFilePointer jarPointer = myVirtualFilePointerManager.create(jarUrl, disposable, listener); - pointersToWatch[0] = jarParentPointer; - pointersToWatch[1] = jarPointer; + VirtualFilePointerListener listener = new LoggingListener(); + VirtualFilePointer jarParentPointer = createPointerByFile(jarParent, listener); + String jarUrl = VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, toSystemIndependentName(jar.getPath()) + JarFileSystem.JAR_SEPARATOR); + VirtualFilePointer jarPointer = myVirtualFilePointerManager.create(jarUrl, disposable, listener); + VirtualFilePointer[] pointersToWatch = {jarParentPointer, jarPointer}; assertTrue(jarParentPointer.isValid()); assertTrue(jarPointer.isValid()); assertTrue(jar.delete()); assertTrue(jarParent.delete()); - refreshVFS(); - + vTemp.refresh(false, true); verifyPointersInCorrectState(pointersToWatch); assertFalse(jarParentPointer.isValid()); assertFalse(jarPointer.isValid()); - UIUtil.dispatchAllInvocationEvents(); - assertEmpty(vTemp.getChildren()); + assertThat(vTemp.getChildren()).isEmpty(); assertTrue(jarParent.mkdir()); FileUtil.copy(originalJar, jar); @@ -461,197 +361,102 @@ public class VirtualFilePointerTest extends PlatformTestCase { assertTrue(jar.exists()); assertTrue(jarParent.exists()); assertTrue(jarParent.getParentFile().exists()); - File child = assertOneElement(PlatformTestUtil.notNull(jarParent.listFiles())); - assertEquals(jar.getName(), child.getName()); - - refreshVFS(); + assertThat(jarParent.list()).containsExactly(jar.getName()); + vTemp.refresh(false, true); verifyPointersInCorrectState(pointersToWatch); assertTrue(jarParentPointer.isValid()); assertTrue(jarPointer.isValid()); - UIUtil.dispatchAllInvocationEvents(); assertTrue(jar.delete()); assertTrue(jarParent.delete()); - refreshVFS(); - UIUtil.dispatchAllInvocationEvents(); - + vTemp.refresh(false, true); verifyPointersInCorrectState(pointersToWatch); assertFalse(jarParentPointer.isValid()); assertFalse(jarPointer.isValid()); - UIUtil.dispatchAllInvocationEvents(); } - public void testJars2() throws Exception { - final File tempDir = createTempDirectory(); - final File jarParent = new File(tempDir, "jarParent"); - assertTrue(jarParent.mkdir()); - VirtualFile vJarParent = LocalFileSystem.getInstance().findFileByIoFile(jarParent); - assertNotNull(vJarParent); - final File jar = new File(jarParent, "x.jar"); - final File originalJar = new File(PathManagerEx.getTestDataPath() + "/psi/generics22/collect-2.2.jar"); + @Test + public void testJars2() throws IOException { + VirtualFile vTemp = getVirtualFile(myTempDir.getRoot()); + File jarParent = myTempDir.newFolder("jarParent"); + File jar = new File(jarParent, "x.jar"); + File originalJar = new File(PathManagerEx.getTestDataPath() + "/psi/generics22/collect-2.2.jar"); FileUtil.copy(originalJar, jar); + getVirtualFile(jar); // Make sure we receive events when jar changes - LocalFileSystem.getInstance().refreshAndFindFileByIoFile(jar); // Make sure we receive events when jar changes - - final VirtualFilePointer[] pointersToWatch = new VirtualFilePointer[1]; - final VirtualFilePointerListener listener = new VirtualFilePointerListener() { - @Override - public void beforeValidityChanged(@NotNull VirtualFilePointer[] pointers) { - verifyPointersInCorrectState(pointersToWatch); - } - - @Override - public void validityChanged(@NotNull VirtualFilePointer[] pointers) { - verifyPointersInCorrectState(pointersToWatch); - } - }; - final String pathInJar = jar.getPath().replace(File.separatorChar, '/') + JarFileSystem.JAR_SEPARATOR; - final String jarUrl = VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, pathInJar); - final VirtualFilePointer jarPointer = myVirtualFilePointerManager.create(jarUrl, disposable, listener); - pointersToWatch[0] = jarPointer; + VirtualFilePointerListener listener = new LoggingListener(); + String jarUrl = VirtualFileManager.constructUrl(JarFileSystem.PROTOCOL, toSystemIndependentName(jar.getPath()) + JarFileSystem.JAR_SEPARATOR); + VirtualFilePointer jarPointer = myVirtualFilePointerManager.create(jarUrl, disposable, listener); + VirtualFilePointer[] pointersToWatch = {jarPointer}; assertTrue(jar.delete()); - long start = System.currentTimeMillis(); + long stop = System.currentTimeMillis() + 10_000; int i; - for (i=0; System.currentTimeMillis() < start + 10_000 && i < 30;i++) { - refreshVFS(); - + for (i = 0; System.currentTimeMillis() < stop && i < 30; i++) { + vTemp.refresh(false, true); verifyPointersInCorrectState(pointersToWatch); assertFalse(jarPointer.isValid()); - UIUtil.dispatchAllInvocationEvents(); - assertTrue(jarParent.exists()); LOG.debug("before structureModificationCount=" + ManagingFS.getInstance().getStructureModificationCount()); - VirtualFile vJar = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(jar); + VirtualFile vJar = getVirtualFile(jar); assertNull(vJar); + LOG.debug("copying"); - FileUtil.copy(originalJar, jar); - assert jar.exists(); - - refreshVFS(); + vTemp.refresh(false, true); verifyPointersInCorrectState(pointersToWatch); - vJar = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(jar); + vJar = getVirtualFile(jar); assertNotNull(vJar); LOG.debug("after structureModificationCount=" + ManagingFS.getInstance().getStructureModificationCount()); assertTrue(jarPointer.isValid()); - UIUtil.dispatchAllInvocationEvents(); assertTrue(jar.delete()); - refreshVFS(); - UIUtil.dispatchAllInvocationEvents(); - + vTemp.refresh(false, true); verifyPointersInCorrectState(pointersToWatch); assertFalse(jarPointer.isValid()); - UIUtil.dispatchAllInvocationEvents(); } - LOG.debug("final i = " + i); + LOG.debug("i = " + i); } - public static void refreshVFS() { - ApplicationManager.getApplication().runWriteAction(() -> { - VirtualFileManager.getInstance().syncRefresh(); - }); - UIUtil.dispatchAllInvocationEvents(); - } - - public static void verifyPointersInCorrectState(VirtualFilePointer[] pointers) { - for (VirtualFilePointer pointer : pointers) { - final VirtualFile file = pointer.getFile(); - assertTrue(file == null || file.isValid()); - } - } - - @NotNull - private VirtualFilePointer createPointerByFile(@NotNull File file, @Nullable VirtualFilePointerListener fileListener) throws IOException { - final String url = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, file.getCanonicalPath().replace(File.separatorChar, '/')); - final VirtualFile vFile = refreshAndFind(url); - return vFile == null - ? myVirtualFilePointerManager.create(url, disposable, fileListener) - : myVirtualFilePointerManager.create(vFile, disposable, fileListener); - } - - public void testFilePointerUpdate() throws Exception { - final File tempDir = createTempDirectory(); - final File file = new File(tempDir, "f1"); - - final VirtualFilePointer pointer = createPointerByFile(file, null); - + @Test + public void testFilePointerUpdate() throws IOException { + VirtualFile vTemp = getVirtualFile(myTempDir.getRoot()); + File file = new File(myTempDir.getRoot(), "f1"); + VirtualFilePointer pointer = createPointerByFile(file, null); assertFalse(pointer.isValid()); - boolean created = file.createNewFile(); - assertTrue(created); - - - doVfsRefresh(tempDir); - + assertTrue(file.createNewFile()); + vTemp.refresh(false, true); assertTrue(pointer.isValid()); - boolean deleted = file.delete(); - assertTrue(deleted); - - doVfsRefresh(tempDir); + assertTrue(file.delete()); + vTemp.refresh(false, true); assertFalse(pointer.isValid()); } - public void testContainerCreateDeletePerformance() { - PlatformTestUtil.startPerformanceTest("VF container create/delete", 100, () -> { - Disposable parent = Disposer.newDisposable(); - for (int i = 0; i < 10_000; i++) { - myVirtualFilePointerManager.createContainer(parent); - } - Disposer.dispose(parent); - }).assertTiming(); - } - - private static void doVfsRefresh(File dir) { - VirtualFile file = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(dir)); - file.refresh(false, true); - } - + @Test public void testDoubleDispose() throws IOException { - final File tempDir = createTempDirectory(); - final File file = new File(tempDir, "f1"); - boolean created = file.createNewFile(); - assertTrue(created); - - - final String url = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, file.getCanonicalPath().replace(File.separatorChar, '/')); - final VirtualFile vFile = refreshAndFind(url); - + File file = myTempDir.newFile("f1"); + VirtualFile vFile = getVirtualFile(file); Disposable disposable = Disposer.newDisposable(); - final VirtualFilePointer pointer = myVirtualFilePointerManager.create(vFile, disposable, new VirtualFilePointerListener() { - }); - - + VirtualFilePointer pointer = myVirtualFilePointerManager.create(vFile, disposable, null); assertTrue(pointer.isValid()); - Disposer.dispose(disposable); assertFalse(pointer.isValid()); } - public static VirtualFile refreshAndFind(@NotNull final String url) { - return WriteCommandAction.runWriteCommandAction(null, (Computable)() -> VirtualFileManager.getInstance().refreshAndFindFileByUrl(url)); - } + @Test + public void testThreadsPerformance() throws Exception { + VirtualFile vTemp = getVirtualFile(myTempDir.getRoot()); + File ioSandPtr = myTempDir.newFile("parent2/f2"); + File ioPtr = myTempDir.newFile("parent1/f1"); - public void testThreadsPerformance() throws IOException, InterruptedException, TimeoutException, ExecutionException { - final File ioTempDir = createTempDirectory(); - final File ioSand = new File(ioTempDir, "sand"); - final File ioSandPtr = new File(ioSand, "f2"); - assertTrue(ioSandPtr.getParentFile().mkdirs()); - assertTrue(ioSandPtr.createNewFile()); - final File ioPtrBase = new File(ioTempDir, "parent"); - final File ioPtr = new File(ioPtrBase, "f1"); - assertTrue(ioPtr.getParentFile().mkdirs()); - assertTrue(ioPtr.createNewFile()); - - doVfsRefresh(ioTempDir); - final VirtualFilePointer pointer = createPointerByFile(ioPtr, null); + vTemp.refresh(false, true); + VirtualFilePointer pointer = createPointerByFile(ioPtr, null); assertTrue(pointer.isValid()); - final VirtualFile virtualFile = pointer.getFile(); - assertNotNull(virtualFile); - assertTrue(virtualFile.isValid()); - final Collection> reads = ContainerUtil.newConcurrentSet(); + assertNotNull(pointer.getFile()); + assertTrue(pointer.getFile().isValid()); + Collection> reads = ContainerUtil.newConcurrentSet(); VirtualFileListener listener = new VirtualFileListener() { @Override public void fileCreated(@NotNull VirtualFileEvent event) { @@ -668,27 +473,24 @@ public class VirtualFilePointerTest extends PlatformTestCase { try { int N = Timings.adjustAccordingToMySpeed(1000, false); LOG.debug("N = " + N); - for (int i=0;i< N;i++) { + for (int i = 0; i < N; i++) { assertNotNull(pointer.getFile()); - FileUtil.delete(ioPtrBase); - doVfsRefresh(ioTempDir); + FileUtil.delete(ioPtr.getParentFile()); + vTemp.refresh(false, true); // ptr is now null, cached as map - VirtualFile v = PlatformTestUtil.notNull(LocalFileSystem.getInstance().findFileByIoFile(ioSandPtr)); - WriteCommandAction.writeCommandAction(getProject()).run(() -> { + WriteAction.runAndWait(() -> { v.delete(this); //inc FS modCount - VirtualFile file = PlatformTestUtil.notNull(LocalFileSystem.getInstance().findFileByIoFile(ioSand)); + VirtualFile file = PlatformTestUtil.notNull(LocalFileSystem.getInstance().findFileByIoFile(ioSandPtr.getParentFile())); file.createChildData(this, ioSandPtr.getName()); }); // ptr is still null - - assertTrue(ioPtrBase.mkdirs()); + assertTrue(ioPtr.getParentFile().mkdirs()); assertTrue(ioPtr.createNewFile()); - stressRead(pointer, reads); - doVfsRefresh(ioTempDir); + vTemp.refresh(false, true); } } finally { @@ -701,9 +503,9 @@ public class VirtualFilePointerTest extends PlatformTestCase { } } - private static void stressRead(@NotNull final VirtualFilePointer pointer, @NotNull final Collection> reads) { + private static void stressRead(VirtualFilePointer pointer, Collection> reads) { for (int i = 0; i < 10; i++) { - final AtomicReference> reference = new AtomicReference<>(); + AtomicReference> reference = new AtomicReference<>(); reference.set(JobLauncher.getInstance().submitToJobThread(() -> ApplicationManager.getApplication().runReadAction(() -> { VirtualFile file = pointer.getFile(); if (file != null && !file.isValid()) { @@ -724,91 +526,11 @@ public class VirtualFilePointerTest extends PlatformTestCase { } } - public void testManyPointersUpdatePerformance() throws IOException { - LoggingListener listener = new LoggingListener(); - final File ioTempDir = createTempDirectory(); - final VirtualFile temp = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(ioTempDir)); - final List events = new ArrayList<>(); - myVirtualFilePointerManager.shelveAllPointersIn(()->{ - for (int i = 0; i < 100_000; i++) { - myVirtualFilePointerManager.create(VfsUtilCore.pathToUrl("/a/b/c/d/" + i), disposable, listener); - events.add(new VFileCreateEvent(this, temp, "xxx" + i, false, true)); - } - PlatformTestUtil.startPerformanceTest("vfp update", 5000, () -> { - for (int i=0; i< 100; i++) { - // simulate VFS refresh events since launching the actual refresh is too slow - myVirtualFilePointerManager.before(events); - myVirtualFilePointerManager.after(events); - } - }).assertTiming(); - }); - } - - public void testMultipleCreationOfTheSamePointerPerformance() { - final LoggingListener listener = new LoggingListener(); - final String url = VfsUtilCore.pathToUrl("/a/b/c/d/e"); - final VirtualFilePointer thePointer = myVirtualFilePointerManager.create(url, disposable, listener); - assertNotNull(TempFileSystem.getInstance()); - PlatformTestUtil.startPerformanceTest("same url vfp create", 9000, () -> { - for (int i = 0; i < 10_000_000; i++) { - VirtualFilePointer pointer = myVirtualFilePointerManager.create(url, disposable, listener); - assertSame(pointer, thePointer); - } - }).assertTiming(); - } - - public void testCidrCrazyAddCreateRenames() throws IOException { - File tempDirectory = createTempDirectory(); - final VirtualFile root = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory)); - - VirtualFile dir1 = createChildDirectory(root, "dir1"); - VirtualFile dir2 = createChildDirectory(root, "dir2"); - - PsiTestUtil.addSourceRoot(getModule(), dir1); - PsiTestUtil.addLibrary(getModule(), "mylib", "", new String[]{dir2.getPath()}, ArrayUtil.EMPTY_STRING_ARRAY); - - assertSourceIs(dir1); - assertLibIs(dir2); - - delete(dir1); - assertSourceIs(null); // srcDir deleted, no more sources - assertLibIs(dir2); // libDir stays the same - myVirtualFilePointerManager.assertConsistency(); - rename(dir2, "dir1"); - myVirtualFilePointerManager.assertConsistency(); - assertSourceIs(dir2); // srcDir re-appeared, sources are "dir1" - assertLibIs(dir2); // libDir renamed, libs are "dir1" now - - rename(dir2, "dir2"); - assertSourceIs(dir2); // srcDir renamed, sources are "dir2" now - assertLibIs(dir2); // libDir renamed, libs are "dir2" now - - dir1 = createChildDirectory(root, "dir1"); - assertNotNull(dir1); - assertSourceIs(dir2); // srcDir stays the same - assertLibIs(dir2); // libDir stays the same - - PsiTestUtil.removeAllRoots(getModule(), getTestProjectJdk()); - } - - private void assertLibIs(VirtualFile dir2) { - VirtualFile libRoot = assertOneElement( - OrderEntryUtil.getModuleLibraries(ModuleRootManager.getInstance(getModule())).get(0).getFiles(OrderRootType.CLASSES)); - assertEquals(dir2, libRoot); - } - - private void assertSourceIs(VirtualFile dir1) { - VirtualFile[] roots = ModuleRootManager.getInstance(getModule()).getSourceRoots(); - VirtualFile[] expected = dir1 == null ? VirtualFile.EMPTY_ARRAY : new VirtualFile[]{dir1}; - assertOrderedEquals(roots, expected); - } - + @Test public void testTwoPointersMergingIntoOne() throws IOException { - File tempDirectory = createTempDirectory(); - final VirtualFile root = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory)); - - VirtualFile dir1 = createChildDirectory(root, "dir1"); - VirtualFile dir2 = createChildDirectory(root, "dir2"); + VirtualFile root = getVirtualFile(myTempDir.getRoot()); + VirtualFile dir1 = WriteAction.computeAndWait(() -> root.createChildDirectory(this, "dir1")); + VirtualFile dir2 = WriteAction.computeAndWait(() -> root.createChildDirectory(this, "dir2")); VirtualFilePointer p1 = myVirtualFilePointerManager.create(dir1, disposable, null); VirtualFilePointer p2 = myVirtualFilePointerManager.create(dir2, disposable, null); @@ -817,182 +539,131 @@ public class VirtualFilePointerTest extends PlatformTestCase { assertTrue(p2.isValid()); assertEquals(dir2, p2.getFile()); - delete(dir1); + WriteAction.runAndWait(() -> dir1.delete(this)); assertNull(p1.getFile()); assertEquals(dir2, p2.getFile()); - rename(dir2, "dir1"); + WriteAction.runAndWait(() -> dir2.rename(this, "dir1")); assertEquals(dir2, p1.getFile()); assertEquals(dir2, p2.getFile()); - rename(dir2, "dir2"); + WriteAction.runAndWait(() -> dir2.rename(this, "dir2")); assertEquals(dir2, p1.getFile()); assertEquals(dir2, p2.getFile()); - createChildDirectory(root, "dir1"); + WriteAction.runAndWait(() -> root.createChildDirectory(this, "dir1")); assertEquals(dir2, p1.getFile()); assertEquals(dir2, p2.getFile()); } - public void testVirtualPointersMustBeAlreadyUpToDateInVFSChangeListeners() throws IOException { - File tempDirectory = createTempDirectory(); - final VirtualFile root = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory)); - - VirtualFile dir1 = createChildDirectory(root, "dir1"); - VirtualFile file = createChildData(dir1, "x.txt"); - setFileText(file, "xxxxxx"); - - PsiTestUtil.addLibrary(getModule(), dir1.getPath()); - - VirtualFileListener listener = new VirtualFileListener() { - @Override - public void fileDeleted(@NotNull VirtualFileEvent event) { - ProjectRootManager.getInstance(getProject()).getFileIndex().getModuleForFile(dir1); - } - }; - LocalFileSystem.getInstance().addVirtualFileListener(listener); - Disposer.register(disposable, () -> LocalFileSystem.getInstance().removeVirtualFileListener(listener)); - - assertTrue(FileUtil.delete(new File(dir1.getPath()))); - LOG.debug("deleted "+dir1); - - try { - while (root.findChild("dir1") != null) { - UIUtil.dispatchAllInvocationEvents(); - LocalFileSystem.getInstance().refresh(false); - } - } - finally { - ApplicationManager.getApplication().runWriteAction(() -> { - Library library = PlatformTestUtil.notNull(LibraryUtil.findLibrary(getModule(), "dir1")); - LibraryTable.ModifiableModel model = library.getTable().getModifiableModel(); - model.removeLibrary(library); - model.commit(); - }); - - - PsiTestUtil.removeAllRoots(getModule(), null); - } - } - + @Test public void testDotDot() throws IOException { - File tempDirectory = createTempDirectory(); - final VirtualFile root = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(tempDirectory)); - - VirtualFile dir1 = createChildDirectory(root, "dir1"); - VirtualFile dir2 = createChildDirectory(root, "dir2"); - VirtualFile file = createChildData(dir1, "x.txt"); - + VirtualFile root = getVirtualFile(myTempDir.getRoot()); + VirtualFile dir1 = WriteAction.computeAndWait(() -> root.createChildDirectory(this, "dir1")); + VirtualFile file = WriteAction.computeAndWait(() -> dir1.createChildData(this, "x.txt")); + VirtualFile dir2 = WriteAction.computeAndWait(() -> root.createChildDirectory(this, "dir2")); VirtualFilePointer pointer = myVirtualFilePointerManager.create(dir2.getUrl() + "/../" + dir1.getName() + "/" + file.getName(), disposable, null); assertEquals(file, pointer.getFile()); } + @Test public void testAlienVirtualFileSystemPointerRemovedFromUrlToIdentityCacheOnDispose() { VirtualFile mockVirtualFile = new MockVirtualFile("test_name", "test_text"); - Disposable disposable1 = Disposer.newDisposable(); - final VirtualFilePointer pointer = VirtualFilePointerManager.getInstance().create(mockVirtualFile, disposable1, null); - - assertInstanceOf(pointer, IdentityVirtualFilePointer.class); + Disposable disposable = Disposer.newDisposable(); + VirtualFilePointer pointer = myVirtualFilePointerManager.create(mockVirtualFile, disposable, null); + assertThat(pointer).isInstanceOf(IdentityVirtualFilePointer.class); assertTrue(pointer.isValid()); VirtualFile virtualFileWithSameUrl = new MockVirtualFile("test_name", "test_text"); - VirtualFilePointer updatedPointer = VirtualFilePointerManager.getInstance().create(virtualFileWithSameUrl, disposable1, null); + VirtualFilePointer updatedPointer = myVirtualFilePointerManager.create(virtualFileWithSameUrl, disposable, null); + assertThat(updatedPointer).isInstanceOf(IdentityVirtualFilePointer.class); + assertTrue(pointer.isValid()); + assertEquals(1, myVirtualFilePointerManager.numberOfCachedUrlToIdentity()); - assertInstanceOf(updatedPointer, IdentityVirtualFilePointer.class); - - assertEquals(1, ((VirtualFilePointerManagerImpl)VirtualFilePointerManager.getInstance()).numberOfCachedUrlToIdentity()); - - Disposer.dispose(disposable1); - - assertEquals(0, ((VirtualFilePointerManagerImpl)VirtualFilePointerManager.getInstance()).numberOfCachedUrlToIdentity()); + Disposer.dispose(disposable); + assertEquals(0, myVirtualFilePointerManager.numberOfCachedUrlToIdentity()); } - private volatile boolean run; - private volatile Throwable exception; - public void testStressConcurrentAccess() throws Throwable { - final File tempDirectory = createTempDirectory(); - VirtualFilePointer fileToCreatePointer = createPointerByFile(tempDirectory, null); - assertNotNull(fileToCreatePointer); - - VirtualFilePointerListener listener = new VirtualFilePointerListener() { - }; - long start = System.currentTimeMillis(); + @Test + public void testStressConcurrentAccess() throws Exception { + VirtualFilePointer fileToCreatePointer = createPointerByFile(myTempDir.getRoot(), null); + VirtualFilePointerListener listener = new VirtualFilePointerListener() { }; + long stop = System.currentTimeMillis() + 15_000; + AtomicBoolean run = new AtomicBoolean(false); + AtomicReference exception = new AtomicReference<>(null); int i; - for (i=0; System.currentTimeMillis() < start + 15_000;i++) { + for (i = 0; System.currentTimeMillis() < stop; i++) { Disposable disposable = Disposer.newDisposable(); // supply listener to separate pointers under one root so that it will be removed on dispose VirtualFilePointerImpl bb = - (VirtualFilePointerImpl)VirtualFilePointerManager.getInstance().create(fileToCreatePointer.getUrl() + "/bb", disposable, listener); + (VirtualFilePointerImpl)myVirtualFilePointerManager.create(fileToCreatePointer.getUrl() + "/bb", disposable, listener); - if (i%1000==0) LOG.info("i = " + i); + if (i % 1000 == 0) LOG.info("i = " + i); - int NThreads = Runtime.getRuntime().availableProcessors(); - CountDownLatch ready = new CountDownLatch(NThreads); + int nThreads = Runtime.getRuntime().availableProcessors(); + CountDownLatch ready = new CountDownLatch(nThreads); Runnable read = () -> { try { ready.countDown(); - while (run) { + while (run.get()) { bb.myNode.myLastUpdated = -15; bb.getUrl(); } } - catch (Throwable e) { - exception = e; + catch (Throwable t) { + exception.set(t); } }; - run = true; - List threads = IntStream.range(0, NThreads).mapToObj(n -> new Thread(read, "reader"+n)).collect(Collectors.toList()); + run.set(true); + List threads = IntStream.range(0, nThreads).mapToObj(n -> new Thread(read, "reader" + n)).collect(Collectors.toList()); threads.forEach(Thread::start); ready.await(); - VirtualFilePointer bc = VirtualFilePointerManager.getInstance().create(fileToCreatePointer.getUrl() + "/b/c", disposable, listener); - assertNotNull(bc); + myVirtualFilePointerManager.create(fileToCreatePointer.getUrl() + "/b/c", disposable, listener); - run = false; + run.set(false); ConcurrencyUtil.joinAll(threads); - if (exception !=null) throw exception; + ExceptionUtil.rethrowAll(exception.get()); Disposer.dispose(disposable); } - LOG.debug("final i = " + i); + LOG.debug("i = " + i); } - public void testGetChildrenMustIncreaseModificationCountIfFoundNewFile() throws Exception { - final File tempDirectory = createTempDirectory(); - VirtualFile vTemp = LocalFileSystem.getInstance().findFileByIoFile(tempDirectory); - assertNotNull(vTemp); - - File file = new File(tempDirectory, "x.txt"); + @Test + public void testGetChildrenMustIncreaseModificationCountIfFoundNewFile() throws IOException { + VirtualFile vTemp = getVirtualFile(myTempDir.getRoot()); + File file = new File(myTempDir.getRoot(), "x.txt"); VirtualFilePointer pointer = createPointerByFile(file, null); - long start = System.currentTimeMillis(); + long stop = System.currentTimeMillis() + 10_000; int i; - for (i=0; System.currentTimeMillis() < start + 10_000 && i < 30;i++) { + for (i = 0; System.currentTimeMillis() < stop && i < 30; i++) { LOG.info("i = " + i); assertTrue(file.createNewFile()); - refreshVFS(); + vTemp.refresh(false, true); Future future = ApplicationManager.getApplication().executeOnPooledThread(() -> ReadAction.run(() -> { - for (int k=0;k<100;k++) { + for (int k = 0; k < 100; k++) { vTemp.getChildren(); } })); TimeoutUtil.sleep(100); - VirtualFile vFile = PlatformTestUtil.notNull(LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file)); + VirtualFile vFile = PlatformTestUtil.notNull(getVirtualFile(file)); assertTrue(vFile.isValid()); assertTrue(pointer.isValid()); assertTrue(file.delete()); - refreshVFS(); + vTemp.refresh(false, true); assertFalse(pointer.isValid()); while (!future.isDone()) { UIUtil.dispatchAllInvocationEvents(); } } - LOG.debug("final i = " + i); + LOG.debug("i = " + i); } + @Test public void testSeveralDirectoriesWithCommonPrefix() throws IOException { - File baseDir = createTempDirectory(); - VirtualFile vDir = LocalFileSystem.getInstance().findFileByIoFile(baseDir); + VirtualFile vDir = getVirtualFile(myTempDir.getRoot()); assertNotNull(vDir); vDir.getChildren(); vDir.refresh(false, true); @@ -1001,56 +672,67 @@ public class VirtualFilePointerTest extends PlatformTestCase { myVirtualFilePointerManager.create(vDir.getUrl() + "/d1/subdir", disposable, listener); myVirtualFilePointerManager.create(vDir.getUrl() + "/d2/subdir", disposable, listener); - File dir = new File(baseDir, "d1"); - FileUtil.createDirectory(dir); - LocalFileSystem.getInstance().refreshAndFindFileByIoFile(dir).getChildren(); - assertEquals("[before:false, after:false]", listener.getLog().toString()); - listener.getLog().clear(); + File dir = myTempDir.newFolder("d1"); + getVirtualFile(dir).getChildren(); + assertEquals("[before:false, after:false]", listener.log.toString()); + listener.log.clear(); File subDir = new File(dir, "subdir"); FileUtil.createDirectory(subDir); - VirtualFile vSubDir = LocalFileSystem.getInstance().refreshAndFindFileByIoFile(subDir); - assertEquals("[before:false, after:true]", listener.getLog().toString()); + getVirtualFile(subDir); + assertEquals("[before:false, after:true]", listener.log.toString()); } - public void testDirectoryPointersWork() throws Exception { - final File dir = createTempDirectory(); - VirtualFile vDir = LocalFileSystem.getInstance().findFileByIoFile(dir); - assertNotNull(vDir); - VirtualFile deep = createChildDirectory(vDir, "deep"); + @Test + public void testDirectoryPointersWork() throws IOException { + VirtualFile vDir = getVirtualFile(myTempDir.getRoot()); + VirtualFile deep = WriteAction.computeAndWait(() -> vDir.createChildDirectory(this, "deep")); LoggingListener listener = new LoggingListener(); Disposable disposable = Disposer.newDisposable(); - VirtualFilePointer ptr = myVirtualFilePointerManager.createDirectoryPointer(vDir.getUrl(), false, disposable, listener); + myVirtualFilePointerManager.createDirectoryPointer(vDir.getUrl(), false, disposable, listener); - createChildData(vDir, "1"); - assertEquals("[before:true, after:true]", listener.getLog().toString()); + WriteAction.runAndWait(() -> vDir.createChildData(this, "1")); + assertEquals("[before:true, after:true]", listener.log.toString()); Disposer.dispose(disposable); listener = new LoggingListener(); myVirtualFilePointerManager.createDirectoryPointer(vDir.getUrl(), true, this.disposable, listener); - createChildData(deep, "1"); - assertEquals("[before:true, after:true]", listener.getLog().toString()); + WriteAction.runAndWait(() -> deep.createChildData(this, "1")); + assertEquals("[before:true, after:true]", listener.log.toString()); } - public void testNotQuiteCanonicalPath() throws Exception { - final File dir = createTempDirectory(); - VirtualFile vDir = LocalFileSystem.getInstance().findFileByIoFile(dir); - assertNotNull(vDir); - VirtualFile deep = createChildDirectory(vDir, "deep"); - VirtualFile file = createChildData(deep, "x..txt"); + @Test + public void testNotQuiteCanonicalPath() throws IOException { + VirtualFile vDir = getVirtualFile(myTempDir.getRoot()); + VirtualFile deep = WriteAction.computeAndWait(() -> vDir.createChildDirectory(this, "deep")); + VirtualFile file = WriteAction.computeAndWait(() -> deep.createChildData(this, "x..txt")); VirtualFilePointer ptr = myVirtualFilePointerManager.create(file, disposable, null); assertTrue(ptr.isValid()); assertTrue(ptr.getUrl(), ptr.getUrl().contains("..")); - VirtualFile existing = createChildData(vDir, "existing.txt"); - assertNotNull(existing); - VirtualFilePointer ptr2 = myVirtualFilePointerManager.create(deep.getUrl()+"/../existing.txt", disposable, null); + WriteAction.runAndWait(() -> vDir.createChildData(this, "existing.txt")); + VirtualFilePointer ptr2 = myVirtualFilePointerManager.create(deep.getUrl() + "/../existing.txt", disposable, null); assertTrue(ptr2.isValid()); assertFalse(ptr2.getUrl(), ptr2.getUrl().contains("..")); - VirtualFilePointer ptr3 = myVirtualFilePointerManager.create(deep.getUrl()+"/../madeup.txt", disposable, null); + VirtualFilePointer ptr3 = myVirtualFilePointerManager.create(deep.getUrl() + "/../madeUp.txt", disposable, null); assertFalse(ptr3.isValid()); assertTrue(ptr3.getUrl(), ptr3.getUrl().contains("..")); } -} + + private static VirtualFile getVirtualFile(File file) { + return LocalFileSystem.getInstance().refreshAndFindFileByIoFile(file); + } + + private VirtualFilePointer createPointerByFile(File file, VirtualFilePointerListener fileListener) { + String url = VirtualFileManager.constructUrl(LocalFileSystem.PROTOCOL, toSystemIndependentName(file.getPath())); + VirtualFile vFile = getVirtualFile(file); + return vFile != null ? myVirtualFilePointerManager.create(vFile, disposable, fileListener) + : myVirtualFilePointerManager.create(url, disposable, fileListener); + } + + private static void verifyPointersInCorrectState(VirtualFilePointer[] pointers) { + assertThat(pointers).allMatch(p -> p.getFile() == null || p.getFile().isValid()); + } +} \ No newline at end of file