Add support for importing resources in test toolchains

Change-Id: I0dc916dd16268c790aecbf60f108f15cd34bb9cd

6 files changed, 137 insertions, 312 deletions

diff --git a/jack-tests/src/com/android/jack/test/toolchain/JackApiToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/JackApiToolchain.java
index 77a6afac..99b0ddb5 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/JackApiToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/JackApiToolchain.java
@@ -69,6 +69,10 @@ public class JackApiToolchain extends JackBasedToolchain {
         jackOptions.getEcjArguments().add(annotationProcessorOutDir.getAbsolutePath());
       }
 
+      for (File res : resImport) {
+        jackOptions.addResource(res);
+      }
+
       for (String ecjArg : extraEcjArgs) {
         jackOptions.getEcjArguments().add(ecjArg);
       }
@@ -136,6 +140,10 @@ public class JackApiToolchain extends JackBasedToolchain {
         jackOptions.getEcjArguments().add(annotationProcessorOutDir.getAbsolutePath());
       }
 
+      for (File res : resImport) {
+        jackOptions.addResource(res);
+      }
+
       for (String ecjArg : extraEcjArgs) {
         jackOptions.getEcjArguments().add(ecjArg);
       }
@@ -188,6 +196,10 @@ public class JackApiToolchain extends JackBasedToolchain {
       jackOptions.getJayceImport().add(in);
       jackOptions.getJayceImport().addAll(staticLibs);
 
+      for (File res : resImport) {
+        jackOptions.addResource(res);
+      }
+
       if (zipFile) {
         jackOptions.setOutputZip(out);
       } else {
@@ -216,6 +228,10 @@ public class JackApiToolchain extends JackBasedToolchain {
       jackOptions.setProguardFlagsFile(proguardFlags);
     }
 
+    for (File res : resImport) {
+      jackOptions.addResource(res);
+    }
+
     for (File staticLib : in) {
       jackOptions.getJayceImport().add(staticLib);
     }
diff --git a/jack-tests/src/com/android/jack/test/toolchain/JackBasedToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/JackBasedToolchain.java
index cb20677a..e5a57acc 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/JackBasedToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/JackBasedToolchain.java
@@ -49,6 +49,8 @@ public abstract class JackBasedToolchain extends AndroidToolchain {
   protected File annotationProcessorOutDir;
   @Nonnull
   protected List<String> extraEcjArgs = new ArrayList<String>();
+  @Nonnull
+  protected List<File> resImport = new ArrayList<File>();
 
   @Nonnull
   public final JackBasedToolchain addProperty(@Nonnull String propertyName,
@@ -81,6 +83,12 @@ public abstract class JackBasedToolchain extends AndroidToolchain {
   }
 
   @Nonnull
+  public JackBasedToolchain addResource(@Nonnull File resource) {
+    resImport.add(resource);
+    return this;
+  }
+
+  @Nonnull
   public final JackBasedToolchain setAnnotationProcessorOutDir(
       @Nonnull File annotationProcessorOutDir) {
     this.annotationProcessorOutDir = annotationProcessorOutDir;
diff --git a/jack-tests/src/com/android/jack/test/toolchain/JackCliToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/JackCliToolchain.java
index 517d9552..485d0663 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/JackCliToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/JackCliToolchain.java
@@ -68,6 +68,11 @@ public class JackCliToolchain extends JackBasedToolchain {
       args.add(classpath);
     }
 
+    for (File res : resImport) {
+      args.add("--import-resource");
+      args.add(res.getPath());
+    }
+
     if (zipFile) {
       args.add("--output-dex-zip");
     } else {
@@ -144,6 +149,11 @@ public class JackCliToolchain extends JackBasedToolchain {
       args.add(classpath);
     }
 
+    for (File res : resImport) {
+      args.add("--import-resource");
+      args.add(res.getPath());
+    }
+
     if (zipFiles) {
       args.add("--output-jack");
     } else {
@@ -207,6 +217,11 @@ public class JackCliToolchain extends JackBasedToolchain {
     }
     args.add(com.android.jack.Main.class.getName());
 
+    for (File res : resImport) {
+      args.add("--import-resource");
+      args.add(res.getPath());
+    }
+
     if (withDebugInfos) {
       args.add("-D");
       args.add("jack.dex.optimize=false");
@@ -257,6 +272,11 @@ public class JackCliToolchain extends JackBasedToolchain {
     }
     args.add(com.android.jack.Main.class.getName());
 
+    for (File res : resImport) {
+      args.add("--import-resource");
+      args.add(res.getPath());
+    }
+
     addProperties(properties, args);
 
     if (jarjarRules != null) {
diff --git a/jack-tests/src/com/android/jack/test/toolchain/LegacyJillToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/LegacyJillToolchain.java
index ebf83f8f..7ebd63ae 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/LegacyJillToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/LegacyJillToolchain.java
@@ -116,6 +116,12 @@ public class LegacyJillToolchain extends JillBasedToolchain {
     throw new AssertionError("Not Yet Implemented");
   }
 
+  @Override
+  @Nonnull
+  public JackBasedToolchain addResource(@Nonnull File resource) {
+    throw new AssertionError("Not applicable");
+  }
+
   private void compileWithExternalRefCompiler(@Nonnull File[] sources,
       @Nonnull String classpath, @Nonnull File out) {
 
diff --git a/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java b/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java
index 10fe3117..7d7c5335 100644
--- a/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java
+++ b/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java
@@ -16,21 +16,18 @@
 
 package com.android.jack.fileconflict;
 
-import com.android.jack.Jack;
-import com.android.jack.Options;
-import com.android.jack.ProguardFlags;
-import com.android.jack.TestTools;
 import com.android.jack.backend.jayce.ImportConflictException;
 import com.android.jack.backend.jayce.JayceFileImporter;
-import com.android.jack.test.category.KnownBugs;
 import com.android.jack.library.FileType;
 import com.android.jack.library.JackLibrary;
 import com.android.jack.resource.ResourceImportConflictException;
 import com.android.jack.resource.ResourceImporter;
 import com.android.jack.shrob.obfuscation.NameProviderFactory;
+import com.android.jack.test.category.KnownBugs;
 import com.android.jack.test.toolchain.AbstractTestTools;
 import com.android.jack.test.toolchain.IToolchain;
 import com.android.jack.test.toolchain.JackApiToolchain;
+import com.android.jack.test.toolchain.JackBasedToolchain;
 import com.android.sched.util.stream.ByteStreamSucker;
 
 import junit.framework.Assert;
@@ -47,9 +44,6 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -453,93 +447,34 @@ public class FileConflictTests {
       @CheckForNull String collisionPolicy) throws Exception {
     // compile source files to a Jack dir
     File jackImport1 = AbstractTestTools.createTempDir();
-    Options options = new Options();
     File lib1 = new File(TEST002_DIR, "lib1");
-    options.addResource(new File(lib1, "rsc"));
-    TestTools.compileSourceToJack(options, lib1, TestTools.getDefaultBootclasspathString(),
-        jackImport1, false /* non-zipped */);
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(lib1, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackImport1,
+        /* zipFiles = */ false,
+        lib1);
 
     File jackImport2 = AbstractTestTools.createTempDir();
-    options = new Options();
     File lib2 = new File(TEST002_DIR, "lib2");
-    options.addResource(new File(lib2, "rsc"));
-    TestTools.compileSourceToJack(options, lib2, TestTools.getDefaultBootclasspathString(),
-        jackImport2, false /* non-zipped */);
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(lib2, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackImport2,
+        /* zipFiles = */ false,
+        lib2);
 
     // run Jack on Jack dirs
-    ProguardFlags flags = new ProguardFlags(new File(TEST002_DIR, "proguard.flags"));
-    options = new Options();
-    List<File> jayceImports = new ArrayList<File>(2);
-    jayceImports.add(jackImport1);
-    jayceImports.add(jackImport2);
-    options.setJayceImports(jayceImports);
-    options.setProguardFlagsFile(Collections.<File>singletonList(flags));
-    if (zip) {
-      options.setJayceOutputZip(jackOutput);
-    } else {
-      options.setJayceOutputDir(jackOutput);
-    }
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new File(TEST002_DIR, "proguard.flags"));
     if (collisionPolicy != null) {
-      options.addProperty(ResourceImporter.RESOURCE_COLLISION_POLICY.getName(), collisionPolicy);
+      toolchain.addProperty(ResourceImporter.RESOURCE_COLLISION_POLICY.getName(), collisionPolicy);
     }
-    Jack.run(options);
+    toolchain.libToLib(new File[] {jackImport1,jackImport2}, jackOutput, /* zipFiles = */ zip);
   }
 
-//  private void runTest002(@Nonnull File jackOutput, boolean zip,
-//      @CheckForNull String collisionPolicy) throws Exception {
-//    // compile source files to a Jack dir
-//    // TODO(jmhenaff): adapt this when resources are added to toolchain APIs
-//    File jackImport1 = TestTools.createTempDir("jack", "dir");
-//    Options options = new Options();
-//    File lib1 = new File(TEST002_DIR, "lib1");
-//    options.addResource(new File(lib1, "rsc"));
-//    TestTools.compileSourceToJack(options, lib1, TestTools.getDefaultBootclasspathString(),
-//        jackImport1, false /* non-zipped */);
-//
-//    File jackImport2 = TestTools.createTempDir("jack", "dir");
-//    options = new Options();
-//    File lib2 = new File(TEST002_DIR, "lib2");
-//    options.addResource(new File(lib2, "rsc"));
-//    TestTools.compileSourceToJack(options, lib2, TestTools.getDefaultBootclasspathString(),
-//        jackImport2, false /* non-zipped */);
-////    File tempJackFolder = AbstractTestTools.createTempDir();
-////    JackApiToolchain toolchain =
-////        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
-////    toolchain.srcToLib(
-////        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-////        tempJackFolder,
-////        /* zipFile = */ false,
-////        TEST002_DIR);
-////
-////    // get paths for Jack files
-////    File myClass1 = new File(tempJackFolder, JACK_FILE_PATH_002_1);
-////    File myClass2 = new File(tempJackFolder, JACK_FILE_PATH_002_2);
-////
-////    // get paths for resources
-////    File resource1 = new File(TEST002_DIR, RESOURCE1_SHORTPATH);
-////    File resource2 = new File(TEST002_DIR, RESOURCE2_SHORTPATH);
-////    File resource3 = new File(TEST002_DIR, RESOURCE3_SHORTPATH);
-////
-////    // create Jack dirs to import
-////    File jackImport1 = AbstractTestTools.createTempDir();
-////    File jackImport2 = AbstractTestTools.createTempDir();
-////    copyFileToDir(myClass1, JACK_FILE_PATH_002_1, jackImport1);
-////    copyFileToDir(resource1, RESOURCE1_LONGPATH, jackImport1);
-////    copyFileToDir(resource2, RESOURCE2_LONGPATH, jackImport1);
-////    copyFileToDir(myClass2, JACK_FILE_PATH_002_2, jackImport2);
-////    copyFileToDir(resource2, RESOURCE1_LONGPATH, jackImport2);
-////    copyFileToDir(resource3, RESOURCE3_LONGPATH, jackImport2);
-//
-//    // run Jack on Jack dirs
-//    toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
-//    toolchain.addProguardFlags(new File(TEST002_DIR, "proguard.flags"));
-//    if (collisionPolicy != null) {
-//      toolchain.addProperty(JayceFileImporter.RESOURCE_COLLISION_POLICY.getName(), collisionPolicy);
-//    }
-//    toolchain.libToLib(new File [] {jackImport1, jackImport2},  jackOutput, zip);
-//
-//  }
-
   private void copyFileToDir(@Nonnull File fileToCopy, @Nonnull String relativePath,
       @Nonnull File dir) throws IOException {
     FileOutputStream fos = null;
diff --git a/jack-tests/tests/com/android/jack/resource/ResourceTests.java b/jack-tests/tests/com/android/jack/resource/ResourceTests.java
index 8ddbeca0..f7bcf913 100644
--- a/jack-tests/tests/com/android/jack/resource/ResourceTests.java
+++ b/jack-tests/tests/com/android/jack/resource/ResourceTests.java
@@ -16,12 +16,9 @@
 
 package com.android.jack.resource;
 
-import com.android.jack.Options;
-import com.android.jack.ProguardFlags;
-import com.android.jack.TestTools;
-import com.android.jack.test.category.KnownBugs;
 import com.android.jack.library.FileType;
 import com.android.jack.shrob.obfuscation.NameProviderFactory;
+import com.android.jack.test.category.KnownBugs;
 import com.android.jack.test.toolchain.AbstractTestTools;
 import com.android.jack.test.toolchain.JackBasedToolchain;
 import com.android.sched.util.stream.ByteStreamSucker;
@@ -40,7 +37,6 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.StringReader;
-import java.util.Collections;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipFile;
 
@@ -83,7 +79,7 @@ public class ResourceTests {
     File jackAr = createJackArchiveWithResources();
 
     // compile Jack archive to a dex dir
-    File dexDir = TestTools.createTempDir("resourcetestdex", "dir");
+    File dexDir = AbstractTestTools.createTempDir();
     JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
     toolchain.libToExe(jackAr, dexDir, /* zipFile = */ false);
 
@@ -114,19 +110,20 @@ public class ResourceTests {
 
   @Test
   public void testJackDirToDexArchive() throws Exception {
-
-    // TODO(jmhenaff) adapt this after rebase. Add API for resources
-
     // compile source file to a Jack dir
-    File jackFolder = TestTools.createTempDir("tempjack", "dir");
-    Options options = new Options();
-    options.addResource(new File(FILE, "rsc"));
-    TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(),
-        jackFolder, false /* non-zipped */);
+    File jackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(FILE, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackFolder,
+        /* zipFiles = */ false,
+        FILE);
 
     // compile Jack dir to dex archive
-    File dexAr = TestTools.createTempFile("resourcetestdex", ".zip");
-    TestTools.compileJackToDex(new Options(), jackFolder, dexAr, true /* zipped */);
+    File dexAr = AbstractTestTools.createTempFile("resourcetestdex", ".zip");
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(jackFolder, dexAr, /* zipFile = */ true);
 
     // check that resources are contained in dex archive
     ZipFile zipFile = new ZipFile(dexAr);
@@ -134,33 +131,6 @@ public class ResourceTests {
     checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false);
     checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false);
     checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false);
-
-//    // compile source file to a Jack dir
-//    File jackFolder = AbstractTestTools.createTempDir();
-//    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.srcToLib(
-//        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-//        jackFolder,
-//        /* zipFiles = */ false,
-//        FILE);
-//
-//    // add resources to Jack dir
-//    copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder);
-//
-//    // compile Jack dir to dex archive
-//    File dexAr = TestTools.createTempFile("resourcetestdex", ".zip");
-//    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.libToDex(jackFolder, dexAr, /* zipFile = */ true);
-//
-//    // check that resources are contained in dex archive
-//    ZipFile zipFile = new ZipFile(dexAr);
-//    checkResourceContent(zipFile, RESOURCE1_LONGPATH, "Res1");
-//    checkResourceContent(zipFile, RESOURCE2_LONGPATH, "Res2");
-//    checkResourceContent(zipFile, RESOURCE3_LONGPATH, "Res3");
-//    checkResourceContent(zipFile, RESOURCE4_LONGPATH, "Res4");
   }
 
   @Test
@@ -185,21 +155,20 @@ public class ResourceTests {
   @Test
   public void testJackDirToJackArchive() throws Exception {
     // compile source file to a Jack dir
-    File jackFolder = TestTools.createTempDir("tempjack", "dir");
-    Options options = new Options();
-    options.addResource(new File(FILE, "rsc"));
-    TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(),
-        jackFolder, false /* non-zipped */);
+    File jackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(FILE, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackFolder,
+        /* zipFiles = */ false,
+        FILE);
 
     // run shrobbing from Jack dir to Jack archive
-    File shrobbedJackAr = TestTools.createTempFile("shrobbedJackAr", ".zip");
-    ProguardFlags flags = new ProguardFlags(new File(FILE, "proguard.flags"));
-    TestTools.shrobJackToJack(new Options(),
-        jackFolder,
-        null /* classpath */,
-        shrobbedJackAr,
-        Collections.singletonList(flags),
-        true /* zipped */);
+    File shrobbedJackAr = AbstractTestTools.createTempFile("shrobbedJackAr", ".zip");
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new File(FILE, "proguard.flags"));
+    toolchain.libToLib(jackFolder, shrobbedJackAr, /* zipFiles = */ true);
 
     // check that resources are contained in Jack archive
     ZipFile zipFile = new ZipFile(shrobbedJackAr);
@@ -207,35 +176,6 @@ public class ResourceTests {
     checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true);
     checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true);
     checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true);
-
-//    // compile source file to a Jack dir
-//    File jackFolder = TestTools.createTempDir("tempjack", "dir");
-//    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.srcToLib(
-//        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-//        jackFolder,
-//        /* zipFiles = */ false,
-//        FILE);
-//
-//
-//    // add resources to Jack dir
-//    copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder);
-//
-//    // run shrobbing from Jack dir to Jack archive
-//    File shrobbedJackAr = AbstractTestTools.createTempFile("shrobbedJackAr", ".zip");
-//    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.addProguardFlags(new File(FILE, "proguard.flags"));
-//    toolchain.libToLib(jackFolder, shrobbedJackAr, /* zipFiles = */ true);
-//
-//    // check that resources are contained in Jack archive
-//    ZipFile zipFile = new ZipFile(shrobbedJackAr);
-//    checkResourceContent(zipFile, RESOURCE1_LONGPATH, "Res1");
-//    checkResourceContent(zipFile, RESOURCE2_LONGPATH, "Res2");
-//    checkResourceContent(zipFile, RESOURCE3_LONGPATH, "Res3");
-//    checkResourceContent(zipFile, RESOURCE4_LONGPATH, "Res4");
   }
 
   @Test
@@ -259,149 +199,75 @@ public class ResourceTests {
 
   @Test
   public void testJackDirToJackDir() throws Exception {
-    /// compile source file to a Jack dir
-    File jackFolder = TestTools.createTempDir("tempjack", "dir");
-    Options options = new Options();
-    options.addResource(new File(FILE, "rsc"));
-    TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(),
-        jackFolder, false /* non-zipped */);
+    // compile source file to a Jack dir
+    File jackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(FILE, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackFolder,
+        /* zipFiles = */ false,
+        FILE);
 
     // run shrobbing from Jack dir to Jack dir
-    File shrobbedJackDir = TestTools.createTempDir("shrobbedJack", "dir");
-    ProguardFlags flags = new ProguardFlags(new File(FILE, "proguard.flags"));
-    TestTools.shrobJackToJack(new Options(),
-        jackFolder,
-        null /* classpath */,
-        shrobbedJackDir,
-        Collections.singletonList(flags),
-        false /* non-zipped */);
+    File shrobbedJackDir = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new File(FILE, "proguard.flags"));
+    toolchain.libToLib(jackFolder, shrobbedJackDir, /* zipFiles = */ false);
 
     // check that resources are contained in Jack dir
     checkResourceContentFromDir(shrobbedJackDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true);
     checkResourceContentFromDir(shrobbedJackDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true);
     checkResourceContentFromDir(shrobbedJackDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true);
     checkResourceContentFromDir(shrobbedJackDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true);
-
-
-//    // compile source file to a Jack dir
-//    File jackFolder = AbstractTestTools.createTempDir();
-//    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.srcToLib(
-//        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-//        jackFolder,
-//        /* zipFiles = */ false,
-//        FILE);
-//
-//    // add resources to Jack dir
-//    copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder);
-//
-//    // run shrobbing from Jack dir to Jack dir
-//    File shrobbedJackDir = AbstractTestTools.createTempDir();
-//    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.addProguardFlags(new File(FILE, "proguard.flags"));
-//    toolchain.libToLib(jackFolder, shrobbedJackDir, /* zipFiles = */ false);
-//
-//
-//    // check that resources are contained in Jack dir
-//    checkResourceContent(shrobbedJackDir, RESOURCE1_LONGPATH, "Res1");
-//    checkResourceContent(shrobbedJackDir, RESOURCE2_LONGPATH, "Res2");
-//    checkResourceContent(shrobbedJackDir, RESOURCE3_LONGPATH, "Res3");
-//    checkResourceContent(shrobbedJackDir, RESOURCE4_LONGPATH, "Res4");
   }
 
   @Test
   public void testJackDirToDexDir() throws Exception {
     // compile source file to a Jack dir
-    File jackFolder = TestTools.createTempDir("tempjack", "dir");
-    Options options = new Options();
-    options.addResource(new File(FILE, "rsc"));
-    TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(),
-        jackFolder, false /* non-zipped */);
+    File jackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(FILE, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackFolder,
+        /* zipFiles = */ false,
+        FILE);
 
     // compile Jack dir to a dex dir
-    File dexDir = TestTools.createTempDir("resourcetestdex", "dir");
-    TestTools.compileJackToDex(new Options(), jackFolder, dexDir, false /* zipped */);
+    File dexDir = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(jackFolder, dexDir, /* zipFile = */ false);
 
     // check that resources are contained in dex dir
     checkResourceContentFromDir(dexDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false);
     checkResourceContentFromDir(dexDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false);
     checkResourceContentFromDir(dexDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false);
     checkResourceContentFromDir(dexDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false);
-
-//    // compile source file to a Jack dir
-//    File jackFolder = AbstractTestTools.createTempDir();
-//    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.srcToLib(
-//        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-//        jackFolder,
-//        /* zipFiles = */ false,
-//        FILE);
-//
-//    // add resources to Jack dir
-//    copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder);
-//
-//    // compile Jack dir to a dex dir
-//    File dexDir = AbstractTestTools.createTempDir();
-//    AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class)
-//      .libToDex(jackFolder, dexDir, /* zipFile = */ false);
-//
-//    // check that resources are contained in dex dir
-//    checkResourceContent(dexDir, RESOURCE1_LONGPATH, "Res1");
-//    checkResourceContent(dexDir, RESOURCE2_LONGPATH, "Res2");
-//    checkResourceContent(dexDir, RESOURCE3_LONGPATH, "Res3");
-//    checkResourceContent(dexDir, RESOURCE4_LONGPATH, "Res4");
   }
 
   @Test
   public void testJackToDexInSameDir() throws Exception {
     // compile source file to a Jack dir
-    File jackFolder = TestTools.createTempDir("tempjack", "dir");
-    Options options = new Options();
-    options.addResource(new File(FILE, "rsc"));
-    TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(),
-        jackFolder, false /* non-zipped */);
+    File jackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(FILE, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackFolder,
+        /* zipFiles = */ false,
+        FILE);
 
     // compile Jack dir to same dir
     File dexDir = jackFolder;
-    TestTools.compileJackToDex(new Options(), jackFolder, dexDir, false /* zipped */);
+    AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class)
+      .libToExe(jackFolder, dexDir, /* zipFile = */ false);
 
     // check that resources are contained in dex dir
     checkResourceContentFromDir(dexDir, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false);
     checkResourceContentFromDir(dexDir, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false);
     checkResourceContentFromDir(dexDir, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false);
     checkResourceContentFromDir(dexDir, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false);
-
-//    // compile source file to a Jack dir
-//    File jackFolder = AbstractTestTools.createTempDir();
-//    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.srcToLib(
-//        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-//        jackFolder,
-//        /* zipFiles = */ false,
-//        FILE);
-//
-//    // add resources to Jack dir
-//    copyFileToDir(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, jackFolder);
-//    copyFileToDir(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, jackFolder);
-//
-//    // compile Jack dir to same dir
-//    File dexDir = jackFolder;
-//    AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class)
-//      .libToDex(jackFolder, dexDir, /* zipFile = */ false);
-//
-//    // check that resources are contained in dex dir
-//    checkResourceContent(dexDir, RESOURCE1_LONGPATH, "Res1");
-//    checkResourceContent(dexDir, RESOURCE2_LONGPATH, "Res2");
-//    checkResourceContent(dexDir, RESOURCE3_LONGPATH, "Res3");
-//    checkResourceContent(dexDir, RESOURCE4_LONGPATH, "Res4");
   }
 
   @Test
@@ -443,42 +309,16 @@ public class ResourceTests {
   @Nonnull
   private File createJackArchiveWithResources() throws Exception {
     // compile source file to a Jack file
-    //File tempJackFolder = TestTools.createTempDir("jack", "dir");
-    File jackAr = TestTools.createTempFile("resourcetestjack", ".zip");
-    Options options = new Options();
-    options.addResource(new File(FILE, "rsc"));
-    TestTools.compileSourceToJack(options, FILE, TestTools.getDefaultBootclasspathString(),
-        jackAr, true /* non-zipped */);
+    File jackAr = AbstractTestTools.createTempFile("resourcetestjack", ".zip");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addResource(new File(FILE, "rsc"));
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackAr,
+        /* zipFiles = */ true,
+        FILE);
 
     return jackAr;
-
-//    // compile source file to a Jack file
-//    File tempJackFolder = AbstractTestTools.createTempDir();
-//    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
-//    toolchain.srcToLib(
-//        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-//        tempJackFolder,
-//        /* zipFiles = */ false,
-//        FILE);
-//
-//    // create Jack archive with resources
-//    File singleJackFile = new File(tempJackFolder, JACK_FILE_PATH);
-//    File jackAr = AbstractTestTools.createTempFile("resourcetestjack", ".zip");
-//    ZipOutputStream zos = null;
-//    try {
-//      zos = new ZipOutputStream(new FileOutputStream(jackAr));
-//
-//      copyFileToZip(singleJackFile, JACK_FILE_PATH, zos);
-//      copyFileToZip(new File(FILE, RESOURCE1_SHORTPATH), RESOURCE1_LONGPATH, zos);
-//      copyFileToZip(new File(FILE, RESOURCE2_SHORTPATH), RESOURCE2_LONGPATH, zos);
-//      copyFileToZip(new File(FILE, RESOURCE3_SHORTPATH), RESOURCE3_LONGPATH, zos);
-//      copyFileToZip(new File(FILE, RESOURCE4_SHORTPATH), RESOURCE4_LONGPATH, zos);
-//    } finally {
-//      if (zos != null) {
-//        zos.close();
-//      }
-//    }
-//    return jackAr;
   }
 
   private void checkResourceContentFromZip(@Nonnull ZipFile zipFile, @Nonnull String entryName,