Cleanup (simpler/faster VFP tests)

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<String> 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());
+  }
 }

java/java-tests/testSrc/com/intellij/java/openapi/vfs/JrtVirtualFilePointerTest.java

@@ -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);
-  }
-}