external build tests: ArtifactBuilderTest converted to Kotlin

This is needed to allow using new DirectoryContentSpec API.

jps/jps-builders/testSrc/org/jetbrains/jps/builders/JpsBuildTestCase.java

@@ -23,6 +23,8 @@ import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.testFramework.UsefulTestCase;
 import com.intellij.util.TimeoutUtil;
 import com.intellij.util.containers.hash.HashMap;
+import com.intellij.util.io.DirectoryContentSpec;
+import com.intellij.util.io.DirectoryContentSpecKt;
 import com.intellij.util.io.TestFileSystemBuilder;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -116,12 +118,22 @@ public abstract class JpsBuildTestCase extends UsefulTestCase {
     expected.build().assertDirectoryEqual(new File(FileUtil.toSystemDependentName(outputPath)));
   }
 
+  protected static void assertOutput(final String outputPath, DirectoryContentSpec expected) {
+    DirectoryContentSpecKt.assertMatches(new File(outputPath), expected);
+  }
+
   protected static void assertOutput(JpsModule module, TestFileSystemBuilder expected) {
     String outputUrl = JpsJavaExtensionService.getInstance().getOutputUrl(module, false);
     assertNotNull(outputUrl);
     assertOutput(JpsPathUtil.urlToPath(outputUrl), expected);
   }
 
+  protected static void assertOutput(JpsModule module, DirectoryContentSpec expected) {
+    String outputUrl = JpsJavaExtensionService.getInstance().getOutputUrl(module, false);
+    assertNotNull(outputUrl);
+    assertOutput(JpsPathUtil.urlToPath(outputUrl), expected);
+  }
+
   protected static void change(String filePath) {
     change(filePath, null);
   }

jps/jps-builders/testSrc/org/jetbrains/jps/builders/rebuild/JpsRebuildTestCase.kt

@@ -18,7 +18,6 @@ package org.jetbrains.jps.builders.rebuild;
 import com.intellij.openapi.application.ex.PathManagerEx
 import com.intellij.openapi.util.io.FileUtil
 import com.intellij.util.io.DirectoryContentSpec
-import com.intellij.util.io.assertMatches
 import org.jetbrains.jps.builders.CompileScopeTestBuilder
 import org.jetbrains.jps.builders.JpsBuildTestCase
 import org.jetbrains.jps.model.java.JpsJavaExtensionService
@@ -48,10 +47,6 @@ abstract class JpsRebuildTestCase: JpsBuildTestCase() {
     assertOutput(myOutputDirectory.absolutePath, expectedOutput);
   }
 
-  fun assertOutput(targetFolder: String, expectedOutput: DirectoryContentSpec) {
-    File(targetFolder).assertMatches(expectedOutput)
-  }
-
   fun loadAndRebuild(projectPath: String, pathVariables: Map<String, String>) {
     loadProject(projectPath, pathVariables);
     rebuild();

jps/jps-builders/testSrc/org/jetbrains/jps/incremental/artifacts/ArtifactBuilderTest.kt

@@ -13,407 +13,423 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.jetbrains.jps.incremental.artifacts;
+package org.jetbrains.jps.incremental.artifacts
 
-import com.intellij.openapi.util.io.FileUtil;
-import com.intellij.util.PathUtil;
-import org.jetbrains.jps.model.artifact.JpsArtifact;
-import org.jetbrains.jps.model.java.JpsJavaExtensionService;
-import org.jetbrains.jps.model.library.JpsLibrary;
-import org.jetbrains.jps.model.module.JpsModule;
-import org.jetbrains.jps.util.JpsPathUtil;
-
-import java.io.BufferedOutputStream;
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.util.Enumeration;
-import java.util.jar.JarEntry;
-import java.util.jar.JarFile;
-import java.util.zip.CRC32;
-import java.util.zip.ZipEntry;
-import java.util.zip.ZipFile;
-import java.util.zip.ZipOutputStream;
-
-import static com.intellij.util.io.TestFileSystemBuilder.fs;
-import static org.jetbrains.jps.incremental.artifacts.LayoutElementTestUtil.archive;
-import static org.jetbrains.jps.incremental.artifacts.LayoutElementTestUtil.root;
+import com.intellij.openapi.util.io.FileUtil
+import com.intellij.util.PathUtil
+import com.intellij.util.io.directoryContent
+import org.jetbrains.jps.incremental.artifacts.LayoutElementTestUtil.archive
+import org.jetbrains.jps.incremental.artifacts.LayoutElementTestUtil.root
+import org.jetbrains.jps.model.java.JpsJavaExtensionService
+import org.jetbrains.jps.util.JpsPathUtil
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.util.jar.JarFile
+import java.util.zip.CRC32
+import java.util.zip.ZipEntry
+import java.util.zip.ZipFile
+import java.util.zip.ZipOutputStream
 
 /**
  * @author nik
  */
-public class ArtifactBuilderTest extends ArtifactBuilderTestCase {
-  public void testFileCopy() {
-    final JpsArtifact a = addArtifact(root().fileCopy(createFile("file.txt", "foo")));
-    buildAll();
-    assertOutput(a, fs().file("file.txt", "foo"));
+class ArtifactBuilderTest : ArtifactBuilderTestCase() {
+  fun testFileCopy() {
+    val a = addArtifact(root().fileCopy(createFile("file.txt", "foo")))
+    buildAll()
+    assertOutput(a, directoryContent { file("file.txt", "foo") })
   }
 
-  public void testDir() {
-    final JpsArtifact a = addArtifact(
+  fun testDir() {
+    val a = addArtifact(
       root()
         .fileCopy(createFile("abc.txt"))
-        .dir("dir")
+          .dir("dir")
           .fileCopy(createFile("xxx.txt", "bar"))
-    );
-    buildAll();
-    assertOutput(a, fs()
-      .file("abc.txt")
-      .dir("dir")
-        .file("xxx.txt", "bar")
-    );
+    )
+    buildAll()
+    assertOutput(a, directoryContent {
+      file("abc.txt")
+      dir("dir") {
+        file("xxx.txt", "bar")
+      }
+    })
   }
 
-  public void testArchive() {
-    final JpsArtifact a = addArtifact(
+  fun testArchive() {
+    val a = addArtifact(
       root()
         .archive("xxx.zip")
           .fileCopy(createFile("X.class", "data"))
           .dir("dir")
-             .fileCopy(createFile("Y.class"))
-    );
-    buildAll();
-    assertOutput(a, fs()
-      .archive("xxx.zip")
-        .file("X.class", "data")
-        .dir("dir")
-          .file("Y.class")
-    );
+            .fileCopy(createFile("Y.class"))
+    )
+    buildAll()
+    assertOutput(a, directoryContent {
+      zip("xxx.zip") {
+        file("X.class", "data")
+        dir("dir") {
+          file("Y.class")
+        }
+      }
+    })
   }
 
-  public void testTwoDirsInArchive() {
-    final String dir1 = PathUtil.getParentPath(PathUtil.getParentPath(createFile("dir1/a/x.txt")));
-    final String dir2 = PathUtil.getParentPath(PathUtil.getParentPath(createFile("dir2/a/y.txt")));
-    final JpsArtifact a = addArtifact(
+  fun testTwoDirsInArchive() {
+    val dir1 = PathUtil.getParentPath(PathUtil.getParentPath(createFile("dir1/a/x.txt")))
+    val dir2 = PathUtil.getParentPath(PathUtil.getParentPath(createFile("dir2/a/y.txt")))
+    val a = addArtifact(
       root()
         .archive("a.jar")
           .dirCopy(dir1)
           .dirCopy(dir2)
           .dir("a").fileCopy(createFile("z.txt"))
-    );
-    buildAll();
-    assertOutput(a, fs()
-      .archive("a.jar")
-        .dir("a")
-          .file("x.txt")
-          .file("y.txt")
-          .file("z.txt")
-    );
+    )
+    buildAll()
+    assertOutput(a, directoryContent {
+      zip("a.jar") {
+        dir("a") {
+          file("x.txt")
+          file("y.txt")
+          file("z.txt")
+        }
+      }
+    })
   }
 
-  public void testArchiveInArchive() {
-    final JpsArtifact a = addArtifact(
+  fun testArchiveInArchive() {
+    val a = addArtifact(
       root()
         .archive("a.jar")
-          .archive("b.jar")
-            .fileCopy(createFile("xxx.txt", "foo"))
-    );
-    buildAll();
-    assertOutput(a, fs()
-      .archive("a.jar")
         .archive("b.jar")
-          .file("xxx.txt", "foo")
-      );
+        .fileCopy(createFile("xxx.txt", "foo"))
+    )
+    buildAll()
+    assertOutput(a, directoryContent {
+      zip("a.jar") {
+        zip("b.jar") {
+          file("xxx.txt", "foo")
+        }
+      }
+    })
   }
 
-  public void testIncludedArtifact() {
-    final JpsArtifact included = addArtifact("included",
-                                          root()
-                                            .fileCopy(createFile("aaa.txt")));
-    final JpsArtifact a = addArtifact(
+  fun testIncludedArtifact() {
+    val included = addArtifact("included",
+                               root()
+                                 .fileCopy(createFile("aaa.txt")))
+    val a = addArtifact(
       root()
         .dir("dir")
-          .artifact(included)
-          .end()
-        .fileCopy(createFile("bbb.txt"))
-    );
-    buildAll();
-
-    assertOutput(included, fs().file("aaa.txt"));
-    assertOutput(a, fs()
-      .dir("dir")
-        .file("aaa.txt")
+        .artifact(included)
         .end()
-      .file("bbb.txt")
-      );
+        .fileCopy(createFile("bbb.txt"))
+    )
+    buildAll()
+
+    assertOutput(included, directoryContent { file("aaa.txt") })
+    assertOutput(a, directoryContent {
+      dir("dir") {
+        file("aaa.txt")
+      }
+      file("bbb.txt")
+  })
   }
 
-  public void testMergeDirectories() {
-    final JpsArtifact included = addArtifact("included",
-                                          root().dir("dir").fileCopy(createFile("aaa.class")));
-    final JpsArtifact a = addArtifact(
+  fun testMergeDirectories() {
+    val included = addArtifact("included",
+                               root().dir("dir").fileCopy(createFile("aaa.class")))
+    val a = addArtifact(
       root()
         .artifact(included)
         .dir("dir")
-          .fileCopy(createFile("bbb.class")));
-    buildAll();
-    assertOutput(a, fs()
-      .dir("dir")
-        .file("aaa.class")
-        .file("bbb.class")
-      );
+        .fileCopy(createFile("bbb.class")))
+    buildAll()
+    assertOutput(a, directoryContent {
+      dir("dir") {
+        file("aaa.class")
+        file("bbb.class")
+      }
+    })
   }
 
-  public void testCopyLibrary() {
-    final JpsLibrary library = addProjectLibrary("lib", getJUnitJarPath());
-    final JpsArtifact a = addArtifact(root().lib(library));
-    buildAll();
-    assertOutput(a, fs().file("junit.jar"));
+  fun testCopyLibrary() {
+    val library = addProjectLibrary("lib", getJUnitJarPath())
+    val a = addArtifact(root().lib(library))
+    buildAll()
+    assertOutput(a, directoryContent { file("junit.jar") })
   }
 
-  public void testModuleOutput() {
-    final String file = createFile("src/A.java", "public class A {}");
-    final JpsModule module = addModule("a", PathUtil.getParentPath(file));
-    final JpsArtifact artifact = addArtifact(root().module(module));
+  fun testModuleOutput() {
+    val file = createFile("src/A.java", "public class A {}")
+    val module = addModule("a", PathUtil.getParentPath(file))
+    val artifact = addArtifact(root().module(module))
 
-    buildArtifacts(artifact);
-    assertOutput(artifact, fs().file("A.class"));
+    buildArtifacts(artifact)
+    assertOutput(artifact, directoryContent { file("A.class") })
   }
 
-  public void testCopyResourcesFromModuleOutput() {
-    String file = createFile("src/a.xml", "");
-    JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(myProject).addResourcePattern("*.xml");
-    JpsModule module = addModule("a", PathUtil.getParentPath(file));
-    JpsArtifact artifact = addArtifact(root().module(module));
-    buildArtifacts(artifact);
-    assertOutput(artifact, fs().file("a.xml"));
+  fun testCopyResourcesFromModuleOutput() {
+    val file = createFile("src/a.xml", "")
+    JpsJavaExtensionService.getInstance().getOrCreateCompilerConfiguration(myProject).addResourcePattern("*.xml")
+    val module = addModule("a", PathUtil.getParentPath(file))
+    val artifact = addArtifact(root().module(module))
+    buildArtifacts(artifact)
+    assertOutput(artifact, directoryContent { file("a.xml") })
   }
 
-  public void testIgnoredFile() {
-    final String file = createFile("a/.svn/a.txt");
-    createFile("a/svn/b.txt");
-    final JpsArtifact a = addArtifact(root().parentDirCopy(PathUtil.getParentPath(file)));
-    buildAll();
-    assertOutput(a, fs().dir("svn").file("b.txt"));
+  fun testIgnoredFile() {
+    val file = createFile("a/.svn/a.txt")
+    createFile("a/svn/b.txt")
+    val a = addArtifact(root().parentDirCopy(PathUtil.getParentPath(file)))
+    buildAll()
+    assertOutput(a, directoryContent { dir("svn") { file("b.txt") }})
   }
 
-  public void testIgnoredFileInArchive() {
-    final String file = createFile("a/.svn/a.txt");
-    createFile("a/svn/b.txt");
-    final JpsArtifact a = addArtifact(archive("a.jar").parentDirCopy(PathUtil.getParentPath(file)));
-    buildAll();
-    assertOutput(a, fs().archive("a.jar").dir("svn").file("b.txt"));
+  fun testIgnoredFileInArchive() {
+    val file = createFile("a/.svn/a.txt")
+    createFile("a/svn/b.txt")
+    val a = addArtifact(archive("a.jar").parentDirCopy(PathUtil.getParentPath(file)))
+    buildAll()
+    assertOutput(a, directoryContent { zip("a.jar") { dir("svn") { file("b.txt")}}})
   }
 
-  public void testCopyExcludedFolder() {
+  fun testCopyExcludedFolder() {
     //explicitly added excluded files should be copied (e.g. compile output)
-    final String file = createFile("xxx/excluded/a.txt");
-    createFile("xxx/excluded/CVS");
-    final String excluded = PathUtil.getParentPath(file);
-    final String dir = PathUtil.getParentPath(excluded);
+    val file = createFile("xxx/excluded/a.txt")
+    createFile("xxx/excluded/CVS")
+    val excluded = PathUtil.getParentPath(file)
+    val dir = PathUtil.getParentPath(excluded)
 
-    final JpsModule module = addModule("myModule");
-    module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(dir));
-    module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(excluded));
+    val module = addModule("myModule")
+    module.contentRootsList.addUrl(JpsPathUtil.pathToUrl(dir))
+    module.excludeRootsList.addUrl(JpsPathUtil.pathToUrl(excluded))
 
-    final JpsArtifact a = addArtifact(root().dirCopy(excluded));
-    buildAll();
-    assertOutput(a, fs().file("a.txt"));
+    val a = addArtifact(root().dirCopy(excluded))
+    buildAll()
+    assertOutput(a, directoryContent { file("a.txt") })
   }
 
-  public void testCopyExcludedFile() {
+  fun testCopyExcludedFile() {
     //excluded files under non-excluded directory should not be copied
-    final String file = createFile("xxx/excluded/a.txt");
-    createFile("xxx/b.txt");
-    createFile("xxx/CVS");
-    final String dir = PathUtil.getParentPath(PathUtil.getParentPath(file));
+    val file = createFile("xxx/excluded/a.txt")
+    createFile("xxx/b.txt")
+    createFile("xxx/CVS")
+    val dir = PathUtil.getParentPath(PathUtil.getParentPath(file))
 
-    JpsModule module = addModule("myModule");
-    module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(dir));
-    module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(file)));
+    val module = addModule("myModule")
+    module.contentRootsList.addUrl(JpsPathUtil.pathToUrl(dir))
+    module.excludeRootsList.addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(file)))
 
-    final JpsArtifact a = addArtifact(root().dirCopy(dir));
-    buildAll();
-    assertOutput(a, fs().file("b.txt"));
+    val a = addArtifact(root().dirCopy(dir))
+    buildAll()
+    assertOutput(a, directoryContent { file("b.txt") })
   }
 
-  public void testExtractDirectory() {
-    final JpsArtifact a = addArtifact("a", root().dir("dir").extractedDir(getJUnitJarPath(), "/junit/textui/"));
-    buildAll();
-    assertOutput(a, fs().dir("dir")
-                           .file("ResultPrinter.class")
-                           .file("TestRunner.class"));
+  fun testExtractDirectory() {
+    val a = addArtifact("a", root().dir("dir").extractedDir(getJUnitJarPath(), "/junit/textui/"))
+    buildAll()
+    assertOutput(a, directoryContent {
+      dir("dir") {
+        file("ResultPrinter.class")
+        file("TestRunner.class")
+      }
+    })
   }
 
-  public void testExtractDirectoryFromExcludedJar() throws IOException {
-    String jarPath = createFile("dir/lib/j.jar");
-    FileUtil.copy(new File(getJUnitJarPath()), new File(jarPath));
-    JpsModule module = addModule("m");
-    String libDir = PathUtil.getParentPath(jarPath);
-    module.getContentRootsList().addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(libDir)));
-    module.getExcludeRootsList().addUrl(JpsPathUtil.pathToUrl(libDir));
-    final JpsArtifact a = addArtifact("a", root().extractedDir(jarPath, "/junit/textui/"));
-    buildAll();
-    assertOutput(a, fs().file("ResultPrinter.class")
-                        .file("TestRunner.class"));
+  @Throws(IOException::class)
+  fun testExtractDirectoryFromExcludedJar() {
+    val jarPath = createFile("dir/lib/j.jar")
+    FileUtil.copy(File(getJUnitJarPath()), File(jarPath))
+    val module = addModule("m")
+    val libDir = PathUtil.getParentPath(jarPath)
+    module.contentRootsList.addUrl(JpsPathUtil.pathToUrl(PathUtil.getParentPath(libDir)))
+    module.excludeRootsList.addUrl(JpsPathUtil.pathToUrl(libDir))
+    val a = addArtifact("a", root().extractedDir(jarPath, "/junit/textui/"))
+    buildAll()
+    assertOutput(a, directoryContent {
+      file("ResultPrinter.class")
+      file("TestRunner.class")
+    })
   }
 
-  public void testPackExtractedDirectory() {
-    final JpsArtifact a = addArtifact("a", root().archive("a.jar").extractedDir(getJUnitJarPath(), "/junit/textui/"));
-    buildAll();
-    assertOutput(a, fs().archive("a.jar")
-                           .file("ResultPrinter.class")
-                           .file("TestRunner.class"));
+  fun testPackExtractedDirectory() {
+    val a = addArtifact("a", root().archive("a.jar").extractedDir(getJUnitJarPath(), "/junit/textui/"))
+    buildAll()
+    assertOutput(a, directoryContent { zip("a.jar") {
+      file("ResultPrinter.class")
+      file("TestRunner.class")
+    }})
   }
 
-  public void testSelfIncludingArtifact() {
-    final JpsArtifact a = addArtifact("a", root());
-    LayoutElementTestUtil.addArtifactToLayout(a, a);
-    assertBuildFailed(a);
+  fun testSelfIncludingArtifact() {
+    val a = addArtifact("a", root())
+    LayoutElementTestUtil.addArtifactToLayout(a, a)
+    assertBuildFailed(a)
   }
 
-  public void testCircularInclusion() {
-    final JpsArtifact a = addArtifact("a", root());
-    final JpsArtifact b = addArtifact("b", root());
-    LayoutElementTestUtil.addArtifactToLayout(a, b);
-    LayoutElementTestUtil.addArtifactToLayout(b, a);
-    assertBuildFailed(a);
-    assertBuildFailed(b);
+  fun testCircularInclusion() {
+    val a = addArtifact("a", root())
+    val b = addArtifact("b", root())
+    LayoutElementTestUtil.addArtifactToLayout(a, b)
+    LayoutElementTestUtil.addArtifactToLayout(b, a)
+    assertBuildFailed(a)
+    assertBuildFailed(b)
   }
 
-  public void testArtifactContainingSelfIncludingArtifact() {
-    JpsArtifact c = addArtifact("c", root());
-    final JpsArtifact a = addArtifact("a", root().artifact(c));
-    LayoutElementTestUtil.addArtifactToLayout(a, a);
-    final JpsArtifact b = addArtifact("b", root().artifact(a));
+  fun testArtifactContainingSelfIncludingArtifact() {
+    val c = addArtifact("c", root())
+    val a = addArtifact("a", root().artifact(c))
+    LayoutElementTestUtil.addArtifactToLayout(a, a)
+    val b = addArtifact("b", root().artifact(a))
 
-    buildArtifacts(c);
-    assertBuildFailed(b);
-    assertBuildFailed(a);
+    buildArtifacts(c)
+    assertBuildFailed(b)
+    assertBuildFailed(a)
   }
 
-  public void testArtifactContainingSelfIncludingArtifactWithoutOutput() {
-    final JpsArtifact a = addArtifact("a", root());
-    LayoutElementTestUtil.addArtifactToLayout(a, a);
-    final JpsArtifact b = addArtifact("b", root().artifact(a));
-    a.setOutputPath(null);
+  fun testArtifactContainingSelfIncludingArtifactWithoutOutput() {
+    val a = addArtifact("a", root())
+    LayoutElementTestUtil.addArtifactToLayout(a, a)
+    val b = addArtifact("b", root().artifact(a))
+    a.outputPath = null
 
-    assertBuildFailed(b);
+    assertBuildFailed(b)
   }
 
   //IDEA-73893
-  public void testManifestFileIsFirstEntry() throws IOException {
-    final String firstFile = createFile("src/A.txt");
-    final String manifestFile = createFile("src/MANIFEST.MF");
-    final String lastFile = createFile("src/Z.txt");
-    final JpsArtifact a = addArtifact(archive("a.jar").dir("META-INF")
-                                       .fileCopy(firstFile).fileCopy(manifestFile).fileCopy(lastFile));
-    buildArtifacts(a);
-    final String jarPath = a.getOutputPath() + "/a.jar";
-    JarFile jarFile = new JarFile(new File(jarPath));
+  @Throws(IOException::class)
+  fun testManifestFileIsFirstEntry() {
+    val firstFile = createFile("src/A.txt")
+    val manifestFile = createFile("src/MANIFEST.MF")
+    val lastFile = createFile("src/Z.txt")
+    val a = addArtifact(archive("a.jar").dir("META-INF")
+                          .fileCopy(firstFile).fileCopy(manifestFile).fileCopy(lastFile))
+    buildArtifacts(a)
+    val jarPath = a.outputPath!! + "/a.jar"
+    val jarFile = JarFile(File(jarPath))
+    jarFile.use {
+      val entries = it.entries()
+      assertTrue(entries.hasMoreElements())
+      val firstEntry = entries.nextElement()
+      assertEquals(JarFile.MANIFEST_NAME, firstEntry.name)
+    }
+  }
+
+  @Throws(IOException::class)
+  fun testPreserveCompressionMethodForEntryExtractedFromOneArchiveAndPackedIntoAnother() {
+    val path = createFile("data/a.jar")
+    val output = ZipOutputStream(BufferedOutputStream(FileOutputStream(File(path))))
     try {
-      final Enumeration<JarEntry> entries = jarFile.entries();
-      assertTrue(entries.hasMoreElements());
-      final JarEntry firstEntry = entries.nextElement();
-      assertEquals(JarFile.MANIFEST_NAME, firstEntry.getName());
+      val entry = ZipEntry("a.txt")
+      val text = "text".toByteArray()
+      entry.method = ZipEntry.STORED
+      entry.size = text.size.toLong()
+      val crc32 = CRC32()
+      crc32.update(text)
+      entry.crc = crc32.value
+      output.putNextEntry(entry)
+      output.write(text)
+      output.closeEntry()
+    }
+    catch (e: Exception) {
+      e.printStackTrace()
     }
     finally {
-      jarFile.close();
+      output.close()
+    }
+    val a = addArtifact(archive("b.jar").extractedDir(path, ""))
+    buildAll()
+    assertOutput(a, directoryContent { zip("b.jar") { file("a.txt", "text") }})
+
+    val jarPath = a.outputPath!! + "/b.jar"
+    val zipFile = ZipFile(File(jarPath))
+    zipFile.use {
+      val entry = it.getEntry("a.txt")
+      assertNotNull(entry)
+      assertEquals(ZipEntry.STORED, entry.method)
     }
   }
 
-  public void testPreserveCompressionMethodForEntryExtractedFromOneArchiveAndPackedIntoAnother() throws IOException {
-    String path = createFile("data/a.jar");
-    ZipOutputStream output = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(new File(path))));
-    try {
-      ZipEntry entry = new ZipEntry("a.txt");
-      byte[] text = "text".getBytes();
-      entry.setMethod(ZipEntry.STORED);
-      entry.setSize(text.length);
-      CRC32 crc32 = new CRC32();
-      crc32.update(text);
-      entry.setCrc(crc32.getValue());
-      output.putNextEntry(entry);
-      output.write(text);
-      output.closeEntry();
-    }
-    catch (Exception e) {
-      e.printStackTrace();
-    }
-    finally {
-      output.close();
-    }
-    JpsArtifact a = addArtifact(archive("b.jar").extractedDir(path, ""));
-    buildAll();
-    assertOutput(a, fs().archive("b.jar").file("a.txt", "text"));
-
-    final String jarPath = a.getOutputPath() + "/b.jar";
-    ZipFile zipFile = new ZipFile(new File(jarPath));
-    try {
-      ZipEntry entry = zipFile.getEntry("a.txt");
-      assertNotNull(entry);
-      assertEquals(ZipEntry.STORED, entry.getMethod());
-    }
-    finally {
-      zipFile.close();
-    }
-  }
-  
-  public void testBuildModuleBeforeArtifactIfSomeDirectoryInsideModuleOutputIsCopiedToArtifact() {
-    String src = PathUtil.getParentPath(PathUtil.getParentPath(createFile("src/x/A.java", "package x; class A{}")));
-    JpsModule module = addModule("m", src);
-    File output = JpsJavaExtensionService.getInstance().getOutputDirectory(module, false);
-    JpsArtifact artifact = addArtifact(root().dirCopy(new File(output, "x").getAbsolutePath()));
-    rebuildAllModulesAndArtifacts();
-    assertOutput(module, fs().dir("x").file("A.class"));
-    assertOutput(artifact, fs().file("A.class"));
-  }
-  
-  public void testClearOutputOnRebuild() {
-    String file = createFile("d/a.txt");
-    JpsArtifact a = addArtifact(root().parentDirCopy(file));
-    buildAll();
-    createFileInArtifactOutput(a, "b.txt");
-    buildAllAndAssertUpToDate();
-    assertOutput(a, fs().file("a.txt").file("b.txt"));
-
-    rebuildAllModulesAndArtifacts();
-    assertOutput(a, fs().file("a.txt").file("b.txt"));
+  fun testBuildModuleBeforeArtifactIfSomeDirectoryInsideModuleOutputIsCopiedToArtifact() {
+    val src = PathUtil.getParentPath(PathUtil.getParentPath(createFile("src/x/A.java", "package x; class A{}")))
+    val module = addModule("m", src)
+    val output = JpsJavaExtensionService.getInstance().getOutputDirectory(module, false)
+    val artifact = addArtifact(root().dirCopy(File(output, "x").absolutePath))
+    rebuildAllModulesAndArtifacts()
+    assertOutput(module, directoryContent { dir("x") { file("A.class") }})
+    assertOutput(artifact, directoryContent { file("A.class") })
   }
 
-  public void testDeleteOnlyOutputFileOnRebuildForArchiveArtifact() {
-    String file = createFile("a.txt");
-    JpsArtifact a = addArtifact(archive("a.jar").fileCopy(file));
-    buildAll();
-    createFileInArtifactOutput(a, "b.txt");
-    buildAllAndAssertUpToDate();
-    assertOutput(a, fs().archive("a.jar").file("a.txt").end().file("b.txt"));
+  fun testClearOutputOnRebuild() {
+    val file = createFile("d/a.txt")
+    val a = addArtifact(root().parentDirCopy(file))
+    buildAll()
+    createFileInArtifactOutput(a, "b.txt")
+    buildAllAndAssertUpToDate()
+    assertOutput(a, directoryContent {
+      file("a.txt")
+      file("b.txt")
+    })
 
-    rebuildAllModulesAndArtifacts();
-    assertOutput(a, fs().archive("a.jar").file("a.txt").end().file("b.txt"));
+    rebuildAllModulesAndArtifacts()
+    assertOutput(a, directoryContent {
+      file("a.txt")
+      file("b.txt")
+    })
   }
 
-  public void testDoNotCreateEmptyArchive() {
-    String file = createFile("dir/a.txt");
-    JpsArtifact a = addArtifact(archive("a.jar").parentDirCopy(file));
-    delete(file);
-    buildAll();
-    assertEmptyOutput(a);
+  fun testDeleteOnlyOutputFileOnRebuildForArchiveArtifact() {
+    val file = createFile("a.txt")
+    val a = addArtifact(archive("a.jar").fileCopy(file))
+    buildAll()
+    createFileInArtifactOutput(a, "b.txt")
+    buildAllAndAssertUpToDate()
+    assertOutput(a, directoryContent {
+      zip("a.jar") { file("a.txt") }
+      file("b.txt")
+    })
+
+    rebuildAllModulesAndArtifacts()
+    assertOutput(a, directoryContent {
+      zip("a.jar") { file("a.txt") }
+      file("b.txt")
+    })
   }
 
-  public void testDoNotCreateEmptyArchiveInsideArchive() {
-    String file = createFile("dir/a.txt");
-    JpsArtifact a = addArtifact(archive("a.jar").archive("inner.jar").parentDirCopy(file));
-    delete(file);
-    buildAll();
-    assertEmptyOutput(a);
+  fun testDoNotCreateEmptyArchive() {
+    val file = createFile("dir/a.txt")
+    val a = addArtifact(archive("a.jar").parentDirCopy(file))
+    delete(file)
+    buildAll()
+    assertEmptyOutput(a)
   }
 
-  public void testDoNotCreateEmptyArchiveFromExtractedDirectory() {
-    final JpsArtifact a = addArtifact("a", archive("a.jar").dir("dir").extractedDir(getJUnitJarPath(), "/xxx/"));
-    buildAll();
-    assertEmptyOutput(a);
+  fun testDoNotCreateEmptyArchiveInsideArchive() {
+    val file = createFile("dir/a.txt")
+    val a = addArtifact(archive("a.jar").archive("inner.jar").parentDirCopy(file))
+    delete(file)
+    buildAll()
+    assertEmptyOutput(a)
   }
 
-  public void testExtractNonExistentJarFile() {
-    JpsArtifact a = addArtifact(root().extractedDir("this-file-does-not-exist.jar", "/"));
-    buildAll();
-    assertEmptyOutput(a);
+  fun testDoNotCreateEmptyArchiveFromExtractedDirectory() {
+    val a = addArtifact("a", archive("a.jar").dir("dir").extractedDir(getJUnitJarPath(), "/xxx/"))
+    buildAll()
+    assertEmptyOutput(a)
   }
 
-  public void testRepackNonExistentJarFile() {
-    JpsArtifact a = addArtifact(archive("a.jar").extractedDir("this-file-does-not-exist.jar", "/").fileCopy(createFile("a.txt")));
-    buildAll();
-    assertOutput(a, fs().archive("a.jar").file("a.txt"));
+  fun testExtractNonExistentJarFile() {
+    val a = addArtifact(root().extractedDir("this-file-does-not-exist.jar", "/"))
+    buildAll()
+    assertEmptyOutput(a)
+  }
+
+  fun testRepackNonExistentJarFile() {
+    val a = addArtifact(archive("a.jar").extractedDir("this-file-does-not-exist.jar", "/").fileCopy(createFile("a.txt")))
+    buildAll()
+    assertOutput(a, directoryContent { zip("a.jar") {file("a.txt")}})
   }
 }

jps/jps-builders/testSrc/org/jetbrains/jps/incremental/artifacts/ArtifactBuilderTestCase.java

@@ -18,6 +18,7 @@ package org.jetbrains.jps.incremental.artifacts;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.project.IntelliJProjectConfiguration;
 import com.intellij.util.ArrayUtil;
+import com.intellij.util.io.DirectoryContentSpec;
 import com.intellij.util.io.TestFileSystemBuilder;
 import com.intellij.util.text.UniqueNameGenerator;
 import org.jetbrains.jps.builders.BuildResult;
@@ -159,6 +160,10 @@ public abstract class ArtifactBuilderTestCase extends JpsBuildTestCase {
     assertOutput(a.getOutputPath(), expected);
   }
 
+  protected static void assertOutput(JpsArtifact a, DirectoryContentSpec expected) {
+    assertOutput(a.getOutputPath(), expected);
+  }
+
   protected void buildAllAndAssertUpToDate() {
     buildAll();
     assertUpToDate();