Use new JUnit based test framework

Bug: 18547020

Change-Id: I5d02ebdecbf79bea035ae8a042d50a06aa7c2a62

154 files changed, 13963 insertions, 557 deletions

diff --git a/jack-tests/.classpath b/jack-tests/.classpath
index 6e2cd3f0..3cc771dd 100644
--- a/jack-tests/.classpath
+++ b/jack-tests/.classpath
@@ -2,7 +2,7 @@
 <classpath>
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
-	<classpathentry excluding="com/android/jack/classpath/test002/lib1override/|com/android/jack/compiletime/|com/android/jack/enums/test003/link/Other.java|com/android/jack/enums/test003/link/Values.java|com/android/jack/error/test001/jack/A.java|com/android/jack/error/test002/jack/A.java|com/android/jack/java7/boxing/|com/android/jack/java7/exceptions/|com/android/jack/java7/parser/|com/android/jack/java7/switches/|com/android/jack/java7/trywithresources/|com/android/jack/nopackage/jack/|com/android/jack/lookup/test001/liboverride/|com/android/jack/jarjar/test003/dontcompile/" kind="src" path="tests"/>
+	<classpathentry excluding="com/android/jack/classpath/test002/lib1override/|com/android/jack/compiletime/test*/**|com/android/jack/enums/test003/link/Other.java|com/android/jack/enums/test003/link/Values.java|com/android/jack/error/test001/jack/A.java|com/android/jack/error/test002/jack/A.java|com/android/jack/jarjar/test003/dontcompile/|com/android/jack/java7/boxing/|com/android/jack/java7/exceptions/|com/android/jack/java7/parser/|com/android/jack/java7/switches/|com/android/jack/java7/trywithresources/|com/android/jack/lookup/test001/liboverride/|com/android/jack/nopackage/test*/**" kind="src" path="tests"/>
 	<classpathentry kind="lib" path="libs/junit4.jar"/>
 	<classpathentry kind="lib" path="libs/antlr-runtime-lib.jar"/>
 	<classpathentry kind="lib" path="libs/dx-ref.jar"/>
diff --git a/jack-tests/.settings/org.eclipse.jdt.core.prefs b/jack-tests/.settings/org.eclipse.jdt.core.prefs
index 10d8c88d..992473c0 100644
--- a/jack-tests/.settings/org.eclipse.jdt.core.prefs
+++ b/jack-tests/.settings/org.eclipse.jdt.core.prefs
@@ -6,6 +6,7 @@ org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annota
 org.eclipse.jdt.core.compiler.annotation.nullable=javax.annotation.CheckForNull
 org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
 org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.methodParameters=do not generate
 org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
 org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
 org.eclipse.jdt.core.compiler.compliance=1.6
diff --git a/jack-tests/Android.mk b/jack-tests/Android.mk
index b0b2e6c7..aec6857e 100644
--- a/jack-tests/Android.mk
+++ b/jack-tests/Android.mk
@@ -93,7 +93,7 @@ $(call declare-test-with-name,assertion/test002)
 $(call declare-test-with-name,assertion/test003)
 
 # Assign
-$(call declare-test-with-name,assign)
+$(call declare-test-with-name,assign/test001)
 
 # Box
 $(call declare-test-with-name,box/test001)
@@ -173,7 +173,7 @@ $(call declare-test-with-name,tryfinally/finally003)
 $(call declare-test-with-name,tryfinally/finally004)
 
 # Fibonacci
-$(call declare-test-with-name,fibonacci)
+$(call declare-test-with-name,fibonacci/test001)
 
 # Flow
 $(call declare-test-with-name,flow/loop)
@@ -242,7 +242,7 @@ $(call declare-test-with-name,optimizations/exprsimplifier/test001)
 $(call declare-test,$(JACK_PATH)/tests/com/android/jack/opcodes/test-opcodes.mk)
 
 # Order
-$(call declare-test-with-name,order)
+$(call declare-test-with-name,order/test001)
 
 # Return
 $(call declare-test-with-name,returnstatement/returnvoid)
@@ -275,7 +275,7 @@ $(call declare-test-with-name,switchstatement/test010)
 $(call declare-test-with-name,synchronize/test001)
 
 # Three Address
-$(call declare-test-with-name,threeaddress)
+$(call declare-test-with-name,threeaddress/test001)
 
 # Throws
 $(call declare-test-with-name,throwstatement/test001)
diff --git a/jack-tests/README b/jack-tests/README
new file mode 100644
index 00000000..3e4f7e65
--- /dev/null
+++ b/jack-tests/README
@@ -0,0 +1,38 @@
+# Copyright (C) 2014 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+To run the tests a configuration file must be provided.
+
+Make a copy of the template so that your settings are not committed.
+
+It can be passed by setting the property tests.config (with -D) with the path to the file.
+
+To be able to use jack-tests to run the tests, the configuration file 
+must define following properties:
+ * jack.home: it must point to the parent dir of Jack git project
+ * runtime.location.<runtime environment name>: location of host android runtime environments
+
+The follwing values are supported:
+ * runtime.location.dalvik-fast-host
+ * runtime.location.dalvik-jit
+ * runtime.location.art-host
+
+Indicate the location of the legacy java compiler with:
+ * toolchain.prebuilt.legacy-java-compiler
+
+In Eclipse: define a run configuration with -Dtests.config as a VM argument.
+On the command line:
+ * use run-jack-tests script with the config file path as first parameter, and the test suite to
+run as the second parameter
+ * use Ant tasks (e.g. jack-test) to run common sets of tests.
diff --git a/jack-tests/prebuilts/dexdump b/jack-tests/prebuilts/dexdump
new file mode 100755
index 00000000..d10116ef
--- /dev/null
+++ b/jack-tests/prebuilts/dexdump
diff --git a/jack-tests/prebuilts/junit4-targetdex-jack.zip b/jack-tests/prebuilts/junit4-targetdex-jack.zip
new file mode 100644
index 00000000..acf39fed
--- /dev/null
+++ b/jack-tests/prebuilts/junit4-targetdex-jack.zip
diff --git a/jack-tests/run-jack-tests b/jack-tests/run-jack-tests
new file mode 100755
index 00000000..31d8593d
--- /dev/null
+++ b/jack-tests/run-jack-tests
@@ -0,0 +1,25 @@
+# Copyright (C) 2012 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#!/bin/bash
+
+if [ $# -lt 2 ]
+then
+  echo "Usage: $(basename $0) <tests config file path> <test suite>+"
+  exit 1
+fi
+set -x
+CURRENT_DIR=$(dirname $0)
+java -Dtests.config=$1 -cp $CURRENT_DIR/dist/jack-tests.jar:$CURRENT_DIR/../jack/dist/jackunittests-lib.jar org.junit.runner.JUnitCore $2
+
diff --git a/jack-tests/src/com/android/jack/test/category/ExtraTests.java b/jack-tests/src/com/android/jack/test/category/ExtraTests.java
new file mode 100644
index 00000000..c1e5c951
--- /dev/null
+++ b/jack-tests/src/com/android/jack/test/category/ExtraTests.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.test.category;
+
+/**
+ * Tests that are not critical, so that we do not want to run them each time we submit a CL.
+ */
+public interface ExtraTests extends NonPreSubmitTests {
+
+}
diff --git a/jack-tests/src/com/android/jack/test/category/KnownBugs.java b/jack-tests/src/com/android/jack/test/category/KnownBugs.java
new file mode 100644
index 00000000..86c6910e
--- /dev/null
+++ b/jack-tests/src/com/android/jack/test/category/KnownBugs.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.test.category;
+
+/**
+ * Tests that show a known Jack bug.
+ */
+public interface KnownBugs extends NonPreSubmitTests {
+
+}
diff --git a/jack-tests/src/com/android/jack/test/category/NonPreSubmitTests.java b/jack-tests/src/com/android/jack/test/category/NonPreSubmitTests.java
new file mode 100644
index 00000000..70cf3cb4
--- /dev/null
+++ b/jack-tests/src/com/android/jack/test/category/NonPreSubmitTests.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.test.category;
+
+/**
+ * Tests that we do not need to run before submitting a CL.
+ */
+public interface NonPreSubmitTests {
+
+}
diff --git a/jack-tests/src/com/android/jack/test/category/RedundantTests.java b/jack-tests/src/com/android/jack/test/category/RedundantTests.java
new file mode 100644
index 00000000..42fac240
--- /dev/null
+++ b/jack-tests/src/com/android/jack/test/category/RedundantTests.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.test.category;
+
+/**
+ * Tests that are already covered by another test. They may be interesting on their own, but do not
+ * need to be included in a pre-submit test suite.
+ */
+public interface RedundantTests extends NonPreSubmitTests {
+
+}
diff --git a/jack-tests/src/com/android/jack/test/category/SlowTests.java b/jack-tests/src/com/android/jack/test/category/SlowTests.java
new file mode 100644
index 00000000..0a7fdbd3
--- /dev/null
+++ b/jack-tests/src/com/android/jack/test/category/SlowTests.java
@@ -0,0 +1,24 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.test.category;
+
+/**
+ * Tests that are time-consuming, so that we do not want to run them each time we submit a CL.
+ */
+public interface SlowTests extends NonPreSubmitTests {
+
+}
diff --git a/jack-tests/tests/com/android/jack/enums/EnumTests.java b/jack-tests/src/com/android/jack/test/comparator/ComparatorSeeds.java
index 361e6a65..47dbe9d3 100644
--- a/jack-tests/tests/com/android/jack/enums/EnumTests.java
+++ b/jack-tests/src/com/android/jack/test/comparator/ComparatorSeeds.java
@@ -14,30 +14,30 @@
  * limitations under the License.
  */
 
-package com.android.jack.enums;
+package com.android.jack.test.comparator;
 
-import com.android.jack.test.helper.RuntimeTestHelper;
-import com.android.jack.test.runtime.RuntimeTestInfo;
-import com.android.jack.test.toolchain.AbstractTestTools;
-
-import org.junit.Before;
-import org.junit.Test;
+import com.android.jack.DifferenceFoundException;
+import com.android.jack.shrob.SeedsComparator;
 
 import java.io.File;
+import java.io.IOException;
 
-public class EnumTests {
-
-  private File baseDir;
+/**
+ * This {@link Comparator} is used to compare shrob seeds.
+ */
+public class ComparatorSeeds extends ComparatorFile {
 
-  @Before
-  public void setUp() {
-    baseDir = AbstractTestTools.getTestRootDir("com.android.jack.enums.test003");
+  public ComparatorSeeds(File candidate, File reference) {
+    super(candidate, reference);
   }
 
-  @Test
-  public void compileAndRunTest() throws Exception {
-    new RuntimeTestHelper(new RuntimeTestInfo(baseDir, "com.android.jack.enums.test003.dx.Tests"))
-        .compileAndRunTest();
+  @Override
+  public void compare() throws DifferenceFoundException, ComparatorException {
+    try {
+      SeedsComparator.compare(reference, candidate);
+    } catch (IOException e) {
+      throw new ComparatorException(e);
+    }
   }
 
 }
diff --git a/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java b/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java
index f3858bf2..d00d3673 100644
--- a/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java
+++ b/jack-tests/src/com/android/jack/test/helper/CheckDexStructureTestHelper.java
@@ -17,6 +17,8 @@
 package com.android.jack.test.helper;
 
 
+import com.android.jack.test.toolchain.AndroidToolchain;
+
 import java.io.File;
 
 import javax.annotation.Nonnull;
@@ -26,8 +28,74 @@ import javax.annotation.Nonnull;
  */
 public class CheckDexStructureTestHelper extends SourceToDexComparisonTestHelper {
 
-  public CheckDexStructureTestHelper(@Nonnull File fileOrSourceList) throws Exception {
-    super(fileOrSourceList);
+  public CheckDexStructureTestHelper(@Nonnull File... filesOrSourceList) throws Exception {
+    super(filesOrSourceList);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setCandidateTestTools(
+      @Nonnull AndroidToolchain candidateTestTools) {
+    return (CheckDexStructureTestHelper) super.setCandidateTestTools(candidateTestTools);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setReferenceTestTools(
+      @Nonnull AndroidToolchain referenceTestTools) {
+    return (CheckDexStructureTestHelper) super.setReferenceTestTools(referenceTestTools);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setCandidateClasspath(@Nonnull File[] classpath) {
+    return (CheckDexStructureTestHelper) super.setCandidateClasspath(classpath);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setReferenceClasspath(@Nonnull File[] classpath) {
+    return (CheckDexStructureTestHelper) super.setReferenceClasspath(classpath);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setWithDebugInfo(boolean withDebugInfo) {
+    return (CheckDexStructureTestHelper) super.setWithDebugInfo(withDebugInfo);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setJarjarRulesFile(@Nonnull File jarjarRulesFile) {
+    return (CheckDexStructureTestHelper) super.setJarjarRulesFile(jarjarRulesFile);
+  }
+
+  @Override
+  @Nonnull
+  public CheckDexStructureTestHelper setProguardFlags(@Nonnull File... proguardFlags) {
+    return (CheckDexStructureTestHelper) super.setProguardFlags(proguardFlags);
+  }
+
+  @Override
+  @Nonnull
+  protected void executeCandidateToolchain() throws Exception {
+    if (withDebugInfos) {
+      getCandidateToolchain().disableDxOptimizations();
+    } else {
+      getCandidateToolchain().enableDxOptimizations();
+    }
+    super.executeCandidateToolchain();
+  }
+
+  @Override
+  @Nonnull
+  protected void executeReferenceToolchain() throws Exception {
+    if (withDebugInfos) {
+      getReferenceToolchain().disableDxOptimizations();
+    } else {
+      getReferenceToolchain().enableDxOptimizations();
+    }
+    super.executeReferenceToolchain();
   }
 
   public void compare() throws Exception {
diff --git a/jack-tests/src/com/android/jack/test/helper/FileChecker.java b/jack-tests/src/com/android/jack/test/helper/FileChecker.java
new file mode 100644
index 00000000..89494c4e
--- /dev/null
+++ b/jack-tests/src/com/android/jack/test/helper/FileChecker.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.test.helper;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+/**
+ * This interface declares a callback method for the caller of a helper to
+ * add specific checks on a file.
+ */
+public interface FileChecker {
+
+  void check(@Nonnull File file) throws Exception;
+
+}
diff --git a/jack-tests/src/com/android/jack/test/helper/IncrementalTestHelper.java b/jack-tests/src/com/android/jack/test/helper/IncrementalTestHelper.java
index 4f5e1724..39a2740e 100644
--- a/jack-tests/src/com/android/jack/test/helper/IncrementalTestHelper.java
+++ b/jack-tests/src/com/android/jack/test/helper/IncrementalTestHelper.java
@@ -17,10 +17,12 @@
 package com.android.jack.test.helper;
 
 import com.android.jack.backend.jayce.JayceFileImporter;
+import com.android.jack.library.FileType;
 import com.android.jack.test.runner.DalvikRunnerHost;
 import com.android.jack.test.runner.RuntimeRunnerFactory;
 import com.android.jack.test.toolchain.AbstractTestTools;
-import com.android.jack.test.toolchain.JackBasedToolchain;
+import com.android.jack.test.toolchain.IToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
 import com.android.jack.test.toolchain.JillBasedToolchain;
 
 import junit.framework.Assert;
@@ -28,13 +30,16 @@ import junit.framework.Assert;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
+import java.io.OutputStream;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
 /**
@@ -58,6 +63,10 @@ public class IncrementalTestHelper {
   private final Set<File> javaFiles = new HashSet<File>();
   @Nonnull
   private final Map<String, Long> fileModificationDate = new HashMap<String, Long>();
+  @Nonnull
+  private OutputStream out = System.out;
+  @Nonnull
+  private OutputStream err = System.err;
 
   public IncrementalTestHelper(@Nonnull File testingFolder) throws IOException {
     this.testingFolder = testingFolder;
@@ -77,10 +86,18 @@ public class IncrementalTestHelper {
     jackFolder = new File(compilerStateFolder, "jackFiles");
   }
 
+  public void setOut(OutputStream out) {
+    this.out = out;
+  }
+
+  public void setErr(OutputStream err) {
+    this.err = err;
+  }
+
   @Nonnull
   public File addJavaFile(@Nonnull String packageName, @Nonnull String fileName,
       @Nonnull String fileContent) throws IOException {
-    File file = AbstractTestTools.createJavaFile(sourceFolder, packageName, fileName, fileContent);
+    File file = AbstractTestTools.createFile(sourceFolder, packageName, fileName, fileContent);
     javaFiles.add(file);
     return file;
   }
@@ -130,8 +147,9 @@ public class IncrementalTestHelper {
       Long previousDate = fileModificationDate.get(jackFile.getAbsolutePath());
       if (previousDate == null || jackFile.lastModified() > previousDate.longValue()) {
         String jackFileName = jackFile.getAbsolutePath();
-        String binaryTypeName = jackFileName.substring(0, jackFileName.indexOf(".jack"));
-        binaryTypeName = binaryTypeName.substring(jackFolder.getAbsolutePath().length() + 1);
+        String binaryTypeName = jackFileName.substring(0, jackFileName.indexOf(".jayce"));
+        binaryTypeName = binaryTypeName.substring((jackFolder.getAbsolutePath() + File.separatorChar
+            + FileType.JAYCE.getPrefix()).length() + 1);
         fqnOfRebuiltTypes.add(binaryTypeName.replace(File.separatorChar, '.'));
       }
     }
@@ -140,13 +158,32 @@ public class IncrementalTestHelper {
   }
 
   public void incrementalBuildFromFolder() throws Exception {
-    JackBasedToolchain jackToolchain =
-        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class, JillBasedToolchain.class);
+    incrementalBuildFromFolder(null, Collections.<File>emptyList());
+  }
+
+  public void incrementalBuildFromFolder(@Nonnull File[] classpath) throws Exception {
+    incrementalBuildFromFolder(classpath, Collections.<File>emptyList());
+  }
+
+  public void incrementalBuildFromFolder(@CheckForNull File[] classpath,
+      @Nonnull List<File> imports) throws Exception {
+
+    List<Class<? extends IToolchain>> excludeList = new ArrayList<Class<? extends IToolchain>>(1);
+    excludeList.add(JillBasedToolchain.class);
+
+    JackApiToolchain jackToolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class, excludeList);
     jackToolchain.setIncrementalFolder(getCompilerStateFolder());
+    jackToolchain.addStaticLibs(imports.toArray(new File[imports.size()]));
+
+    jackToolchain.setOutputStream(out);
+    jackToolchain.setErrorStream(err);
 
-    jackToolchain.srcToExe(
-        AbstractTestTools.getClasspathAsString(jackToolchain.getDefaultBootClasspath()), dexOutDir,
-        sourceFolder);
+    File[] bootclasspath = jackToolchain.getDefaultBootClasspath();
+
+    jackToolchain.srcToExe(classpath == null ? AbstractTestTools.getClasspathAsString(bootclasspath)
+        : AbstractTestTools.getClasspathsAsString(bootclasspath, classpath), dexOutDir,
+        /* zipFile = */ false, sourceFolder);
 
     Thread.sleep(1000);
   }
@@ -162,8 +199,18 @@ public class IncrementalTestHelper {
   }
 
   @Nonnull
+  public File getDexFile() {
+    return dexFile;
+  }
+
+  @Nonnull
+  public File getJackFolder() {
+    return jackFolder;
+  }
+
+  @Nonnull
   public List<File> getJackFiles() {
-    return AbstractTestTools.getFiles(jackFolder, ".jack");
+    return AbstractTestTools.getFiles(jackFolder, ".jayce");
   }
 
 }
diff --git a/jack-tests/src/com/android/jack/test/helper/RuntimeTestHelper.java b/jack-tests/src/com/android/jack/test/helper/RuntimeTestHelper.java
index 29236999..2d1a8738 100644
--- a/jack-tests/src/com/android/jack/test/helper/RuntimeTestHelper.java
+++ b/jack-tests/src/com/android/jack/test/helper/RuntimeTestHelper.java
@@ -18,6 +18,7 @@ package com.android.jack.test.helper;
 
 import com.google.common.base.CharMatcher;
 import com.google.common.base.Splitter;
+import com.google.common.io.Files;
 
 import com.android.jack.test.runner.RuntimeRunner;
 import com.android.jack.test.runtime.RuntimeTestInfo;
@@ -45,14 +46,11 @@ import javax.annotation.Nonnull;
 public class RuntimeTestHelper {
 
   @Nonnull
-  private AndroidToolchain candidateTestTools;
-  @Nonnull
-  private AndroidToolchain referenceTestTools;
-
-  @Nonnull
   private List<File> baseDirs = new ArrayList<File>(1);
   @Nonnull
   private List<String> jUnitClasses = new ArrayList<String>(1);
+  @Nonnull
+  private List<File> referenceExtraSources = new ArrayList<File>(0);
 
   @Nonnull
   private String srcDirName = "jack";
@@ -65,6 +63,11 @@ public class RuntimeTestHelper {
 
   private boolean withDebugInfos = false;
 
+  private SourceLevel level = SourceLevel.JAVA_6;
+
+  @Nonnull
+  private List<FileChecker> testExeCheckers = new ArrayList<FileChecker>(0);
+
   @CheckForNull
   private String jarjarRulesFileName;
   @CheckForNull
@@ -73,11 +76,6 @@ public class RuntimeTestHelper {
   @Nonnull
   private String propertyFileName = "test.properties";
 
-  {
-    candidateTestTools = AbstractTestTools.getCandidateToolchain(AndroidToolchain.class);
-    referenceTestTools = AbstractTestTools.getReferenceToolchain(AndroidToolchain.class);
-  }
-
   public RuntimeTestHelper(@Nonnull RuntimeTestInfo... rtTestInfos) {
     for (RuntimeTestInfo info : rtTestInfos) {
       baseDirs.add(info.directory);
@@ -117,8 +115,7 @@ public class RuntimeTestHelper {
 
   @Nonnull
   public RuntimeTestHelper setSourceLevel(@Nonnull SourceLevel level) {
-    candidateTestTools.setSourceLevel(level);
-    referenceTestTools.setSourceLevel(level);
+    this.level = level;
     return this;
   }
 
@@ -140,7 +137,25 @@ public class RuntimeTestHelper {
     return this;
   }
 
+  @Nonnull
+  public RuntimeTestHelper addTestExeFileChecker(@Nonnull FileChecker checker) {
+    this.testExeCheckers.add(checker);
+    return this;
+  }
+
+  @Nonnull
+  public RuntimeTestHelper addReferenceExtraSources (@Nonnull File... extraSrc) {
+    for (File file : extraSrc) {
+      referenceExtraSources.add(file);
+    }
+    return this;
+  }
+
   public void compileAndRunTest() throws Exception {
+    compileAndRunTest(/* checkStructure = */ false);
+  }
+
+  public void compileAndRunTest(boolean checkStructure) throws Exception {
     Properties testProperties = new Properties();
     try {
       loadTestProperties(testProperties);
@@ -148,8 +163,19 @@ public class RuntimeTestHelper {
       // No file, no pb
     }
 
-    candidateTestTools.setWithDebugInfos(withDebugInfos);
-    referenceTestTools.setWithDebugInfos(withDebugInfos);
+//    AndroidToolchain candidateTestTools =
+//        AbstractTestTools.getCandidateToolchain(AndroidToolchain.class);
+//    AndroidToolchain referenceTestTools =
+//        AbstractTestTools.getReferenceToolchain(AndroidToolchain.class);
+//
+//    candidateTestTools.setSourceLevel(level);
+//    referenceTestTools.setSourceLevel(level);
+//
+//    candidateTestTools.setWithDebugInfos(withDebugInfos);
+//    referenceTestTools.setWithDebugInfos(withDebugInfos);
+
+    AndroidToolchain candidateTestTools = createCandidateToolchain();
+    AndroidToolchain referenceTestTools = createReferenceToolchain();
 
     File[] candidateBootClasspath = candidateTestTools.getDefaultBootClasspath();
     File[] referenceBootClasspath = referenceTestTools.getDefaultBootClasspath();
@@ -165,27 +191,30 @@ public class RuntimeTestHelper {
     File libLibCandidate = null;
     if (getLibSrc().length != 0) {
       libLibRef =
-          AbstractTestTools.createTempFile("-lib-ref", referenceTestTools.getLibraryExtension());
+          AbstractTestTools.createTempFile("lib-ref", referenceTestTools.getLibraryExtension());
       File libBinaryRefDir = AbstractTestTools.createTempDir();
       libBinaryRef = new File(libBinaryRefDir, referenceTestTools.getBinaryFileName());
-      referenceTestTools.srcToLib(referenceBootClasspathAsString, libLibRef, /* zipFiles = */true,
+      referenceTestTools.srcToLib(referenceBootClasspathAsString, libLibRef, /* zipFiles = */ true,
           getLibSrc());
-      referenceTestTools.libToDex(libLibRef, libBinaryRefDir);
+      referenceTestTools.libToExe(libLibRef, libBinaryRefDir, /* zipFile */ false);
 
-      libLibCandidate = AbstractTestTools.createTempFile("-lib-candidate",
+      libLibCandidate = AbstractTestTools.createTempFile("lib-candidate",
           candidateTestTools.getLibraryExtension());
       candidateTestTools.srcToLib(candidateBootClasspathAsString, libLibCandidate,
-      /* zipFiles = */true, getLibSrc());
+      /* zipFiles = */ true, getLibSrc());
     }
 
     // Compile test src
+    candidateTestTools = createCandidateToolchain();
+
     String candidateClasspathAsString;
     String referenceClasspathAsString;
+    File[] candidateClassPath = candidateBootClasspath;
     if (getLibSrc().length != 0) {
-      File[] candidateClassPath = new File[candidateBootClasspath.length + 1];
+      candidateClassPath = new File[candidateBootClasspath.length + 1];
       System.arraycopy(candidateBootClasspath, 0, candidateClassPath, 0,
           candidateBootClasspath.length);
-      candidateClassPath[candidateClassPath.length - 1] = libLibRef;
+      candidateClassPath[candidateClassPath.length - 1] = libLibCandidate;
       candidateClasspathAsString = AbstractTestTools.getClasspathAsString(candidateClassPath);
       File[] referenceClasspath = new File[referenceBootClasspath.length + 1];
       System.arraycopy(referenceBootClasspath, 0, referenceClasspath, 0,
@@ -202,28 +231,53 @@ public class RuntimeTestHelper {
 
     File testBinaryDir = AbstractTestTools.createTempDir();
     File testBinary = new File(testBinaryDir, candidateTestTools.getBinaryFileName());
-    if (jarjarRules != null) {
-      candidateTestTools.setJarjarRules(jarjarRules);
+
+    if (checkStructure) {
+      CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper(getSrcDir());
+      helper.setCandidateClasspath(candidateClassPath);
+      helper.setCandidateTestTools(candidateTestTools);
+      if (jarjarRules != null) {
+        helper.setJarjarRulesFile(jarjarRules);
+      }
+      helper.setProguardFlags(proguargFlags.toArray(new File[proguargFlags.size()]));
+      helper.compare();
+      Files.copy(helper.getCandidateDex(),
+          new File(testBinaryDir, helper.getCandidateDex().getName()));
+    } else {
+      if (jarjarRules != null) {
+        candidateTestTools.setJarjarRules(jarjarRules);
+      }
+      candidateTestTools.addProguardFlags(proguargFlags.toArray(new File [proguargFlags.size()]));
+      candidateTestTools.srcToExe(candidateClasspathAsString, testBinaryDir, /* zipFile = */ false,
+          getSrcDir());
+    }
+
+    for (FileChecker checker : testExeCheckers) {
+      checker.check(testBinary);
     }
-    candidateTestTools.addProguardFlags(proguargFlags.toArray(new File [proguargFlags.size()]));
-    candidateTestTools.srcToExe(candidateClasspathAsString, testBinaryDir, getSrcDir());
 
+    referenceTestTools = createReferenceToolchain();
     File testLib =
         AbstractTestTools.createTempFile("testRef", referenceTestTools.getLibraryExtension());
-    referenceTestTools.srcToLib(referenceClasspathAsString, testLib, /* zipFiles = */true,
+    referenceTestTools.srcToLib(referenceClasspathAsString, testLib, /* zipFiles = */ true,
         getSrcDir());
 
     // Compile link src
+    candidateTestTools = createCandidateToolchain();
+
     File linkBinary = null;
     if (getLinkSrc().length != 0) {
       File linkBinaryDir = AbstractTestTools.createTempDir();
       linkBinary = new File(linkBinaryDir, candidateTestTools.getBinaryFileName());
       candidateTestTools.setJarjarRules(jarjarRules);
       candidateTestTools.addProguardFlags(proguargFlags.toArray(new File [proguargFlags.size()]));
-      candidateTestTools.srcToExe(candidateBootClasspathAsString, linkBinaryDir, getLinkSrc());
+      candidateTestTools.srcToExe(candidateBootClasspathAsString, linkBinaryDir,
+          /* zipFile = */ false, getLinkSrc());
     }
 
     // Compile ref part src
+    referenceTestTools = createReferenceToolchain();
+
     List<File> referenceClasspath = new ArrayList<File>();
     for (File f : referenceBootClasspath) {
       referenceClasspath.add(f);
@@ -234,12 +288,29 @@ public class RuntimeTestHelper {
     if (testLib != null) {
       referenceClasspath.add(testLib);
     }
+
     referenceClasspathAsString = AbstractTestTools.getClasspathAsString(
         referenceClasspath.toArray(new File[referenceClasspath.size()]));
 
+
+    File [] refSources = getRefSrcDir();
+//    File [] sources = new File [referenceExtraSources.size() + refSources.length];
+    List<File> sources = new ArrayList<File>(referenceExtraSources.size() + refSources.length);
+    sources = Lists.addAll(sources, refSources);
+    sources = Lists.addAll(sources, referenceExtraSources);
+
     File refPartBinaryDir = AbstractTestTools.createTempDir();
+//    File [] sources = new File [referenceExtraSources.size() + 1];
+//    sources[0] = getRefSrcDir()[0];
+//    for (int i = 1; i < sources.length; i++) {
+//      sources[i] = referenceExtraSources.get(i - 1);
+//    }
     File refPartBinary = new File(refPartBinaryDir, referenceTestTools.getBinaryFileName());
-    referenceTestTools.srcToExe(referenceClasspathAsString, refPartBinaryDir, getRefSrcDir());
+    referenceTestTools.srcToExe(
+        referenceClasspathAsString,
+        refPartBinaryDir,
+        /* zipFile = */ false,
+        sources.toArray(new File[sources.size()]));
 
     List<File> rtClasspath = new ArrayList<File>();
     rtClasspath.add(new File(AbstractTestTools.getJackRootDir(),
@@ -264,13 +335,32 @@ public class RuntimeTestHelper {
         rtClasspath.toArray(new File[rtClasspath.size()]));
   }
 
+  @Nonnull
+  private AndroidToolchain createCandidateToolchain() {
+    AndroidToolchain candidateTestTools =
+        AbstractTestTools.getCandidateToolchain(AndroidToolchain.class);
+    candidateTestTools.setSourceLevel(level);
+    candidateTestTools.setWithDebugInfos(withDebugInfos);
+    return candidateTestTools;
+  }
+
+  @Nonnull
+  private AndroidToolchain createReferenceToolchain() {
+    AndroidToolchain referenceTestTools =
+        AbstractTestTools.getReferenceToolchain(AndroidToolchain.class);
+    referenceTestTools.setSourceLevel(level);
+    referenceTestTools.setWithDebugInfos(withDebugInfos);
+    return referenceTestTools;
+  }
+
   private static void runOnRuntimeEnvironments(@Nonnull List<String> jUnitClasses,
       @Nonnull Properties testProperties, @Nonnull File... classpathFiles) throws Exception {
     List<RuntimeRunner> runnerList = AbstractTestTools.listRuntimeTestRunners(testProperties);
+    String[] names = Lists.add(jUnitClasses, 0, AbstractTestTools.JUNIT_RUNNER_NAME).toArray(
+        new String[jUnitClasses.size()]);
     for (RuntimeRunner runner : runnerList) {
       Assert.assertEquals(0, runner.run(
-          getRuntimeArgs(runner.getClass().getSimpleName(), testProperties), Lists.add(jUnitClasses,
-              0, AbstractTestTools.JUNIT_RUNNER_NAME).toArray(new String[jUnitClasses.size() + 1]),
+          getRuntimeArgs(runner.getClass().getSimpleName(), testProperties), names,
           classpathFiles));
     }
   }
diff --git a/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java b/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java
index 72d9108a..87db1bea 100644
--- a/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java
+++ b/jack-tests/src/com/android/jack/test/helper/SourceToDexComparisonTestHelper.java
@@ -47,7 +47,7 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper
   private File[] referenceClasspath;
 
   @Nonnull
-  private File fileOrSourceList;
+  private File[] filesOrSourceList;
 
   @CheckForNull
   private File jarjarRulesFile = null;
@@ -61,9 +61,9 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper
 
   protected boolean withDebugInfos = false;
 
-  public SourceToDexComparisonTestHelper(@Nonnull File fileOrSourceList) throws Exception {
+  public SourceToDexComparisonTestHelper(@Nonnull File... filesOrSourceList) throws Exception {
 
-    this.fileOrSourceList = fileOrSourceList;
+    this.filesOrSourceList = filesOrSourceList;
 
     candidateTestTools = getCandidateToolchain();
     referenceTestTools = getReferenceToolchain();
@@ -120,6 +120,22 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper
     return this;
   }
 
+  public File getCandidateDex() {
+    return candidateDex;
+  }
+
+  public File getCandidateDexDir() {
+    return candidateDexDir;
+  }
+
+  public File getReferenceDex() {
+    return refDex;
+  }
+
+  public File getReferenceDexDir() {
+    return refDexDir;
+  }
+
   @Nonnull
   public Comparator createDexFileComparator() {
     ComparatorDex comparator = new ComparatorDex(candidateDex, refDex);
@@ -138,7 +154,7 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper
   }
 
   @Nonnull
-  public SourceToDexComparisonTestHelper setProguardFlags(@Nonnull File[] proguardFlags) {
+  public SourceToDexComparisonTestHelper setProguardFlags(@Nonnull File... proguardFlags) {
     this.proguardFlagFiles = proguardFlags;
     return this;
   }
@@ -149,9 +165,10 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper
     if (jarjarRulesFile != null) {
       candidateTestTools.setJarjarRules(jarjarRulesFile);
     }
+    candidateTestTools.setWithDebugInfos(withDebugInfos);
     candidateTestTools.addProguardFlags(proguardFlagFiles).srcToExe(
         AbstractTestTools.getClasspathAsString(candidateClasspath), candidateDexDir,
-        fileOrSourceList);
+        /* zipFile = */ false, filesOrSourceList);
   }
 
   @Override
@@ -160,7 +177,9 @@ public class SourceToDexComparisonTestHelper extends GenericComparisonTestHelper
     if (jarjarRulesFile != null) {
       referenceTestTools.setJarjarRules(jarjarRulesFile);
     }
+    referenceTestTools.setWithDebugInfos(withDebugInfos);
     referenceTestTools.addProguardFlags(proguardFlagFiles).srcToExe(
-        AbstractTestTools.getClasspathAsString(referenceClasspath), refDexDir, fileOrSourceList);
+        AbstractTestTools.getClasspathAsString(referenceClasspath), refDexDir,
+        /* zipFile = */ false, filesOrSourceList);
   }
 }
diff --git a/jack-tests/src/com/android/jack/test/runtime/RuntimeTest.java b/jack-tests/src/com/android/jack/test/runtime/RuntimeTest.java
index 3fdb14ae..d1d20768 100644
--- a/jack-tests/src/com/android/jack/test/runtime/RuntimeTest.java
+++ b/jack-tests/src/com/android/jack/test/runtime/RuntimeTest.java
@@ -19,6 +19,7 @@ package com.android.jack.test.runtime;
 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
 /**
@@ -27,15 +28,15 @@ import javax.annotation.Nonnull;
  */
 public abstract class RuntimeTest {
 
-  @Nonnull
-  protected List<RuntimeTestInfo> rtTestInfos = new ArrayList<RuntimeTestInfo>();
-
-  protected  RuntimeTest() {
-    fillRtTestInfos();
-  }
+  @CheckForNull
+  protected List<RuntimeTestInfo> rtTestInfos = null;
 
   @Nonnull
   public final List<RuntimeTestInfo> getRuntimeTestInfos() {
+    if (rtTestInfos == null) {
+      rtTestInfos = new ArrayList<RuntimeTestInfo>();
+      fillRtTestInfos();
+    }
     return rtTestInfos;
   }
 
diff --git a/jack-tests/src/com/android/jack/test/toolchain/AbstractTestTools.java b/jack-tests/src/com/android/jack/test/toolchain/AbstractTestTools.java
index ed0f6b07..448927a5 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/AbstractTestTools.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/AbstractTestTools.java
@@ -50,13 +50,14 @@ public abstract class AbstractTestTools {
 
   @Nonnull
   public static final String JUNIT_RUNNER_NAME = "org.junit.runner.JUnitCore";
-  @Nonnull
-  public static final String TESTS_CONFIGURATION_FILE_VARIABLE = "TESTS_CONFIGURATION_FILE";
 
   @Nonnull
   private static HashMap<String, ToolchainBuilder> toolchainBuilders;
 
   @Nonnull
+  private static final File JACK_ROOT_DIR;
+
+  @Nonnull
   private static final String JACK_TESTS_FOLDER =
       "toolchain" + File.separator + "jack" + File.separator + "jack-tests";
 
@@ -85,6 +86,57 @@ public abstract class AbstractTestTools {
   private static final Map<String, File> runtimeEnvironmentLocations = new HashMap<String, File>();
 
 
+  static {
+
+    toolchainBuilders = new HashMap<String, ToolchainBuilder>();
+    toolchainBuilders.put("jack-cli"   , new JackCliToolchainBuilder());
+    toolchainBuilders.put("jack-api"   , new JackApiToolchainBuilder());
+    toolchainBuilders.put("legacy"     , new LegacyToolchainBuilder());
+    toolchainBuilders.put("jill-legacy", new LegacyJillToolchainBuilder());
+
+    testsProperties = new Properties();
+    String filePath = System.getProperty("tests.config");
+
+    if (filePath == null) {
+      throw new TestConfigurationException(
+          "Configuration file not specified. It must be passed with -Dtests.config on command"
+          + "line.");
+    }
+
+    File propertyFile;
+    propertyFile = new File(filePath);
+    if (!propertyFile.isAbsolute()) {
+      propertyFile =
+          new File(System.getenv("user.dir") , filePath);
+    }
+
+    if (!propertyFile.exists()) {
+      throw new TestConfigurationException("Configuration file not found: '" + filePath + "'");
+    }
+
+    try {
+      testsProperties.load(new FileInputStream(propertyFile));
+      runtimes.addAll(parseRuntimeList(testsProperties.getProperty(RUNTIME_LIST_KEY)));
+    } catch (FileNotFoundException e) {
+      throw new TestConfigurationException(e);
+    } catch (IOException e) {
+      throw new TestConfigurationException(e);
+    } catch (SecurityException e) {
+      throw new TestConfigurationException(e);
+    } catch (IllegalArgumentException e) {
+      throw new TestConfigurationException(e);
+    } catch (RuntimeRunnerException e) {
+      throw new TestConfigurationException(e);
+    }
+
+    String jackHome = testsProperties.getProperty("jack.home");
+
+    if (jackHome == null) {
+      throw new TestConfigurationException("'jack.home' property is not set");
+    }
+    JACK_ROOT_DIR = new File(jackHome);
+  }
+
   private interface ToolchainBuilder {
     IToolchain build();
   }
@@ -126,12 +178,15 @@ public abstract class AbstractTestTools {
     }
   }
 
-  private static File getPrebuilt(@Nonnull String prebuiltName) {
-    String prebuiltPath = getProperty(TOOLCHAIN_PREBUILT_PREFIX + prebuiltName);
+  public static File getPrebuilt(@Nonnull String prebuiltName) {
+    String prebuiltVarName = TOOLCHAIN_PREBUILT_PREFIX + prebuiltName;
+    String prebuiltPath;
 
-    if (prebuiltPath == null) {
+    try {
+      prebuiltPath = getProperty(prebuiltVarName);
+    } catch (TestConfigurationException e) {
       throw new TestConfigurationException(
-          "Cannot find path for prebuilt 'prebuiltName' in test.properties");
+          "Cannot find path for prebuilt '" + prebuiltName + "'", e);
     }
 
     File result = new File(prebuiltPath);
@@ -146,56 +201,10 @@ public abstract class AbstractTestTools {
     return result;
   }
 
-  static {
-    toolchainBuilders = new HashMap<String, ToolchainBuilder>();
-    toolchainBuilders.put("jack-cli"   , new JackCliToolchainBuilder());
-    toolchainBuilders.put("jack-api"   , new JackApiToolchainBuilder());
-    toolchainBuilders.put("legacy"     , new LegacyToolchainBuilder());
-    toolchainBuilders.put("jill-legacy", new LegacyJillToolchainBuilder());
-
-    testsProperties = new Properties();
-    String filePath = System.getenv(TESTS_CONFIGURATION_FILE_VARIABLE);
-    File propertyFile;
-    if (filePath != null) {
-      propertyFile = new File(filePath);
-      if (!propertyFile.isAbsolute()) {
-        propertyFile = new File(System.getProperty("user.dir"), filePath);
-      }
-    } else {
-      filePath = JACK_TESTS_FOLDER + File.separatorChar + "tests.properties";
-      propertyFile =
-          new File(getJackRootDir(), filePath);
-    }
-
-    if (!propertyFile.exists()) {
-      throw new TestConfigurationException("Configuration file not found: '" + filePath + "'");
-    }
-
-    try {
-      testsProperties.load(new FileInputStream(propertyFile));
-      runtimes.addAll(parseRuntimeList(testsProperties.getProperty(RUNTIME_LIST_KEY)));
-    } catch (FileNotFoundException e) {
-      throw new TestConfigurationException(e);
-    } catch (IOException e) {
-      throw new TestConfigurationException(e);
-    } catch (SecurityException e) {
-      throw new TestConfigurationException(e);
-    } catch (IllegalArgumentException e) {
-      throw new TestConfigurationException(e);
-    } catch (RuntimeRunnerException e) {
-      throw new TestConfigurationException(e);
-    }
-  }
 
   @Nonnull
   public static final File getJackRootDir() {
-    String pwdPath = System.getProperty("user.dir");
-    String[] splitPath = pwdPath.split(JACK_TESTS_FOLDER);
-    if (splitPath[0].equals(pwdPath)) {
-      assert splitPath.length == 1;
-      throw new AssertionError("Unable to compute tests root directory");
-    }
-    return new File(splitPath[0]);
+    return JACK_ROOT_DIR;
   }
 
   @Nonnull
@@ -208,42 +217,59 @@ public abstract class AbstractTestTools {
     return new File(getTestsRootDir(), packageName.replace(".", File.separator));
   }
 
-  /**
-   * Return the {@link IToolchain} specified in the tests configuration file if it matches the
-   * requirements expressed in paramters. Otherwise, test is ignored.
-   *
-   * @param classes Optional list of types. The first one is used to check that the candidate type
-   *        is of this type. Otherwise JUnit test will be ignored. If more types are provided, they
-   *        serve to narrow the expected type set, and are used for exclusion, i.e. if returned
-   *        type is of one of these types, test is ignored.
-   * @return The candidate toolchain that fulfills the requirements.
-   */
   @SuppressWarnings("unchecked")
   @Nonnull
-  public static final <T extends IToolchain> T getCandidateToolchain(
-      @Nonnull Class<? extends IToolchain>... classes) {
+  public static final <T extends IToolchain> T getCandidateToolchain() {
     IToolchain result = createToolchain("candidate.toolchain");
-    if (classes.length > 0) {
-      Assume.assumeTrue(classes[0].isAssignableFrom(result.getClass()));
-      for (int i = 1; i < classes.length; i++) {
-        Assume.assumeTrue(!classes[i].isAssignableFrom(result.getClass()));
-      }
-    }
     return (T) result;
   }
 
   @Nonnull
-  public static final IToolchain getReferenceToolchain() {
-    return createToolchain("reference.toolchain");
+  public static final <T extends IToolchain> T getCandidateToolchain(
+      @Nonnull Class<? extends IToolchain> clazz) {
+    T result = getCandidateToolchain();
+    Assume.assumeTrue(clazz.isAssignableFrom(result.getClass()));
+    return result;
+  }
+
+  @Nonnull
+  public static final <T extends IToolchain> T getCandidateToolchain(
+      @Nonnull Class<? extends IToolchain> clazz,
+      @Nonnull List<Class<? extends IToolchain>> excludeClazz) {
+    T result = getCandidateToolchain(clazz);
+
+    for (Class<? extends IToolchain> c : excludeClazz) {
+      Assume.assumeTrue(!c.isAssignableFrom(result.getClass()));
+    }
+
+    return result;
   }
 
   @SuppressWarnings("unchecked")
   @Nonnull
+  public static final <T extends IToolchain> T getReferenceToolchain() {
+    return (T) createToolchain("reference.toolchain");
+  }
+
+  @Nonnull
   public static final <T extends IToolchain> T getReferenceToolchain(
-      @Nonnull Class<?> expectedClass) {
-    IToolchain result = getReferenceToolchain();
-    Assume.assumeTrue(expectedClass.isAssignableFrom(result.getClass()));
-    return (T) result;
+      @Nonnull Class<? extends IToolchain> clazz) {
+    T result = getReferenceToolchain();
+    Assume.assumeTrue(clazz.isAssignableFrom(result.getClass()));
+    return result;
+  }
+
+  @Nonnull
+  public static final <T extends IToolchain> T getReferenceToolchain(
+      @Nonnull Class<? extends IToolchain> clazz,
+      @Nonnull List<Class<? extends IToolchain>> excludeClazz) {
+    T result = getReferenceToolchain(clazz);
+
+    for (Class<? extends IToolchain> c : excludeClazz) {
+      Assume.assumeTrue(!c.isAssignableFrom(result.getClass()));
+    }
+
+    return result;
   }
 
   @Nonnull
@@ -374,7 +400,7 @@ public abstract class AbstractTestTools {
   }
 
   @Nonnull
-  public static File createJavaFile(@Nonnull File folder, @Nonnull String packageName,
+  public static File createFile(@Nonnull File folder, @Nonnull String packageName,
       @Nonnull String fileName, @Nonnull String fileContent) throws IOException {
     File packageFolder = new File(folder, packageName.replace('.', File.separatorChar));
     if (!packageFolder.exists() && !packageFolder.mkdirs()) {
@@ -549,7 +575,8 @@ public abstract class AbstractTestTools {
 
     if (rtLocationPath == null) {
       throw new TestConfigurationException(
-          "Location for runtime '" + rtName + "' is not specified");
+          "Location for runtime '" + rtName + "' is not specified. Set property '"
+              + RUNTIME_LOCATION_PREFIX + rtName + "'");
     }
     File rtLocation = new File(rtLocationPath);
     if (!rtLocation.exists()) {
diff --git a/jack-tests/src/com/android/jack/test/toolchain/DummyToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/DummyToolchain.java
index 9e130688..f66578fe 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/DummyToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/DummyToolchain.java
@@ -18,6 +18,7 @@ package com.android.jack.test.toolchain;
 
 import java.io.File;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
 /**
@@ -34,24 +35,24 @@ public class DummyToolchain extends AndroidToolchain {
 
   @Override
   @Nonnull
-  public void srcToExe(@Nonnull String classpath, @Nonnull File out,
-      @Nonnull File... sources) throws Exception {
+  public void srcToExe(@CheckForNull String classpath, @Nonnull File out,
+      boolean zipFile, @Nonnull File... sources) throws Exception {
   }
 
   @Override
   @Nonnull
-  public void srcToLib(@Nonnull String classpath, @Nonnull File out,
+  public void srcToLib(@CheckForNull String classpath, @Nonnull File out,
       boolean zipFiles, @Nonnull File... sources) throws Exception {
   }
 
   @Override
   @Nonnull
-  public void libToDex(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToExe(@Nonnull File in, @Nonnull File out, boolean zipFile) throws Exception {
   }
 
   @Override
   @Nonnull
-  public void libToLib(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToLib(@Nonnull File[] in, @Nonnull File out, boolean zipFiles) throws Exception {
   }
 
   @Override
@@ -73,4 +74,5 @@ public class DummyToolchain extends AndroidToolchain {
     // Do nothing
     return this;
   }
+
 }
diff --git a/jack-tests/src/com/android/jack/test/toolchain/IToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/IToolchain.java
index 8c35d1dc..184682b6 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/IToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/IToolchain.java
@@ -20,7 +20,9 @@ import com.android.jack.test.toolchain.Toolchain.SourceLevel;
 
 import java.io.File;
 import java.io.OutputStream;
+import java.util.List;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 import javax.annotation.processing.Processor;
 
@@ -31,18 +33,24 @@ import javax.annotation.processing.Processor;
 public interface IToolchain {
 
   @Nonnull
-  void srcToExe(@Nonnull String classpath, @Nonnull File out, @Nonnull File... sources)
-      throws Exception;
+  void srcToExe(@CheckForNull String classpath, @Nonnull File out, boolean zipFile,
+      @Nonnull File... sources) throws Exception;
 
   @Nonnull
-  void srcToLib(@Nonnull String classpath, @Nonnull File out, boolean zipFiles,
+  void srcToLib(@CheckForNull String classpath, @Nonnull File out, boolean zipFiles,
       @Nonnull File... sources) throws Exception;
 
   @Nonnull
-  void libToDex(@Nonnull File in, @Nonnull File out) throws Exception;
+  void libToExe(@Nonnull File in, @Nonnull File out, boolean zipFile) throws Exception;
+
+  @Nonnull
+  void libToLib(@Nonnull File in, @Nonnull File out, boolean zipFiles) throws Exception;
+
+  @Nonnull
+  void libToLib(@Nonnull File[] in, @Nonnull File out, boolean zipFiles) throws Exception;
 
   @Nonnull
-  void libToLib(@Nonnull File in, @Nonnull File out) throws Exception;
+  void libToLib(@Nonnull List<File> in, @Nonnull File out, boolean zipFiles) throws Exception;
 
   @Nonnull
   IToolchain addStaticLibs(@Nonnull File... staticLibs);
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 7466b937..4e3b167d 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/JackApiToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/JackApiToolchain.java
@@ -18,15 +18,16 @@ package com.android.jack.test.toolchain;
 
 import com.android.jack.Jack;
 import com.android.jack.Options;
+import com.android.jack.backend.dex.rop.CodeItemBuilder;
 import com.android.jack.experimental.incremental.JackIncremental;
 import com.android.jack.shrob.spec.Flags;
 
 import java.io.File;
 import java.util.ArrayList;
-import java.util.List;
 import java.util.Map;
 import java.util.Map.Entry;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
 /**
@@ -39,36 +40,26 @@ public class JackApiToolchain extends JackBasedToolchain {
 
   JackApiToolchain() {}
 
-  @Override
   @Nonnull
-  public JackApiToolchain disableDxOptimizations() {
-    jackOptions.disableDxOptimizations();
+  public JackApiToolchain setVerbosityLevel(@Nonnull Options.VerbosityLevel level) {
+    jackOptions.setVerbosityLevel(level);
     return this;
   }
 
   @Override
   @Nonnull
-  public JackApiToolchain enableDxOptimizations() {
-    jackOptions.enableDxOptimizations();
-    return this;
-  }
-
-  @Override
-  @Nonnull
-  public void srcToExe(@Nonnull String classpath, @Nonnull File out, @Nonnull File... sources)
-      throws Exception {
+  public void srcToExe(@CheckForNull String classpath, @Nonnull File out, boolean zipFile,
+      @Nonnull File... sources) throws Exception {
 
     try {
-      System.setOut(outRedirectStream);
-      System.setErr(errRedirectStream);
-
       addProperties(properties, jackOptions);
 
       if (jackOptions.getFlags() != null) {
         jackOptions.applyShrobFlags();
       }
 
-      jackOptions.setEcjArguments(AbstractTestTools.buildEcjArgs());
+      // jackOptions.setEcjArguments(AbstractTestTools.buildEcjArgs());
+      jackOptions.setEcjArguments(new ArrayList<String>());
 
       if (annotationProcessorClass != null) {
         jackOptions.getEcjArguments().add("-processor");
@@ -88,25 +79,26 @@ public class JackApiToolchain extends JackBasedToolchain {
       /* mustExist = */false, sources);
       jackOptions.setClasspath(classpath);
 
-      // !zip
-      jackOptions.setOutputDir(out);
+      if (zipFile) {
+        jackOptions.setOutputZip(out);
+      } else {
+        jackOptions.setOutputDir(out);
+      }
 
       jackOptions.setJayceImports(staticLibs);
 
       jackOptions.setJarjarRulesFile(jarjarRules);
-      List<File> proguardFlagsFiles = new ArrayList<File>();
-
-      for (File flagFile : proguardFlagsFiles) {
-        proguardFlagsFiles.add(flagFile);
-      }
 
-      if (proguardFlagsFiles.size() > 0) {
-        jackOptions.setProguardFlagsFile(proguardFlagsFiles);
+      if (proguardFlags.size() > 0) {
+        jackOptions.setProguardFlagsFile(proguardFlags);
       }
 
       jackOptions.addProperty(Options.EMIT_LOCAL_DEBUG_INFO.getName(),
           Boolean.toString(withDebugInfos));
 
+      System.setOut(outRedirectStream);
+      System.setErr(errRedirectStream);
+
       if (jackOptions.getIncrementalFolder() != null) {
         JackIncremental.run(jackOptions);
       } else {
@@ -121,51 +113,63 @@ public class JackApiToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void srcToLib(@Nonnull String classpath, @Nonnull File out, boolean zipFiles,
+  public void srcToLib(@CheckForNull String classpath, @Nonnull File out, boolean zipFiles,
       @Nonnull File... sources) throws Exception {
 
     try {
-      Options options = jackOptions;
+      addProperties(properties, jackOptions);
 
-      addProperties(properties, options);
+      if (jackOptions.getFlags() != null) {
+        jackOptions.applyShrobFlags();
+      }
 
-      options.setClasspath(classpath);
+      jackOptions.setClasspath(classpath);
 
       if (zipFiles) {
-        options.setJayceOutputZip(out);
+        jackOptions.setJayceOutputZip(out);
       } else {
-        options.setJayceOutputDir(out);
+        jackOptions.setJayceOutputDir(out);
       }
 
-      options.setEcjArguments(AbstractTestTools.buildEcjArgs());
+      jackOptions.setEcjArguments(new ArrayList<String>());
 
       if (annotationProcessorClass != null) {
-        options.getEcjArguments().add("-processor");
-        options.getEcjArguments().add(annotationProcessorClass.getName());
+        jackOptions.getEcjArguments().add("-processor");
+        jackOptions.getEcjArguments().add(annotationProcessorClass.getName());
       }
 
       if (annotationProcessorOutDir != null) {
-        options.getEcjArguments().add("-d");
-        options.getEcjArguments().add(annotationProcessorOutDir.getAbsolutePath());
+        jackOptions.getEcjArguments().add("-d");
+        jackOptions.getEcjArguments().add(annotationProcessorOutDir.getAbsolutePath());
       }
 
       for (String ecjArg : extraEcjArgs) {
-        options.getEcjArguments().add(ecjArg);
+        jackOptions.getEcjArguments().add(ecjArg);
       }
 
-      AbstractTestTools.addFile(options.getEcjArguments(),
+      AbstractTestTools.addFile(jackOptions.getEcjArguments(),
       /* mustExist = */false, sources);
 
-      options.addProperty(Options.EMIT_LOCAL_DEBUG_INFO.getName(),
+
+      jackOptions.setJarjarRulesFile(jarjarRules);
+
+      if (proguardFlags.size() > 0) {
+        jackOptions.setProguardFlagsFile(proguardFlags);
+      }
+
+      jackOptions.addProperty(Options.EMIT_LOCAL_DEBUG_INFO.getName(),
           Boolean.toString(withDebugInfos));
 
+      jackOptions.addProperty(CodeItemBuilder.DEX_OPTIMIZE.getName(),
+          Boolean.toString(!withDebugInfos));
+
       System.setOut(outRedirectStream);
       System.setErr(errRedirectStream);
 
-      if (options.getIncrementalFolder() != null) {
-        JackIncremental.run(options);
+      if (jackOptions.getIncrementalFolder() != null) {
+        JackIncremental.run(jackOptions);
       } else {
-        Jack.run(options);
+        Jack.run(jackOptions);
       }
 
     } finally {
@@ -176,24 +180,36 @@ public class JackApiToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void libToDex(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToExe(@Nonnull File in, @Nonnull File out, boolean zipFile) throws Exception {
     System.setOut(outRedirectStream);
     System.setErr(errRedirectStream);
 
     try {
-      Options options = jackOptions;
-      addProperties(properties, options);
+      addProperties(properties, jackOptions);
+
+      if (jackOptions.getFlags() != null) {
+        jackOptions.applyShrobFlags();
+      }
+
+      jackOptions.setJarjarRulesFile(jarjarRules);
 
-      options.getJayceImport().add(in);
-      options.getJayceImport().addAll(staticLibs);
+      if (proguardFlags.size() > 0) {
+        jackOptions.setProguardFlagsFile(proguardFlags);
+      }
+
+      jackOptions.getJayceImport().add(in);
+      jackOptions.getJayceImport().addAll(staticLibs);
 
-      // !zip
-      options.setOutputDir(out);
+      if (zipFile) {
+        jackOptions.setOutputZip(out);
+      } else {
+        jackOptions.setOutputDir(out);
+      }
 
-      if (options.getIncrementalFolder() != null) {
-        JackIncremental.run(options);
+      if (jackOptions.getIncrementalFolder() != null) {
+        JackIncremental.run(jackOptions);
       } else {
-        Jack.run(options);
+        Jack.run(jackOptions);
       }
 
     } finally {
@@ -204,8 +220,38 @@ public class JackApiToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void libToLib(@Nonnull File in, @Nonnull File out) throws Exception {
-    throw new AssertionError("Not Yet Implemented");
+  public void libToLib(@Nonnull File[] in, @Nonnull File out, boolean zipFiles) throws Exception {
+    addProperties(properties, jackOptions);
+
+    jackOptions.setJarjarRulesFile(jarjarRules);
+
+    if (jackOptions.getFlags() != null) {
+      jackOptions.applyShrobFlags();
+    }
+
+    if (proguardFlags.size() > 0) {
+      jackOptions.setProguardFlagsFile(proguardFlags);
+    }
+
+    for (File staticLib : in) {
+      jackOptions.getJayceImport().add(staticLib);
+    }
+
+    for (File staticLib : staticLibs) {
+      jackOptions.getJayceImport().add(staticLib);
+    }
+
+    if (zipFiles) {
+      jackOptions.setJayceOutputZip(out);
+    } else {
+      jackOptions.setJayceOutputDir(out);
+    }
+
+    if (jackOptions.getIncrementalFolder() != null) {
+      JackIncremental.run(jackOptions);
+    } else {
+      Jack.run(jackOptions);
+    }
   }
 
   @Nonnull
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 729eb89c..3e13d9e7 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/JackBasedToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/JackBasedToolchain.java
@@ -16,6 +16,10 @@
 
 package com.android.jack.test.toolchain;
 
+import com.android.jack.backend.dex.DexFileWriter;
+import com.android.jack.backend.dex.MultiDexLegacy;
+import com.android.jack.backend.dex.rop.CodeItemBuilder;
+
 import java.io.File;
 import java.util.ArrayList;
 import java.util.HashMap;
@@ -30,6 +34,15 @@ import javax.annotation.Nonnull;
  */
 public abstract class JackBasedToolchain extends AndroidToolchain {
 
+  /**
+   * Available mode for the multidex feature
+   */
+  public enum MultiDexKind {
+    NONE,
+    NATIVE,
+    LEGACY
+  }
+
   @Nonnull
   protected final Map<String, String> properties = new HashMap<String, String>();
   @CheckForNull
@@ -44,6 +57,23 @@ public abstract class JackBasedToolchain extends AndroidToolchain {
     return this;
   }
 
+  public final JackBasedToolchain setMultiDexKind(@Nonnull MultiDexKind kind) {
+    switch (kind) {
+      case NATIVE:
+        addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+        break;
+      case LEGACY:
+        addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+        addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+        break;
+      case NONE:
+        break;
+      default:
+        throw new AssertionError("Unsupported multi dex kind: '" + kind.name() + "'");
+    }
+    return this;
+  }
+
   @Nonnull
   public final JackBasedToolchain addEcjArgs(@Nonnull String arg) {
     extraEcjArgs.add(arg);
@@ -79,10 +109,24 @@ public abstract class JackBasedToolchain extends AndroidToolchain {
 
   @Override
   @Nonnull
+  public JackBasedToolchain disableDxOptimizations() {
+    addProperty(CodeItemBuilder.DEX_OPTIMIZE.getName(), "false");
+    return this;
+  }
+
+  @Override
+  @Nonnull
+  public JackBasedToolchain enableDxOptimizations() {
+    addProperty(CodeItemBuilder.DEX_OPTIMIZE.getName(), "true");
+    return this;
+  }
+
+  @Override
+  @Nonnull
   public File[] getDefaultBootClasspath() {
     return new File[] {new File(AbstractTestTools.getJackRootDir(),
         "toolchain/jack/jack-tests/libs/core-stubs-mini.jar"), new File(
         AbstractTestTools.getJackRootDir(),
-        "toolchain/jack/jack-tests/prebuilts/junit4-hostdex.jar")};
+        "toolchain/jack/jack-tests/prebuilts/junit4-targetdex-jack.zip")};
   }
 }
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 17f11dd7..34d974f9 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/JackCliToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/JackCliToolchain.java
@@ -16,7 +16,6 @@
 
 package com.android.jack.test.toolchain;
 
-import com.android.jack.backend.dex.rop.CodeItemBuilder;
 import com.android.jack.util.ExecuteFile;
 
 import java.io.File;
@@ -47,8 +46,8 @@ public class JackCliToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void srcToExe(@Nonnull String classpath, @Nonnull File out,
-      @Nonnull File... sources) throws Exception {
+  public void srcToExe(@CheckForNull String classpath, @Nonnull File out,
+      boolean zipFile, @Nonnull File... sources) throws Exception {
 
     List<String> args = new ArrayList<String>();
     args.add("java");
@@ -63,41 +62,37 @@ public class JackCliToolchain extends JackBasedToolchain {
       args.add(com.android.jack.Main.class.getName());
     }
 
-    if (withDebugInfos) {
-      args.add("-D");
-      args.add("jack.dex.optimize=false");
-    } else {
-      args.add("-D");
-      args.add("jack.dex.optimize=true");
-    }
-
     addProperties(properties, args);
 
-    args.add("--classpath");
-    args.add(classpath);
+    if (classpath != null) {
+      args.add("--classpath");
+      args.add(classpath);
+    }
 
-    args.add("-o");
+    if (zipFile) {
+      args.add("--output-dex-zip");
+    } else {
+      args.add("--output-dex");
+    }
     args.add(out.getAbsolutePath());
 
     if (jarjarRules != null) {
-      args.add("--jarjar-rules");
+      args.add("--config-jarjar");
       args.add(jarjarRules.getAbsolutePath());
     }
 
     for (File flags : proguardFlags) {
-      args.add("--proguard-flags");
+      args.add("--config-proguard");
       args.add(flags.getAbsolutePath());
     }
 
     for (File staticLib : staticLibs) {
-      args.add("--import-jack");
+      args.add("--import");
       args.add(staticLib.getAbsolutePath());
     }
 
     args.addAll(extraJackArgs);
 
-    args.add("--ecj");
-
     if (withDebugInfos) {
       args.add("-g");
     }
@@ -129,7 +124,7 @@ public class JackCliToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void srcToLib(@Nonnull String classpath, @Nonnull File out,
+  public void srcToLib(@CheckForNull String classpath, @Nonnull File out,
       boolean zipFiles, @Nonnull File... sources) throws Exception {
 
     List<String> args = new ArrayList<String>();
@@ -147,19 +142,29 @@ public class JackCliToolchain extends JackBasedToolchain {
 
     addProperties(properties, args);
 
-    args.add("--classpath");
-    args.add(classpath);
+    if (classpath != null) {
+      args.add("--classpath");
+      args.add(classpath);
+    }
 
     if (zipFiles) {
-      args.add("--jack-output-zip");
+      args.add("--output-jack");
     } else {
-      args.add("--jack-output");
+      args.add("--output-jack-dir");
     }
     args.add(out.getAbsolutePath());
 
     args.addAll(extraJackArgs);
 
-    args.add("--ecj");
+    if (jarjarRules != null) {
+      args.add("--config-jarjar");
+      args.add(jarjarRules.getAbsolutePath());
+    }
+
+    for (File flags : proguardFlags) {
+      args.add("--config-proguard");
+      args.add(flags.getAbsolutePath());
+    }
 
     if (withDebugInfos) {
       args.add("-g");
@@ -192,7 +197,7 @@ public class JackCliToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void libToDex(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToExe(@Nonnull File in, @Nonnull File out, boolean zipFile) throws Exception {
 
     List<String> args = new ArrayList<String>();
     args.add("java");
@@ -217,15 +222,20 @@ public class JackCliToolchain extends JackBasedToolchain {
 
     addProperties(properties, args);
 
-    args.add("--import-jack");
+    args.add("--import");
     args.add(in.getAbsolutePath());
 
     for (File staticLib : staticLibs) {
-      args.add("--import-jack");
+      args.add("--import");
       args.add(staticLib.getAbsolutePath());
     }
 
-    args.add("-o");
+    if (zipFile) {
+      args.add("--output-dex-zip");
+    } else {
+      args.add("--output-dex");
+    }
+
     args.add(out.getAbsolutePath());
 
     ExecuteFile exec = new ExecuteFile(args.toArray(new String[args.size()]));
@@ -240,22 +250,58 @@ public class JackCliToolchain extends JackBasedToolchain {
 
   @Override
   @Nonnull
-  public void libToLib(@Nonnull File in, @Nonnull File out) throws Exception {
-    throw new AssertionError("Not Yet Implemented");
-  }
+  public void libToLib(@Nonnull File[] in, @Nonnull File out, boolean zipFiles) throws Exception {
+    List<String> args = new ArrayList<String>();
+    args.add("java");
+    args.add("-cp");
+    args.add(jackPrebuilt.getAbsolutePath());
 
-  @Override
-  @Nonnull
-  public JackCliToolchain disableDxOptimizations() {
-    addProperty(CodeItemBuilder.DEX_OPTIMIZE.getName(), "false");
-    return this;
-  }
+    if (incrementalFolder != null) {
+      args.add(com.android.jack.experimental.incremental.Main.class.getName());
+      args.add("--incremental-folder");
+      args.add(incrementalFolder.getAbsolutePath());
+    } else {
+      args.add(com.android.jack.Main.class.getName());
+    }
+
+    addProperties(properties, args);
+
+    if (jarjarRules != null) {
+      args.add("--config-jarjar");
+      args.add(jarjarRules.getAbsolutePath());
+    }
+
+    for (File flags : proguardFlags) {
+      args.add("--config-proguard");
+      args.add(flags.getAbsolutePath());
+    }
+
+    for (File staticlib : in) {
+      args.add("--import");
+      args.add(staticlib.getAbsolutePath());
+    }
+
+    for (File staticLib : staticLibs) {
+      args.add("--import");
+      args.add(staticLib.getAbsolutePath());
+    }
+
+    if (zipFiles) {
+      args.add("--output-jack");
+    } else {
+      args.add("--output-jack-dir");
+    }
+    args.add(out.getAbsolutePath());
+
+    ExecuteFile exec = new ExecuteFile(args.toArray(new String[args.size()]));
+    exec.setErr(outRedirectStream);
+    exec.setOut(errRedirectStream);
+    exec.setVerbose(true);
+
+    if (!exec.run()) {
+      throw new RuntimeException("Jack compiler exited with an error");
+    }
 
-  @Override
-  @Nonnull
-  public JackCliToolchain enableDxOptimizations() {
-    addProperty(CodeItemBuilder.DEX_OPTIMIZE.getName(), "true");
-    return this;
   }
 
   @Nonnull
@@ -278,4 +324,5 @@ public class JackCliToolchain extends JackBasedToolchain {
       args.add(entry.getKey() + "=" + entry.getValue());
     }
   }
+
 }
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 5ebf6e4f..ebf83f8f 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/LegacyJillToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/LegacyJillToolchain.java
@@ -45,8 +45,8 @@ public class LegacyJillToolchain extends JillBasedToolchain {
 
   @Override
   @Nonnull
-  public void srcToExe(@Nonnull String classpath, @Nonnull File out, @Nonnull File... sources)
-      throws Exception {
+  public void srcToExe(@Nonnull String classpath, @Nonnull File out, boolean zipFile,
+      @Nonnull File... sources) throws Exception {
     try {
 
       File jarFile         = AbstractTestTools.createTempFile("legacyLib", ".jar");
@@ -71,7 +71,7 @@ public class LegacyJillToolchain extends JillBasedToolchain {
       File jillLib = AbstractTestTools.createTempFile("jillLib", ".jar");
       executeJill(jarFileProguard, jillLib, true);
 
-      libToDex(jillLib, out);
+      libToExe(jillLib, out, zipFile);
 
     } catch (IOException e) {
       throw new RuntimeException("Legacy toolchain exited with an error", e);
@@ -112,7 +112,7 @@ public class LegacyJillToolchain extends JillBasedToolchain {
 
   @Override
   @Nonnull
-  public void libToLib(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToLib(@Nonnull File[] in, @Nonnull File out, boolean zipFiles) throws Exception {
     throw new AssertionError("Not Yet Implemented");
   }
 
diff --git a/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java b/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java
index 3a5a231d..19fcf927 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/LegacyToolchain.java
@@ -25,6 +25,7 @@ import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
 
 /**
@@ -50,8 +51,8 @@ public class LegacyToolchain extends AndroidToolchain {
 
   @Override
   @Nonnull
-  public void srcToExe(@Nonnull String classpath, @Nonnull File out,
-      @Nonnull File... sources) throws Exception {
+  public void srcToExe(@CheckForNull String classpath, @Nonnull File out,
+      boolean zipFile, @Nonnull File... sources) throws Exception {
 
     try {
 
@@ -74,7 +75,7 @@ public class LegacyToolchain extends AndroidToolchain {
         jarFileProguard = jarFileJarjar;
       }
 
-      libToDex(jarFileProguard, out);
+      libToExe(jarFileProguard, out, zipFile);
 
     } catch (IOException e) {
       throw new RuntimeException("Legacy toolchain exited with an error", e);
@@ -83,7 +84,7 @@ public class LegacyToolchain extends AndroidToolchain {
 
   @Override
   @Nonnull
-  public void srcToLib(@Nonnull String classpath, @Nonnull File out,
+  public void srcToLib(@CheckForNull String classpath, @Nonnull File out,
       boolean zipFiles, @Nonnull File... sources) throws Exception {
 
     try {
@@ -113,10 +114,10 @@ public class LegacyToolchain extends AndroidToolchain {
 
   @Override
   @Nonnull
-  public void libToDex(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToExe(@Nonnull File in, @Nonnull File out, boolean zipFile) throws Exception {
 
     try {
-      compileWithDx(in, out);
+      compileWithDx(in, out, zipFile);
     } catch (IOException e) {
       throw new RuntimeException("Legacy toolchain exited with an error", e);
     }
@@ -124,7 +125,7 @@ public class LegacyToolchain extends AndroidToolchain {
 
   @Override
   @Nonnull
-  public void libToLib(@Nonnull File in, @Nonnull File out) throws Exception {
+  public void libToLib(@Nonnull File[] in, @Nonnull File out, boolean zipFiles) throws Exception {
     throw new AssertionError("Not Yet Implemented");
   }
 
@@ -170,8 +171,10 @@ public class LegacyToolchain extends AndroidToolchain {
     args.add(inJar.getAbsolutePath());
     args.add("-outjars");
     args.add(outJar.getAbsolutePath());
-    args.add("-libraryjars");
-    args.add(bootclasspathStr);
+    if (bootclasspathStr != null) {
+      args.add("-libraryjars");
+      args.add(bootclasspathStr);
+    }
     args.add("-verbose");
     args.add("-forceprocessing");
     args.add("-dontoptimize");
@@ -194,10 +197,22 @@ public class LegacyToolchain extends AndroidToolchain {
     }
   }
 
-  private void compileWithEcj(@Nonnull File[] sources, @Nonnull String classpath,
+  private void compileWithEcj(@Nonnull File[] sources, @CheckForNull String classpath,
       @Nonnull File out) {
-
-    throw new AssertionError("Not yet implemented");
+    List<String> args = new ArrayList<String>(4 + sources.length);
+    if (classpath != null) {
+      args.add("-classpath");
+      args.add(classpath);
+    }
+    addSourceLevel(sourceLevel, args);
+    args.add("-noExit");
+    args.add("-preserveAllLocals");
+    args.add("-d");
+    args.add(out.getAbsolutePath());
+    for (File sourceFile : sources) {
+      args.add(sourceFile.getAbsolutePath());
+    }
+    org.eclipse.jdt.internal.compiler.batch.Main.main(args.toArray(new String[args.size()]));
   }
 
   @Override
@@ -229,7 +244,7 @@ public class LegacyToolchain extends AndroidToolchain {
   }
 
   private void compileWithExternalRefCompiler(@Nonnull File[] sources,
-      @Nonnull String classpath, @Nonnull File out) {
+      @CheckForNull String classpath, @Nonnull File out) {
 
     List<String> arguments = new ArrayList<String>();
 
@@ -265,7 +280,7 @@ public class LegacyToolchain extends AndroidToolchain {
     }
   }
 
-  private void compileWithDx(File in, File out)
+  private void compileWithDx(@Nonnull File in, @Nonnull File out, boolean zipFile)
       throws IOException {
 
     try {
@@ -274,7 +289,7 @@ public class LegacyToolchain extends AndroidToolchain {
 
       Arguments arguments = new Arguments();
 
-      arguments.jarOutput = false;
+      arguments.jarOutput = zipFile;
       arguments.outName = new File(out, getBinaryFileName()).getAbsolutePath();
       arguments.optimize = !withDebugInfos && useDxOptimization;
       // this only means we deactivate the check that no core classes are included
diff --git a/jack-tests/src/com/android/jack/test/toolchain/Toolchain.java b/jack-tests/src/com/android/jack/test/toolchain/Toolchain.java
index d35d814b..6954f276 100644
--- a/jack-tests/src/com/android/jack/test/toolchain/Toolchain.java
+++ b/jack-tests/src/com/android/jack/test/toolchain/Toolchain.java
@@ -67,21 +67,32 @@ public abstract class Toolchain implements IToolchain {
 
   @Override
   @Nonnull
-  public abstract void srcToExe(@Nonnull String classpath, @Nonnull File out,
-      @Nonnull File... sources) throws Exception;
+  public abstract void srcToExe(@CheckForNull String classpath, @Nonnull File out,
+      boolean zipFile, @Nonnull File... sources) throws Exception;
 
   @Override
   @Nonnull
-  public abstract void srcToLib(@Nonnull String classpath, @Nonnull File out,
+  public abstract void srcToLib(@CheckForNull String classpath, @Nonnull File out,
       boolean zipFiles, @Nonnull File... sources) throws Exception;
 
   @Override
   @Nonnull
-  public abstract void libToDex(@Nonnull File in, @Nonnull File out) throws Exception;
+  public abstract void libToExe(@Nonnull File in, @Nonnull File out, boolean zipFile)
+      throws Exception;
 
   @Override
   @Nonnull
-  public abstract void libToLib(@Nonnull File in, @Nonnull File out) throws Exception;
+  public final void libToLib(@Nonnull File in, @Nonnull File out, boolean zipFiles)
+      throws Exception {
+    libToLib(new File[] {in}, out, zipFiles);
+  }
+
+  @Override
+  @Nonnull
+  public final void libToLib(@Nonnull List<File> in, @Nonnull File out, boolean zipFiles)
+      throws Exception {
+    libToLib(in.toArray(new File[in.size()]), out, zipFiles);
+  }
 
   @Override
   @Nonnull
@@ -135,9 +146,6 @@ public abstract class Toolchain implements IToolchain {
   @Override
   @Nonnull
   public final Toolchain setOutputStream(@Nonnull OutputStream outputStream) {
-    if (outRedirectStream != null) {
-      outRedirectStream.close();
-    }
     outRedirectStream = new PrintStream(outputStream);
     return this;
   }
@@ -145,9 +153,6 @@ public abstract class Toolchain implements IToolchain {
   @Override
   @Nonnull
   public final Toolchain setErrorStream(@Nonnull OutputStream errorStream) {
-    if (errRedirectStream != null) {
-      errRedirectStream.close();
-    }
     errRedirectStream = new PrintStream(errorStream);
     return this;
   }
diff --git a/jack-tests/tests.properties b/jack-tests/tests.properties
deleted file mode 100644
index 34ce165f..00000000
--- a/jack-tests/tests.properties
+++ /dev/null
@@ -1,12 +0,0 @@
-reference.toolchain=legacy
-candidate.toolchain=jack-api
-#candidate.toolchain=jill-legacy
-toolchain.prebuilt.jack=toolchain/jack/jack/dist/jack.jar
-toolchain.prebuilt.jill=toolchain/jill/jill/dist/jill.jar
-toolchain.prebuilt.jarjar=toolchain/jack/jack-tests/prebuilts/jarjar.jar
-toolchain.prebuilt.proguard=toolchain/jack/jack-tests/prebuilts/proguard.jar
-toolchain.prebuilt.legacy-java-compiler=/usr/lib/jvm/java-6-sun/bin/javac
-runtime.list=dalvik-fast-host,art-host,dalvik-fast-device
-runtime.location.dalvik-fast-host=/disk2/tmp/dalvik-host.rt
-runtime.location.dalvik-jit-host=/disk2/tmp/dalvik-host.rt
-runtime.location.art-host=/disk2/tmp/art-host.rt
diff --git a/jack-tests/tests.properties.template b/jack-tests/tests.properties.template
new file mode 100644
index 00000000..995cec5c
--- /dev/null
+++ b/jack-tests/tests.properties.template
@@ -0,0 +1,20 @@
+jack.home=
+
+# Toolchain names among legacy, jill-legacy, jack-api, jack-cli
+reference.toolchain=
+candidate.toolchain=
+
+toolchain.prebuilt.jack=toolchain/jack/jack/dist/jack.jar
+toolchain.prebuilt.jill=toolchain/jill/jill/dist/jill.jar
+toolchain.prebuilt.jarjar=toolchain/jack/jack-tests/prebuilts/jarjar.jar
+toolchain.prebuilt.proguard=toolchain/jack/jack-tests/prebuilts/proguard.jar
+toolchain.prebuilt.dexdump=toolchain/jack/jack-tests/prebuilts/dexdump
+
+# dalvik-fast-host, dalvik-jit-host, art-host,
+runtime.list=
+runtime.location.dalvik-fast-host=
+runtime.location.dalvik-jit-host=
+runtime.location.art-host=
+
+toolchain.prebuilt.legacy-java-compiler=
+
diff --git a/jack-tests/tests/com/android/jack/AllTests.java b/jack-tests/tests/com/android/jack/AllTests.java
index 091867be..e8579dc7 100644
--- a/jack-tests/tests/com/android/jack/AllTests.java
+++ b/jack-tests/tests/com/android/jack/AllTests.java
@@ -1,54 +1,133 @@
-/*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
 package com.android.jack;
 
+import com.android.jack.analysis.dfa.reachingdefs.ReachingDefsTests;
 import com.android.jack.annotation.AnnotationTests;
 import com.android.jack.arithmetic.ArithmeticTests;
-import com.android.jack.classpath.ClasspathTest;
-import com.android.jack.enums.EnumTests;
-import com.android.jack.error.AnnotationProcessorErrorTest;
-import com.android.jack.error.CommandLineErrorTest;
-import com.android.jack.error.FileAccessErrorTest;
-import com.android.jack.experimenal.incremental.DependenciesTests005;
+import com.android.jack.array.ArrayTests;
+import com.android.jack.assertion.AssertionTests;
+import com.android.jack.assign.AssignTests;
+import com.android.jack.box.BoxTests;
+import com.android.jack.bridge.BridgeTests;
+import com.android.jack.cast.CastAllTests;
+import com.android.jack.classpath.ClasspathTests;
+import com.android.jack.clinit.ClinitTests;
+import com.android.jack.comparison.ComparisonTests;
+import com.android.jack.compiletime.CompileTimeTests;
+import com.android.jack.conditional.ConditionalTests;
+import com.android.jack.constant.ConstantTests;
+import com.android.jack.debug.DebugTests;
+import com.android.jack.dx.DxTests;
+import com.android.jack.enums.EnumsTests;
+import com.android.jack.error.ErrorHandlingAllTests;
+import com.android.jack.experimental.incremental.DependencyAllTests;
+import com.android.jack.external.ExternalTests;
+import com.android.jack.fibonacci.FibonacciTests;
+import com.android.jack.field.FieldTests;
+import com.android.jack.fileconflict.FileConflictTests;
+import com.android.jack.flow.FlowTests;
+import com.android.jack.frontend.MissingClassTest;
+import com.android.jack.generic.basic.GenericTests;
+import com.android.jack.ifstatement.IfstatementTests;
+import com.android.jack.imports.ImportTests;
+import com.android.jack.init.InitTests;
+import com.android.jack.inner.InnerTests;
+import com.android.jack.instance.InstanceTest;
+import com.android.jack.invoke.InvokeTests;
 import com.android.jack.jarjar.JarjarTests;
-import com.android.jack.shrob.ObfuscationWithoutMappingTests;
+import com.android.jack.java7.Java7AllTest;
+import com.android.jack.label.LabelTest;
+import com.android.jack.lookup.LookupTests;
+import com.android.jack.multidex.MultiDexAllTests;
+import com.android.jack.newarray.NewarrayTests;
+import com.android.jack.nopackage.NoPackageTests;
+import com.android.jack.opcodes.OpcodesTests;
+import com.android.jack.optimizations.exprsimplifier.ExprsimplifierTests;
+import com.android.jack.optimizations.notsimplifier.NotsimplifierTests;
+import com.android.jack.optimizations.uselesscopy.UselessVariableCopyTest;
+import com.android.jack.order.OrderTests;
+import com.android.jack.preprocessor.PreProcessorTests;
+import com.android.jack.resource.ResourceTests;
+import com.android.jack.returnstatement.ReturnstatementTests;
+import com.android.jack.shrob.ShrobAllTests;
+import com.android.jack.string.StringTests;
+import com.android.jack.switchstatement.SwitchstatementTests;
+import com.android.jack.synchronize.SynchronizeTests;
+import com.android.jack.threeaddress.ThreeaddressTests;
+import com.android.jack.throwstatement.ThrowstatementTests;
 import com.android.jack.tools.merger.MergerAllTests;
+import com.android.jack.trycatch.TrycatchTests;
+import com.android.jack.tryfinally.TryfinallyTests;
+import com.android.jack.type.TypeTests;
+import com.android.jack.unary.UnaryTests;
+import com.android.jack.verify.VerifyTests;
+import com.android.jack.withphantom.WithPhantomTests;
 
 import org.junit.runner.RunWith;
 import org.junit.runners.Suite;
 import org.junit.runners.Suite.SuiteClasses;
 
-/**
- * Test suite containing all tests (except for regression tests that must be run from the command
- * line).
- */
 @RunWith(Suite.class)
 @SuiteClasses(value = {
     AnnotationTests.class,
     ArithmeticTests.class,
-    ClasspathTest.class,
-    DependenciesTests005.class,
-    EnumTests.class,
+    ArrayTests.class,
+    AssertionTests.class,
+    AssignTests.class,
+    BoxTests.class,
+    BridgeTests.class,
+    CastAllTests.class,
+    ClasspathTests.class,
+    ClinitTests.class,
+    ComparisonTests.class,
+    CompileTimeTests.class,
+    ConditionalTests.class,
+    ConstantTests.class,
+    DebugTests.class,
+    DependencyAllTests.class,
+    DxTests.class,
+    EnumsTests.class,
+    ExternalTests.class,
+    ErrorHandlingAllTests.class,
+    FibonacciTests.class,
+    FieldTests.class,
+    FileConflictTests.class,
+    FlowTests.class,
+    GenericTests.class,
     JarjarTests.class,
+    IfstatementTests.class,
+    InitTests.class,
+    InnerTests.class,
+    InstanceTest.class,
+    ImportTests.class,
+    InvokeTests.class,
+    Java7AllTest.class,
+    LabelTest.class,
+    LookupTests.class,
     MergerAllTests.class,
-    ObfuscationWithoutMappingTests.class,
-    AnnotationProcessorErrorTest.class,
-    FileAccessErrorTest.class,
-    CommandLineErrorTest.class
+    MissingClassTest.class,
+    MultiDexAllTests.class,
+    NewarrayTests.class,
+    ExprsimplifierTests.class,
+    NotsimplifierTests.class,
+    NoPackageTests.class,
+    OrderTests.class,
+    OpcodesTests.class,
+    PreProcessorTests.class,
+    ReturnstatementTests.class,
+    ResourceTests.class,
+    ReachingDefsTests.class,
+    ShrobAllTests.class,
+    StringTests.class,
+    SwitchstatementTests.class,
+    SynchronizeTests.class,
+    ThreeaddressTests.class,
+    ThrowstatementTests.class,
+    TrycatchTests.class,
+    TryfinallyTests.class,
+    TypeTests.class,
+    UnaryTests.class,
+    UselessVariableCopyTest.class,
+    VerifyTests.class,
+    WithPhantomTests.class,
   })
-public class AllTests {
-}
+public class AllTests {}
diff --git a/jack-tests/tests/com/android/jack/LongLastingTests.java b/jack-tests/tests/com/android/jack/LongLastingTests.java
new file mode 100644
index 00000000..d0a3f406
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/LongLastingTests.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack;
+
+
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.test.category.SlowTests;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.experimental.categories.Categories.ExcludeCategory;
+import org.junit.experimental.categories.Categories.IncludeCategory;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+
+
+
+/**
+ * Test suite containing tests that are too time-consuming and cannot be run before submitting each
+ * CL.
+ */
+@RunWith(Categories.class)
+@IncludeCategory(SlowTests.class)
+@ExcludeCategory(KnownBugs.class)
+@SuiteClasses(value = {AllTests.class})
+public class LongLastingTests {
+}
diff --git a/jack-tests/tests/com/android/jack/PreSubmitTests.java b/jack-tests/tests/com/android/jack/PreSubmitTests.java
new file mode 100644
index 00000000..ac877716
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/PreSubmitTests.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack;
+
+
+import com.android.jack.test.category.NonPreSubmitTests;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.experimental.categories.Categories.ExcludeCategory;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * Test suite to run before submitting a CL (along with regression tests).
+ */
+@RunWith(Categories.class)
+@ExcludeCategory(NonPreSubmitTests.class)
+@SuiteClasses(value = {AllWithRegressionTests.class})
+public class PreSubmitTests {
+}
diff --git a/jack-tests/tests/com/android/jack/RegressionTests.java b/jack-tests/tests/com/android/jack/RegressionTests.java
index 3a7ecc6a..5cc95a04 100644
--- a/jack-tests/tests/com/android/jack/RegressionTests.java
+++ b/jack-tests/tests/com/android/jack/RegressionTests.java
@@ -18,9 +18,46 @@ package com.android.jack;
 
 import com.android.jack.annotation.AnnotationTests;
 import com.android.jack.arithmetic.ArithmeticTests;
+import com.android.jack.array.ArrayTests;
+import com.android.jack.assertion.AssertionTests;
+import com.android.jack.assign.AssignTests;
+import com.android.jack.box.BoxTests;
+import com.android.jack.bridge.BridgeTests;
+import com.android.jack.cast.CastTests;
+import com.android.jack.comparison.ComparisonTests;
+import com.android.jack.conditional.ConditionalTests;
+import com.android.jack.constant.ConstantTests;
+import com.android.jack.debug.DebugTests;
+import com.android.jack.dx.DxTests;
+import com.android.jack.enums.EnumsTests;
+import com.android.jack.external.ExternalTests;
+import com.android.jack.fibonacci.FibonacciTests;
+import com.android.jack.field.FieldTests;
+import com.android.jack.flow.FlowTests;
+import com.android.jack.ifstatement.IfstatementTests;
+import com.android.jack.init.InitTests;
+import com.android.jack.inner.InnerTests;
+import com.android.jack.invoke.InvokeTests;
+import com.android.jack.newarray.NewarrayTests;
+import com.android.jack.opcodes.OpcodesTests;
+import com.android.jack.optimizations.exprsimplifier.ExprsimplifierTests;
+import com.android.jack.optimizations.notsimplifier.NotsimplifierTests;
+import com.android.jack.order.OrderTests;
+import com.android.jack.returnstatement.ReturnstatementTests;
+import com.android.jack.shrob.ShrobRuntimeTests;
+import com.android.jack.string.StringTests;
+import com.android.jack.switchstatement.SwitchstatementTests;
+import com.android.jack.synchronize.SynchronizeTests;
 import com.android.jack.test.helper.RuntimeTestHelper;
 import com.android.jack.test.runtime.RuntimeTest;
 import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.threeaddress.ThreeaddressTests;
+import com.android.jack.throwstatement.ThrowstatementTests;
+import com.android.jack.trycatch.TrycatchTests;
+import com.android.jack.tryfinally.TryfinallyTests;
+import com.android.jack.type.TypeTests;
+import com.android.jack.unary.UnaryTests;
+import com.android.jack.verify.VerifyTests;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -32,7 +69,44 @@ public class RegressionTests {
 
   public RuntimeTest[] tests = {
       new AnnotationTests(),
-      new ArithmeticTests()
+      new ArithmeticTests(),
+      new ArrayTests(),
+      new AssertionTests(),
+      new AssignTests(),
+      new BoxTests(),
+      new BridgeTests(),
+      new CastTests(),
+      new ComparisonTests(),
+      new ConditionalTests(),
+      new ConstantTests(),
+      new DebugTests(),
+      new DxTests(),
+      new EnumsTests(),
+      new ExprsimplifierTests(),
+      new ExternalTests(),
+      new FibonacciTests(),
+      new FieldTests(),
+      new FlowTests(),
+      new IfstatementTests(),
+      new InitTests(),
+      new InnerTests(),
+      new InvokeTests(),
+      new NewarrayTests(),
+      new NotsimplifierTests(),
+//      new OpcodesTests(),
+      new OrderTests(),
+      new ReturnstatementTests(),
+      new ShrobRuntimeTests(),
+      new StringTests(),
+      new SwitchstatementTests(),
+      new SynchronizeTests(),
+      new ThreeaddressTests(),
+      new ThrowstatementTests(),
+      new TrycatchTests(),
+      new TryfinallyTests(),
+      new TypeTests(),
+      new UnaryTests(),
+      new VerifyTests(),
   };
 
   @BeforeClass
diff --git a/jack-tests/tests/com/android/jack/analysis/dfa/reachingdefs/ReachingDefsTests.java b/jack-tests/tests/com/android/jack/analysis/dfa/reachingdefs/ReachingDefsTests.java
new file mode 100644
index 00000000..9053198f
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/analysis/dfa/reachingdefs/ReachingDefsTests.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.analysis.dfa.reachingdefs;
+
+import com.android.jack.Options;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackApiToolchain;
+import com.android.jack.util.filter.SignatureMethodFilter;
+
+import org.junit.Test;
+
+import java.io.File;
+
+public class ReachingDefsTests {
+
+  @Test
+  public void testDfa001() throws Exception {
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    toolchain.addProperty(Options.METHOD_FILTER.getName(), "method-with-signature");
+    toolchain.addProperty(SignatureMethodFilter.METHOD_SIGNATURE_FILTER.getName(),
+        "dfaWithSwitch(I)I");
+    toolchain.addProperty(ReachingDefinitions.REACHING_DEFS_CHECKER.getName(), "test001Checker");
+
+    String classpath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath());
+    File dexOutDir = AbstractTestTools.createTempDir();
+    File testSourceDir = AbstractTestTools.getTestRootDir("com.android.jack.analysis.dfa.reachingdefs.test001");
+
+    toolchain.srcToExe(classpath, dexOutDir, /* zipFile = */ false, testSourceDir);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java b/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java
index e68228ef..9b1aa63b 100644
--- a/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java
+++ b/jack-tests/tests/com/android/jack/annotation/AnnotationTests.java
@@ -1,28 +1,29 @@
 /*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 
 package com.android.jack.annotation;
 
-import com.android.jack.Main;
+import com.android.jack.test.category.KnownBugs;
 import com.android.jack.test.category.RuntimeRegressionTest;
 import com.android.jack.test.helper.CheckDexStructureTestHelper;
 import com.android.jack.test.helper.RuntimeTestHelper;
 import com.android.jack.test.runtime.RuntimeTest;
 import com.android.jack.test.runtime.RuntimeTestInfo;
 import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -32,35 +33,148 @@ import java.io.File;
 
 public class AnnotationTests extends RuntimeTest {
 
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test001"),
+    "com.android.jack.annotation.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test002"),
+    "com.android.jack.annotation.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test003"),
+    "com.android.jack.annotation.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test005"),
+    "com.android.jack.annotation.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test006"),
+    "com.android.jack.annotation.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test007"),
+    "com.android.jack.annotation.test007.dx.Tests");
+
+  private RuntimeTestInfo TEST008 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test008"),
+    "com.android.jack.annotation.test008.dx.Tests");
+
+  private RuntimeTestInfo TEST009 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.annotation.test009"),
+    "com.android.jack.annotation.test009.dx.Tests");
+
   private static final File ANNOTATION001_PATH =
       AbstractTestTools.getTestRootDir("com.android.jack.annotation.test001.jack");
 
-  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
-      AbstractTestTools.getTestRootDir("com.android.jack.annotation.test001"),
-      "com.android.jack.annotation.test001.dx.Tests");
-
   @BeforeClass
   public static void setUpClass() {
-    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+    AnnotationTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest(/* checkStructure = */ true);
   }
 
   @Test
-  public void checkStructure() throws Exception {
-    CheckDexStructureTestHelper env =
-        new CheckDexStructureTestHelper(new File(ANNOTATION001_PATH, "Annotation2.java"));
-    env.setWithDebugInfo(true);
-    env.compare();
+  public void test001_2() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        new File[] {
+          new File(ANNOTATION001_PATH, "Annotation8.java"),
+          new File(ANNOTATION001_PATH, "Annotated2.java")});
   }
 
+
   @Test
   @Category(RuntimeRegressionTest.class)
-  public void runtimeTest001() throws Exception {
-    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest(/* checkStructure = */ true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest(/* checkStructure = */ true);
+  }
+
+  @Test
+  public void test003_1() throws Exception {
+    CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper(
+        AbstractTestTools.getTestRootDir("com.android.jack.annotation.test003.jack"));
+    helper.compare();
+  }
+
+  @Test
+  public void test004() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.annotation.test004");
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        testFolder);
+  }
+
+  @Test
+  public void test004_1() throws Exception {
+    CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper(
+        AbstractTestTools.getTestRootDir("com.android.jack.annotation.test004.jack"));
+    helper.compare();
+  }
+
+  @Test
+  // Annotation on package are not supported in dex format: http://code.google.com/p/android/issues/detail?id=16149
+  @Category({RuntimeRegressionTest.class, KnownBugs.class})
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Test
+  public void test005_1() throws Exception {
+    CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper(
+        AbstractTestTools.getTestRootDir("com.android.jack.annotation.test005.jack"));
+    helper.compare();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest(/* checkStructure = */ true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest(/* checkStructure = */ true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test008() throws Exception {
+    new RuntimeTestHelper(TEST008).compileAndRunTest(/* checkStructure = */ true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test009() throws Exception {
+    new RuntimeTestHelper(TEST009).compileAndRunTest(/* checkStructure = */ true);
   }
 
   @Override
   protected void fillRtTestInfos() {
     rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+//    rtTestInfos.add(TEST005); // KnownBug
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+    rtTestInfos.add(TEST008);
+    rtTestInfos.add(TEST009);
   }
-
 }
diff --git a/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java b/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java
index 1b6ee1a0..28a42725 100644
--- a/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java
+++ b/jack-tests/tests/com/android/jack/arithmetic/ArithmeticTests.java
@@ -1,18 +1,18 @@
 /*
- * Copyright (C) 2014 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
 
 package com.android.jack.arithmetic;
 
@@ -29,22 +29,54 @@ import org.junit.experimental.categories.Category;
 public class ArithmeticTests extends RuntimeTest {
 
   private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
-      AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test001"),
-      "com.android.jack.arithmetic.test001.dx.Tests");
+    AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test001"),
+    "com.android.jack.arithmetic.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test002"),
+    "com.android.jack.arithmetic.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test003"),
+    "com.android.jack.arithmetic.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.arithmetic.test004"),
+    "com.android.jack.arithmetic.test004.dx.Tests");
 
   @BeforeClass
   public static void setUpClass() {
     ArithmeticTests.class.getClassLoader().setDefaultAssertionStatus(true);
   }
-
   @Test
   @Category(RuntimeRegressionTest.class)
   public void test001() throws Exception {
     new RuntimeTestHelper(TEST001).compileAndRunTest();
   }
 
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
   @Override
   protected void fillRtTestInfos() {
     rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
   }
 }
diff --git a/jack-tests/tests/com/android/jack/array/ArrayTests.java b/jack-tests/tests/com/android/jack/array/ArrayTests.java
new file mode 100644
index 00000000..db2a4e85
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/array/ArrayTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.array;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ArrayTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.array.test001"),
+    "com.android.jack.array.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ArrayTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/assertion/AssertionTests.java b/jack-tests/tests/com/android/jack/assertion/AssertionTests.java
new file mode 100644
index 00000000..be97229c
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/assertion/AssertionTests.java
@@ -0,0 +1,73 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.assertion;
+
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class AssertionTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.assertion.test001"),
+    "com.android.jack.assertion.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.assertion.test002"),
+    "com.android.jack.assertion.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.assertion.test003"),
+    "com.android.jack.assertion.test003.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    AssertionTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  // this test must be run with assertions enabled (for now, use dalvik)
+  @Category({RuntimeRegressionTest.class, KnownBugs.class})
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+//    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/assign/AssignTests.java b/jack-tests/tests/com/android/jack/assign/AssignTests.java
new file mode 100644
index 00000000..565996a4
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/assign/AssignTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.assign;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class AssignTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.assign.test001"),
+    "com.android.jack.assign.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    AssignTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/assign/dx/Tests.java b/jack-tests/tests/com/android/jack/assign/test001/dx/Tests.java
index 24e1d415..4ca76b91 100644
--- a/jack-tests/tests/com/android/jack/assign/dx/Tests.java
+++ b/jack-tests/tests/com/android/jack/assign/test001/dx/Tests.java
@@ -14,13 +14,13 @@
  * limitations under the License.
  */
 
-package com.android.jack.assign.dx;
+package com.android.jack.assign.test001.dx;
+
+import com.android.jack.assign.test001.jack.Assignments;
 
 import org.junit.Assert;
 import org.junit.Test;
 
-import com.android.jack.assign.jack.Assignments;
-
 /**
  * Tests Assignments.
  */
diff --git a/jack-tests/tests/com/android/jack/assign/jack/Assignments.java b/jack-tests/tests/com/android/jack/assign/test001/jack/Assignments.java
index d2a03d2a..7718129e 100644
--- a/jack-tests/tests/com/android/jack/assign/jack/Assignments.java
+++ b/jack-tests/tests/com/android/jack/assign/test001/jack/Assignments.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.assign.jack;
+package com.android.jack.assign.test001.jack;
 
 public class Assignments {
   public static int field = 5;
diff --git a/jack-tests/tests/com/android/jack/box/BoxTests.java b/jack-tests/tests/com/android/jack/box/BoxTests.java
new file mode 100644
index 00000000..9f8c94d6
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/box/BoxTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.box;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class BoxTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.box.test001"),
+    "com.android.jack.box.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    BoxTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/bridge/BridgeTests.java b/jack-tests/tests/com/android/jack/bridge/BridgeTests.java
new file mode 100644
index 00000000..0b4eab9c
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/bridge/BridgeTests.java
@@ -0,0 +1,161 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.bridge;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+public class BridgeTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test001"),
+    "com.android.jack.bridge.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test002"),
+    "com.android.jack.bridge.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test003"),
+    "com.android.jack.bridge.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test004"),
+    "com.android.jack.bridge.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test005"),
+    "com.android.jack.bridge.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test006"),
+    "com.android.jack.bridge.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.bridge.test007"),
+    "com.android.jack.bridge.test007.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    BridgeTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  // TODO(jmhenaff): reintroduce ExtraTests category for this one?
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest();
+  }
+
+  @Test
+  public void test008() throws Exception {
+
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    File srcFolder = AbstractTestTools.getTestRootDir("com.android.jack.bridge.test008.jack");
+    File jackZipOfGenericPackageProtected = AbstractTestTools.createTempFile("tmpBridge", ".zip");
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackZipOfGenericPackageProtected,
+        /* zipFiles = */ true,
+        srcFolder);
+
+    // Build jack file from PublicExtendsGeneric.java
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    File jackZipOfPublicExtendsGeneric = AbstractTestTools.createTempFile("tmpBridge", ".zip");
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {jackZipOfGenericPackageProtected}),
+        jackZipOfPublicExtendsGeneric,
+        /* zipFiles = */ true,
+        new File(srcFolder, "sub/PublicExtendsGeneric.java"));
+
+    // Build dex file representing Caller.java
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain = toolchain.addStaticLibs(jackZipOfPublicExtendsGeneric);
+    File outDexFolder = AbstractTestTools.createTempDir();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        outDexFolder,
+        /* zipFile = */ false,
+        new File(srcFolder, "Caller.java"));
+  }
+
+  @Test
+  public void test009() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.bridge.test009"));
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/cast/CastAllTests.java b/jack-tests/tests/com/android/jack/cast/CastAllTests.java
new file mode 100644
index 00000000..803546b0
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/cast/CastAllTests.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.jack.cast;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Categories.class)
+@SuiteClasses(
+value = {
+    CastTests.class,
+    UselessCastRemoverTest.class
+    })
+public class CastAllTests {
+}
\ No newline at end of file
diff --git a/jack-tests/tests/com/android/jack/cast/CastTests.java b/jack-tests/tests/com/android/jack/cast/CastTests.java
new file mode 100644
index 00000000..c0761f7f
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/cast/CastTests.java
@@ -0,0 +1,139 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.cast;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import javax.annotation.Nonnull;
+
+public class CastTests extends RuntimeTest {
+
+  private RuntimeTestInfo EXPLICIT001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.explicit001"),
+    "com.android.jack.cast.explicit001.dx.Tests");
+
+  private RuntimeTestInfo IMPLICIT001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit001"),
+    "com.android.jack.cast.implicit001.dx.Tests");
+
+  private RuntimeTestInfo IMPLICIT002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit002"),
+    "com.android.jack.cast.implicit002.dx.Tests");
+
+  private RuntimeTestInfo IMPLICIT003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit003"),
+    "com.android.jack.cast.implicit003.dx.Tests");
+
+  private RuntimeTestInfo IMPLICIT004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.implicit004"),
+    "com.android.jack.cast.implicit004.dx.Tests");
+
+  private RuntimeTestInfo USELESS001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.useless001"),
+    "com.android.jack.cast.useless001.dx.Tests");
+
+  private RuntimeTestInfo USELESS002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.cast.useless002"),
+    "com.android.jack.cast.useless002.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    CastTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void explicit001() throws Exception {
+    new RuntimeTestHelper(EXPLICIT001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void implicit001() throws Exception {
+    new RuntimeTestHelper(IMPLICIT001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void implicit002() throws Exception {
+    new RuntimeTestHelper(IMPLICIT002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void implicit003() throws Exception {
+    new RuntimeTestHelper(IMPLICIT003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void implicit004() throws Exception {
+    new RuntimeTestHelper(IMPLICIT004).compileAndRunTest();
+  }
+
+  @Test
+  public void implicitCast005() throws Exception {
+    compileTest("implicit005");
+  }
+
+  @Test
+  public void implicitCast006() throws Exception {
+    compileTest("implicit006");
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void useless001() throws Exception {
+    new RuntimeTestHelper(USELESS001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void useless002() throws Exception {
+    new RuntimeTestHelper(USELESS002).compileAndRunTest();
+  }
+
+  /**
+   * Verifies that the test source can compile from source to dex file.
+   */
+  private void compileTest(@Nonnull String name) throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */false,
+        AbstractTestTools.getTestRootDir("com.android.jack.cast." + name + ".jack"));
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(EXPLICIT001);
+    rtTestInfos.add(IMPLICIT001);
+    rtTestInfos.add(IMPLICIT002);
+    rtTestInfos.add(IMPLICIT003);
+    rtTestInfos.add(IMPLICIT004);
+    rtTestInfos.add(USELESS001);
+    rtTestInfos.add(USELESS002);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/cast/UselessCastRemoverTest.java b/jack-tests/tests/com/android/jack/cast/UselessCastRemoverTest.java
new file mode 100644
index 00000000..da117bde
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/cast/UselessCastRemoverTest.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.cast;
+
+
+import com.android.jack.TestTools;
+import com.android.jack.backend.dex.DexFileWriter;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import junit.framework.Assert;
+
+import org.jf.dexlib.CodeItem;
+import org.jf.dexlib.DexFile;
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class UselessCastRemoverTest {
+
+  @Nonnull
+  private static final String CAST = "com/android/jack/transformations/cast/jack/Data";
+
+  @Nonnull
+  private static final String CAST_USELESS002 = "com/android/jack/cast/useless002/jack/UselessCast";
+  @Nonnull
+  private static final String CAST_USELESS003 = "com/android/jack/cast/useless003/jack/UselessCast";
+
+  @BeforeClass
+  public static void setUp() throws Exception {
+    UselessCastRemoverTest.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void test001() throws Exception {
+    compileAndCheckUselessCast("com.android.jack.cast.test001",
+        "Lcom/android/jack/cast/test001/jack/Test001;", "get",
+        "(Lcom/android/jack/cast/test001/jack/Test001;)I");
+  }
+
+  @Test
+  public void test002() throws Exception {
+    compileAndCheckUselessCast("com.android.jack.cast.test002",
+        "Lcom/android/jack/cast/test002/jack/Test002;", "get",
+        "(Lcom/android/jack/cast/test002/jack/Test002;)I");
+  }
+
+  @Test
+  public void test003() throws Exception {
+    compileAndCheckUselessCast("com.android.jack.cast.test003",
+        "Lcom/android/jack/cast/test003/jack/Test003;", "get",
+        "(Lcom/android/jack/cast/test003/jack/A;)I");
+  }
+
+  private void compileAndCheckUselessCast(@Nonnull String testPackage, @Nonnull String typeSig,
+      @Nonnull String methodName, @Nonnull String methSig) throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir(testPackage);
+    File outFolder = AbstractTestTools.createTempDir();
+    File out = new File(outFolder, DexFileWriter.DEX_FILENAME);
+
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        outFolder,
+        /* zipFile = */false, testFolder);
+
+    DexFile dexFile = new DexFile(out);
+    CodeItem ci = TestTools.getEncodedMethod(dexFile, typeSig, methodName, methSig).codeItem;
+
+    Assert.assertFalse(hasOpcode(ci, Opcode.CHECK_CAST));
+    Assert.assertFalse(hasOpcode(ci, Opcode.CHECK_CAST_JUMBO));
+  }
+
+  private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) {
+    for (Instruction inst : codeItem.getInstructions()) {
+      if (inst.opcode == opcode) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+}
\ No newline at end of file
diff --git a/jack-tests/tests/com/android/jack/classpath/ClasspathTest.java b/jack-tests/tests/com/android/jack/classpath/ClasspathTest.java
deleted file mode 100644
index 8fde0388..00000000
--- a/jack-tests/tests/com/android/jack/classpath/ClasspathTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.jack.classpath;
-
-import com.android.jack.test.toolchain.AbstractTestTools;
-import com.android.jack.test.toolchain.IToolchain;
-
-import org.junit.BeforeClass;
-import org.junit.Test;
-
-import java.io.File;
-
-public class ClasspathTest {
-
-  @BeforeClass
-  public static void setUpClass() {
-    ClasspathTest.class.getClassLoader().setDefaultAssertionStatus(true);
-  }
-
-  @Test
-  public void test001() throws Exception {
-    File libOut = AbstractTestTools.createTempDir();
-
-    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
-    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-        libOut, false,
-        new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "lib"));
-
-    File testOut = AbstractTestTools.createTempDir();
-    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
-        + File.pathSeparatorChar + libOut.getAbsolutePath(), testOut, false,
-        new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "jack"));
-  }
-
-  @Test
-  public void test002() throws Exception {
-    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
-
-    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test002");
-    File outFolder = AbstractTestTools.createTempDir();
-
-    File lib1Out = AbstractTestTools.createDir(outFolder, "lib1");
-    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-        lib1Out,
-        /* zipFiles = */ false, new File(testFolder, "lib1"));
-
-    File lib1BisOut = AbstractTestTools.createDir(outFolder, "lib1override");
-    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
-        lib1BisOut,
-        /* zipFiles = */false, new File(testFolder, "lib1override"));
-
-    File lib2Out = AbstractTestTools.createDir(outFolder, "lib2");
-    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
-        + File.pathSeparatorChar + lib1Out.getAbsolutePath(), lib2Out,
-    /* zipFiles = */false, new File(testFolder, "lib2"));
-
-    toolchain.addStaticLibs(lib2Out);
-    toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
-        + File.pathSeparatorChar + lib1BisOut.getAbsolutePath(), outFolder,
-        new File(testFolder, "jack"));
-
-  }
-}
diff --git a/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java b/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java
new file mode 100644
index 00000000..f43e3b05
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/classpath/ClasspathTests.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.classpath;
+
+import com.android.jack.Jack;
+import com.android.jack.JackAbortException;
+import com.android.jack.Options;
+import com.android.jack.TestTools;
+import com.android.jack.library.FileType;
+import com.android.jack.library.LibraryReadingException;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.IOException;
+
+public class ClasspathTests {
+
+  @BeforeClass
+  public static void setUpClass() {
+    ClasspathTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void test001() throws Exception {
+    File libOut = AbstractTestTools.createTempDir();
+
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        libOut, false,
+        new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "lib"));
+
+    File testOut = AbstractTestTools.createTempDir();
+    toolchain.srcToLib(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
+        + File.pathSeparatorChar + libOut.getAbsolutePath(), testOut, false,
+        new File(AbstractTestTools.getTestRootDir("com.android.jack.classpath.test001"), "jack"));
+  }
+
+  @Test
+  public void test002() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+
+    String defaultBootCp =
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath());
+
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test002");
+    File outFolder = AbstractTestTools.createTempDir();
+
+    File lib1Out = AbstractTestTools.createDir(outFolder, "lib1");
+    toolchain.srcToLib(defaultBootCp,
+        lib1Out,
+        /* zipFiles = */ false, new File(testFolder, "lib1"));
+
+    File lib1BisOut = AbstractTestTools.createDir(outFolder, "lib1override");
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(defaultBootCp,
+        lib1BisOut,
+        /* zipFiles = */ false, new File(testFolder, "lib1override"));
+
+    File lib2Out = AbstractTestTools.createDir(outFolder, "lib2");
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(defaultBootCp
+        + File.pathSeparatorChar + lib1Out.getAbsolutePath(), lib2Out,
+    /* zipFiles = */ false, new File(testFolder, "lib2"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.addStaticLibs(lib2Out);
+    toolchain.srcToExe(defaultBootCp
+        + File.pathSeparatorChar + lib1BisOut.getAbsolutePath(), outFolder,
+        /* zipFile = */ false, new File(testFolder, "jack"));
+
+  }
+
+  @Test
+  public void test003() throws Exception {
+    File testDir = AbstractTestTools.getTestRootDir("com.android.jack.classpath.test003");
+
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    File libOut = AbstractTestTools.createTempDir();
+    File libSrc = new File(testDir, "lib");
+    String defaultBootClasspath =
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath());
+    toolchain.srcToLib(defaultBootClasspath, libOut, /* zipFiles = */ false, libSrc);
+
+    {
+      // reference compilation
+      toolchain = AbstractTestTools.getCandidateToolchain();
+      File testOut = AbstractTestTools.createTempDir();
+      File testSrc = new File(testDir, "jack");
+      toolchain.srcToLib(defaultBootClasspath + File.pathSeparatorChar + libOut.getAbsolutePath(),
+          testOut, /* zipFiles = */ false, testSrc);
+    }
+
+    {
+      // delete unused inner in classpath and check we can still compile with it
+      boolean deleted =
+          new File(libOut, FileType.JAYCE.getPrefix()
+              + "/com/android/jack/classpath/test003/lib/HasInnersClasses$InnerToDelete.jayce")
+      .delete();
+      Assert.assertTrue(deleted);
+      toolchain = AbstractTestTools.getCandidateToolchain();
+      File testOut = AbstractTestTools.createTempDir();
+      File testSrc = new File(testDir, "jack");
+      toolchain.srcToLib(defaultBootClasspath + File.pathSeparatorChar + libOut.getAbsolutePath(),
+          testOut, /* zipFiles = */ false, testSrc);
+    }
+  }
+
+  @Test
+  public void libOfLib() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    String defaultClasspath =
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath());
+    File libOfLibOut = AbstractTestTools.createTempFile("libOfLibOut", ".zip");
+    File sourceDir = AbstractTestTools.getTestRootDir("com.android.jack.liboflib.lib2");
+    toolchain.srcToLib(defaultClasspath, libOfLibOut, /* zipFiles = */ true, sourceDir);
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    File libOut = AbstractTestTools.createTempFile("libOut", ".zip");
+    sourceDir = AbstractTestTools.getTestRootDir("com.android.jack.liboflib.lib");
+    toolchain.srcToLib(defaultClasspath + File.pathSeparatorChar + libOfLibOut.getAbsolutePath(),
+        libOut, /* zipFiles = */ true, sourceDir);
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    File mainOut = AbstractTestTools.createTempFile("mainOut", ".zip");
+    sourceDir = AbstractTestTools.getTestRootDir("com.android.jack.liboflib.main");
+    toolchain.srcToLib(defaultClasspath + File.pathSeparatorChar + libOut.getAbsolutePath(),
+        mainOut, /* zipFiles = */ true, sourceDir);
+  }
+
+  @Test
+  public void testMissingClasspathEntry() throws Exception {
+    String defaultClasspath = TestTools.getDefaultBootclasspathString();
+    File srcDir = TestTools.getJackTestsWithJackFolder("classpath/test004");
+    String classpathWithMissingEntry = defaultClasspath + File.pathSeparator +
+        new File(srcDir, "missing.jack").getAbsolutePath();
+
+    File testOut = TestTools.createTempFile("ClasspathTest", "missing");
+    TestTools.compileSourceToJack(new Options(), srcDir, classpathWithMissingEntry,
+        testOut, true);
+
+    Options strict = new Options();
+    strict.addProperty(Jack.STRICT_CLASSPATH.getName(), "true");
+    try {
+      TestTools.compileSourceToJack(strict, srcDir, classpathWithMissingEntry,
+        testOut, true);
+      Assert.fail();
+    } catch (JackAbortException e) {
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+    }
+  }
+
+  @Test
+  public void testInvalidClasspathEntry() throws Exception {
+    File srcDir = TestTools.getJackTestsWithJackFolder("classpath/test004");
+    compileWithInvalidClasspathEntry(srcDir, new File(srcDir, "Classpath004.java"));
+    compileWithInvalidClasspathEntry(srcDir, new File(srcDir, "invalid.jack"));
+    compileWithInvalidClasspathEntry(srcDir, new File(srcDir, "notjack.zip"));
+  }
+
+  private void compileWithInvalidClasspathEntry(File srcDir, File invalidJack) throws IOException,
+      Exception {
+    Assert.assertTrue(invalidJack.isFile());
+    String classpathWithInvalidEntry = TestTools.getDefaultBootclasspathString() +
+        File.pathSeparator + invalidJack.getAbsolutePath();
+
+    File testOut = TestTools.createTempFile("ClasspathTest", "invalid");
+    TestTools.compileSourceToJack(new Options(), srcDir, classpathWithInvalidEntry,
+        testOut, true);
+
+    Options strict = new Options();
+    strict.addProperty(Jack.STRICT_CLASSPATH.getName(), "true");
+    try {
+      TestTools.compileSourceToJack(strict, srcDir, classpathWithInvalidEntry,
+          testOut, true);
+      Assert.fail();
+    } catch (JackAbortException e) {
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+    }
+  }
+
+
+}
diff --git a/jack-tests/tests/com/android/jack/clinit/ClinitTests.java b/jack-tests/tests/com/android/jack/clinit/ClinitTests.java
new file mode 100644
index 00000000..be461e2d
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/clinit/ClinitTests.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.clinit;
+
+import com.android.jack.Main;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class ClinitTests {
+
+  public static final String CLASS_WITH_VARIABLE_INIT_BINARY_NAME
+    = "com/android/jack/clinit/jack/ClInitWithVariableInit";
+
+  @Before
+  public void setUp() throws Exception {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void testCompileWithClinit() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.clinit.jack"));
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/comparison/ComparisonTests.java b/jack-tests/tests/com/android/jack/comparison/ComparisonTests.java
new file mode 100644
index 00000000..6a85530e
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/comparison/ComparisonTests.java
@@ -0,0 +1,50 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.comparison;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ComparisonTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.comparison.test001"),
+    "com.android.jack.comparison.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ComparisonTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/compiletime/CompileTimeTests.java b/jack-tests/tests/com/android/jack/compiletime/CompileTimeTests.java
new file mode 100644
index 00000000..878fd40d
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/compiletime/CompileTimeTests.java
@@ -0,0 +1,53 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.compiletime;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class CompileTimeTests {
+
+
+  @BeforeClass
+  public static void setUpClass() {
+    CompileTimeTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void test001() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.compiletime.test001.jack"));
+  }
+
+  @Test
+  public void test002() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.compiletime.test002.jack"));
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/conditional/ConditionalTests.java b/jack-tests/tests/com/android/jack/conditional/ConditionalTests.java
new file mode 100644
index 00000000..c7d42543
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/conditional/ConditionalTests.java
@@ -0,0 +1,115 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.conditional;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ConditionalTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test001"),
+    "com.android.jack.conditional.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test002"),
+    "com.android.jack.conditional.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test003"),
+    "com.android.jack.conditional.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test004"),
+    "com.android.jack.conditional.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test005"),
+    "com.android.jack.conditional.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test006"),
+    "com.android.jack.conditional.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.conditional.test007"),
+    "com.android.jack.conditional.test007.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ConditionalTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/constant/ConstantTests.java b/jack-tests/tests/com/android/jack/constant/ConstantTests.java
new file mode 100644
index 00000000..d60fb2f7
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/constant/ConstantTests.java
@@ -0,0 +1,174 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.constant;
+
+import com.android.jack.TestTools;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.FileChecker;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import junit.framework.Assert;
+
+import org.jf.dexlib.CodeItem;
+import org.jf.dexlib.DexFile;
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+
+public class ConstantTests extends RuntimeTest {
+
+  private RuntimeTestInfo CLAZZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.clazz"),
+    "com.android.jack.constant.clazz.dx.Tests");
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test001"),
+    "com.android.jack.constant.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test002"),
+    "com.android.jack.constant.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test003"),
+    "com.android.jack.constant.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test004"),
+    "com.android.jack.constant.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test005"),
+    "com.android.jack.constant.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test006"),
+    "com.android.jack.constant.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.constant.test007"),
+    "com.android.jack.constant.test007.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ConstantTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void clazz() throws Exception {
+    new RuntimeTestHelper(CLAZZ).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005)
+    .addTestExeFileChecker(new FileChecker() {
+
+      @Override
+      public void check(@Nonnull File file) throws Exception {
+        DexFile dexFile = new DexFile(file);
+        CodeItem ci =
+            TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/constant/test005/jack/Constant005;",
+                "test", "()I").codeItem;
+
+        Assert.assertEquals(7, countOpcode(ci, Opcode.CONST_4));
+      }
+    }).compileAndRunTest();
+  }
+
+  @Nonnegative
+  private int countOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) {
+    int countOpcode = 0;
+    for (Instruction inst : codeItem.getInstructions()) {
+      if (inst.opcode == opcode) {
+        countOpcode++;
+      }
+    }
+    return countOpcode;
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test008() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.constant.test008"));
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(CLAZZ);
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/debug/DebugTests.java b/jack-tests/tests/com/android/jack/debug/DebugTests.java
new file mode 100644
index 00000000..2cfd0d2d
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/debug/DebugTests.java
@@ -0,0 +1,147 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.debug;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.CheckDexStructureTestHelper;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import javax.annotation.Nonnull;
+
+public class DebugTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.debug.test001"),
+      "com.android.jack.debug.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.debug.test002"),
+    "com.android.jack.debug.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.debug.test004"),
+    "com.android.jack.debug.test004.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    DebugTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001)
+        .setWithDebugInfos(true).compileAndRunTest(/* checkStructure  = */ true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002)
+        .setWithDebugInfos(true).compileAndRunTest(/* checkStructure  = */ true);
+  }
+
+  @Test
+  public void test003() throws Exception {
+    checkStructure("003");
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004)
+        .setWithDebugInfos(true).compileAndRunTest(/* checkStructure  = */ true);
+  }
+
+  @Test
+  public void test005() throws Exception {
+    checkStructure("005");
+  }
+
+  @Test
+  public void test006() throws Exception {
+    checkStructure("006");
+  }
+
+  @Test
+  public void test007() throws Exception {
+    checkStructure("007");
+  }
+
+  @Test
+  public void test008() throws Exception {
+    checkStructure("008");
+  }
+
+  @Test
+  public void test009() throws Exception {
+    checkStructure("009");
+  }
+
+  @Test
+  public void test010() throws Exception {
+    checkStructure("010");
+  }
+
+  @Test
+  public void test011() throws Exception {
+    checkStructure("011");
+  }
+
+  @Test
+  public void test012() throws Exception {
+    checkStructure("012");
+  }
+
+  @Test
+  public void test013() throws Exception {
+    checkStructure("013");
+  }
+
+  @Test
+  public void test014() throws Exception {
+    checkStructure("014");
+  }
+
+  @Test
+  @Ignore("Debug comparison fails because of local variable default initialization")
+  public void test019() throws Exception {
+    checkStructure("019");
+  }
+
+  private void checkStructure(@Nonnull String testNumber) throws Exception {
+    CheckDexStructureTestHelper helper = new CheckDexStructureTestHelper(
+        AbstractTestTools.getTestRootDir("com.android.jack.debug.test" + testNumber + ".jack"));
+    helper.setWithDebugInfo(true).compare();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST004);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/dx/DxTests.java b/jack-tests/tests/com/android/jack/dx/DxTests.java
new file mode 100644
index 00000000..9e5e8155
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/dx/DxTests.java
@@ -0,0 +1,171 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.dx;
+
+import com.android.jack.TestTools;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.FileChecker;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import junit.framework.Assert;
+
+import org.jf.dexlib.CodeItem;
+import org.jf.dexlib.DexFile;
+import org.jf.dexlib.ClassDataItem.EncodedMethod;
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.jf.dexlib.Code.Analysis.AnalyzedInstruction;
+import org.jf.dexlib.Code.Analysis.MethodAnalyzer;
+import org.jf.dexlib.Code.Format.Instruction23x;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class DxTests extends RuntimeTest {
+
+  private RuntimeTestInfo COMPILER = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.dx.compiler"),
+    "com.android.jack.dx.compiler.dx.Tests");
+
+  private RuntimeTestInfo OPTIMIZER = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.dx.optimizer"),
+    "com.android.jack.dx.optimizer.dx.Tests");
+
+  private RuntimeTestInfo OVERLAPPING = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.dx.overlapping"),
+    "com.android.jack.dx.overlapping.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    DxTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void compiler() throws Exception {
+    new RuntimeTestHelper(COMPILER).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void optimizer() throws Exception {
+    new RuntimeTestHelper(OPTIMIZER).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void overlapping() throws Exception {
+    new RuntimeTestHelper(OVERLAPPING)
+    .addTestExeFileChecker(new FileChecker() {
+
+      @Override
+      public void check(@Nonnull File file) throws Exception {
+        DexFile dexFile = new DexFile(file);
+        EncodedMethod em =
+            TestTools.getEncodedMethod(dexFile,
+                "Lcom/android/jack/dx/overlapping/jack/Data;", "test002",
+                "(IJJ)J");
+
+        checkThatRegistersDoesNotOverlap(em);
+      }
+
+    })
+    .addTestExeFileChecker(new FileChecker() {
+
+      @Override
+      public void check(@Nonnull File file) throws Exception {
+        DexFile dexFile = new DexFile(file);
+        EncodedMethod em =
+            TestTools.getEncodedMethod(dexFile,
+                "Lcom/android/jack/dx/overlapping/jack/Data;", "test001",
+                "(IJJ)J");
+
+        checkThatRegistersDoesNotOverlap(em);
+      }
+
+    })
+    .compileAndRunTest();
+  }
+
+  @Test
+  @Ignore("Dx register allocator use div_int instead of div_int_2addr in some cases.")
+  public void testRegallocator() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    File dexOutDir = AbstractTestTools.createTempDir();
+    File outFile = new File(dexOutDir, "classes.dex");
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        dexOutDir,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.dx.regallocator.jack"));
+
+    DexFile dexFile = new DexFile(outFile);
+
+    CodeItem ci =
+        TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/dx/regallocator/jack/Data;",
+            "compute1", "(I)I").codeItem;
+    Assert.assertTrue(hasOpcode(ci, Opcode.DIV_INT_2ADDR));
+    ci =
+        TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/dx/regallocator/jack/Data;",
+            "compute2", "(I)I").codeItem;
+    Assert.assertTrue(hasOpcode(ci, Opcode.DIV_INT_2ADDR));
+  }
+
+  private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) {
+    for (Instruction inst : codeItem.getInstructions()) {
+      if (inst.opcode == opcode) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  private void checkThatRegistersDoesNotOverlap(@Nonnull EncodedMethod em) {
+    MethodAnalyzer ma = new MethodAnalyzer(em, false, null);
+    for (AnalyzedInstruction ai : ma.getInstructions()) {
+      if (ai.getInstruction() instanceof Instruction23x) {
+        Instruction23x inst = (Instruction23x) ai.getInstruction();
+        // Register overlaps in the following cases
+        // v0, v1 = ..., v1, v2
+        // v0, v1 = v1, v2, ...
+        // v1, v2 = ..., v0, v1
+        // v1, v2 = v0, v1, ...
+        if (inst.getRegisterA() + 1 == inst.getRegisterC()
+            || inst.getRegisterA() + 1 == inst.getRegisterB()
+            || inst.getRegisterA() == inst.getRegisterC() + 1
+            || inst.getRegisterA() == inst.getRegisterB() + 1) {
+          Assert.fail("Register overlapping");
+        }
+      }
+    }
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(COMPILER);
+    rtTestInfos.add(OPTIMIZER);
+    rtTestInfos.add(OVERLAPPING);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/enums/EnumsTests.java b/jack-tests/tests/com/android/jack/enums/EnumsTests.java
new file mode 100644
index 00000000..0b6bb7d0
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/enums/EnumsTests.java
@@ -0,0 +1,69 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.enums;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class EnumsTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.enums.test001"),
+    "com.android.jack.enums.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.enums.test002"),
+    "com.android.jack.enums.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.enums.test003"),
+      "com.android.jack.enums.test003.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    EnumsTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java b/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java
index fea5b186..5cbd7a01 100644
--- a/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java
+++ b/jack-tests/tests/com/android/jack/error/AnnotationProcessorErrorTest.java
@@ -64,7 +64,7 @@ public class AnnotationProcessorErrorTest {
   public void testAnnotationProcessorError001() throws Exception {
     ErrorTestHelper te = new ErrorTestHelper();
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(),"jack.incremental", "A.java",
+    AbstractTestTools.createFile(te.getSourceFolder(),"jack.incremental", "A.java",
         "package jack.incremental; \n"+
         "public class A {} \n");
 
@@ -74,7 +74,7 @@ public class AnnotationProcessorErrorTest {
     try {
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
-          te.getOutputDexFolder(), te.getSourceFolder());
+          te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder());
       Assert.fail();
     } catch (JackUserException e) {
       // Failure is ok since output for annotation processor is not specify.
@@ -110,7 +110,7 @@ public class AnnotationProcessorErrorTest {
 
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
-          + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), te.getSourceFolder());
+          + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder());
 
       Assert.fail();
     } catch (FrontendCompilationException e) {
@@ -131,7 +131,7 @@ public class AnnotationProcessorErrorTest {
     buildAnnotationRequiredByAnnotationProc(te, new Class<?>[] {SourceAnnotationTest.class,
         SourceErrorAnnotationTest.class});
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n"
+    AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n"
         + "import " + SourceErrorAnnotationTest.class.getName() + ";\n"
         + "@" + SourceErrorAnnotationTest.class.getSimpleName() + "\n"
         + "public class A {}\n");
@@ -146,7 +146,7 @@ public class AnnotationProcessorErrorTest {
     try {
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
-          + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), te.getSourceFolder());
+          + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder());
       Assert.fail();
     } catch (FrontendCompilationException ex) {
       // Failure is ok since source generated by annotation processor does not compile.
@@ -165,7 +165,7 @@ public class AnnotationProcessorErrorTest {
     buildAnnotationRequiredByAnnotationProc(te, new Class<?>[] {SourceAnnotationTest.class,
         SourceErrorAnnotationTest.class});
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n"
+    AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n"
         + "import " + SourceAnnotationTest.class.getName() + ";\n"
         + "@" + SourceAnnotationTest.class.getSimpleName() + "\n"
         + "public class A {}\n");
@@ -177,7 +177,7 @@ public class AnnotationProcessorErrorTest {
     File dexOutput = te.getOutputDexFolder();
     jackApiToolchain.srcToExe(
         AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
-        + File.pathSeparator + te.getJackFolder(), dexOutput, te.getSourceFolder());
+        + File.pathSeparator + te.getJackFolder(), dexOutput, /* zipFile = */ false, te.getSourceFolder());
 
     DexFile dexFile = new DexFile(new File(dexOutput, jackApiToolchain.getBinaryFileName()));
     List<String> sourceFileInDex = new ArrayList<String>();
@@ -193,7 +193,7 @@ public class AnnotationProcessorErrorTest {
 
     buildAnnotationRequiredByAnnotationProc(te, new Class<?>[] {ResourceAnnotationTest.class});
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n"
+    AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java", "package jack.incremental;\n"
         + "import " + ResourceAnnotationTest.class.getName() + ";\n"
         + "@" + ResourceAnnotationTest.class.getSimpleName() + "\n"
         + "public class A {}\n");
@@ -204,7 +204,7 @@ public class AnnotationProcessorErrorTest {
 
     jackApiToolchain.srcToExe(
         AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
-        + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), te.getSourceFolder());
+        + File.pathSeparator + te.getJackFolder(), te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder());
 
     File discoverFile = new File(te.getTestingFolder(), ResourceAnnotationProcessor.FILENAME);
     Assert.assertTrue(discoverFile.exists());
diff --git a/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java b/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java
index 3e72329e..d9551701 100644
--- a/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java
+++ b/jack-tests/tests/com/android/jack/error/CommandLineErrorTest.java
@@ -19,6 +19,8 @@ package com.android.jack.error;
 import com.android.jack.IllegalOptionsException;
 import com.android.jack.Main;
 import com.android.jack.NothingToDoException;
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.frontend.FrontendCompilationException;
 import com.android.jack.test.helper.ErrorTestHelper;
 import com.android.jack.test.toolchain.AbstractTestTools;
 import com.android.jack.test.toolchain.JackApiToolchain;
@@ -27,6 +29,7 @@ import junit.framework.Assert;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
+import org.junit.experimental.categories.Category;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -56,7 +59,7 @@ public class CommandLineErrorTest {
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
           + File.pathSeparator + ite.getJackFolder(), ite.getOutputDexFolder(),
-          ite.getSourceFolder());
+          /* zipFile = */ false, ite.getSourceFolder());
       Assert.fail();
     } catch (IllegalOptionsException e) {
       // Failure is ok since a bad options is passed to ecj.
@@ -82,7 +85,7 @@ public class CommandLineErrorTest {
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
           + File.pathSeparator + ite.getJackFolder(), ite.getOutputDexFolder(),
-          ite.getSourceFolder());
+          /* zipFile = */ false, ite.getSourceFolder());
       Assert.fail();
     } catch (NothingToDoException e) {
       // Failure is ok since there is no source files.
@@ -92,4 +95,33 @@ public class CommandLineErrorTest {
     }
   }
 
+  /**
+   * Checks that compilation fails correctly when java.lang.Object does not exist on classpath.
+   */
+  @Test
+  public void testCommandLineError003() throws Exception {
+    ErrorTestHelper ite = new ErrorTestHelper();
+
+    File sourceFile = AbstractTestTools.createFile(ite.getSourceFolder(), "jack.incremental",
+        "A.java", "package jack.incremental; \n" + "public class A {} \n");
+
+    JackApiToolchain jackApiToolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    jackApiToolchain.setErrorStream(errOut);
+    jackApiToolchain.setOutputStream(out);
+
+    try {
+      jackApiToolchain.srcToExe(null, ite.getOutputDexFolder(),
+          /* zipFile = */ false, ite.getSourceFolder());
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Failure is ok, since java.lang.Object does not exists.
+    } finally {
+      Assert.assertEquals("", out.toString());
+      Assert.assertTrue(errOut.toString().contains("The type java.lang.Object cannot be found in source files, "
+          + "imported jack libs or the classpath"));
+    }
+  }
+
 }
diff --git a/jack-tests/tests/com/android/jack/error/ConfigErrorTest.java b/jack-tests/tests/com/android/jack/error/ConfigErrorTest.java
new file mode 100644
index 00000000..3e074f59
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/error/ConfigErrorTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.error;
+
+import com.android.jack.test.helper.ErrorTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackApiToolchain;
+import com.android.sched.util.config.UnknownPropertyNameException;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+
+public class ConfigErrorTest {
+
+  @Test
+  public void testUnknownProperty001() throws Exception {
+    ErrorTestHelper ite = new ErrorTestHelper();
+
+    JackApiToolchain jackApiToolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    jackApiToolchain.setErrorStream(errOut);
+
+    File sourceFile = AbstractTestTools.createFile(ite.getSourceFolder(), "jack.config", "A.java",
+        "package jack.config; \n"+
+        "public class A {} \n");
+
+    jackApiToolchain.addProperty("unknown", "true");
+
+    try {
+      jackApiToolchain.srcToExe(
+          AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
+          ite.getOutputDexFolder(), /* zipFile = */ true, ite.getSourceFolder());
+      Assert.fail();
+    } catch (UnknownPropertyNameException e) {
+      // Expected since we use an unknown property.
+    } finally {
+      Assert.assertEquals("", errOut.toString());
+    }
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/error/ErrorHandlingAllTests.java b/jack-tests/tests/com/android/jack/error/ErrorHandlingAllTests.java
new file mode 100644
index 00000000..f459d7a4
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/error/ErrorHandlingAllTests.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.android.jack.error;
+
+import org.junit.experimental.categories.Categories;
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Categories.class)
+@SuiteClasses(
+value = {
+    AnnotationProcessorErrorTest.class,
+    CommandLineErrorTest.class,
+    ConfigErrorTest.class,
+    ErrorTest.class,
+    FileAccessErrorTest.class,
+    JackFormatErrorTest.class,
+    SourceErrorTest.class
+    })
+public class ErrorHandlingAllTests {
+}
\ No newline at end of file
diff --git a/jack-tests/tests/com/android/jack/error/ErrorTest.java b/jack-tests/tests/com/android/jack/error/ErrorTest.java
new file mode 100644
index 00000000..321780cb
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/error/ErrorTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.error;
+
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+
+import javax.annotation.Nonnull;
+
+/**
+ * JUnit checking that compilation failed properly.
+ */
+public class ErrorTest {
+
+  @BeforeClass
+  public static void setUpClass() {
+    ErrorTest.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void testError001() throws Exception {
+    checkInternalCompilerException("error.test001");
+  }
+
+  @Test
+  public void testError002() throws Exception {
+    checkInternalCompilerException("error.test002");
+  }
+
+  private void checkInternalCompilerException(@Nonnull String testName)
+      throws Exception, IOException {
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+    toolchain.setErrorStream(err);
+
+    try {
+      toolchain.srcToExe(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          AbstractTestTools.createTempDir(),
+          /* zipFile = */ false,
+          AbstractTestTools.getTestRootDir("com.android.jack." + testName + ".jack"));
+    } catch (FrontendCompilationException e) {
+      Assert.assertTrue(!err.toString().contains("InternalCompilerException"));
+    } catch (RuntimeException e) {
+      Assert.fail();
+    }
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java b/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java
index f9ce418a..5d52bced 100644
--- a/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java
+++ b/jack-tests/tests/com/android/jack/error/FileAccessErrorTest.java
@@ -16,14 +16,19 @@
 
 package com.android.jack.error;
 
+import com.android.jack.JackAbortException;
 import com.android.jack.JackUserException;
 import com.android.jack.Main;
+import com.android.jack.backend.jayce.JayceFileImporter;
 import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.library.LibraryIOException;
+import com.android.jack.library.LibraryReadingException;
 import com.android.jack.load.JackLoadingException;
 import com.android.jack.test.helper.ErrorTestHelper;
 import com.android.jack.test.toolchain.AbstractTestTools;
 import com.android.jack.test.toolchain.JackApiToolchain;
 import com.android.sched.util.config.PropertyIdException;
+import com.android.sched.util.file.WrongPermissionException;
 
 import junit.framework.Assert;
 
@@ -50,7 +55,7 @@ public class FileAccessErrorTest {
   public void testFileAccessError001() throws Exception {
     ErrorTestHelper te = new ErrorTestHelper();
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java",
+    AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java",
         "package jack.incremental; \n"+
         "public class A {} \n");
 
@@ -63,7 +68,7 @@ public class FileAccessErrorTest {
     try {
       jackApiToolchain.srcToLib(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
-          jackOutputFile, false, te.getSourceFolder());
+          jackOutputFile, /* zipFiles = */ false, te.getSourceFolder());
       Assert.fail();
     } catch (PropertyIdException e) {
       // Failure is ok since jack output folder is not readable
@@ -75,13 +80,62 @@ public class FileAccessErrorTest {
   }
 
   /**
+   * Checks that compilation fails correctly when folder containing jack files is not readable.
+   */
+  @Test
+  public void testFileAccessError002() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    File srcFile = AbstractTestTools.createFile(helper.getSourceFolder(), "jack.incremental",
+        "A.java", "package jack.incremental; \n" + "public class A {} \n");
+
+    JackApiToolchain jackApiToolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    jackApiToolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
+        helper.getJackFolder(), /* zipFiles = */ false, helper.getSourceFolder());
+
+    AbstractTestTools.deleteFile(srcFile);
+
+    srcFile = AbstractTestTools.createFile(helper.getSourceFolder(), "jack.incremental", "B.java",
+        "package jack.incremental; \n" + "public class B extends A {} \n");
+
+    // Modify read permission of folder containing jack files
+    if (!helper.getJackFolder().setReadable(false)) {
+      Assert.fail("Fails to change file permissions of " + helper.getJackFolder().getAbsolutePath());
+    }
+
+    jackApiToolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    jackApiToolchain.setErrorStream(errOut);
+    jackApiToolchain.addStaticLibs(helper.getJackFolder());
+    try {
+      jackApiToolchain.srcToExe(
+          AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
+          helper.getOutputDexFolder(), /* zipFile = */ false, helper.getSourceFolder());
+      Assert.fail();
+    } catch (JackAbortException e) {
+      // Failure is ok since Jack file could not be imported since folder is not readable
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+      Assert.assertTrue(e.getCause().getCause() instanceof WrongPermissionException);
+    } finally {
+      Assert.assertTrue("", errOut.toString().contains("is not readable"));
+      if (!helper.getJackFolder().setReadable(true)) {
+        Assert.fail("Fails to change file permissions of " + helper.getJackFolder().getAbsolutePath());
+      }
+    }
+  }
+
+  /**
    * Checks that compilation fails correctly when source file is not readable.
    */
   @Test
   public void testFileAccessError003() throws Exception {
     ErrorTestHelper te = new ErrorTestHelper();
 
-    File a = AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java",
+    File a = AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java",
         "package jack.incremental; \n"+
         "public class A {} \n");
     if (!a.setReadable(false)) {
@@ -95,7 +149,7 @@ public class FileAccessErrorTest {
     try {
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
-          te.getOutputDexFolder(), te.getSourceFolder());
+          te.getOutputDexFolder(), /* zipFile = */ false, te.getSourceFolder());
       Assert.fail();
     } catch (FrontendCompilationException e) {
       // Failure is ok since source file is not readable
@@ -114,7 +168,7 @@ public class FileAccessErrorTest {
   public void testFileAccessError004() throws Exception {
     ErrorTestHelper te = new ErrorTestHelper();
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(), "jack.incremental", "A.java",
+    AbstractTestTools.createFile(te.getSourceFolder(), "jack.incremental", "A.java",
         "package jack.incremental; \n"+
         "public class A {} \n");
 
@@ -126,29 +180,32 @@ public class FileAccessErrorTest {
 
     AbstractTestTools.deleteJavaFile(te.getSourceFolder(), "jack.incremental", "A.java");
 
-    AbstractTestTools.createJavaFile(te.getSourceFolder(),"jack.incremental", "B.java",
+    AbstractTestTools.createFile(te.getSourceFolder(),"jack.incremental", "B.java",
         "package jack.incremental; \n"+
         "public class B extends A {} \n");
 
     ByteArrayOutputStream errOut = new ByteArrayOutputStream();
     try {
-      for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), ".jack")) {
+      for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), JayceFileImporter.JAYCE_FILE_EXTENSION)) {
         if (!jackFile.setReadable(false)) {
           Assert.fail("Fails to change file permissions of " + jackFile.getAbsolutePath());
         }
       }
 
       jackApiToolchain.setErrorStream(errOut);
-      jackApiToolchain.srcToLib(
+      jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath())
           + File.pathSeparator + te.getJackFolder().getAbsolutePath(),
           AbstractTestTools.createTempDir(), false, te.getSourceFolder());
       Assert.fail();
-    } catch (JackLoadingException e) {
-      // Failure is ok since jack file is not readable
+    } catch (JackAbortException e) {
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+      Assert.assertTrue(e.getCause().getCause() instanceof LibraryIOException);
     } finally {
-      Assert.assertEquals("", errOut.toString());
-      for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), ".jack")) {
+      String errOutput = errOut.toString();
+      Assert.assertTrue(errOutput.contains("is an invalid library"));
+      Assert.assertTrue(errOutput.contains("is not readable"));
+      for (File jackFile : AbstractTestTools.getFiles(te.getJackFolder(), JayceFileImporter.JAYCE_FILE_EXTENSION)) {
         if (!jackFile.setReadable(true)) {
           Assert.fail("Fails to change file permissions of " + jackFile.getAbsolutePath());
         }
@@ -169,7 +226,7 @@ public class FileAccessErrorTest {
 
       jackApiToolchain.srcToExe(
           AbstractTestTools.getClasspathAsString(jackApiToolchain.getDefaultBootClasspath()),
-          te.getOutputDexFolder(), new File(te.getSourceFolder(), "A.java"));
+          te.getOutputDexFolder(), /* zipFile = */ false, new File(te.getSourceFolder(), "A.java"));
 
       Assert.fail();
     } catch (JackUserException e) {
diff --git a/jack-tests/tests/com/android/jack/error/JackFormatErrorTest.java b/jack-tests/tests/com/android/jack/error/JackFormatErrorTest.java
new file mode 100644
index 00000000..c518e9f4
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/error/JackFormatErrorTest.java
@@ -0,0 +1,188 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.error;
+
+import com.android.jack.JackAbortException;
+import com.android.jack.Main;
+import com.android.jack.Options.VerbosityLevel;
+import com.android.jack.jayce.JayceFormatException;
+import com.android.jack.jayce.JayceProperties;
+import com.android.jack.library.FileType;
+import com.android.jack.library.JackLibrary;
+import com.android.jack.library.JackLibraryFactory;
+import com.android.jack.library.LibraryFormatException;
+import com.android.jack.library.LibraryReadingException;
+import com.android.jack.library.v0001.Version;
+import com.android.jack.load.JackLoadingException;
+import com.android.jack.test.helper.ErrorTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+
+/**
+ * JUnit test checking Jack behavior on exceptions.
+ */
+public class JackFormatErrorTest {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Checks that compilation fails correctly when jayce file is corrupted.
+   */
+  @Test
+  public void testJackFormatError001() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(new File(helper.getJackFolder(), FileType.JAYCE.getPrefix()), "jack.incremental",
+                "A.jayce", "jayce(" + JackLibraryFactory.DEFAULT_MAJOR_VERSION + "." + Version.MINOR
+                    + ")Corrupted");
+    AbstractTestTools.createFile(helper.getJackFolder(), "", "jack.properties",
+                JackLibrary.KEY_LIB_EMITTER + "=unknown\n"
+                + JackLibrary.KEY_LIB_EMITTER_VERSION + "=0\n"
+                + JackLibrary.KEY_LIB_MAJOR_VERSION + "=" + Version.MAJOR + "\n"
+                + JackLibrary.KEY_LIB_MINOR_VERSION + "=" + Version.MINOR + "\n"
+                + FileType.JAYCE.buildPropertyName(null /*suffix*/) + "=true\n"
+                + JayceProperties.KEY_JAYCE_MAJOR_VERSION + "=2\n"
+                + JayceProperties.KEY_JAYCE_MINOR_VERSION + "=14\n");
+
+    AbstractTestTools.createFile(helper.getSourceFolder(),"jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B extends A {} \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    toolchain.setVerbosityLevel(VerbosityLevel.DEBUG);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
+          + File.pathSeparatorChar + helper.getJackFolder().getAbsolutePath(),
+          helper.getOutputDexFolder(), /* zipFile= */ false, helper.getSourceFolder());
+      Assert.fail();
+    } catch (JackAbortException e) {
+      // Failure is ok since jack file is corrupted.
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+      Assert.assertTrue(e.getCause().getCause() instanceof LibraryFormatException);
+    } finally {
+      Assert.assertTrue(errOut.toString().contains("is an invalid library"));
+      Assert.assertTrue(errOut.toString().contains(
+          "Unexpected node NForStatement, NDeclaredType was expected"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails correctly when jack file header is corrupted.
+   */
+  @Test
+  public void testJackFormatError002() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(new File(helper.getJackFolder(), FileType.JAYCE.getPrefix()), "jack.incremental",
+                "A.jayce", "jayce()");
+    AbstractTestTools.createFile(helper.getJackFolder(), "", "jack.properties",
+                JackLibrary.KEY_LIB_EMITTER + "=unknown\n"
+                + JackLibrary.KEY_LIB_EMITTER_VERSION + "=0\n"
+                + JackLibrary.KEY_LIB_MAJOR_VERSION + "=" + Version.MAJOR + "\n"
+                + JackLibrary.KEY_LIB_MINOR_VERSION + "=" + Version.MINOR + "\n"
+                + FileType.JAYCE.buildPropertyName(null /*suffix*/) + "=true\n"
+                + JayceProperties.KEY_JAYCE_MAJOR_VERSION + "=2\n"
+                + JayceProperties.KEY_JAYCE_MINOR_VERSION + "=14\n");
+
+
+    AbstractTestTools.createFile(helper.getSourceFolder(),"jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B extends A {} \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    toolchain.setVerbosityLevel(VerbosityLevel.DEBUG);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
+          + File.pathSeparatorChar + helper.getJackFolder().getAbsolutePath(),
+          helper.getOutputDexFolder(), /* zipFile= */ false, helper.getSourceFolder());
+      Assert.fail();
+    } catch (JackAbortException e) {
+      // Failure is ok since jack file header is corrupted.
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+      Assert.assertTrue(e.getCause().getCause() instanceof LibraryFormatException);
+    } finally {
+      Assert.assertTrue(errOut.toString().contains("is an invalid library"));
+      Assert.assertTrue(errOut.toString().contains("Invalid Jayce header"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails correctly when jack file is not longer supported.
+   */
+  @Test
+  public void testJackFormatError003() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(new File(helper.getJackFolder(), FileType.JAYCE.getPrefix()),
+        "jack.incremental",
+        "A.jayce", "jayce()");
+    AbstractTestTools.createFile(helper.getJackFolder(), "", "jack.properties",
+        JackLibrary.KEY_LIB_EMITTER + "=unknown\n"
+        + JackLibrary.KEY_LIB_EMITTER_VERSION + "=0\n"
+        + JackLibrary.KEY_LIB_MAJOR_VERSION + "=" + Version.MAJOR + "\n"
+        + JackLibrary.KEY_LIB_MINOR_VERSION + "=" + Version.MINOR + "\n"
+        + FileType.JAYCE.buildPropertyName(null /*suffix*/) + "=true\n"
+        + JayceProperties.KEY_JAYCE_MAJOR_VERSION + "=0\n"
+        + JayceProperties.KEY_JAYCE_MINOR_VERSION + "=0\n");
+
+    AbstractTestTools.createFile(helper.getSourceFolder(),"jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B extends A {} \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    toolchain.setVerbosityLevel(VerbosityLevel.DEBUG);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
+          + File.pathSeparatorChar + helper.getJackFolder().getAbsolutePath(),
+          helper.getOutputDexFolder(), /* zipFile= */ false, helper.getSourceFolder());
+      Assert.fail();
+    } catch (JackAbortException e) {
+      // Failure is ok since jack file header is corrupted.
+      Assert.assertTrue(e.getCause() instanceof LibraryReadingException);
+      Assert.assertTrue(e.getCause().getCause() instanceof LibraryFormatException);
+    } finally {
+      Assert.assertTrue(errOut.toString().contains("is an invalid library"));
+      Assert.assertTrue(errOut.toString().contains("Jayce version 0 not supported"));
+    }
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/error/SourceErrorTest.java b/jack-tests/tests/com/android/jack/error/SourceErrorTest.java
new file mode 100644
index 00000000..afee3fea
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/error/SourceErrorTest.java
@@ -0,0 +1,349 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.error;
+
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.ErrorTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+
+import javax.annotation.Nonnull;
+
+/**
+ * JUnit test checking Jack behavior with source errors.
+ */
+public class SourceErrorTest {
+
+  /**
+   * Checks that compilation fails because of invalid "class" keyword.
+   */
+  @Test
+  public void testInvalidSource001() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public clas A {}\n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertTrue(
+          errOut.toString().contains("Syntax error on token \"clas\", class expected"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of invalid "public" keyword.
+   */
+  @Test
+  public void testInvalidSource002() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "publi class A {}\n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertTrue(
+          errOut.toString().contains("Syntax error on token \"publi\", public expected"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of a class name that does not match the file name.
+   */
+  @Test
+  public void testInvalidSource003() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public class B {}\n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertTrue(
+          errOut.toString().contains("The public type B must be defined in its own file"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of an import of a class that is not on classpath.
+   */
+  @Test
+  public void testInvalidSource004() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "import jack.invalidsource.B;\n"
+        + "public class A {}\n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertTrue(
+          errOut.toString().contains("The import jack.invalidsource.B cannot be resolved"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because there are too many methods in a single class.
+   */
+  @Test
+  public void testInvalidSource005() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    int methodCount = 65536;
+    StringBuilder content =
+        new StringBuilder("public class A {");
+    // -1 due to implicit init method
+    for (int mthIdx = 0; mthIdx < methodCount - 1; mthIdx++) {
+      content.append("public void m" + mthIdx + "() {} \n");
+    }
+    content.append("} \n");
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.overflow", "A.java",
+        "package jack.overflow; \n" + content.toString());
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setOutputStream(out);
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Failure is ok, since there are too many methods.
+    } finally {
+      Assert.assertEquals("", out.toString());
+      Assert.assertTrue(
+          errOut.toString().contains("Too many methods for type A. Maximum is 65535"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of several source errors.
+   */
+  @Test
+  public void testInvalidSource006() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public class A { private voi m() {} } \n");
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "B.java", "package jack.invalidsource;\n"
+        + "public class B { private void m(in a) {}; \n private void n(int a) {re}; } \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setOutputStream(out);
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    }  catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertEquals("", out.toString());
+      String errorString = errOut.toString();
+      Assert.assertTrue(errorString.contains("in cannot be resolved to a type"));
+      Assert.assertTrue(errorString.contains(
+          "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration"));
+      Assert.assertTrue(
+          errorString.contains("Syntax error, insert \";\" to complete BlockStatements"));
+      Assert.assertTrue(errorString.contains("voi cannot be resolved to a type"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of a source error, with also some warnings.
+   */
+  @Test
+  public void testInvalidSource007() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public class A { private void m() {} } \n");
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "B.java", "package jack.invalidsource;\n"
+        + "public class B { private void m(in a) {}; \n private void n(int a) {}; } \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setOutputStream(out);
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertEquals("", out.toString());
+      Assert.assertTrue(errOut.toString().contains("in cannot be resolved to a type"));
+      Assert.assertTrue(errOut.toString().contains(
+          "The method n(int) from the type B is never used locally"));
+      Assert.assertTrue(
+          errOut.toString().contains("The method m() from the type A is never used locally"));
+    }
+  }
+
+  /**
+   * Checks that compilation succeeds but prints several warnings.
+   */
+  @Test
+  public void testInvalidSource008() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public class A { private void m() {} } \n");
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "B.java", "package jack.invalidsource;\n"
+        + "public class B { private void m(int a) {}; \n private void n(int a) {}; } \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setOutputStream(out);
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+    }  finally {
+      Assert.assertEquals("", out.toString());
+      Assert.assertTrue(errOut.toString().contains(
+          "The method m(int) from the type B is never used locally"));
+      Assert.assertTrue(errOut.toString().contains(
+          "The method n(int) from the type B is never used locally"));
+      Assert.assertTrue(
+          errOut.toString().contains("The method m() from the type A is never used locally"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of an invalid type.
+   * undefinedTypeId = typeRelatedCategory + 2
+   */
+  @Test
+  public void testInvalidSource009() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public class A { private void m(in a) {}; } \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setOutputStream(out);
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertEquals("", out.toString());
+      Assert.assertTrue(errOut.toString().contains("in cannot be resolved to a type"));
+    }
+  }
+
+  /**
+   * Checks that compilation fails because of a parsing error.
+   * parsingErrorInsertToCompleteId = syntaxCategory + internalCategory + 240
+   */
+  @Test
+  public void testInvalidSource010() throws Exception {
+    ErrorTestHelper helper = new ErrorTestHelper();
+
+    AbstractTestTools.createFile(helper.getSourceFolder(), "jack.invalidsource", "A.java", "package jack.invalidsource;\n"
+        + "public class A { private void n(int a) {re;} } \n");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    ByteArrayOutputStream out = new ByteArrayOutputStream();
+    ByteArrayOutputStream errOut = new ByteArrayOutputStream();
+    toolchain.setOutputStream(out);
+    toolchain.setErrorStream(errOut);
+
+    try {
+      compile(toolchain, helper);
+      Assert.fail();
+    } catch (FrontendCompilationException ex) {
+      // Failure is ok since source does not compile.
+    } finally {
+      Assert.assertEquals("", out.toString());
+      Assert.assertTrue(errOut.toString().contains(
+          "Syntax error, insert \"VariableDeclarators\" to complete LocalVariableDeclaration"));
+    }
+  }
+
+  private void compile(@Nonnull IToolchain toolchain, @Nonnull ErrorTestHelper helper)
+      throws Exception {
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        helper.getOutputDexFolder(),
+        /* zipFile = */ false, helper.getSourceFolder());
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest001.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest001.java
new file mode 100644
index 00000000..3a0a93b9
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest001.java
@@ -0,0 +1,571 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest001 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Checks that compilation failed due to deletion of B.
+   * Compilation must recompile A and failed since B does not longer exists.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(AbstractTestTools.createTempDir());
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A extends B {} \n");
+
+    File f = ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B {} \n");
+
+    ite.incrementalBuildFromFolder();
+
+    ite.deleteJavaFile(f);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+    }
+  }
+
+  /**
+   * Checks that compilation failed due to deletion of I.
+   * Compilation must recompile A and failed since I does not longer exists.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A implements I {} \n");
+
+    File f = ite.addJavaFile("jack.incremental", "I.java",
+        "package jack.incremental; \n"+
+        "public interface I {} \n");
+
+    ite.incrementalBuildFromFolder();
+
+    ite.deleteJavaFile(f);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+    }
+  }
+
+  /**
+   * Check that only type A is recompiled since it was modified (extends of B removed).
+   */
+  @Test
+  public void testDependency003() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(AbstractTestTools.createTempDir());
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A extends B {} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B {} \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A {} \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(1, fqnOfRebuiltTypes.size());
+    Assert.assertEquals("jack.incremental.A", fqnOfRebuiltTypes.get(0));
+  }
+
+  /**
+   * Check that no types are recompiled between two incremental build without modification.
+   */
+  @Test
+  public void testDependency004() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_004"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A extends B {} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B {} \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(0, fqnOfRebuiltTypes.size());
+  }
+
+  /**
+   * Check that B and C are recompiled since C is modified.
+   * B must also be recompiled since it used C.
+   */
+  @Test
+  public void testDependency005() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_005"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A {} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public void m(C c) {} } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C {} \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C { public void m() {} } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+  }
+
+  /**
+   * Check that B and C are recompiled since C is modified.
+   * B must also be recompiled since it used C.
+   */
+  @Test
+  public void testDependency006() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_006"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A {} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public void m() {C c = new C();} } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C {} \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C { public void m() {} } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+  }
+
+  /**
+   * Check that A, B and C are recompiled since C is modified.
+   * A, B must be recompiled since they are sub-type of C.
+   */
+  @Test
+  public void testDependency007() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_007"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A extends B {} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B extends C {} \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C {} \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C { public void m() {} } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(3, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+  }
+
+  /**
+   * Check that compilation of A failed due to a modification into B.
+   */
+  @Test
+  public void testDependency008() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_008"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public void test() {new B().m();}} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public void m(){} } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public void m(int i){} } \n");
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+    }
+  }
+
+  /**
+   * Check that A and B are recompiled.
+   * A must be recompiled since it used a field of B.
+   */
+  @Test
+  public void testDependency009() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_009"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public int getCst() {return B.i;} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static int i; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static int i; public static int j; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+  }
+
+  /**
+   * Check that A and B are recompiled.
+   * A must be recompiled since it used a method of B.
+   */
+  @Test
+  public void testDependency010() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_010"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public void callTest() {B.test();} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static void test(){} } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static void test() {}  public static void test1() {} } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+  }
+
+  /**
+   * Check that A is recompiled and that compilation failed since B does not longer exists.
+   */
+  @Test
+  public void testDependency011() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_011"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public boolean callTest(Object o) { return o instanceof B;} } \n");
+
+    File f = ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B {} \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.deleteJavaFile(f);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+    }
+  }
+
+  /**
+   * Check that A and B are recompiled.
+   * A must be recompiled since it used a constant from B.
+   */
+  @Test
+  public void testDependency012() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_012"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public int getCst() {return B.i;} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static final int i = 10; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static final int i = 12; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+  }
+
+  /**
+   * Check that A and B are recompiled.
+   * A must be recompiled since it used a constant from B.
+   */
+  @Test
+  public void testDependency013() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_013"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public int getCst() {return B.i1 + B.i2;} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static final int i1 = 10; public static final int i2 = 20; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static final int i1 = 20; public static final int i2 = 20; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+  }
+
+  /**
+   * Check that A and B are recompiled.
+   * A must be recompiled since it used a constant from B.
+   */
+  @Test
+  public void testDependency014() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_014"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { public int getCst() {return B.b + C.c;} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static final int b = 10; } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C { public static final int c = 10; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C { public static final int c = 20; } \n");
+
+    ite.incrementalBuildFromFolder();
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public static final int b = 20; } \n");
+
+    ite.incrementalBuildFromFolder();
+    fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+  }
+
+  /**
+   * Check that second and third compilation failed since I was modified but not B for the second
+   * compilation and not A for the third. Check that fourth compilation rebuilt A, B, I since I and
+   * B was modified.
+   */
+  @Test
+  public void testDependency015() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_015"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A extends B { @Override public void m() {} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B implements I { @Override public void m() {}  } \n");
+
+    ite.addJavaFile("jack.incremental", "I.java",
+        "package jack.incremental; \n"+
+        "public interface I { public void m(); } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "I.java",
+        "package jack.incremental; \n"+
+        "public interface I { public void m(int i); } \n");
+
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+    ite.setErr(err);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+      Assert.assertTrue(
+          err.toString().contains("The type B must implement the inherited abstract method I.m(int)"));
+      Assert.assertTrue(
+          err.toString().contains("The method m() of type B must override or implement a supertype method"));
+    }
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B implements I { @Override public void m(int i) {}  } \n");
+
+    err = new ByteArrayOutputStream();
+    ite.setErr(err);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+      Assert.assertTrue(err.toString()
+          .contains("The method m() of type A must override or implement a supertype method"));
+    }
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A extends B { @Override public void m(int i) {}  } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(3, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.I"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest002.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest002.java
new file mode 100644
index 00000000..fcded878
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest002.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest002 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that adding a more precise method is well detected.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B extends A { public void call(E e) { System.out.println(\"E\"); } } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { public static void main(String[] args) {new B().call(new D()); } } \n");
+
+    ite.addJavaFile("jack.incremental", "D.java",
+        "package jack.incremental; \n"+
+        "public class D extends E  { } \n");
+
+    ite.addJavaFile("jack.incremental", "E.java",
+        "package jack.incremental; \n"+
+        "public class E  { } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public void call(D d) { System.out.println(\"D\"); } } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(3, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimenal/incremental/DependenciesTests005.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest003.java
index 6b50799f..457cd49f 100644
--- a/jack-tests/tests/com/android/jack/experimenal/incremental/DependenciesTests005.java
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest003.java
@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package com.android.jack.experimenal.incremental;
+package com.android.jack.experimental.incremental;
 
 import com.android.jack.Main;
+import com.android.jack.TestTools;
 import com.android.jack.test.helper.IncrementalTestHelper;
-import com.android.jack.test.toolchain.AbstractTestTools;
 
 import junit.framework.Assert;
 
@@ -30,7 +30,7 @@ import java.util.List;
 /**
  * JUnit test checking dependencies between Java files.
  */
-public class DependenciesTests005 {
+public class DependenciesTest003 {
 
   @BeforeClass
   public static void setUpClass() {
@@ -38,33 +38,36 @@ public class DependenciesTests005 {
   }
 
   /**
-   * Check that runtime is correct after incremental compilation due to a constant modification.
+   * Check that file modification implying to transform an interface call to a virtual call is well
+   * detected.
    */
   @Test
   public void testDependency001() throws Exception {
     IncrementalTestHelper ite =
-        new IncrementalTestHelper(AbstractTestTools.createTempDir());
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
 
     ite.addJavaFile("jack.incremental", "A.java",
         "package jack.incremental; \n"+
-        "public class A  { public static void main(String[] args) {" +
-        "System.out.print(C.str + B.str);} " +
-        "} \n");
+        "public class A  { public void test(B b) {b.call1().call2();} } \n");
 
     ite.addJavaFile("jack.incremental", "B.java",
         "package jack.incremental; \n"+
-        "public class B  { public static final String str = \"HELLO\"; } \n");
+        "public class B { public I call1() {return new C();} } \n");
 
     ite.addJavaFile("jack.incremental", "C.java",
         "package jack.incremental; \n"+
-        "public class C  { public static final String str = \"STRING:\"; } \n");
+        "public class C  implements I { @Override public void call2() { } } \n");
+
+    ite.addJavaFile("jack.incremental", "I.java",
+        "package jack.incremental; \n"+
+        "public interface I {  public void call2(); } \n");
 
     ite.incrementalBuildFromFolder();
     ite.snapshotJackFilesModificationDate();
 
     ite.addJavaFile("jack.incremental", "B.java",
         "package jack.incremental; \n"+
-        "public class B  { public static final String str = \"INCREMENTAL\"; } \n");
+        "public class B { public C call1() {return new C();} } \n");
 
     ite.incrementalBuildFromFolder();
 
@@ -72,9 +75,5 @@ public class DependenciesTests005 {
     Assert.assertEquals(2, fqnOfRebuiltTypes.size());
     Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
     Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
-
-     Assert.assertEquals("STRING:INCREMENTAL", ite.run("jack.incremental.A"));
   }
-
-
 }
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest004.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest004.java
new file mode 100644
index 00000000..2d3a962a
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest004.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest004 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that changing a class into an interface is well detected.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public void test(B b) {b.call1();} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public void call1() {} } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public interface B { public void call1(); } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest005.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest005.java
new file mode 100644
index 00000000..fffd2da3
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest005.java
@@ -0,0 +1,229 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+@Ignore("Tree")
+public class DependenciesTest005 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that runtime is correct after incremental compilation due to a constant modification.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public static void main(String[] args) {" +
+        "System.out.print(C.str + B.str);} " +
+        "} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B  { public static final String str = \"HELLO\"; } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { public static final String str = \"STRING:\"; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B  { public static final String str = \"INCREMENTAL\"; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+
+    Assert.assertEquals("STRING:INCREMENTAL", ite.run("jack.incremental.A"));
+  }
+
+
+  /**
+   * Check that runtime is correct after incremental compilation due to a constant modification.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public static void main(String[] args) {" +
+        "System.out.print(B.str);} " +
+        "} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B  { public static final String str = \"HELLO\" + C.str; } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { public static final String str = \" WORLD\"; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { public static final String str = \" EVERYBODY\"; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(3, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+
+    Assert.assertEquals("HELLO EVERYBODY", ite.run("jack.incremental.A"));
+  }
+
+  /**
+   * Check that runtime is correct after incremental compilation due to a constant modification.
+   */
+  @Test
+  public void testDependency003() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_003"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A { " +
+        "   public static final String A = \"A\";" +
+        "   public static final String AB = \"A\" + B.B;"+
+        "   public static void main(String[] args) { System.out.print(B.BA); } } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { \n" +
+        "   public static final String B = \"B\"; \n" +
+        "   public static final String BA = \"B\" + A.A; }");
+
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    Assert.assertEquals("BA", ite.run("jack.incremental.A"));
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { \n" +
+        "   public static final String B = \"B\"; \n" +
+        "   public static final String BA = \"B\" + A.AB; }");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+
+    Assert.assertEquals("BAB", ite.run("jack.incremental.A"));
+  }
+
+  /**
+   * Check that runtime is correct after incremental compilation due to a constant modification.
+   */
+  @Test
+  public void testDependency004() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_004"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public static void main(String[] args) {" +
+        "System.out.print(B.str);} " +
+        "} \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B  { public static final String str = D.str + C.str; } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { public static final String str = \"WORLD\" + E.str; } \n");
+
+    ite.addJavaFile("jack.incremental", "D.java",
+        "package jack.incremental; \n"+
+        "public class D  { public static final String str = \"HELLO\" + E.str; } \n");
+
+    ite.addJavaFile("jack.incremental", "E.java",
+        "package jack.incremental; \n"+
+        "public class E  { public static final String str = \"/\"; } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { public static final String str = \"EVERYBODY\"; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(3, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+
+    Assert.assertEquals("HELLO/EVERYBODY", ite.run("jack.incremental.A"));
+
+    ite.snapshotJackFilesModificationDate();
+
+    ite.addJavaFile("jack.incremental", "E.java",
+        "package jack.incremental; \n"+
+        "public class E  { public static final String str = \" \"; } \n");
+
+    ite.incrementalBuildFromFolder();
+
+    fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(4, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.D"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.E"));
+
+    Assert.assertEquals("HELLO EVERYBODY", ite.run("jack.incremental.A"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest006.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest006.java
new file mode 100644
index 00000000..a27b2394
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest006.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+@Ignore("Tree")
+public class DependenciesTest006 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that runtime is correct after class renaming.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public static void main(String[] args) {" +
+        "System.out.print(new B().getString());} " +
+        "} \n");
+
+    File f = ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B  { public String getString() { return (\"B\"); } } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  { } \n");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+
+    ite.deleteJavaFile(f);
+    ite.addJavaFile("jack.incremental", "_B.java",
+        "package jack.incremental; \n"+
+        "public class _B  { public String getString() { return (\"_B\"); } } \n");
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e)  {
+      // Error is ok
+    }
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public static void main(String[] args) {" +
+        "System.out.print(new _B().getString());} " +
+        "} \n");
+
+    ite.incrementalBuildFromFolder();
+
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental._B"));
+
+    Assert.assertEquals("_B", ite.run("jack.incremental.A"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest007.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest007.java
new file mode 100644
index 00000000..329a3e3f
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest007.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+@Ignore("Tree")
+public class DependenciesTest007 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that runtime is correct after transformation of an interface call to a virtual call.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n"+
+        "public class A  { public static void main(String[] args) { new B().call1().call2();} } \n");
+
+    ite.addJavaFile("jack.incremental", "B.java",
+        "package jack.incremental; \n"+
+        "public class B { public I call1() {return new C();} } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n"+
+        "public class C  implements I { @Override public void call2(){System.out.print(\"C\");}\n"+
+         "} \n");
+
+    ite.addJavaFile("jack.incremental", "I.java",
+        "package jack.incremental; \n"+
+        "public interface I {  public void call2(); } \n");
+
+
+      ite.incrementalBuildFromFolder();
+      ite.snapshotJackFilesModificationDate();
+
+      ite.addJavaFile("jack.incremental", "B.java",
+          "package jack.incremental; \n"+
+          "public class B { public C call1() {return new C();} } \n");
+
+      ite.incrementalBuildFromFolder();
+
+      List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+      Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+      Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+      Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+
+      Assert.assertEquals("C", ite.run("jack.incremental.A"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest008.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest008.java
new file mode 100644
index 00000000..2ad9b836
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest008.java
@@ -0,0 +1,126 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest008 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that jack files are deleted according to recompiled files.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n" +
+        "public class A { \n" +
+        " public static class B { public void m() {} } \n" +
+        " public static void main(String[] args) {new B().m();} } \n");
+
+      ite.incrementalBuildFromFolder();
+      Assert.assertEquals(2, ite.getJackFiles().size());
+
+      ite.addJavaFile("jack.incremental", "A.java",
+          "package jack.incremental; \n" +
+          "public class A { \n" +
+          " public static void main(String[] args) {new B().m();} } \n");
+
+      try {
+        ite.incrementalBuildFromFolder();
+        Assert.fail();
+      } catch (FrontendCompilationException e)  {
+        // Error is ok
+        Assert.assertEquals(0, ite.getJackFiles().size());
+      }
+  }
+
+  /**
+   * Check that jack files are deleted according to recompiled files.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n" +
+        "public class A { } \n" +
+        "class B { } \n");
+
+      ite.incrementalBuildFromFolder();
+      Assert.assertEquals(2, ite.getJackFiles().size());
+
+      ite.addJavaFile("jack.incremental", "A.java",
+          "package jack.incremental; \n" +
+          "public class A { }\n");
+
+      ite.incrementalBuildFromFolder();
+      Assert.assertEquals(1, ite.getJackFiles().size());
+  }
+
+  /**
+   * Check that jack files are deleted according to recompiled files.
+   */
+  @Test
+  public void testDependency003() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_003"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \n" +
+        "public class A { } \n" +
+        "class B { } \n");
+
+    ite.addJavaFile("jack.incremental", "C.java",
+        "package jack.incremental; \n" +
+        "public class C { public void test() {new B();} } \n");
+
+      ite.incrementalBuildFromFolder();
+      Assert.assertEquals(3, ite.getJackFiles().size());
+
+      ite.addJavaFile("jack.incremental", "A.java",
+          "package jack.incremental; \n" +
+          "public class A { }\n");
+
+      try {
+        ite.incrementalBuildFromFolder();
+        Assert.fail();
+      } catch (FrontendCompilationException e)  {
+        // Error is ok
+        Assert.assertEquals(0, ite.getJackFiles().size());
+      }
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest009.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest009.java
new file mode 100644
index 00000000..a09a1c09
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest009.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.experimental.incremental.CompilerState;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest009 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that usages does not change during incremental compilation and that dependencies are
+   * identical.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A extends B { }");
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B extends C { }");
+
+    ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { }");
+
+    ite.incrementalBuildFromFolder();
+
+    CompilerState csm = new CompilerState(ite.getCompilerStateFolder());
+    csm.read();
+    Map<String, Set<String>> dependencies1 = csm.computeDependencies();
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A extends B { public int field;}");
+
+    ite.incrementalBuildFromFolder();
+
+    csm.read();
+    Map<String, Set<String>> dependencies2 = csm.computeDependencies();
+
+    assert dependencies1.equals(dependencies2);
+    Assert.assertEquals(dependencies1, dependencies2);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest010.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest010.java
new file mode 100644
index 00000000..d5051bfb
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest010.java
@@ -0,0 +1,185 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+@Ignore("Tree")
+public class DependenciesTest010 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that incremental compilation support switch on constant value.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { "
+        + "public static void main(String[] args) {"
+        + "     System.out.print(new A().test(2));"
+        + "   }"
+        + "   public int test(int value) {"
+        + "       switch(value) {"
+        + "         case B.val1: return 1;"
+        + "         case B.val2: return 2;"
+        + "         case B.val3: return 3;"
+        + "      }"
+        + "    return 0;"
+        + " } }");
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "    public static final int val1 = 1;"
+        + "    public static final int val2 = 2;"
+        + "    public static final int val3 = val2 + C.val4;"
+        + "}");
+
+    ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n"
+        + "    public static final int val4 = 1;"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals("2", ite.run("jack.incremental.A"));
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "    public static final int val1 =11;"
+        + "    public static final int val2 =12;"
+        + "    public static final int val3 =13;"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertEquals("0", ite.run("jack.incremental.A"));
+
+    ite.snapshotJackFilesModificationDate();
+    ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n"
+        + "    public static final int val4 = 0;"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(1, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.C"));
+    Assert.assertEquals("0", ite.run("jack.incremental.A"));
+
+    ite.snapshotJackFilesModificationDate();
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { "
+        + "public static void main(String[] args) {"
+        + "     System.out.print(new A().test(12));"
+        + "   }"
+        + "   public int test(int value) {"
+        + "       switch(value) {"
+        + "         case B.val1: return 1;"
+        + "         case B.val2: return 2;"
+        + "         case B.val3: return 3;"
+        + "      }"
+        + "    return 0;"
+        + " } }");
+
+    ite.incrementalBuildFromFolder();
+    fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(1, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertEquals("2", ite.run("jack.incremental.A"));
+  }
+
+
+  /**
+   * Check that incremental compilation support switch on enum.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_002"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "import jack.incremental.B;"
+        + "public class A { "
+        + "public static void main(String[] args) {"
+        + "     System.out.print(new A().test(B.VAL1));"
+        + "   }"
+        + "   public int test(B b) {"
+        + "       switch(b) {"
+        + "         case VAL1: return 1;"
+        + "         case VAL2: return C.val4;"
+        + "         case VAL3: return 3;"
+        + "      }"
+        + "    return 0;"
+        + " } }");
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public enum B { \n"
+        + "    VAL1,"
+        + "    VAL2,"
+        + "    VAL3"
+        + "}");
+
+    ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n"
+        + "    public static final int val4 =2;"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals("1", ite.run("jack.incremental.A"));
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public enum B { \n"
+        + "    VAL1,"
+        + "    VAL2,"
+        + "    VAL3,"
+        + "    VAL4"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(2, fqnOfRebuiltTypes.size());
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.A"));
+    Assert.assertTrue(fqnOfRebuiltTypes.contains("jack.incremental.B"));
+    Assert.assertEquals("1", ite.run("jack.incremental.A"));
+  }
+
+}
+
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest011.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest011.java
new file mode 100644
index 00000000..fb05a072
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest011.java
@@ -0,0 +1,82 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.List;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest011 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that incremental compilation support throws declaration.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    File f = ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A extends Exception { "
+        + "}");
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "    public void m() throws A { }"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(2, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(f);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Ok
+    }
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "    public void m() { }"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    List<String> fqnOfRebuiltTypes = ite.getFQNOfRebuiltTypes();
+    Assert.assertEquals(1, fqnOfRebuiltTypes.size());
+  }
+}
+
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest012.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest012.java
new file mode 100644
index 00000000..db6d6a3b
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest012.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest012 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that incremental compilation support class literal usages.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n"
+        + "public Class getClazz() { "
+        + "   return B.class; "
+        + "} "
+        + "}");
+
+    File f = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(2, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(f);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Ok
+    }
+  }
+}
+
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest013.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest013.java
new file mode 100644
index 00000000..de6116e9
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest013.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+
+/**
+ * JUnit test checking dependencies between Java files.
+ */
+public class DependenciesTest013 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that incremental compilation support array creation.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n"
+        + "public int getLength() { "
+        + "   return new B[1].length; "
+        + "} "
+        + "}");
+
+    File f = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(2, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(f);
+
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+    ite.setErr(err);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Ok
+    } finally {
+      Assert.assertTrue(err.toString().contains("B cannot be resolved to a type"));
+    }
+  }
+
+  /**
+   * Check that incremental compilation support array usages.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n"
+        + "public int getLength() { "
+        + "   return B.array.length; "
+        + "} "
+        + "}");
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "public static C []array; \n"
+        + "}");
+
+    File f = ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(3, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(f);
+
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+    ite.setErr(err);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Ok
+    } finally {
+      Assert.assertTrue(err.toString().contains("C cannot be resolved to a type"));
+    }
+  }
+
+  /**
+   * Check that incremental compilation support array usages.
+   */
+  @Test
+  public void testDependency003() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n"
+        + "public int getLength() { "
+        + "   return B.array.length; "
+        + "} "
+        + "}");
+
+    ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n"
+        + "public static C [][]array; \n"
+        + "}");
+
+    File f = ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n"
+        + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(3, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(f);
+
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+    ite.setErr(err);
+
+    try {
+      ite.incrementalBuildFromFolder();
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      // Ok
+    } finally {
+      Assert.assertTrue(err.toString().contains("C cannot be resolved to a type"));
+    }
+  }
+}
+
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest014.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest014.java
new file mode 100644
index 00000000..8f768f08
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest014.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.dx.io.DexBuffer;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileInputStream;
+
+/**
+ * JUnit test checking incremental support when files are deleted.
+ */
+public class DependenciesTest014 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that incremental compilation works when file without dependency is deleted.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n" + "}");
+
+    File f = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n" + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(2, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(f);
+    ite.incrementalBuildFromFolder();
+    DexBuffer db = new DexBuffer(new FileInputStream(ite.getDexFile()));
+    for (String typeName : db.typeNames()) {
+      if (typeName.equals("Ljack/incremental/B;")) {
+        Assert.fail();
+      }
+    }
+  }
+
+  /**
+   * Check that incremental compilation works when dependency file is deleted.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper ite =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n" + "}");
+
+    File fB = ite.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B extends C { \n" + "}");
+
+    File fC = ite.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n" + "}");
+
+    ite.incrementalBuildFromFolder();
+    ite.snapshotJackFilesModificationDate();
+    Assert.assertEquals(3, ite.getJackFiles().size());
+
+    ite.deleteJavaFile(fB);
+    ite.deleteJavaFile(fC);
+    ite.incrementalBuildFromFolder();
+    DexBuffer db = new DexBuffer(new FileInputStream(ite.getDexFile()));
+    for (String typeName : db.typeNames()) {
+      if (typeName.equals("Ljack/incremental/B;") ||
+          typeName.equals("Ljack/incremental/C;")) {
+        Assert.fail();
+      }
+    }
+  }
+}
+
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest015.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest015.java
new file mode 100644
index 00000000..d6f0ae20
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest015.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.experimental.incremental;
+
+import com.android.jack.Main;
+import com.android.jack.TestTools;
+import com.android.jack.dx.io.DexBuffer;
+import com.android.jack.frontend.FrontendCompilationException;
+import com.android.jack.test.helper.IncrementalTestHelper;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * JUnit test checking incremental support.
+ */
+public class DependenciesTest015 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Check that incremental compilation works when library on classpath is modified.
+   */
+  @Test
+  public void testDependency001() throws Exception {
+    IncrementalTestHelper iteLib =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_lib"));
+
+    File f = iteLib.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public abstract class A { \n" + "public abstract void m(); }");
+
+    iteLib.incrementalBuildFromFolder();
+    iteLib.snapshotJackFilesModificationDate();
+    List<File> jackFilesLib = iteLib.getJackFiles();
+    Assert.assertEquals(1, jackFilesLib.size());
+
+
+    IncrementalTestHelper iteProg =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_prog"));
+
+    iteProg.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B extends A { \n" + " @Override public void m(){} }");
+
+    iteProg.incrementalBuildFromFolder(new File[]{iteLib.getJackFolder()});
+    iteProg.snapshotJackFilesModificationDate();
+    Assert.assertEquals(1, iteProg.getJackFiles().size());
+
+    iteLib.deleteJavaFile(f);
+    iteLib.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public abstract class A { \n" + "public abstract int m(); }");
+    iteLib.incrementalBuildFromFolder();
+    iteLib.snapshotJackFilesModificationDate();
+    jackFilesLib = iteLib.getJackFiles();
+    Assert.assertEquals(1, jackFilesLib.size());
+
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+    iteProg.setErr(err);
+    try {
+      iteProg.incrementalBuildFromFolder(new File[] {iteLib.getJackFolder()});
+      Assert.fail();
+    } catch (FrontendCompilationException e) {
+      Assert.assertTrue(err.toString().contains(
+          "The return type is incompatible with A.m()"));
+    }
+  }
+
+  /**
+   * Check that incremental compilation works when library on import options is modified.
+   */
+  @Test
+  public void testDependency002() throws Exception {
+    IncrementalTestHelper iteLib =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_lib"));
+
+    iteLib.addJavaFile("jack.incremental", "A.java", "package jack.incremental; \n"
+        + "public class A { \n" + "public void m() {} }");
+
+    iteLib.incrementalBuildFromFolder();
+    iteLib.snapshotJackFilesModificationDate();
+    List<File> jackFilesLib = iteLib.getJackFiles();
+    Assert.assertEquals(1, jackFilesLib.size());
+
+
+    IncrementalTestHelper iteProg =
+        new IncrementalTestHelper(TestTools.createTempDir("DependenciesTest_", "_001_prog"));
+
+    iteProg.addJavaFile("jack.incremental", "B.java", "package jack.incremental; \n"
+        + "public class B { \n" + " public void m(){} }");
+
+    iteProg.incrementalBuildFromFolder(null /*classpath*/, Arrays.asList(iteLib.getJackFolder()));
+    iteProg.snapshotJackFilesModificationDate();
+    Assert.assertEquals(2, iteProg.getJackFiles().size());
+
+    DexBuffer db = new DexBuffer(new FileInputStream(iteProg.getDexFile()));
+    Assert.assertTrue(db.typeNames().contains("Ljack/incremental/A;"));
+    Assert.assertTrue(db.typeNames().contains("Ljack/incremental/B;"));
+
+    iteLib.addJavaFile("jack.incremental", "C.java", "package jack.incremental; \n"
+        + "public class C { \n" + "public void m() {} }");
+    iteLib.incrementalBuildFromFolder();
+    iteLib.snapshotJackFilesModificationDate();
+    jackFilesLib = iteLib.getJackFiles();
+    Assert.assertEquals(2, jackFilesLib.size());
+
+
+    iteProg.incrementalBuildFromFolder(null, Arrays.asList(iteLib.getJackFolder()));
+    iteProg.snapshotJackFilesModificationDate();
+    Assert.assertEquals(3, iteProg.getJackFiles().size());
+
+    db = new DexBuffer(new FileInputStream(iteProg.getDexFile()));
+    Assert.assertTrue(db.typeNames().contains("Ljack/incremental/A;"));
+    Assert.assertTrue(db.typeNames().contains("Ljack/incremental/B;"));
+    Assert.assertTrue(db.typeNames().contains("Ljack/incremental/C;"));
+  }
+}
+
diff --git a/jack-tests/tests/com/android/jack/experimental/incremental/DependencyAllTests.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependencyAllTests.java
new file mode 100644
index 00000000..e8b42a86
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependencyAllTests.java
@@ -0,0 +1,15 @@
+package com.android.jack.experimental.incremental;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses(value = {DependenciesTest001.class, DependenciesTest002.class,
+    DependenciesTest003.class, DependenciesTest004.class, DependenciesTest005.class,
+    DependenciesTest006.class, DependenciesTest007.class, DependenciesTest008.class,
+    DependenciesTest009.class, DependenciesTest010.class, DependenciesTest011.class,
+    DependenciesTest012.class, DependenciesTest013.class, DependenciesTest014.class,
+    DependenciesTest015.class})
+public class DependencyAllTests {
+}
\ No newline at end of file
diff --git a/jack-tests/tests/com/android/jack/external/ExternalTests.java b/jack-tests/tests/com/android/jack/external/ExternalTests.java
new file mode 100644
index 00000000..99838282
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/external/ExternalTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.external;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ExternalTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.external.test001"),
+    "com.android.jack.external.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ExternalTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/fibonacci/FibonacciTests.java b/jack-tests/tests/com/android/jack/fibonacci/FibonacciTests.java
new file mode 100644
index 00000000..cfbe2f96
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/fibonacci/FibonacciTests.java
@@ -0,0 +1,68 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.fibonacci;
+
+import com.android.jack.TestTools;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.comparator.ComparatorDex;
+import com.android.jack.test.helper.CheckDexStructureTestHelper;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+public class FibonacciTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001"),
+    "com.android.jack.fibonacci.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    FibonacciTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  /**
+   * Compiles FibonacciThreeAddress into a {@code DexFile} and compares it to a dex file created
+   * using a reference compiler and {@code dx}.
+   * @throws Exception
+   */
+  @Test
+  public void testCompareFiboDexFile() throws Exception {
+    SourceToDexComparisonTestHelper helper =
+        new CheckDexStructureTestHelper(new File(TEST001.directory, "jack"));
+    helper.runTest(new ComparatorDex(helper.getCandidateDex(), helper.getReferenceDex()));
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/fibonacci/dx/Tests.java b/jack-tests/tests/com/android/jack/fibonacci/test001/dx/Tests.java
index 4bdf6f7b..a88c9cee 100644
--- a/jack-tests/tests/com/android/jack/fibonacci/dx/Tests.java
+++ b/jack-tests/tests/com/android/jack/fibonacci/test001/dx/Tests.java
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package com.android.jack.fibonacci.dx;
+package com.android.jack.fibonacci.test001.dx;
 
-import com.android.jack.fibonacci.jack.FibonacciThreeAddress;
+import com.android.jack.fibonacci.test001.jack.FibonacciThreeAddress;
 
 import junit.framework.Assert;
 
diff --git a/jack-tests/tests/com/android/jack/fibonacci/jack/Fibo.java b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/Fibo.java
index fdaf4be3..cb99b627 100644
--- a/jack-tests/tests/com/android/jack/fibonacci/jack/Fibo.java
+++ b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/Fibo.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.fibonacci.jack;
+package com.android.jack.fibonacci.test001.jack;
 
 /**
  * Fibonacci test.
diff --git a/jack-tests/tests/com/android/jack/fibonacci/jack/FibonacciThreeAddress.java b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/FibonacciThreeAddress.java
index 099cbf12..9cf4927b 100644
--- a/jack-tests/tests/com/android/jack/fibonacci/jack/FibonacciThreeAddress.java
+++ b/jack-tests/tests/com/android/jack/fibonacci/test001/jack/FibonacciThreeAddress.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.fibonacci.jack;
+package com.android.jack.fibonacci.test001.jack;
 
 /**
  * Fibonacci test in three-address style.
diff --git a/jack-tests/tests/com/android/jack/field/FieldTests.java b/jack-tests/tests/com/android/jack/field/FieldTests.java
new file mode 100644
index 00000000..87f20450
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/field/FieldTests.java
@@ -0,0 +1,176 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.field;
+
+import com.android.jack.TestTools;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.comparator.ComparatorDex;
+import com.android.jack.test.helper.CheckDexStructureTestHelper;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import javax.annotation.Nonnull;
+
+public class FieldTests extends RuntimeTest {
+
+  private RuntimeTestInfo INSTANCE001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.instance001"),
+    "com.android.jack.field.instance001.dx.Tests");
+
+  private RuntimeTestInfo INSTANCE002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.instance002"),
+    "com.android.jack.field.instance002.dx.Tests");
+
+  private RuntimeTestInfo INSTANCE003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.instance003"),
+    "com.android.jack.field.instance003.dx.Tests");
+
+  private RuntimeTestInfo INSTANCE004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.instance004"),
+    "com.android.jack.field.instance004.dx.Tests");
+
+  private RuntimeTestInfo STATIC001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.static001"),
+    "com.android.jack.field.static001.dx.Tests");
+
+  private RuntimeTestInfo STATIC002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.static002"),
+    "com.android.jack.field.static002.dx.Tests");
+
+  private RuntimeTestInfo STATIC004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.static004"),
+    "com.android.jack.field.static004.dx.Tests");
+
+  private RuntimeTestInfo STATIC005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.field.static005"),
+    "com.android.jack.field.static005.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    FieldTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void instance001() throws Exception {
+    new RuntimeTestHelper(INSTANCE001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void instance002() throws Exception {
+    new RuntimeTestHelper(INSTANCE002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void instance003() throws Exception {
+    new RuntimeTestHelper(INSTANCE003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void instance004() throws Exception {
+    new RuntimeTestHelper(INSTANCE004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void static001() throws Exception {
+    new RuntimeTestHelper(STATIC001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void static002() throws Exception {
+    new RuntimeTestHelper(STATIC002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void static004() throws Exception {
+    new RuntimeTestHelper(STATIC004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void static005() throws Exception {
+    new RuntimeTestHelper(STATIC005).compileAndRunTest();
+  }
+
+  @Test
+  public void testCompileInstance6() throws Exception {
+    compileTest("instance005");
+  }
+
+  @Test
+  public void testCompileStatic() throws Exception {
+    compileTest("static003");
+  }
+
+  /**
+   * Compiles StaticField.java into a {@code DexFile} and compares it to a dex file created
+   * using a reference compiler and {@code dx}.
+   */
+  @Test
+  public void testStatic() throws Exception {
+    checkStructure("static003");
+  }
+
+  /**
+   * Compiles InstanceField.java into a {@code DexFile} and compares it to a dex file created
+   * using a reference compiler and {@code dx}.
+   */
+  @Test
+  public void testInstance() throws Exception {
+    checkStructure("instance005");
+  }
+
+  private void compileTest(@Nonnull String test) throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.field." + test + ".jack"));
+  }
+
+  private void checkStructure(@Nonnull String test) throws Exception {
+    SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper(
+        AbstractTestTools.getTestRootDir("com.android.jack.field." + test + ".jack"));
+    helper.runTest(new ComparatorDex(helper.getCandidateDex(), helper.getReferenceDex()));
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(INSTANCE001);
+    rtTestInfos.add(INSTANCE002);
+    rtTestInfos.add(INSTANCE003);
+    rtTestInfos.add(INSTANCE004);
+    rtTestInfos.add(STATIC001);
+    rtTestInfos.add(STATIC002);
+    rtTestInfos.add(STATIC004);
+    rtTestInfos.add(STATIC005);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java b/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java
new file mode 100644
index 00000000..ccce9392
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/fileconflict/FileConflictTests.java
@@ -0,0 +1,607 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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.backend.jayce.ResourceImportConflictException;
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.library.FileType;
+import com.android.jack.library.JackLibrary;
+import com.android.jack.shrob.obfuscation.NameProviderFactory;
+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;
+
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+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;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nonnull;
+
+/**
+ * JUnit tests for resource support.
+ */
+public class FileConflictTests {
+
+  @Nonnull
+  private static final String COMMON_PATH_001 = "com/android/jack/fileconflict/test001/jack/";
+  @Nonnull
+  private static final String COMMON_PATH_002 = "com/android/jack/fileconflict/test002/jack/";
+  @Nonnull
+  private static final String JACK_FILE_PATH_1 =
+      FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_001 + "MyClass.jayce";
+  @Nonnull
+  private static final String JACK_FILE_PATH_2 =
+      FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_001 + "MyClass2.jayce";
+  @Nonnull
+  private static final String JACK_FILE_PATH_3 =
+      FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_001 + "MyClass3.jayce";
+  @Nonnull
+  private static final String DEX_FILE_PATH_1 =
+      FileType.DEX.getPrefix() + "/" + COMMON_PATH_001 + "MyClass.dex";
+  @Nonnull
+  private static final String DEX_FILE_PATH_2 =
+      FileType.DEX.getPrefix() + "/" + COMMON_PATH_001 + "MyClass2.dex";
+  @Nonnull
+  private static final String DEX_FILE_PATH_3 =
+      FileType.DEX.getPrefix() + "/" + COMMON_PATH_001 + "MyClass3.dex";
+  @Nonnull
+  private static final String JACK_FILE_PATH_002_1 =
+      FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_002 + "IrrelevantForTest.jayce";
+  @Nonnull
+  private static final String JACK_FILE_PATH_002_2 =
+      FileType.JAYCE.getPrefix() + "/" + COMMON_PATH_002 + "IrrelevantForTest2.jayce";
+  @Nonnull
+  private static final String RESOURCE1_SHORTPATH = "Resource1";
+  @Nonnull
+  private static final String RESOURCE2_SHORTPATH = "Resource2";
+  @Nonnull
+  private static final String RESOURCE3_SHORTPATH = "Resource3";
+  @Nonnull
+  private static final String RESOURCE1_LONGPATH = FileType.RSC.getPrefix() + "/"
+      + RESOURCE1_SHORTPATH;
+  @Nonnull
+  private static final String RESOURCE2_LONGPATH = FileType.RSC.getPrefix() + "/"
+      + RESOURCE2_SHORTPATH;
+  @Nonnull
+  private static final String RESOURCE3_LONGPATH = FileType.RSC.getPrefix() + "/"
+      + RESOURCE3_SHORTPATH;
+
+  @Nonnull
+  private static final File TEST001_DIR =
+      AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test001.jack");
+
+  @Nonnull
+  private static final File TEST002_DIR =
+      AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test002.jack");
+
+  @BeforeClass
+  public static void setUpClass() {
+    FileConflictTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting Jack files, and
+   * outputting to a Jack folder, with no collision policy specified.
+   * @throws Exception
+   */
+  @Test
+  public void test001a() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+    try {
+      runTest001(jackOutput, null);
+      Assert.fail();
+    } catch (ImportConflictException e) {
+    }
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting Jack files, and
+   * outputting to a Jack folder, with the collision policy set to "fail".
+   * @throws Exception
+   */
+  @Test
+  public void test001b() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+    try {
+      runTest001(jackOutput, "fail");
+      Assert.fail();
+    } catch (ImportConflictException e) {
+    }
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting Jack files, and
+   * outputting to a Jack folder, with the collision policy set to "keep-first".
+   * @throws Exception
+   */
+  @Test
+  public void test001c() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+    runTest001(jackOutput, "keep-first");
+    File myClass1 = new File(jackOutput, JACK_FILE_PATH_1);
+    File myClass2 = new File(jackOutput, JACK_FILE_PATH_2);
+    File myClass3 = new File(jackOutput, JACK_FILE_PATH_3);
+    Assert.assertTrue(myClass1.exists());
+    Assert.assertTrue(myClass2.exists());
+    Assert.assertTrue(myClass3.exists());
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and
+   * outputting to a Jack folder, with no collision policy specified.
+   * @throws Exception
+   */
+  @Test
+  public void test002a() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+    try {
+      runTest002(jackOutput, false /* non-zipped */, null);
+      Assert.fail();
+    } catch (ResourceImportConflictException e) {
+    }
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and
+   * outputting to a Jack folder, with the collision policy set to "fail".
+   * @throws Exception
+   */
+  @Test
+  public void test002b() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+    try {
+      runTest002(jackOutput, false /* non-zipped */, "fail");
+      Assert.fail();
+    } catch (ResourceImportConflictException e) {
+    }
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and
+   * outputting to a Jack folder, with the collision policy set to "keep-first".
+   * @throws Exception
+   */
+  @Test
+  public void test002c() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+    runTest002(jackOutput, false /* non-zipped */, "keep-first");
+    checkResourceContent(jackOutput, RESOURCE1_LONGPATH, "Res1");
+    checkResourceContent(jackOutput, RESOURCE2_LONGPATH, "Res2");
+    checkResourceContent(jackOutput, RESOURCE3_LONGPATH, "Res3");
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and
+   * outputting to a Jack zip, with no collision policy specified.
+   * @throws Exception
+   */
+  @Test
+  public void test002d() throws Exception {
+    File jackOutput = AbstractTestTools.createTempFile("jackoutput", ".zip");
+    try {
+      runTest002(jackOutput, true /* zipped */, null);
+      Assert.fail();
+    } catch (ResourceImportConflictException e) {
+    }
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and
+   * outputting to a Jack zip, with the collision policy set to "fail".
+   * @throws Exception
+   */
+  @Test
+  public void test002e() throws Exception {
+    File jackOutput = AbstractTestTools.createTempFile("jackoutput", ".zip");
+    try {
+      runTest002(jackOutput, true /* zipped */, "fail");
+      Assert.fail();
+    } catch (ResourceImportConflictException e) {
+    }
+  }
+
+  /**
+   * Test the behavior of Jack when importing 2 Jack folders containing conflicting resources, and
+   * outputting to a Jack zip, with the collision policy set to "keep-first".
+   * @throws Exception
+   */
+  @Test
+  public void test002f() throws Exception {
+    File jackOutput = AbstractTestTools.createTempFile("jackoutput", ".zip");
+    runTest002(jackOutput, true /* zipped */, "keep-first");
+    ZipFile zipFile = new ZipFile(jackOutput);
+    checkResourceContent(zipFile, RESOURCE1_LONGPATH, "Res1");
+    checkResourceContent(zipFile, RESOURCE2_LONGPATH, "Res2");
+    checkResourceContent(zipFile, RESOURCE3_LONGPATH, "Res3");
+  }
+
+  /**
+   * Test the behavior of Jack when outputting a Jack file to a Jack folder where a Jack file of the
+   * same name already exists. We expect the previous file to be overridden.
+   * @throws Exception
+   */
+  @Test
+  public void test003a() throws Exception {
+    // compile source files to a Jack dir
+    File jackOutput = AbstractTestTools.createTempDir();
+    File testSrcDir = AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test003");
+    File tempJackFolder = AbstractTestTools.createTempDir();
+
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        testSrcDir);
+
+    // get paths for Jack files
+    String jackFilePath =
+        FileType.JAYCE.getPrefix() + "/com/android/jack/fileconflict/test003/jack/MyClass.jayce";
+    File myClass1 = new File(tempJackFolder, jackFilePath);
+
+    // get paths for Dex files
+    String dexFilePath =
+        FileType.DEX.getPrefix() + "/com/android/jack/fileconflict/test003/jack/MyClass.dex";
+    File myClass1Dex = new File(tempJackFolder, dexFilePath);
+
+    String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/');
+    File libProperties = new File(tempJackFolder, libPropName);
+
+    // create Jack dirs to import
+    File jackImport1 = AbstractTestTools.createTempDir();
+    copyFileToDir(libProperties, libPropName, jackImport1);
+    copyFileToDir(myClass1, jackFilePath, jackImport1);
+    copyFileToDir(myClass1Dex, dexFilePath, jackImport1);
+
+    // copy Jack file to output dir
+    copyFileToDir(myClass1, jackFilePath, jackOutput);
+    copyFileToDir(myClass1Dex, dexFilePath, jackOutput);
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.addProguardFlags(new File(testSrcDir, "proguard.flags"));
+    toolchain.libToLib(jackImport1, jackOutput, false);
+  }
+
+  /**
+   * Test the behavior of Jack when outputting a resource to a Jack folder where a file of the
+   * same name already exists. We expect the previous file to be overridden.
+   * @throws Exception
+   */
+  @Test
+  @Ignore("Now jack generate library, a previous file can not exists")
+  public void test003b() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+
+    // compile source files to a Jack dir
+    File testSrcDir = AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test003.jack");
+    File tempJackFolder = AbstractTestTools.createTempDir();
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        testSrcDir);
+
+    // get paths for Jack files
+    String jackFilePath =
+        FileType.JAYCE.getPrefix() + "/com/android/jack/fileconflict/test003/jack/MyClass.jayce";
+    File myClass1 = new File(tempJackFolder, jackFilePath);
+
+    String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/');
+    File libProperties = new File(tempJackFolder, libPropName);
+
+    // create Jack dirs to import
+    File jackImport1 = AbstractTestTools.createTempDir();
+    String resourcePath = "com/android/jack/fileconflict/test003/jack/Resource";
+    File resource = new File(testSrcDir, "Resource");
+    copyFileToDir(libProperties, libPropName, jackImport1);
+    copyFileToDir(myClass1, jackFilePath, jackImport1);
+    copyFileToDir(resource, resourcePath, jackImport1);
+
+    // copy a different resource to output dir with the same name
+    File resource2 = new File(testSrcDir, "Resource2");
+    copyFileToDir(resource2, resourcePath, jackOutput);
+
+    // run Jack on Jack dir
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.libToLib(jackImport1, jackOutput, /* zipFiles = */ false);
+
+    checkResourceContent(jackOutput, resourcePath, "Res1");
+
+  }
+
+  /**
+   * Test the behavior of Jack when renaming a Jack file along with the resource with a matching
+   * name, and when a resource with the same name (after renaming) already exists.
+   * @throws Exception
+   */
+  @Test
+  @Category(KnownBugs.class)
+  public void test004() throws Exception {
+    File jackOutput = AbstractTestTools.createTempDir();
+
+    // compile source files to a Jack dir
+    File testSrcDir = AbstractTestTools.getTestRootDir("com.android.jack.fileconflict.test004.jack");
+    File tempJackFolder = AbstractTestTools.createTempDir();
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        testSrcDir);
+
+    // get paths for Jack files
+    String jackFilePath =
+        FileType.JAYCE.getPrefix() + "/com/android/jack/fileconflict/test004/jack/MyClass.jayce";
+    File myClass1 = new File(tempJackFolder, jackFilePath);
+
+    String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/');
+    File libProperties = new File(tempJackFolder, libPropName);
+
+    // create Jack dirs to import
+    File jackImport1 = AbstractTestTools.createTempDir();
+    File resource = new File(testSrcDir, "MyClass.txt");
+    copyFileToDir(libProperties, libPropName, jackImport1);
+    copyFileToDir(myClass1, jackFilePath, jackImport1);
+    copyFileToDir(resource, "com/android/jack/fileconflict/test004/jack/MyClass.txt", jackImport1);
+    System.out.println(jackImport1.getAbsolutePath());
+
+    // copy a different resource to output dir with the same name
+    File resource2 = new File(testSrcDir, "a.txt");
+    copyFileToDir(resource2, "pcz/nbqfcvq/wnpx/svyrpcbsyvph/hrgh004/wnpx/ZmPyngg.txt", jackOutput);
+
+    // run Jack on Jack dir
+    toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.addProguardFlags(new File(testSrcDir, "proguard.flags"));
+    toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13");
+    toolchain.libToLib(jackImport1, jackOutput, /* zipFiles = */ false);
+
+    checkResourceContent(jackOutput, "pcz/nbqfcvq/wnpx/svyrpcbsyvph/hrgh004/wnpx/ZmPyngg.txt",
+        "MyClass");
+  }
+
+  private void runTest001(@Nonnull File jackOutput, @CheckForNull String collisionPolicy)
+      throws Exception {
+    // compile source files to a Jack dir
+    File tempJackFolder = AbstractTestTools.createTempDir();
+    JackApiToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFile = */ false,
+        TEST001_DIR);
+
+    // get paths for Jack files
+    File myClass1 = new File(tempJackFolder, JACK_FILE_PATH_1);
+    File myClass2 = new File(tempJackFolder, JACK_FILE_PATH_2);
+    File myClass3 = new File(tempJackFolder, JACK_FILE_PATH_3);
+
+    // get paths for dex files
+    File myClass1Dex = new File(tempJackFolder, DEX_FILE_PATH_1);
+    File myClass2Dex = new File(tempJackFolder, DEX_FILE_PATH_2);
+    File myClass3Dex = new File(tempJackFolder, DEX_FILE_PATH_3);
+
+    String libPropName = JackLibrary.LIBRARY_PROPERTIES_VPATH.getPathAsString('/');
+    File libProperties = new File(tempJackFolder, libPropName);
+
+    // create Jack dirs to import
+    File jackImport1 = AbstractTestTools.createTempDir();
+    File jackImport2 = AbstractTestTools.createTempDir();
+    copyFileToDir(libProperties, libPropName, jackImport1);
+    copyFileToDir(myClass1, JACK_FILE_PATH_1, jackImport1);
+    copyFileToDir(myClass1Dex, DEX_FILE_PATH_1, jackImport1);
+    copyFileToDir(myClass2, JACK_FILE_PATH_2, jackImport1);
+    copyFileToDir(myClass2Dex, DEX_FILE_PATH_2, jackImport1);
+    copyFileToDir(libProperties, libPropName, jackImport2);
+    copyFileToDir(myClass1, JACK_FILE_PATH_1, jackImport2);
+    copyFileToDir(myClass1Dex, DEX_FILE_PATH_1, jackImport2);
+    copyFileToDir(myClass3, JACK_FILE_PATH_3, jackImport2);
+    copyFileToDir(myClass3Dex, DEX_FILE_PATH_3, jackImport2);
+
+    // run Jack on Jack dirs
+    toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.addProguardFlags(new File(TEST001_DIR, "proguard.flags"));
+    toolchain.addStaticLibs(jackImport1, jackImport2);
+    if (collisionPolicy != null) {
+      toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), collisionPolicy);
+    }
+    toolchain.libToLib(new File [] {jackImport1, jackImport2}, jackOutput, /* zipFiles = */ false);
+  }
+
+  private void runTest002(@Nonnull File jackOutput, boolean zip,
+      @CheckForNull String collisionPolicy) throws Exception {
+    // compile source files to a Jack dir
+    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 */);
+
+    // 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);
+    }
+    if (collisionPolicy != null) {
+      options.addProperty(JayceFileImporter.RESOURCE_COLLISION_POLICY.getName(), collisionPolicy);
+    }
+    Jack.run(options);
+  }
+
+//  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;
+    FileInputStream fis = null;
+    try {
+      fis = new FileInputStream(fileToCopy);
+      File copiedFile = new File(dir, relativePath);
+      File parentDir = copiedFile.getParentFile();
+      if (!parentDir.exists()) {
+        boolean res = parentDir.mkdirs();
+        if (!res) {
+          throw new AssertionError();
+        }
+      }
+      try {
+        fos = new FileOutputStream(copiedFile);
+        ByteStreamSucker sucker = new ByteStreamSucker(fis, fos);
+        sucker.suck();
+      } finally {
+        if (fos != null) {
+          fos.close();
+        }
+      }
+    } finally {
+      if (fis != null) {
+        fis.close();
+      }
+    }
+  }
+
+  private void checkResourceContent(@Nonnull File dir, @Nonnull String path,
+      @Nonnull String expectedContent) throws IOException {
+    assert dir.isDirectory();
+    File file = new File(dir, path);
+    Assert.assertTrue(file.exists());
+    BufferedReader reader = null;
+    try {
+      InputStream in = new FileInputStream(file);
+      reader = new BufferedReader(new InputStreamReader(in));
+      String line = reader.readLine();
+      Assert.assertEquals(expectedContent, line);
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+
+  private void checkResourceContent(@Nonnull ZipFile zipFile, @Nonnull String entryName,
+      @Nonnull String expectedContent) throws IOException {
+    ZipEntry entry = zipFile.getEntry(entryName);
+    Assert.assertNotNull(entry);
+    BufferedReader reader = null;
+    try {
+      InputStream in = zipFile.getInputStream(entry);
+      reader = new BufferedReader(new InputStreamReader(in));
+      String line = reader.readLine();
+      Assert.assertEquals(expectedContent, line);
+    } finally {
+      if (reader != null) {
+        reader.close();
+      }
+    }
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/flow/FlowTests.java b/jack-tests/tests/com/android/jack/flow/FlowTests.java
new file mode 100644
index 00000000..527b3cb7
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/flow/FlowTests.java
@@ -0,0 +1,60 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.flow;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class FlowTests extends RuntimeTest {
+
+  private RuntimeTestInfo CFG001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.flow.cfg001"),
+    "com.android.jack.flow.cfg001.dx.Tests");
+
+  private RuntimeTestInfo LOOP = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.flow.loop"),
+    "com.android.jack.flow.loop.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    FlowTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void cfg001() throws Exception {
+    new RuntimeTestHelper(CFG001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void loop() throws Exception {
+    new RuntimeTestHelper(LOOP).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(CFG001);
+    rtTestInfos.add(LOOP);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/frontend/MissingClassTest.java b/jack-tests/tests/com/android/jack/frontend/MissingClassTest.java
new file mode 100644
index 00000000..b4c3efd1
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/frontend/MissingClassTest.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.frontend;
+
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+public class MissingClassTest {
+
+  @Test
+  @Category(KnownBugs.class)
+  public void test001() throws Exception {
+    File outJackTmpMissing = AbstractTestTools.createTempDir();
+    File outJackTmpSuper = AbstractTestTools.createTempDir();
+    File outJackTmpTest = AbstractTestTools.createTempDir();
+
+    IToolchain toolchain =  AbstractTestTools.getCandidateToolchain();
+
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        outJackTmpMissing,
+        /* zipFiles= */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.frontend.test001.jack.missing"));
+
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
+            + File.pathSeparatorChar + outJackTmpMissing.getPath(),
+        outJackTmpSuper,
+        /* zipFiles= */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.frontend.test001.jack.sub2"));
+
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath())
+            + File.pathSeparatorChar + outJackTmpSuper.getPath(),
+        outJackTmpTest,
+        /* zipFiles= */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.frontend.test001.jack.test"));
+
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/generic/basic/GenericTests.java b/jack-tests/tests/com/android/jack/generic/basic/GenericTests.java
new file mode 100644
index 00000000..d8896917
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/generic/basic/GenericTests.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.generic.basic;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * JUnit test for compilation of generics.
+ */
+public class GenericTests {
+
+  @BeforeClass
+  public static void setUpClass() {
+    GenericTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Verifies that the test source can compile from source to dex file.
+   */
+  @Test
+  public void testCompileBasic() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.generic.basic.jack"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/ifstatement/IfstatementTests.java b/jack-tests/tests/com/android/jack/ifstatement/IfstatementTests.java
new file mode 100644
index 00000000..d831f17c
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/ifstatement/IfstatementTests.java
@@ -0,0 +1,82 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.ifstatement;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class IfstatementTests extends RuntimeTest {
+
+  private RuntimeTestInfo ADVANCEDTEST = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.advancedTest"),
+    "com.android.jack.ifstatement.advancedTest.dx.Tests");
+
+  private RuntimeTestInfo CFGTEST = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.cfgTest"),
+    "com.android.jack.ifstatement.cfgTest.dx.Tests");
+
+  private RuntimeTestInfo FASTPATH = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.fastpath"),
+    "com.android.jack.ifstatement.fastpath.dx.Tests");
+
+  private RuntimeTestInfo SIMPLETEST = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.ifstatement.simpleTest"),
+    "com.android.jack.ifstatement.simpleTest.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    IfstatementTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void advancedTest() throws Exception {
+    new RuntimeTestHelper(ADVANCEDTEST).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void cfgTest() throws Exception {
+    new RuntimeTestHelper(CFGTEST).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void fastpath() throws Exception {
+    new RuntimeTestHelper(FASTPATH).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void simpleTest() throws Exception {
+    new RuntimeTestHelper(SIMPLETEST).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(ADVANCEDTEST);
+    rtTestInfos.add(CFGTEST);
+    rtTestInfos.add(FASTPATH);
+    rtTestInfos.add(SIMPLETEST);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/imports/ImportTests.java b/jack-tests/tests/com/android/jack/imports/ImportTests.java
new file mode 100644
index 00000000..79e9269f
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/imports/ImportTests.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.imports;
+
+import com.android.jack.backend.jayce.ImportConflictException;
+import com.android.jack.backend.jayce.JayceFileImporter;
+import com.android.jack.backend.jayce.TypeImportConflictException;
+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 junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+
+public class ImportTests {
+
+  @BeforeClass
+  public static void setUpClass() {
+    ImportTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void testCompileNonConflictingSourceAndImport() throws Exception {
+    File jackOut = AbstractTestTools.createTempDir();
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackOut,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001.jack"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.addStaticLibs(jackOut);
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.threeaddress.test001.jack"));
+  }
+
+  @Test
+  public void testCompileConflictingSourceAndImport() throws Exception {
+    File jackOut = AbstractTestTools.createTempDir();
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackOut,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001.jack"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.addStaticLibs(jackOut);
+    try {
+      toolchain.srcToExe(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          AbstractTestTools.createTempDir(),
+          /* zipFile = */ false,
+          AbstractTestTools.getTestRootDir("com.android.jack.fibonacci.test001.jack"));
+      Assert.fail();
+    } catch (ImportConflictException e) {
+      // expected
+    }
+  }
+
+  @Test
+  public void testConflictingImport() throws Exception {
+    String testName = "com.android.jack.inner.test015";
+    File lib = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        lib,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir(testName + ".lib"));
+
+
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addStaticLibs(lib);
+    toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), "keep-first");
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempFile("inner15", ".zip"),
+        /* zipFile = */ true,
+        AbstractTestTools.getTestRootDir(testName + ".jack"));
+  }
+
+  @Test
+  public void testConflictingImportWithFailPolicy1() throws Exception {
+    String testName = "com.android.jack.inner.test015";
+    File lib = AbstractTestTools.createTempDir();
+    JackApiToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        lib,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir(testName + ".lib"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    // import twice the same lib
+    toolchain.addStaticLibs(lib, lib);
+    toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), "fail");
+    try {
+      toolchain.srcToExe(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          AbstractTestTools.createTempFile("inner15", ".zip"),
+          /* zipFile = */ true,
+          AbstractTestTools.getTestRootDir(testName + ".jack"));
+      Assert.fail();
+    } catch (TypeImportConflictException e) {
+      // Exception is ok
+    }
+  }
+
+  @Test
+  public void testConflictingImportWithFailPolicy2() throws Exception {
+    String testName = "com.android.jack.inner.test015";
+    File lib1 = AbstractTestTools.createTempDir();
+    JackApiToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        lib1,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir(testName + ".lib"));
+
+    File lib2 = AbstractTestTools.createTempDir();
+    toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        lib2,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir(testName + ".lib"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    // import twice the same lib
+    toolchain.addStaticLibs(lib1, lib2);
+    toolchain.addProperty(JayceFileImporter.COLLISION_POLICY.getName(), "fail");
+
+    try {
+      toolchain.srcToExe(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          AbstractTestTools.createTempFile("inner15", ".zip"),
+          /* zipFile = */ true,
+          AbstractTestTools.getTestRootDir(testName + ".jack"));
+      Assert.fail();
+    } catch (TypeImportConflictException e) {
+      // Exception is ok
+    }
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/init/InitTests.java b/jack-tests/tests/com/android/jack/init/InitTests.java
new file mode 100644
index 00000000..c6215991
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/init/InitTests.java
@@ -0,0 +1,61 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.init;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class InitTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.init.test002"),
+    "com.android.jack.init.test002.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    InitTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void test001() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.init.test001.jack"));
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST002);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/inner/InnerTests.java b/jack-tests/tests/com/android/jack/inner/InnerTests.java
new file mode 100644
index 00000000..26b810a8
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/inner/InnerTests.java
@@ -0,0 +1,349 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.inner;
+
+import com.android.jack.TestTools;
+import com.android.jack.test.category.RedundantTests;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.comparator.ComparatorDex;
+import com.android.jack.test.helper.CheckDexStructureTestHelper;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import javax.annotation.Nonnull;
+
+public class InnerTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test001"),
+    "com.android.jack.inner.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test002"),
+    "com.android.jack.inner.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test003"),
+    "com.android.jack.inner.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test004"),
+    "com.android.jack.inner.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test005"),
+    "com.android.jack.inner.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test006"),
+    "com.android.jack.inner.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test007"),
+    "com.android.jack.inner.test007.dx.Tests");
+
+  private RuntimeTestInfo TEST008 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test008"),
+    "com.android.jack.inner.test008.dx.Tests");
+
+  private RuntimeTestInfo TEST009 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test009"),
+    "com.android.jack.inner.test009.dx.Tests");
+
+  private RuntimeTestInfo TEST010 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test010"),
+    "com.android.jack.inner.test010.dx.Tests");
+
+  private RuntimeTestInfo TEST011 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test011"),
+    "com.android.jack.inner.test011.dx.Tests");
+
+  private RuntimeTestInfo TEST012 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test012"),
+    "com.android.jack.inner.test012.dx.Tests");
+
+  private RuntimeTestInfo TEST013 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test013"),
+    "com.android.jack.inner.test013.dx.Tests");
+
+  private RuntimeTestInfo TEST014 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test014"),
+    "com.android.jack.inner.test014.dx.Tests");
+
+  private RuntimeTestInfo TEST015 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test015"),
+    "com.android.jack.inner.test015.dx.Tests");
+
+  private RuntimeTestInfo TEST016 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test016"),
+    "com.android.jack.inner.test016.dx.Tests");
+
+  private RuntimeTestInfo TEST017 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test017"),
+    "com.android.jack.inner.test017.dx.Tests");
+
+  private RuntimeTestInfo TEST018 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test018"),
+    "com.android.jack.inner.test018.dx.Tests");
+
+  private RuntimeTestInfo TEST019 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test019"),
+    "com.android.jack.inner.test019.dx.Tests");
+
+  private RuntimeTestInfo TEST020 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test020"),
+    "com.android.jack.inner.test020.dx.Tests");
+
+  private RuntimeTestInfo TEST021 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test021"),
+    "com.android.jack.inner.test021.dx.Tests");
+
+  private RuntimeTestInfo TEST022 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test022"),
+    "com.android.jack.inner.test022.dx.Tests");
+
+  private RuntimeTestInfo TEST023 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test023"),
+    "com.android.jack.inner.test023.dx.Tests");
+
+  private RuntimeTestInfo TEST024 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test024"),
+    "com.android.jack.inner.test024.dx.Tests");
+
+  private RuntimeTestInfo TEST026 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.inner.test026"),
+    "com.android.jack.inner.test026.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    InnerTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test008() throws Exception {
+    new RuntimeTestHelper(TEST008).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test009() throws Exception {
+    new RuntimeTestHelper(TEST009).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test010() throws Exception {
+    new RuntimeTestHelper(TEST010).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test011() throws Exception {
+    new RuntimeTestHelper(TEST011).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test012() throws Exception {
+    new RuntimeTestHelper(TEST012).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test013() throws Exception {
+    new RuntimeTestHelper(TEST013).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test014() throws Exception {
+    new RuntimeTestHelper(TEST014).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test015() throws Exception {
+    new RuntimeTestHelper(TEST015).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test016() throws Exception {
+    new RuntimeTestHelper(TEST016).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test017() throws Exception {
+    new RuntimeTestHelper(TEST017).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test018() throws Exception {
+    new RuntimeTestHelper(TEST018).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test019() throws Exception {
+    new RuntimeTestHelper(TEST019).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test020() throws Exception {
+    new RuntimeTestHelper(TEST020).compileAndRunTest(true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test021() throws Exception {
+    new RuntimeTestHelper(TEST021).compileAndRunTest(true);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test022() throws Exception {
+    new RuntimeTestHelper(TEST022).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test023() throws Exception {
+    new RuntimeTestHelper(TEST023).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test024() throws Exception {
+    new RuntimeTestHelper(TEST024).compileAndRunTest();
+  }
+
+  @Test
+  public void test025() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.inner.test025.jack"));
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test026() throws Exception {
+    new RuntimeTestHelper(TEST026).compileAndRunTest();
+  }
+
+  @Test
+  public void testCheckStructure20() throws Exception {
+    //TODO: find out why debug info check fails
+    checkStructure("test020");
+  }
+
+  @Test
+  @Category(RedundantTests.class)
+  public void testCompile21() throws Exception {
+    checkStructure("test021");
+  }
+
+  private void checkStructure(@Nonnull String test) throws Exception {
+    SourceToDexComparisonTestHelper helper = new CheckDexStructureTestHelper(
+        AbstractTestTools.getTestRootDir("com.android.jack.inner." + test + ".jack"));
+    helper.runTest(new ComparatorDex(helper.getCandidateDex(), helper.getReferenceDex()));
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+    rtTestInfos.add(TEST008);
+    rtTestInfos.add(TEST009);
+    rtTestInfos.add(TEST010);
+    rtTestInfos.add(TEST011);
+    rtTestInfos.add(TEST012);
+    rtTestInfos.add(TEST013);
+    rtTestInfos.add(TEST014);
+    rtTestInfos.add(TEST015);
+    rtTestInfos.add(TEST016);
+    rtTestInfos.add(TEST017);
+    rtTestInfos.add(TEST018);
+    rtTestInfos.add(TEST019);
+    rtTestInfos.add(TEST020);
+    rtTestInfos.add(TEST021);
+    rtTestInfos.add(TEST022);
+    rtTestInfos.add(TEST023);
+    rtTestInfos.add(TEST024);
+    rtTestInfos.add(TEST026);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/instance/InstanceTest.java b/jack-tests/tests/com/android/jack/instance/InstanceTest.java
new file mode 100644
index 00000000..e44111cf
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/instance/InstanceTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.instance;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+public class InstanceTest {
+
+  @Before
+  public void setUp() throws Exception {
+    InstanceTest.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void testReturnThis() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        new File( AbstractTestTools.getTestRootDir("com.android.jack.instance.test001.jack"),
+            "Instance.java"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/invoke/InvokeTests.java b/jack-tests/tests/com/android/jack/invoke/InvokeTests.java
new file mode 100644
index 00000000..1db4e57b
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/invoke/InvokeTests.java
@@ -0,0 +1,115 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.invoke;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class InvokeTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test001"),
+    "com.android.jack.invoke.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test002"),
+    "com.android.jack.invoke.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test003"),
+    "com.android.jack.invoke.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test004"),
+    "com.android.jack.invoke.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test005"),
+    "com.android.jack.invoke.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test006"),
+    "com.android.jack.invoke.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.invoke.test007"),
+    "com.android.jack.invoke.test007.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    InvokeTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java b/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java
index 6bac5cc2..dbfe543a 100644
--- a/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java
+++ b/jack-tests/tests/com/android/jack/jarjar/JarjarTests.java
@@ -19,30 +19,71 @@ package com.android.jack.jarjar;
 import com.android.jack.test.helper.RuntimeTestHelper;
 import com.android.jack.test.runtime.RuntimeTestInfo;
 import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+import com.tonicsystems.jarjar.PackageRemapper;
+import com.tonicsystems.jarjar.PatternElement;
+import com.tonicsystems.jarjar.Rule;
+import com.tonicsystems.jarjar.Wildcard;
+
+import junit.framework.Assert;
 
 import org.junit.Before;
 import org.junit.Test;
 
 import java.io.File;
+import java.util.Collections;
 
 import javax.annotation.Nonnull;
 
 public class JarjarTests {
 
   @Nonnull
-  private File baseDir;
+  private RuntimeTestInfo JARJAR001 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test001"),
+      "com.android.jack.jarjar.test001.dx.Tests");
+
+  @Nonnull
+  private RuntimeTestInfo JARJAR003 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test003"),
+      "com.android.jack.jarjar.test003.dx.Tests");
 
   @Before
   public void setUp() {
-    baseDir = AbstractTestTools.getTestRootDir("com.android.jack.jarjar.test001");
+    JarjarTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void jarjar001() throws Exception {
+    new RuntimeTestHelper(JARJAR001)
+    .setJarjarRulesFileName("jarjar-rules.txt")
+    .compileAndRunTest();
   }
 
   @Test
-  public void compileAndRunTest() throws Exception {
-    RuntimeTestHelper rtEnv = new RuntimeTestHelper(
-        new RuntimeTestInfo(baseDir, "com.android.jack.jarjar.test001.dx.Tests"));
-    rtEnv.setJarjarRulesFileName("jarjar-rules.txt");
-    rtEnv.compileAndRunTest();
+  public void jarjar003() throws Exception {
+    new RuntimeTestHelper(JARJAR003)
+    .setJarjarRulesFileName("jarjar-rules.txt")
+    .compileAndRunTest();
+  }
+
+  @Test
+  public void jarjar003_1() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.setJarjarRules(new File(JARJAR003.directory, "jarjar-rules.txt"));
+    File lib = AbstractTestTools.createTempFile("jarjarTest003Jack", ".zip");
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        lib,
+        /* zipFiles = */ true,
+        new File(JARJAR003.directory, "jack"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(),
+            new File [] {lib}),
+        AbstractTestTools.createTempFile("jarjarTest003dx", ".zip"),
+        /* zipFiles = */ true,
+        new File(JARJAR003.directory, "dontcompile/TestWithRelocatedReference.java"));
   }
 
 }
diff --git a/jack-tests/tests/com/android/jack/java7/BoxingTest.java b/jack-tests/tests/com/android/jack/java7/BoxingTest.java
new file mode 100644
index 00000000..8327f68e
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/java7/BoxingTest.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.java7;
+
+import com.android.jack.Main;
+import com.android.jack.Options;
+import com.android.jack.TestTools;
+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.JackBasedToolchain;
+import com.android.jack.test.toolchain.Toolchain.SourceLevel;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+/**
+ * JUnit test for compilation of Java 7 features
+ */
+public class BoxingTest {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Category(KnownBugs.class)
+  @Test
+  public void java7Boxing001() throws Exception {
+    IToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain();
+    toolchain.setSourceLevel(SourceLevel.JAVA_7).srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.java7.boxing.test001.jack"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java b/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java
index ecbe578d..73d4ff8e 100644
--- a/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java
+++ b/jack-tests/tests/com/android/jack/java7/ExceptionsTest.java
@@ -68,7 +68,7 @@ public class ExceptionsTest {
         AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
     jackBasedToolchain.setSourceLevel(SourceLevel.JAVA_7).srcToExe(
         AbstractTestTools.getClasspathAsString(jackBasedToolchain.getDefaultBootClasspath()),
-        AbstractTestTools.createTempDir(), new File(
+        AbstractTestTools.createTempDir(), /* zipFile = */ false, new File(
             AbstractTestTools.getTestRootDir("com.android.jack.java7.exceptions." + name), "jack"));
   }
 }
diff --git a/jack-tests/tests/com/android/jack/java7/Java7AllTest.java b/jack-tests/tests/com/android/jack/java7/Java7AllTest.java
new file mode 100644
index 00000000..fe9cdb4c
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/java7/Java7AllTest.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.java7;
+
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+/**
+ * JUnit test for compilation of Java 7 features
+ */
+@RunWith(Suite.class)
+@SuiteClasses(value = {
+    SwitchesTest.class,
+    ExceptionsTest.class,
+    BoxingTest.class,
+    TryWithResourcesTests.class
+    })
+public class Java7AllTest {
+}
diff --git a/jack-tests/tests/com/android/jack/java7/SwitchesTest.java b/jack-tests/tests/com/android/jack/java7/SwitchesTest.java
new file mode 100644
index 00000000..3fb13d3e
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/java7/SwitchesTest.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.java7;
+
+import com.android.jack.Main;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+import com.android.jack.test.toolchain.Toolchain.SourceLevel;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+/**
+ * JUnit test for compilation of Java 7 features
+ */
+public class SwitchesTest {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void java7Switches001() throws Exception {
+    compileJava7Test("test001");
+  }
+
+  @Test
+  public void java7Switches002() throws Exception {
+    compileJava7Test("test002");
+  }
+
+  @Test
+  public void java7Switches003() throws Exception {
+    compileJava7Test("test003");
+  }
+
+  @Test
+  public void java7Switches004() throws Exception {
+
+    File jackZipFile = AbstractTestTools.createTempFile("tmp", ".zip");
+
+    IToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain();
+    toolchain.setSourceLevel(SourceLevel.JAVA_7).srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        jackZipFile,
+        /* zipFiles = */ true,
+        AbstractTestTools.getTestRootDir("com.android.jack.java7.switches.test001.jack"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.setSourceLevel(SourceLevel.JAVA_7).libToExe(
+        jackZipFile,
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false);
+  }
+
+  private void compileJava7Test(@Nonnull String name) throws Exception {
+    IToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain();
+    toolchain.setSourceLevel(SourceLevel.JAVA_7).srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(), /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.java7.switches." + name + ".jack"));
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/java7/TryWithResourcesTests.java b/jack-tests/tests/com/android/jack/java7/TryWithResourcesTests.java
new file mode 100644
index 00000000..0584b6d1
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/java7/TryWithResourcesTests.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.java7;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+import com.android.jack.test.toolchain.Toolchain.SourceLevel;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * JUnit test for compilation of try-with-resources.
+ */
+public class TryWithResourcesTests {
+
+  @BeforeClass
+  public static void setUpClass() {
+    TryWithResourcesTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * Verifies that the test source can compiled from source to dex file.
+   */
+  @Test
+  public void testCompile() throws Exception {
+    IToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain();
+    toolchain.setSourceLevel(SourceLevel.JAVA_7)
+    .srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.java7.trywithresources.test001.jack"));
+  }
+
+  /**
+   * Verifies that the test source can compiled from source to dex file.
+   */
+  @Test
+  public void testCompile2() throws Exception {
+    IToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain();
+    toolchain.setSourceLevel(SourceLevel.JAVA_7)
+    .srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.java7.trywithresources.test002.jack"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/label/LabelTest.java b/jack-tests/tests/com/android/jack/label/LabelTest.java
new file mode 100644
index 00000000..945a215e
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/label/LabelTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.label;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+
+public class LabelTest {
+
+  @Before
+  public void setUp() throws Exception {
+    LabelTest.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void labelMustNotBreakTree() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        new File(AbstractTestTools.getTestRootDir("com.android.jack.label.test001.jack"), "Label.java"));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/lookup/LookupTests.java b/jack-tests/tests/com/android/jack/lookup/LookupTests.java
new file mode 100644
index 00000000..a51615e9
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/lookup/LookupTests.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.lookup;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.Test;
+
+import java.io.File;
+
+public class LookupTests {
+
+  @Test
+  public void test001() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    File lib = AbstractTestTools.createTempDir();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        lib,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.lookup.test001.lib"));
+
+    File libOverride = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        libOverride,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.lookup.test001.liboverride"));
+
+    File jacks = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools
+            .getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {lib}),
+        jacks,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.lookup.test001.jack"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.libToLib(
+        new File [] {jacks, libOverride},
+        AbstractTestTools.createTempFile("Lookup001", ".zip"),
+        /* zipFiles = */ true);
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexAllTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexAllTests.java
new file mode 100644
index 00000000..957dbcf1
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/multidex/MultiDexAllTests.java
@@ -0,0 +1,12 @@
+package com.android.jack.multidex;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses(value = {
+    MultiDexTests.class,
+    MultiDexOverflowTests.class})
+public class MultiDexAllTests {
+}
diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexOverflowTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexOverflowTests.java
new file mode 100644
index 00000000..8152c207
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/multidex/MultiDexOverflowTests.java
@@ -0,0 +1,180 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.multidex;
+
+import com.android.jack.JackAbortException;
+import com.android.jack.TestTools;
+import com.android.jack.backend.dex.DexFileWriter;
+import com.android.jack.backend.dex.DexWritingException;
+import com.android.jack.backend.dex.MainDexOverflowException;
+import com.android.jack.backend.dex.MultiDexLegacy;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackApiToolchain;
+import com.android.jack.tools.merger.FieldIdOverflowException;
+import com.android.jack.tools.merger.MethodIdOverflowException;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+
+import javax.annotation.Nonnegative;
+import javax.annotation.Nonnull;
+
+public class MultiDexOverflowTests {
+
+  private static File annotations;
+
+  @Nonnull
+  private static final String EXPECTED_MESSAGE =
+      "Error during the dex writing phase: classes.dex has too many IDs";
+
+  @BeforeClass
+  public static void init() throws IOException, Exception {
+    annotations = MultiDexTests.prepareAnnotations();
+  }
+
+  @Test
+  public void testMinimalMainDexOverflowWithMethods() throws Exception {
+    File srcFolder = TestTools.createTempDir("src", "dir");
+    File outFolder = TestTools.createTempDir("out", "dir");
+
+    int fileCount = 655;
+    for (int fileIdx = 0; fileIdx < fileCount; fileIdx++) {
+      generateJavaFileWithMethods(srcFolder, fileIdx, 100);
+    }
+    generateJavaFileWithMethods(srcFolder, fileCount, 36);
+
+    JackApiToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    toolchain.setErrorStream(baos);
+
+    try {
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathsAsString(
+            toolchain.getDefaultBootClasspath(),
+            new File[] {annotations}),
+        outFolder,
+        /* zipFile = */ false,
+        srcFolder);
+      Assert.fail();
+    } catch (JackAbortException e) {
+      Throwable cause = e.getCause();
+      Assert.assertTrue(cause instanceof DexWritingException);
+      Assert.assertTrue(cause.getCause() instanceof MainDexOverflowException);
+      Assert.assertTrue(cause.getCause().getCause() instanceof MethodIdOverflowException);
+      Assert.assertTrue(baos.toString().contains(EXPECTED_MESSAGE));
+    }
+  }
+
+  @Test
+  public void testStandardMainDexOverflowWithFields() throws Exception {
+    File srcFolder = TestTools.createTempDir("src", "dir");
+    File outFolder = TestTools.createTempDir("out", "dir");
+
+    int fileCount = 655;
+    for (int fileIdx = 0; fileIdx < fileCount; fileIdx++) {
+      generateJavaFileWithFields(srcFolder, fileIdx, 100);
+    }
+    generateJavaFileWithFields(srcFolder, fileCount, 37);
+
+    JackApiToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+
+    ByteArrayOutputStream baos = new ByteArrayOutputStream();
+    toolchain.setErrorStream(baos);
+
+    try {
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathsAsString(
+            toolchain.getDefaultBootClasspath(),
+            new File[] {annotations}),
+        outFolder,
+        /* zipFile = */ false,
+        srcFolder);
+      Assert.fail();
+    } catch (JackAbortException e) {
+      Throwable cause = e.getCause();
+      Assert.assertTrue(cause instanceof DexWritingException);
+      Assert.assertTrue(cause.getCause() instanceof MainDexOverflowException);
+      Assert.assertTrue(cause.getCause().getCause() instanceof FieldIdOverflowException);
+      Assert.assertTrue(baos.toString().contains(EXPECTED_MESSAGE));
+    }
+  }
+
+  private void generateJavaFileWithMethods(@Nonnull File srcFolder, @Nonnegative int fileIdx,
+      @Nonnegative int methodCount) throws IOException, FileNotFoundException {
+    File javaFile = new File(srcFolder, "A" + fileIdx + ".java");
+    if (!javaFile.createNewFile()) {
+      throw new IOException("Failed to create file " + javaFile.getAbsolutePath());
+    }
+    FileOutputStream fos = null;
+    try {
+      fos = new FileOutputStream(javaFile);
+      StringBuilder content = new StringBuilder("package jack.merger; \n"
+          + "@com.android.jack.annotations.ForceInMainDex public class A" + fileIdx + " {\n");
+      // -1 due to implicit init method
+      for (int mthIdx = 0; mthIdx < methodCount - 1; mthIdx++) {
+        content.append("public void m" + mthIdx + "() {} \n");
+      }
+      content.append("} \n");
+      fos.write(content.toString().getBytes());
+    } finally {
+      if (fos != null) {
+        fos.close();
+      }
+    }
+  }
+
+  private void generateJavaFileWithFields(@Nonnull File srcFolder, @Nonnegative int fileIdx,
+      @Nonnegative int fieldCount) throws IOException, FileNotFoundException {
+    File javaFile = new File(srcFolder, "A" + fileIdx + ".java");
+    if (!javaFile.createNewFile()) {
+      throw new IOException("Failed to create file " + javaFile.getAbsolutePath());
+    }
+    FileOutputStream fos = null;
+    try {
+      fos = new FileOutputStream(javaFile);
+      StringBuilder content = new StringBuilder("package jack.merger; \n"
+          + "@com.android.jack.annotations.ForceInMainDex public class A" + fileIdx + " {\n");
+      for (int fieldIdx = 0; fieldIdx < fieldCount; fieldIdx++) {
+        content.append("public int f" + fieldIdx + ";\n");
+      }
+      content.append("} \n");
+      fos.write(content.toString().getBytes());
+    } finally {
+      if (fos != null) {
+        fos.close();
+      }
+    }
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java b/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java
new file mode 100644
index 00000000..983c882c
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/multidex/MultiDexTests.java
@@ -0,0 +1,546 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.multidex;
+
+import com.google.common.io.Files;
+
+import com.android.jack.DifferenceFoundException;
+import com.android.jack.Options;
+import com.android.jack.TestTools;
+import com.android.jack.backend.dex.DexFileWriter;
+import com.android.jack.backend.dex.MultiDexLegacy;
+import com.android.jack.library.FileType;
+import com.android.jack.preprocessor.PreProcessor;
+import com.android.jack.shrob.ListingComparator;
+import com.android.jack.test.comparator.Comparator;
+import com.android.jack.test.comparator.ComparatorException;
+import com.android.jack.test.comparator.ComparatorFile;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.DummyToolchain;
+import com.android.jack.test.toolchain.IToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+import com.android.jack.util.ExecuteFile;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Properties;
+
+import javax.annotation.Nonnull;
+
+public class MultiDexTests {
+
+  private static File annotations;
+  private static File frameworks;
+  private static File library;
+
+  private class ComparatorMultiDexListing extends ComparatorFile {
+
+    protected ComparatorMultiDexListing(File candidate, File reference) {
+      super(candidate, reference);
+    }
+
+    @Override
+    public void compare() throws DifferenceFoundException, ComparatorException {
+      try {
+        ListingComparator.compare(reference, getListingOfDex(candidate));
+      } catch (IOException e) {
+        throw new ComparatorException(e);
+      }
+    }
+  }
+
+  @BeforeClass
+  public static void init() throws IOException, Exception {
+    MultiDexTests.class.getClassLoader().setDefaultAssertionStatus(true);
+
+    annotations = prepareAnnotations();
+
+    frameworks = prepareFrameworks();
+
+    library = prepareLibrary(frameworks);
+  }
+
+  @Test
+  public void versionedTest001a() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+
+    addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp"));
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(testFolder);
+
+    env.setCandidateTestTools(toolchain);
+
+    List<File> cp = new ArrayList<File>();
+    cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath()));
+    cp.add(annotations);
+    cp.add(frameworks);
+    env.setCandidateClasspath(cp.toArray(new File[cp.size()]));
+    env.setReferenceTestTools(new DummyToolchain());
+
+    env.runTest(new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-001.txt")));
+
+    Assert.assertFalse(new File(env.getCandidateDexDir(), "classes2.dex").exists());
+  }
+
+  @Test
+  public void versionedTest001b() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp"));
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(testFolder);
+    env.setCandidateTestTools(toolchain);
+    List<File> cp = new ArrayList<File>();
+    cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath()));
+    cp.add(annotations);
+    cp.add(frameworks);
+    env.setCandidateClasspath(cp.toArray(new File[cp.size()]));
+    env.setReferenceTestTools(new DummyToolchain());
+
+    Comparator c1 = new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-002-1.txt"));
+    Comparator c2 = new ComparatorMultiDexListing(new File(env.getCandidateDexDir(), "classes2.dex"), new File(testFolder, "ref-list-002-2.txt"));
+    env.runTest(c1, c2);
+
+    Assert.assertFalse(new File(env.getCandidateDexDir(), "classes3.dex").exists());
+  }
+
+  @Test
+  public void versionedTest001c() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test001.jack");
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-003.jpp"));
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(testFolder);
+    env.setCandidateTestTools(toolchain);
+    List<File> cp = new ArrayList<File>();
+    cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath()));
+    cp.add(annotations);
+    cp.add(frameworks);
+    env.setCandidateClasspath(cp.toArray(new File[cp.size()]));
+    env.setReferenceTestTools(new DummyToolchain());
+
+    Comparator c1 = new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-003-1.txt"));
+    Comparator c2 = new ComparatorMultiDexListing(new File(env.getCandidateDexDir(), "classes2.dex"), new File(testFolder, "ref-list-003-2.txt"));
+    env.runTest(c1, c2);
+
+    Assert.assertFalse(new File(env.getCandidateDexDir(), "classes3.dex").exists());
+  }
+
+  @Test
+  public void versionedTest001a_withoutAnnotations() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test001");
+    File out = TestTools.createTempDir("out", "");
+    Options app1Options = addCommonOptionsForMultiDex(new File(testFolder, "config-001.jpp"));
+
+    app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+
+    TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + frameworks.getPath(),
+        out, false);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    ListingComparator.compare(new File(testFolder, "ref-list-001.txt"), outList);
+    Assert.assertFalse(new File(out, "classes2.dex").exists());
+    return;
+  }
+
+  @Test
+  public void versionedTest001b__withoutAnnotations() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test001");
+    File out = TestTools.createTempDir("out", "");
+    Options app1Options = addCommonOptionsForMultiDex(new File(testFolder, "config-001.jpp"));
+
+    app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+
+    TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + frameworks.getPath(),
+        out, false);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    ListingComparator.compare(new File(testFolder, "ref-list-002-1.txt"), outList);
+    File outList2 = getListingOfDex(new File(out, "classes2.dex"));
+    ListingComparator.compare(new File(testFolder, "ref-list-002-2.txt"), outList2);
+    Assert.assertFalse(new File(out, "classes3.dex").exists());
+    return;
+  }
+
+  @Test
+  public void versionedTest001c_withoutAnnotations() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test001");
+    File out = TestTools.createTempDir("out", "");
+    Options app1Options = addCommonOptionsForMultiDex(new File(testFolder, "config-003.jpp"));
+
+    app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+
+    TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + frameworks.getPath(),
+        out, false);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    ListingComparator.compare(new File(testFolder, "ref-list-003-1.txt"), outList);
+    File outList2 = getListingOfDex(new File(out, "classes2.dex"));
+    ListingComparator.compare(new File(testFolder, "ref-list-003-2.txt"), outList2);
+    Assert.assertFalse(new File(out, "classes3.dex").exists());
+    return;
+  }
+
+  private Options addCommonOptionsForMultiDex(@Nonnull File configFile) {
+    Options app1Options = new Options();
+    app1Options.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    app1Options.addProperty(PreProcessor.ENABLE.getName(), "true");
+    app1Options.addProperty(PreProcessor.FILE.getName(), configFile.getAbsolutePath());
+    return app1Options;
+  }
+
+  private void addCommonOptionsForMultiDex(@Nonnull JackApiToolchain toolchain,
+      @Nonnull File configFile) {
+    toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    toolchain.addProperty(PreProcessor.ENABLE.getName(), "true");
+    toolchain.addProperty(PreProcessor.FILE.getName(), configFile.getAbsolutePath());
+  }
+
+  private File getListingOfDex(@Nonnull File dex) throws IOException, FileNotFoundException {
+    assert dex.isFile();
+    ExecuteFile exec =
+        new ExecuteFile(new String[]{
+            "bash", "-c", AbstractTestTools.getPrebuilt("dexdump").getAbsolutePath() + " "
+        + dex.getAbsolutePath() +
+        " | grep \"  Class descriptor  : \" | cut -d\\' -f2 | sed -e 's/$/:/'"});
+
+    File outList = TestTools.createTempFile("types", ".txt");
+
+    exec.setOut(outList);
+    Assert.assertTrue(exec.run());
+    return outList;
+  }
+
+  private int getTypeCountInDex(@Nonnull File dex) throws IOException, FileNotFoundException {
+    assert dex.isFile();
+    ExecuteFile exec =
+        new ExecuteFile(new String[]{
+            "bash", "-c", AbstractTestTools.getPrebuilt("dexdump").getAbsolutePath() + " "
+        + dex.getAbsolutePath() +
+        " | grep \"  Class descriptor  : \" | wc -l"});
+
+    File out = TestTools.createTempFile("typeNumber", ".txt");
+
+    exec.setOut(out);
+    Assert.assertTrue(exec.run());
+    BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream(out)));
+    try {
+      String readLine = reader.readLine();
+      assert readLine != null;
+      return Integer.parseInt(readLine.trim());
+    } finally {
+      reader.close();
+    }
+  }
+
+  @Nonnull
+  private static File prepareLib(@Nonnull File sources, @Nonnull File... classpath) throws Exception {
+    File outDir = AbstractTestTools.createTempDir();
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), classpath),
+        outDir,
+        /* zipFiles = */ false,
+        sources);
+    return outDir;
+  }
+
+  @Nonnull
+  private static File prepareFrameworks() throws IOException, Exception {
+    return prepareLib(AbstractTestTools.getTestRootDir("com.android.jack.multidex.fakeframeworks"));
+//    File frameworks = TestTools.createTempDir("frameworks", "");
+//    TestTools.compileSourceToJack(new Options(),
+//        TestTools.getJackTestFolder("multidex/fakeframeworks"),
+//        TestTools.getDefaultBootclasspathString(), frameworks, false);
+//    return frameworks;
+  }
+
+  @Nonnull
+  protected static File prepareAnnotations() throws IOException, Exception {
+    return prepareLib(AbstractTestTools.getTestRootDir("com.android.jack.annotations"));
+//    File annotations = TestTools.createTempDir("multidexAnnotations", "");
+//    TestTools.compileSourceToJack(new Options(),
+//        TestTools.getFromAndroidTree(
+//            "toolchain/jack/jack-tests/tests/com/android/jack/annotations/"),
+//            TestTools.getDefaultBootclasspathString(), annotations, false);
+//    return annotations;
+  }
+
+  @Nonnull
+  private static File prepareLibrary(@Nonnull File frameworks) throws IOException, Exception {
+    return prepareLib(AbstractTestTools.getTestRootDir("com.android.jack.multidex.fakelibrary"),
+        frameworks);
+//    File library = TestTools.createTempDir("multidexLibrary", "");
+//    TestTools.compileSourceToJack(new Options(),
+//        TestTools.getJackTestFolder("multidex/fakelibrary"),
+//        TestTools.getDefaultBootclasspathString() + File.pathSeparator + frameworks.getPath(),
+//        library, false);
+//    return library;
+  }
+
+  private static void setMetaIntoJackProperties(@Nonnull File library) throws IOException {
+    File jackProperties = new File(library, "jack.properties");
+    Properties libraryProperties = new Properties();
+    FileInputStream fis = null;
+    FileOutputStream fos = null;
+    try {
+      fis = new FileInputStream(jackProperties);
+      libraryProperties.load(fis);
+    } catch (IOException e) {
+      Assert.fail();
+    } finally {
+      if (fis != null) {
+        fis.close();
+      }
+    }
+    try {
+      fos = new FileOutputStream(jackProperties);
+      libraryProperties.put(FileType.JPP.buildPropertyName(null /*suffix*/), "true");
+        libraryProperties.store(fos, "Library properties");
+    } catch (IOException e) {
+      Assert.fail();
+    } finally {
+      if (fos != null) {
+        fos.close();
+      }
+    }
+  }
+
+  @Test
+  public void legacyAppTest002a() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack");
+    File out = AbstractTestTools.createTempDir();
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp"));
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {annotations, frameworks, library}),
+        out,
+        /* zipFile = */ false,
+        testFolder);
+
+    File classesDex = new File(out, "classes.dex");
+    Assert.assertTrue(classesDex.exists());
+    File classes2Dex = new File(out, "classes2.dex");
+    Assert.assertTrue(classes2Dex.exists());
+    File classes3Dex = new File(out, "classes3.dex");
+    Assert.assertFalse(classes3Dex.exists());
+    int totalTypeNumber = getTypeCountInDex(classesDex) + getTypeCountInDex(classes2Dex);
+    Assert.assertEquals(100, totalTypeNumber);
+    return;
+  }
+
+  @Test
+  public void legacyAppTest002b() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack");
+    File out = AbstractTestTools.createTempDir();
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    addCommonOptionsForMultiDex(toolchain, new File(testFolder, "config-001.jpp"));
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+    toolchain.addStaticLibs(library);
+
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathsAsString(toolchain.getDefaultBootClasspath(), new File [] {annotations, frameworks}),
+        out,
+        /* zipFile = */ false,
+        testFolder);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    // The old toolchain is doing a little better than us here it seems to identify when
+    // InterfaceWithEnum.class instance is used or not.
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-002-1.txt"), outList);
+    File outList2 = getListingOfDex(new File(out, "classes2.dex"));
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-002-2.txt"), outList2);
+    Assert.assertFalse(new File(out, "classes3.dex").exists());
+    return;
+  }
+
+  @Test
+  public void legacyAppTest002b_auto() throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.multidex.test002.jack");
+    File autoLibrary = prepareLibrary(frameworks);
+    setMetaIntoJackProperties(autoLibrary);
+    File jackInf = new File(autoLibrary, FileType.JPP.getPrefix());
+    Assert.assertTrue(jackInf.mkdir());
+    Files.copy(new File(testFolder,"config-001.jpp"), new File(jackInf, "config-001.jpp"));
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+    toolchain.addStaticLibs(autoLibrary);
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(testFolder);
+    env.setCandidateTestTools(toolchain);
+    List<File> cp = new ArrayList<File>();
+    cp.addAll(Arrays.asList(toolchain.getDefaultBootClasspath()));
+    cp.add(annotations);
+    cp.add(frameworks);
+    env.setCandidateClasspath(cp.toArray(new File[cp.size()]));
+    env.setReferenceTestTools(new DummyToolchain());
+
+    Comparator c1 = new ComparatorMultiDexListing(env.getCandidateDex(), new File(testFolder, "ref-list-002-1.txt"));
+    Comparator c2 = new ComparatorMultiDexListing(new File(env.getCandidateDexDir(), "classes2.dex"), new File(testFolder, "ref-list-002-2.txt"));
+    env.runTest(c1, c2);
+
+    Assert.assertFalse(new File(env.getCandidateDexDir(), "classes3.dex").exists());
+  }
+
+  @Test
+  public void legacyAppTest002a_withoutAnnotations() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002");
+    File out = TestTools.createTempDir("out", "");
+    Options app1Options = addCommonOptionsForMultiDex(
+        new File(testFolder,"config-001.jpp"));
+    app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+
+    TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + frameworks.getPath()
+        + File.pathSeparator + library.getPath(), out, false);
+
+    File classesDex = new File(out, "classes.dex");
+    Assert.assertTrue(classesDex.exists());
+    File classes2Dex = new File(out, "classes2.dex");
+    Assert.assertTrue(classes2Dex.exists());
+    File classes3Dex = new File(out, "classes3.dex");
+    Assert.assertFalse(classes3Dex.exists());
+    int totalTypeNumber = getTypeCountInDex(classesDex) + getTypeCountInDex(classes2Dex);
+    Assert.assertEquals(100, totalTypeNumber);
+    return;
+  }
+
+  @Test
+  public void legacyAppTest002b_withoutAnnotations() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002");
+    File out = TestTools.createTempDir("out", "");
+    Options app1Options = addCommonOptionsForMultiDex(
+        new File(testFolder,"config-001.jpp"));
+    app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+    app1Options.addJayceImport(library);
+
+    TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + frameworks.getPath(),
+        out, false);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    // The old toolchain is doing a little better than us here it seems to identify when
+    // InterfaceWithEnum.class instance is used or not.
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-002-1.txt"), outList);
+    File outList2 = getListingOfDex(new File(out, "classes2.dex"));
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-002-2.txt"), outList2);
+    Assert.assertFalse(new File(out, "classes3.dex").exists());
+    return;
+  }
+
+  @Test
+  public void legacyAppTest002b_auto_withoutAnnotations() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test002");
+    File autoLibrary = prepareLibrary(frameworks);
+    setMetaIntoJackProperties(autoLibrary);
+    File jackInf = new File(autoLibrary, FileType.JPP.getPrefix());
+    Assert.assertTrue(jackInf.mkdir());
+    Files.copy(new File(testFolder,"config-001.jpp"), new File(jackInf, "config-001.jpp"));
+
+    File out = TestTools.createTempDir("out", "");
+    Options app1Options = new Options();
+    app1Options.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    app1Options.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+    app1Options.addJayceImport(autoLibrary);
+
+    TestTools.compileSourceToDex(app1Options, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + frameworks.getPath(),
+        out, false);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    // The old toolchain is doing a little better than us here it seems to identify when
+    // InterfaceWithEnum.class instance is used or not.
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-002-1.txt"), outList);
+    File outList2 = getListingOfDex(new File(out, "classes2.dex"));
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-002-2.txt"), outList2);
+    Assert.assertFalse(new File(out, "classes3.dex").exists());
+    return;
+  }
+
+  /**
+   * Verifies that classes annotated with runtime visible annotations are put in main dex.
+   */
+  @Test
+  public void legacyAppTest003() throws Exception {
+
+    File testFolder = TestTools.getJackTestsWithJackFolder("multidex/test003");
+
+    File out = TestTools.createTempDir("out", "");
+    Options appOptions = new Options();
+    appOptions.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    appOptions.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "minimal-multidex");
+
+    TestTools.compileSourceToDex(appOptions, testFolder, TestTools.getDefaultBootclasspathString()
+        + File.pathSeparator + annotations.getPath() + File.pathSeparator + frameworks.getPath(),
+        out, false);
+
+    File outList = getListingOfDex(new File(out, "classes.dex"));
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-003-1.txt"), outList);
+    File outList2 = getListingOfDex(new File(out, "classes2.dex"));
+    ListingComparator.compare(
+        new File(testFolder,"ref-list-003-2.txt"), outList2);
+    Assert.assertFalse(new File(out, "classes3.dex").exists());
+    return;
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/newarray/NewarrayTests.java b/jack-tests/tests/com/android/jack/newarray/NewarrayTests.java
new file mode 100644
index 00000000..94f84978
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/newarray/NewarrayTests.java
@@ -0,0 +1,93 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.newarray;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class NewarrayTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.newarray.test001"),
+    "com.android.jack.newarray.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.newarray.test002"),
+    "com.android.jack.newarray.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.newarray.test003"),
+    "com.android.jack.newarray.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.newarray.test004"),
+    "com.android.jack.newarray.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.newarray.test005"),
+      "com.android.jack.newarray.test005.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    NewarrayTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/nopackage/NoPackageTests.java b/jack-tests/tests/com/android/jack/nopackage/NoPackageTests.java
new file mode 100644
index 00000000..54c5978b
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/nopackage/NoPackageTests.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.nopackage;
+
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+
+public class NoPackageTests {
+
+  @BeforeClass
+  public static void setUpClass() {
+    NoPackageTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void test001() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.nopackage.test001.jack"));
+  }
+
+  @Test
+  public void test001_throughJayce() throws Exception {
+    File tmpDir = AbstractTestTools.createTempDir();
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tmpDir,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.nopackage.test001.jack"));
+
+    toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.libToExe(tmpDir, AbstractTestTools.createTempDir(), /* zipFile = */ false);
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/nopackage/jack/ClassInDefaultPackage.java b/jack-tests/tests/com/android/jack/nopackage/test001/jack/ClassInDefaultPackage.java
index 91e24242..91e24242 100644
--- a/jack-tests/tests/com/android/jack/nopackage/jack/ClassInDefaultPackage.java
+++ b/jack-tests/tests/com/android/jack/nopackage/test001/jack/ClassInDefaultPackage.java
diff --git a/jack-tests/tests/com/android/jack/nopackage/jack/InnerInDefaultPackage.java b/jack-tests/tests/com/android/jack/nopackage/test001/jack/InnerInDefaultPackage.java
index 48e7c487..48e7c487 100644
--- a/jack-tests/tests/com/android/jack/nopackage/jack/InnerInDefaultPackage.java
+++ b/jack-tests/tests/com/android/jack/nopackage/test001/jack/InnerInDefaultPackage.java
diff --git a/jack-tests/tests/com/android/jack/opcodes/OpcodesTests.java b/jack-tests/tests/com/android/jack/opcodes/OpcodesTests.java
new file mode 100644
index 00000000..0830306b
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/opcodes/OpcodesTests.java
@@ -0,0 +1,1740 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.opcodes;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class OpcodesTests extends RuntimeTest {
+
+  @Nonnull
+  private RuntimeTestInfo INVOKE_STATIC = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_static"),
+    "com.android.jack.opcodes.invoke_static.Test_invoke_static");
+
+  @Nonnull
+  private RuntimeTestInfo ARRAY_LENGTH = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.array_length"),
+    "com.android.jack.opcodes.array_length.Test_array_length");
+
+  @Nonnull
+  private RuntimeTestInfo NEG_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_float"),
+    "com.android.jack.opcodes.neg_float.Test_neg_float");
+
+  @Nonnull
+  private RuntimeTestInfo SUB_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_double"),
+    "com.android.jack.opcodes.sub_double.Test_sub_double");
+
+  @Nonnull
+  private RuntimeTestInfo AGET = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget"),
+    "com.android.jack.opcodes.aget.Test_aget");
+
+  @Nonnull
+  private RuntimeTestInfo APUT_BYTE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_byte"),
+    "com.android.jack.opcodes.aput_byte.Test_aput_byte");
+
+  @Nonnull
+  private RuntimeTestInfo OPC_NEW = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_new"),
+    "com.android.jack.opcodes.opc_new.Test_opc_new");
+
+  @Nonnull
+  private RuntimeTestInfo CMPL_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpl_double"),
+    "com.android.jack.opcodes.cmpl_double.Test_cmpl_double");
+
+  @Nonnull
+  private RuntimeTestInfo IF_GTZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_gtz"),
+    "com.android.jack.opcodes.if_gtz.Test_if_gtz");
+
+  @Nonnull
+  private RuntimeTestInfo FLOAT_TO_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.float_to_long"),
+    "com.android.jack.opcodes.float_to_long.Test_float_to_long");
+
+  @Nonnull
+  private RuntimeTestInfo ADD_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_long"),
+    "com.android.jack.opcodes.add_long.Test_add_long");
+
+  @Nonnull
+  private RuntimeTestInfo ADD_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_float"),
+    "com.android.jack.opcodes.add_float.Test_add_float");
+
+  @Nonnull
+  private RuntimeTestInfo IPUT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.iput"),
+    "com.android.jack.opcodes.iput.Test_iput");
+
+  @Nonnull
+  private RuntimeTestInfo DIV_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_float"),
+    "com.android.jack.opcodes.div_float.Test_div_float");
+
+  @Nonnull
+  private RuntimeTestInfo USHR_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.ushr_long"),
+    "com.android.jack.opcodes.ushr_long.Test_ushr_long");
+
+  @Nonnull
+  private RuntimeTestInfo CONST_WIDE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.const_wide"),
+    "com.android.jack.opcodes.const_wide.Test_const_wide");
+
+  @Nonnull
+  private RuntimeTestInfo XOR_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.xor_int"),
+    "com.android.jack.opcodes.xor_int.Test_xor_int");
+
+  @Nonnull
+  private RuntimeTestInfo AGET_OBJECT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_object"),
+    "com.android.jack.opcodes.aget_object.Test_aget_object");
+
+  @Nonnull
+  private RuntimeTestInfo CONST4_16 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.const4_16"),
+    "com.android.jack.opcodes.const4_16.Test_const4_16");
+
+  @Nonnull
+  private RuntimeTestInfo REM_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_long"),
+    "com.android.jack.opcodes.rem_long.Test_rem_long");
+
+  @Nonnull
+  private RuntimeTestInfo USHR_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.ushr_int"),
+    "com.android.jack.opcodes.ushr_int.Test_ushr_int");
+
+  @Nonnull
+  private RuntimeTestInfo IF_GE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_ge"),
+    "com.android.jack.opcodes.if_ge.Test_if_ge");
+
+  @Nonnull
+  private RuntimeTestInfo SUB_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_long"),
+    "com.android.jack.opcodes.sub_long.Test_sub_long");
+
+  @Nonnull
+  private RuntimeTestInfo FLOAT_TO_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.float_to_int"),
+    "com.android.jack.opcodes.float_to_int.Test_float_to_int");
+
+  @Nonnull
+  private RuntimeTestInfo INT_TO_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_long"),
+    "com.android.jack.opcodes.int_to_long.Test_int_to_long");
+
+  @Nonnull
+  private RuntimeTestInfo OR_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.or_long"),
+    "com.android.jack.opcodes.or_long.Test_or_long");
+
+  @Nonnull
+  private RuntimeTestInfo IF_GEZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_gez"),
+    "com.android.jack.opcodes.if_gez.Test_if_gez");
+
+  @Nonnull
+  private RuntimeTestInfo SHL_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shl_int"),
+    "com.android.jack.opcodes.shl_int.Test_shl_int");
+
+  @Nonnull
+  private RuntimeTestInfo LONG_TO_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.long_to_float"),
+    "com.android.jack.opcodes.long_to_float.Test_long_to_float");
+
+  @Nonnull
+  private RuntimeTestInfo DIV_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_int"),
+    "com.android.jack.opcodes.div_int.Test_div_int");
+
+  @Nonnull
+  private RuntimeTestInfo AND_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.and_long"),
+    "com.android.jack.opcodes.and_long.Test_and_long");
+
+  @Nonnull
+  private RuntimeTestInfo DOUBLE_TO_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.double_to_long"),
+    "com.android.jack.opcodes.double_to_long.Test_double_to_long");
+
+  @Nonnull
+  private RuntimeTestInfo MUL_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_long"),
+    "com.android.jack.opcodes.mul_long.Test_mul_long");
+
+  @Nonnull
+  private RuntimeTestInfo DOUBLE_TO_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.double_to_int"),
+    "com.android.jack.opcodes.double_to_int.Test_double_to_int");
+
+  @Nonnull
+  private RuntimeTestInfo IF_NEZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_nez"),
+    "com.android.jack.opcodes.if_nez.Test_if_nez");
+
+  @Nonnull
+  private RuntimeTestInfo APUT_OBJECT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_object"),
+    "com.android.jack.opcodes.aput_object.Test_aput_object");
+
+  @Nonnull
+  private RuntimeTestInfo IF_LT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_lt"),
+    "com.android.jack.opcodes.if_lt.Test_if_lt");
+
+  @Nonnull
+  private RuntimeTestInfo INT_TO_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_double"),
+    "com.android.jack.opcodes.int_to_double.Test_int_to_double");
+
+  @Nonnull
+  private RuntimeTestInfo MUL_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_int"),
+    "com.android.jack.opcodes.mul_int.Test_mul_int");
+
+  @Nonnull
+  private RuntimeTestInfo SPUT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sput"),
+    "com.android.jack.opcodes.sput.Test_sput");
+
+  @Nonnull
+  private RuntimeTestInfo SHL_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shl_long"),
+    "com.android.jack.opcodes.shl_long.Test_shl_long");
+
+  @Nonnull
+  private RuntimeTestInfo NEG_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_long"),
+    "com.android.jack.opcodes.neg_long.Test_neg_long");
+
+  @Nonnull
+  private RuntimeTestInfo LONG_TO_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.long_to_int"),
+    "com.android.jack.opcodes.long_to_int.Test_long_to_int");
+
+  @Nonnull
+  private RuntimeTestInfo OPC_GOTO = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_goto"),
+    "com.android.jack.opcodes.opc_goto.Test_opc_goto");
+
+  @Nonnull
+  private RuntimeTestInfo INT_TO_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_float"),
+    "com.android.jack.opcodes.int_to_float.Test_int_to_float");
+
+  @Nonnull
+  private RuntimeTestInfo XOR_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.xor_long"),
+    "com.android.jack.opcodes.xor_long.Test_xor_long");
+
+  @Nonnull
+  private RuntimeTestInfo MONITOR_ENTER = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.monitor_enter"),
+    "com.android.jack.opcodes.monitor_enter.Test_monitor_enter");
+
+  @Nonnull
+  private RuntimeTestInfo IF_EQZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_eqz"),
+    "com.android.jack.opcodes.if_eqz.Test_if_eqz");
+
+  @Nonnull
+  private RuntimeTestInfo INVOKE_DIRECT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_direct"),
+    "com.android.jack.opcodes.invoke_direct.Test_invoke_direct");
+
+  @Nonnull
+  private RuntimeTestInfo CMPL_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpl_float"),
+    "com.android.jack.opcodes.cmpl_float.Test_cmpl_float");
+
+  @Nonnull
+  private RuntimeTestInfo CHECK_CAST = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.check_cast"),
+    "com.android.jack.opcodes.check_cast.Test_check_cast");
+
+  @Nonnull
+  private RuntimeTestInfo OPC_THROW = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_throw"),
+    "com.android.jack.opcodes.opc_throw.Test_opc_throw");
+
+  @Nonnull
+  private RuntimeTestInfo INT_TO_SHORT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_short"),
+    "com.android.jack.opcodes.int_to_short.Test_int_to_short");
+
+  @Nonnull
+  private RuntimeTestInfo PACKED_SWITCH = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.packed_switch"),
+    "com.android.jack.opcodes.packed_switch.Test_packed_switch");
+
+  @Nonnull
+  private RuntimeTestInfo AGET_CHAR = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_char"),
+    "com.android.jack.opcodes.aget_char.Test_aget_char");
+
+  @Nonnull
+  private RuntimeTestInfo RETURN_OBJECT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.return_object"),
+    "com.android.jack.opcodes.return_object.Test_return_object");
+
+  @Nonnull
+  private RuntimeTestInfo OPC_CONST = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_const"),
+    "com.android.jack.opcodes.opc_const.Test_opc_const");
+
+  @Nonnull
+  private RuntimeTestInfo SUB_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_int"),
+    "com.android.jack.opcodes.sub_int.Test_sub_int");
+
+  @Nonnull
+  private RuntimeTestInfo APUT_CHAR = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_char"),
+    "com.android.jack.opcodes.aput_char.Test_aput_char");
+
+  @Nonnull
+  private RuntimeTestInfo NEG_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_int"),
+    "com.android.jack.opcodes.neg_int.Test_neg_int");
+
+  @Nonnull
+  private RuntimeTestInfo MUL_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_double"),
+    "com.android.jack.opcodes.mul_double.Test_mul_double");
+
+  @Nonnull
+  private RuntimeTestInfo DOUBLE_TO_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.double_to_float"),
+    "com.android.jack.opcodes.double_to_float.Test_double_to_float");
+
+  @Nonnull
+  private RuntimeTestInfo INT_TO_BYTE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_byte"),
+    "com.android.jack.opcodes.int_to_byte.Test_int_to_byte");
+
+  @Nonnull
+  private RuntimeTestInfo IF_LE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_le"),
+    "com.android.jack.opcodes.if_le.Test_if_le");
+
+  @Nonnull
+  private RuntimeTestInfo INVOKE_VIRTUAL = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_virtual"),
+    "com.android.jack.opcodes.invoke_virtual.Test_invoke_virtual");
+
+  @Nonnull
+  private RuntimeTestInfo DIV_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_double"),
+    "com.android.jack.opcodes.div_double.Test_div_double");
+
+  @Nonnull
+  private RuntimeTestInfo IF_GT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_gt"),
+    "com.android.jack.opcodes.if_gt.Test_if_gt");
+
+  @Nonnull
+  private RuntimeTestInfo AGET_SHORT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_short"),
+    "com.android.jack.opcodes.aget_short.Test_aget_short");
+
+  @Nonnull
+  private RuntimeTestInfo CONST_STRING = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.const_string"),
+    "com.android.jack.opcodes.const_string.Test_const_string");
+
+  @Nonnull
+  private RuntimeTestInfo OR_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.or_int"),
+    "com.android.jack.opcodes.or_int.Test_or_int");
+
+  @Nonnull
+  private RuntimeTestInfo REM_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_int"),
+    "com.android.jack.opcodes.rem_int.Test_rem_int");
+
+  @Nonnull
+  private RuntimeTestInfo REM_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_double"),
+    "com.android.jack.opcodes.rem_double.Test_rem_double");
+
+  @Nonnull
+  private RuntimeTestInfo LONG_TO_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.long_to_double"),
+    "com.android.jack.opcodes.long_to_double.Test_long_to_double");
+
+  @Nonnull
+  private RuntimeTestInfo IF_NE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_ne"),
+    "com.android.jack.opcodes.if_ne.Test_if_ne");
+
+  @Nonnull
+  private RuntimeTestInfo CMP_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmp_long"),
+    "com.android.jack.opcodes.cmp_long.Test_cmp_long");
+
+  @Nonnull
+  private RuntimeTestInfo SGET = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sget"),
+    "com.android.jack.opcodes.sget.Test_sget");
+
+  @Nonnull
+  private RuntimeTestInfo AGET_WIDE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_wide"),
+    "com.android.jack.opcodes.aget_wide.Test_aget_wide");
+
+  @Nonnull
+  private RuntimeTestInfo IF_LTZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_ltz"),
+    "com.android.jack.opcodes.if_ltz.Test_if_ltz");
+
+  @Nonnull
+  private RuntimeTestInfo OPC_INSTANCEOF = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_instanceof"),
+    "com.android.jack.opcodes.opc_instanceof.Test_opc_instanceof");
+
+  @Nonnull
+  private RuntimeTestInfo NEG_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.neg_double"),
+    "com.android.jack.opcodes.neg_double.Test_neg_double");
+
+  @Nonnull
+  private RuntimeTestInfo RETURN_WIDE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.return_wide"),
+    "com.android.jack.opcodes.return_wide.Test_return_wide");
+
+  @Nonnull
+  private RuntimeTestInfo FLOAT_TO_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.float_to_double"),
+    "com.android.jack.opcodes.float_to_double.Test_float_to_double");
+
+  @Nonnull
+  private RuntimeTestInfo APUT_SHORT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_short"),
+    "com.android.jack.opcodes.aput_short.Test_aput_short");
+
+  @Nonnull
+  private RuntimeTestInfo CMPG_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpg_double"),
+    "com.android.jack.opcodes.cmpg_double.Test_cmpg_double");
+
+  @Nonnull
+  private RuntimeTestInfo IF_LEZ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_lez"),
+    "com.android.jack.opcodes.if_lez.Test_if_lez");
+
+  @Nonnull
+  private RuntimeTestInfo IF_EQ = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.if_eq"),
+    "com.android.jack.opcodes.if_eq.Test_if_eq");
+
+  @Nonnull
+  private RuntimeTestInfo NEW_ARRAY = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.new_array"),
+    "com.android.jack.opcodes.new_array.Test_new_array");
+
+  @Nonnull
+  private RuntimeTestInfo SHR_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shr_long"),
+    "com.android.jack.opcodes.shr_long.Test_shr_long");
+
+  @Nonnull
+  private RuntimeTestInfo ADD_DOUBLE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_double"),
+    "com.android.jack.opcodes.add_double.Test_add_double");
+
+  @Nonnull
+  private RuntimeTestInfo DIV_LONG = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.div_long"),
+    "com.android.jack.opcodes.div_long.Test_div_long");
+
+  @Nonnull
+  private RuntimeTestInfo SPARSE_SWITCH = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sparse_switch"),
+    "com.android.jack.opcodes.sparse_switch.Test_sparse_switch");
+
+  @Nonnull
+  private RuntimeTestInfo INVOKE_INTERFACE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_interface"),
+    "com.android.jack.opcodes.invoke_interface.Test_invoke_interface");
+
+  @Nonnull
+  private RuntimeTestInfo APUT_WIDE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput_wide"),
+    "com.android.jack.opcodes.aput_wide.Test_aput_wide");
+
+  @Nonnull
+  private RuntimeTestInfo AGET_BYTE = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aget_byte"),
+    "com.android.jack.opcodes.aget_byte.Test_aget_byte");
+
+  @Nonnull
+  private RuntimeTestInfo APUT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.aput"),
+    "com.android.jack.opcodes.aput.Test_aput");
+
+  @Nonnull
+  private RuntimeTestInfo SHR_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.shr_int"),
+    "com.android.jack.opcodes.shr_int.Test_shr_int");
+
+  @Nonnull
+  private RuntimeTestInfo OPC_RETURN = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.opc_return"),
+    "com.android.jack.opcodes.opc_return.Test_opc_return");
+
+  @Nonnull
+  private RuntimeTestInfo INVOKE_SUPER = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.invoke_super"),
+    "com.android.jack.opcodes.invoke_super.Test_invoke_super");
+
+  @Nonnull
+  private RuntimeTestInfo MUL_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.mul_float"),
+    "com.android.jack.opcodes.mul_float.Test_mul_float");
+
+  @Nonnull
+  private RuntimeTestInfo SUB_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.sub_float"),
+    "com.android.jack.opcodes.sub_float.Test_sub_float");
+
+  @Nonnull
+  private RuntimeTestInfo ADD_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.add_int"),
+    "com.android.jack.opcodes.add_int.Test_add_int");
+
+  @Nonnull
+  private RuntimeTestInfo INT_TO_CHAR = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.int_to_char"),
+    "com.android.jack.opcodes.int_to_char.Test_int_to_char");
+
+  @Nonnull
+  private RuntimeTestInfo AND_INT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.and_int"),
+    "com.android.jack.opcodes.and_int.Test_and_int");
+
+  @Nonnull
+  private RuntimeTestInfo CMPG_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.cmpg_float"),
+    "com.android.jack.opcodes.cmpg_float.Test_cmpg_float");
+
+  @Nonnull
+  private RuntimeTestInfo IGET = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.iget"),
+    "com.android.jack.opcodes.iget.Test_iget");
+
+  @Nonnull
+  private RuntimeTestInfo REM_FLOAT = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.opcodes.rem_float"),
+    "com.android.jack.opcodes.rem_float.Test_rem_float");
+
+
+  @BeforeClass
+  public static void setUpClass() {
+    OpcodesTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void invoke_static() throws Exception {
+    new RuntimeTestHelper(INVOKE_STATIC)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void array_length() throws Exception {
+    new RuntimeTestHelper(ARRAY_LENGTH)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void neg_float() throws Exception {
+    new RuntimeTestHelper(NEG_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sub_double() throws Exception {
+    new RuntimeTestHelper(SUB_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aget() throws Exception {
+    new RuntimeTestHelper(AGET)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aput_byte() throws Exception {
+    new RuntimeTestHelper(APUT_BYTE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void opc_new() throws Exception {
+    new RuntimeTestHelper(OPC_NEW)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void cmpl_double() throws Exception {
+    new RuntimeTestHelper(CMPL_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_gtz() throws Exception {
+    new RuntimeTestHelper(IF_GTZ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void float_to_long() throws Exception {
+    new RuntimeTestHelper(FLOAT_TO_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void add_long() throws Exception {
+    new RuntimeTestHelper(ADD_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void add_float() throws Exception {
+    new RuntimeTestHelper(ADD_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void iput() throws Exception {
+    new RuntimeTestHelper(IPUT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void div_float() throws Exception {
+    new RuntimeTestHelper(DIV_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void ushr_long() throws Exception {
+    new RuntimeTestHelper(USHR_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void const_wide() throws Exception {
+    new RuntimeTestHelper(CONST_WIDE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void xor_int() throws Exception {
+    new RuntimeTestHelper(XOR_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aget_object() throws Exception {
+    new RuntimeTestHelper(AGET_OBJECT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void const4_16() throws Exception {
+    new RuntimeTestHelper(CONST4_16)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void rem_long() throws Exception {
+    new RuntimeTestHelper(REM_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void ushr_int() throws Exception {
+    new RuntimeTestHelper(USHR_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_ge() throws Exception {
+    new RuntimeTestHelper(IF_GE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sub_long() throws Exception {
+    new RuntimeTestHelper(SUB_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void float_to_int() throws Exception {
+    new RuntimeTestHelper(FLOAT_TO_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void int_to_long() throws Exception {
+    new RuntimeTestHelper(INT_TO_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void or_long() throws Exception {
+    new RuntimeTestHelper(OR_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_gez() throws Exception {
+    new RuntimeTestHelper(IF_GEZ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void shl_int() throws Exception {
+    new RuntimeTestHelper(SHL_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void long_to_float() throws Exception {
+    new RuntimeTestHelper(LONG_TO_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void div_int() throws Exception {
+    new RuntimeTestHelper(DIV_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void and_long() throws Exception {
+    new RuntimeTestHelper(AND_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void double_to_long() throws Exception {
+    new RuntimeTestHelper(DOUBLE_TO_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void mul_long() throws Exception {
+    new RuntimeTestHelper(MUL_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void double_to_int() throws Exception {
+    new RuntimeTestHelper(DOUBLE_TO_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_nez() throws Exception {
+    new RuntimeTestHelper(IF_NEZ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aput_object() throws Exception {
+    new RuntimeTestHelper(APUT_OBJECT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_lt() throws Exception {
+    new RuntimeTestHelper(IF_LT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void int_to_double() throws Exception {
+    new RuntimeTestHelper(INT_TO_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void mul_int() throws Exception {
+    new RuntimeTestHelper(MUL_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sput() throws Exception {
+    new RuntimeTestHelper(SPUT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void shl_long() throws Exception {
+    new RuntimeTestHelper(SHL_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void neg_long() throws Exception {
+    new RuntimeTestHelper(NEG_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void long_to_int() throws Exception {
+    new RuntimeTestHelper(LONG_TO_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void opc_goto() throws Exception {
+    new RuntimeTestHelper(OPC_GOTO)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void int_to_float() throws Exception {
+    new RuntimeTestHelper(INT_TO_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void xor_long() throws Exception {
+    new RuntimeTestHelper(XOR_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void monitor_enter() throws Exception {
+    new RuntimeTestHelper(MONITOR_ENTER)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_eqz() throws Exception {
+    new RuntimeTestHelper(IF_EQZ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void invoke_direct() throws Exception {
+    new RuntimeTestHelper(INVOKE_DIRECT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void cmpl_float() throws Exception {
+    new RuntimeTestHelper(CMPL_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void check_cast() throws Exception {
+    new RuntimeTestHelper(CHECK_CAST)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void opc_throw() throws Exception {
+    new RuntimeTestHelper(OPC_THROW)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void int_to_short() throws Exception {
+    new RuntimeTestHelper(INT_TO_SHORT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void packed_switch() throws Exception {
+    new RuntimeTestHelper(PACKED_SWITCH)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aget_char() throws Exception {
+    new RuntimeTestHelper(AGET_CHAR)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void return_object() throws Exception {
+    new RuntimeTestHelper(RETURN_OBJECT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void opc_const() throws Exception {
+    new RuntimeTestHelper(OPC_CONST)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sub_int() throws Exception {
+    new RuntimeTestHelper(SUB_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aput_char() throws Exception {
+    new RuntimeTestHelper(APUT_CHAR)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void neg_int() throws Exception {
+    new RuntimeTestHelper(NEG_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void mul_double() throws Exception {
+    new RuntimeTestHelper(MUL_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void double_to_float() throws Exception {
+    new RuntimeTestHelper(DOUBLE_TO_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void int_to_byte() throws Exception {
+    new RuntimeTestHelper(INT_TO_BYTE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_le() throws Exception {
+    new RuntimeTestHelper(IF_LE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void invoke_virtual() throws Exception {
+    new RuntimeTestHelper(INVOKE_VIRTUAL)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void div_double() throws Exception {
+    new RuntimeTestHelper(DIV_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_gt() throws Exception {
+    new RuntimeTestHelper(IF_GT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aget_short() throws Exception {
+    new RuntimeTestHelper(AGET_SHORT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void const_string() throws Exception {
+    new RuntimeTestHelper(CONST_STRING)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void or_int() throws Exception {
+    new RuntimeTestHelper(OR_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void rem_int() throws Exception {
+    new RuntimeTestHelper(REM_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void rem_double() throws Exception {
+    new RuntimeTestHelper(REM_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void long_to_double() throws Exception {
+    new RuntimeTestHelper(LONG_TO_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_ne() throws Exception {
+    new RuntimeTestHelper(IF_NE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void cmp_long() throws Exception {
+    new RuntimeTestHelper(CMP_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sget() throws Exception {
+    new RuntimeTestHelper(SGET)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aget_wide() throws Exception {
+    new RuntimeTestHelper(AGET_WIDE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_ltz() throws Exception {
+    new RuntimeTestHelper(IF_LTZ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void opc_instanceof() throws Exception {
+    new RuntimeTestHelper(OPC_INSTANCEOF)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void neg_double() throws Exception {
+    new RuntimeTestHelper(NEG_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void return_wide() throws Exception {
+    new RuntimeTestHelper(RETURN_WIDE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void float_to_double() throws Exception {
+    new RuntimeTestHelper(FLOAT_TO_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aput_short() throws Exception {
+    new RuntimeTestHelper(APUT_SHORT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void cmpg_double() throws Exception {
+    new RuntimeTestHelper(CMPG_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_lez() throws Exception {
+    new RuntimeTestHelper(IF_LEZ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void if_eq() throws Exception {
+    new RuntimeTestHelper(IF_EQ)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void new_array() throws Exception {
+    new RuntimeTestHelper(NEW_ARRAY)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void shr_long() throws Exception {
+    new RuntimeTestHelper(SHR_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void add_double() throws Exception {
+    new RuntimeTestHelper(ADD_DOUBLE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void div_long() throws Exception {
+    new RuntimeTestHelper(DIV_LONG)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sparse_switch() throws Exception {
+    new RuntimeTestHelper(SPARSE_SWITCH)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void invoke_interface() throws Exception {
+    new RuntimeTestHelper(INVOKE_INTERFACE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aput_wide() throws Exception {
+    new RuntimeTestHelper(APUT_WIDE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aget_byte() throws Exception {
+    new RuntimeTestHelper(AGET_BYTE)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void aput() throws Exception {
+    new RuntimeTestHelper(APUT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void shr_int() throws Exception {
+    new RuntimeTestHelper(SHR_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void opc_return() throws Exception {
+    new RuntimeTestHelper(OPC_RETURN)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void invoke_super() throws Exception {
+    new RuntimeTestHelper(INVOKE_SUPER)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void mul_float() throws Exception {
+    new RuntimeTestHelper(MUL_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void sub_float() throws Exception {
+    new RuntimeTestHelper(SUB_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void add_int() throws Exception {
+    new RuntimeTestHelper(ADD_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void int_to_char() throws Exception {
+    new RuntimeTestHelper(INT_TO_CHAR)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void and_int() throws Exception {
+    new RuntimeTestHelper(AND_INT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void cmpg_float() throws Exception {
+    new RuntimeTestHelper(CMPG_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void iget() throws Exception {
+    new RuntimeTestHelper(IGET)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+  @Test
+  //@Category(RuntimeRegressionTest.class)
+  public void rem_float() throws Exception {
+    new RuntimeTestHelper(REM_FLOAT)
+    .setSrcDirName("jm")
+    .setRefDirName( ".")
+    .addReferenceExtraSources(new File(AbstractTestTools.getJackRootDir(), "toolchain/jack/jack-tests/src/com/android/jack/DxTestCase.java"))
+    .compileAndRunTest();
+  }
+
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(INVOKE_STATIC);
+    rtTestInfos.add(ARRAY_LENGTH);
+    rtTestInfos.add(NEG_FLOAT);
+    rtTestInfos.add(SUB_DOUBLE);
+    rtTestInfos.add(AGET);
+    rtTestInfos.add(APUT_BYTE);
+    rtTestInfos.add(OPC_NEW);
+    rtTestInfos.add(CMPL_DOUBLE);
+    rtTestInfos.add(IF_GTZ);
+    rtTestInfos.add(FLOAT_TO_LONG);
+    rtTestInfos.add(ADD_LONG);
+    rtTestInfos.add(ADD_FLOAT);
+    rtTestInfos.add(IPUT);
+    rtTestInfos.add(DIV_FLOAT);
+    rtTestInfos.add(USHR_LONG);
+    rtTestInfos.add(CONST_WIDE);
+    rtTestInfos.add(XOR_INT);
+    rtTestInfos.add(AGET_OBJECT);
+    rtTestInfos.add(CONST4_16);
+    rtTestInfos.add(REM_LONG);
+    rtTestInfos.add(USHR_INT);
+    rtTestInfos.add(IF_GE);
+    rtTestInfos.add(SUB_LONG);
+    rtTestInfos.add(FLOAT_TO_INT);
+    rtTestInfos.add(INT_TO_LONG);
+    rtTestInfos.add(OR_LONG);
+    rtTestInfos.add(IF_GEZ);
+    rtTestInfos.add(SHL_INT);
+    rtTestInfos.add(LONG_TO_FLOAT);
+    rtTestInfos.add(DIV_INT);
+    rtTestInfos.add(AND_LONG);
+    rtTestInfos.add(DOUBLE_TO_LONG);
+    rtTestInfos.add(MUL_LONG);
+    rtTestInfos.add(DOUBLE_TO_INT);
+    rtTestInfos.add(IF_NEZ);
+    rtTestInfos.add(APUT_OBJECT);
+    rtTestInfos.add(IF_LT);
+    rtTestInfos.add(INT_TO_DOUBLE);
+    rtTestInfos.add(MUL_INT);
+    rtTestInfos.add(SPUT);
+    rtTestInfos.add(SHL_LONG);
+    rtTestInfos.add(NEG_LONG);
+    rtTestInfos.add(LONG_TO_INT);
+    rtTestInfos.add(OPC_GOTO);
+    rtTestInfos.add(INT_TO_FLOAT);
+    rtTestInfos.add(XOR_LONG);
+    rtTestInfos.add(MONITOR_ENTER);
+    rtTestInfos.add(IF_EQZ);
+    rtTestInfos.add(INVOKE_DIRECT);
+    rtTestInfos.add(CMPL_FLOAT);
+    rtTestInfos.add(CHECK_CAST);
+    rtTestInfos.add(OPC_THROW);
+    rtTestInfos.add(INT_TO_SHORT);
+    rtTestInfos.add(PACKED_SWITCH);
+    rtTestInfos.add(AGET_CHAR);
+    rtTestInfos.add(RETURN_OBJECT);
+    rtTestInfos.add(OPC_CONST);
+    rtTestInfos.add(SUB_INT);
+    rtTestInfos.add(APUT_CHAR);
+    rtTestInfos.add(NEG_INT);
+    rtTestInfos.add(MUL_DOUBLE);
+    rtTestInfos.add(DOUBLE_TO_FLOAT);
+    rtTestInfos.add(INT_TO_BYTE);
+    rtTestInfos.add(IF_LE);
+    rtTestInfos.add(INVOKE_VIRTUAL);
+    rtTestInfos.add(DIV_DOUBLE);
+    rtTestInfos.add(IF_GT);
+    rtTestInfos.add(AGET_SHORT);
+    rtTestInfos.add(CONST_STRING);
+    rtTestInfos.add(OR_INT);
+    rtTestInfos.add(REM_INT);
+    rtTestInfos.add(REM_DOUBLE);
+    rtTestInfos.add(LONG_TO_DOUBLE);
+    rtTestInfos.add(IF_NE);
+    rtTestInfos.add(CMP_LONG);
+    rtTestInfos.add(SGET);
+    rtTestInfos.add(AGET_WIDE);
+    rtTestInfos.add(IF_LTZ);
+    rtTestInfos.add(OPC_INSTANCEOF);
+    rtTestInfos.add(NEG_DOUBLE);
+    rtTestInfos.add(RETURN_WIDE);
+    rtTestInfos.add(FLOAT_TO_DOUBLE);
+    rtTestInfos.add(APUT_SHORT);
+    rtTestInfos.add(CMPG_DOUBLE);
+    rtTestInfos.add(IF_LEZ);
+    rtTestInfos.add(IF_EQ);
+    rtTestInfos.add(NEW_ARRAY);
+    rtTestInfos.add(SHR_LONG);
+    rtTestInfos.add(ADD_DOUBLE);
+    rtTestInfos.add(DIV_LONG);
+    rtTestInfos.add(SPARSE_SWITCH);
+    rtTestInfos.add(INVOKE_INTERFACE);
+    rtTestInfos.add(APUT_WIDE);
+    rtTestInfos.add(AGET_BYTE);
+    rtTestInfos.add(APUT);
+    rtTestInfos.add(SHR_INT);
+    rtTestInfos.add(OPC_RETURN);
+    rtTestInfos.add(INVOKE_SUPER);
+    rtTestInfos.add(MUL_FLOAT);
+    rtTestInfos.add(SUB_FLOAT);
+    rtTestInfos.add(ADD_INT);
+    rtTestInfos.add(INT_TO_CHAR);
+    rtTestInfos.add(AND_INT);
+    rtTestInfos.add(CMPG_FLOAT);
+    rtTestInfos.add(IGET);
+    rtTestInfos.add(REM_FLOAT);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/exprsimplifier/ExprsimplifierTests.java b/jack-tests/tests/com/android/jack/optimizations/exprsimplifier/ExprsimplifierTests.java
new file mode 100644
index 00000000..2534c3ca
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/exprsimplifier/ExprsimplifierTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.optimizations.exprsimplifier;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ExprsimplifierTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.optimizations.exprsimplifier.test001"),
+    "com.android.jack.optimizations.exprsimplifier.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ExprsimplifierTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/notsimplifier/NotsimplifierTests.java b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/NotsimplifierTests.java
new file mode 100644
index 00000000..0962ae2f
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/notsimplifier/NotsimplifierTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.optimizations.notsimplifier;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class NotsimplifierTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.optimizations.notsimplifier.test001"),
+    "com.android.jack.optimizations.notsimplifier.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    NotsimplifierTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/optimizations/uselesscopy/UselessVariableCopyTest.java b/jack-tests/tests/com/android/jack/optimizations/uselesscopy/UselessVariableCopyTest.java
new file mode 100644
index 00000000..eaae6aee
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/optimizations/uselesscopy/UselessVariableCopyTest.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.optimizations.uselesscopy;
+
+import com.android.jack.TestTools;
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+
+import junit.framework.Assert;
+
+import org.jf.dexlib.CodeItem;
+import org.jf.dexlib.DexFile;
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class UselessVariableCopyTest {
+
+  /**
+   * Verify that generated dex does not contains useless 'mov' instructions.
+   */
+  @Test
+  @Category(KnownBugs.class)
+  public void test001() throws Exception {
+    File out = AbstractTestTools.createTempDir();
+    File outDex = new File(out, "classes.dex");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.disableDxOptimizations();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        out,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.optimizations.uselesscopy.test001.jack"));
+
+    DexFile dexFile = new DexFile(outDex);
+    CodeItem ci =
+        TestTools.getEncodedMethod(dexFile,
+            "Lcom/android/jack/optimizations/uselesscopy/test001/jack/Test001;", "test",
+            "(Ljava/lang/Object;)Z").codeItem;
+
+    Assert.assertFalse(hasOpcode(ci, Opcode.MOVE_OBJECT));
+  }
+
+  private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) {
+    for (Instruction inst : codeItem.getInstructions()) {
+      if (inst.opcode == opcode) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/order/OrderTests.java b/jack-tests/tests/com/android/jack/order/OrderTests.java
new file mode 100644
index 00000000..c62c8003
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/order/OrderTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.order;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class OrderTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.order.test001"),
+    "com.android.jack.order.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    OrderTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/order/dx/Tests.java b/jack-tests/tests/com/android/jack/order/test001/dx/Tests.java
index 4c2243bf..9d272672 100644
--- a/jack-tests/tests/com/android/jack/order/dx/Tests.java
+++ b/jack-tests/tests/com/android/jack/order/test001/dx/Tests.java
@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-package com.android.jack.order.dx;
+package com.android.jack.order.test001.dx;
 
-import com.android.jack.order.jack.Order;
+import com.android.jack.order.test001.jack.Order;
 
 import org.junit.Assert;
 import org.junit.Test;
diff --git a/jack-tests/tests/com/android/jack/order/jack/Order.java b/jack-tests/tests/com/android/jack/order/test001/jack/Order.java
index 47ee620f..770f9f9b 100644
--- a/jack-tests/tests/com/android/jack/order/jack/Order.java
+++ b/jack-tests/tests/com/android/jack/order/test001/jack/Order.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.order.jack;
+package com.android.jack.order.test001.jack;
 
 /**
  * Evaluation order test.
diff --git a/jack-tests/tests/com/android/jack/preprocessor/PreProcessorTests.java b/jack-tests/tests/com/android/jack/preprocessor/PreProcessorTests.java
new file mode 100644
index 00000000..e5627bb7
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/preprocessor/PreProcessorTests.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.preprocessor;
+
+import com.android.jack.Main;
+import com.android.jack.Options;
+import com.android.jack.TestTools;
+import com.android.jack.ir.ast.JAnnotation;
+import com.android.jack.ir.ast.JDefinedClassOrInterface;
+import com.android.jack.ir.ast.JMethod;
+import com.android.jack.ir.ast.JSession;
+import com.android.jack.lookup.JNodeLookup;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+import com.android.sched.util.RunnableHooks;
+
+import junit.framework.Assert;
+
+import org.antlr.runtime.ANTLRFileStream;
+import org.antlr.runtime.CommonTokenStream;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+import java.util.Collection;
+
+public class PreProcessorTests {
+
+  @BeforeClass
+  public static void setUpClass() throws Exception {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void test001_002() throws Exception {
+    File testDir = AbstractTestTools.getTestRootDir("com.android.jack.preprocessor.test001.jack");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProperty(PreProcessor.ENABLE.getName(), "true");
+    toolchain.addProperty(PreProcessor.FILE.getName(),
+        new File(testDir, "config.jpp").getAbsolutePath());
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempFile("annotationAdderTest", ".out.zip"),
+        /* zipFile = */ true,
+        testDir);
+  }
+
+  @Test
+  public void test001_001() throws Exception {
+    File testDir = AbstractTestTools.getTestRootDir("com.android.jack.preprocessor.test001.jack");
+    File tempDir = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempDir,
+        /* zipFiles = */ false,
+        testDir);
+
+    Options args = TestTools.buildCommandLineArgs(
+        new File(testDir, "app1/ApplicationActivity1.java"));
+    args.setClasspath(tempDir.getPath());
+    RunnableHooks hooks = new RunnableHooks();
+    JSession session = TestTools.buildSession(args, hooks);
+    ANTLRFileStream in = new ANTLRFileStream(new File(testDir, "config.jpp").getAbsolutePath());
+    PreProcessorLexer lexer = new PreProcessorLexer(in);
+    CommonTokenStream tokens = new CommonTokenStream(lexer);
+    PreProcessorParser parser = new PreProcessorParser(tokens);
+    Collection<Rule> rules = parser.rules(session);
+    Scope scope = new TypeToEmitScope(session);
+    for (Rule rule : rules) {
+      Context context = new Context();
+      if (!rule.getSet().eval(scope, context).isEmpty()) {
+        context.getRequest(session).commit();
+      }
+    }
+
+    JAnnotation installerAnnotation = session.getPhantomLookup().getAnnotation(
+        "Lcom/android/jack/preprocessor/test001/jack/MultiDexInstaller;");
+    JNodeLookup lookup = session.getLookup();
+    {
+      JDefinedClassOrInterface coi = lookup.getClass(
+          "Lcom/android/jack/preprocessor/test001/jack/app1/ApplicationActivity1;");
+      Assert.assertFalse(coi.getAnnotations(installerAnnotation).isEmpty());
+      for (JMethod method : coi.getMethods()) {
+        if (method.getName().equals("noAnnotation")) {
+          Assert.assertTrue(method.getAnnotations(installerAnnotation).isEmpty());
+        } else {
+          Assert.assertFalse(method.getAnnotations(installerAnnotation).isEmpty());
+        }
+      }
+    }
+
+    hooks.runHooks();
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/resource/ResourceTests.java b/jack-tests/tests/com/android/jack/resource/ResourceTests.java
new file mode 100644
index 00000000..4a364b05
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/resource/ResourceTests.java
@@ -0,0 +1,589 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+import com.android.sched.util.stream.ByteStreamSucker;
+
+import junit.framework.Assert;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+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;
+
+import javax.annotation.Nonnull;
+
+/**
+ * JUnit tests for resource support.
+ */
+public class ResourceTests {
+
+  @Nonnull
+  private static final String COMMON_PATH = "com/android/jack/resource/test001/jack/";
+  @Nonnull
+  private static final String JACK_FILE_PATH = FileType.JAYCE.getPrefix() + "/" + COMMON_PATH
+      + "IrrelevantForTest.jayce";
+  @Nonnull
+  private static final String DEX_FILE_PATH = FileType.DEX.getPrefix() + "/" + COMMON_PATH
+      + "IrrelevantForTest.dex";
+  @Nonnull
+  private static final String RESOURCE1_SHORTPATH = "Resource1";
+  @Nonnull
+  private static final String RESOURCE2_SHORTPATH = "Resource2";
+  @Nonnull
+  private static final String RESOURCE3_SHORTPATH = "pack/Resource3";
+  @Nonnull
+  private static final String RESOURCE4_SHORTPATH = "pack/Resource4";
+
+  @Nonnull
+  private static final File FILE =
+      AbstractTestTools.getTestRootDir("com.android.jack.resource.test001.jack");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ResourceTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void testJackArchiveToDexDir() throws Exception {
+    // compile source file to a Jack archive and add resources
+    File jackAr = createJackArchiveWithResources();
+
+    // compile Jack archive to a dex dir
+    File dexDir = TestTools.createTempDir("resourcetestdex", "dir");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(jackAr, 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);
+  }
+
+  @Test
+  public void testJackArchiveToDexArchive() throws Exception {
+    // compile source file to a Jack archive and add resources
+    File jackAr = createJackArchiveWithResources();
+
+    // compile Jack archive to dex archive
+    File dexAr = AbstractTestTools.createTempFile("resourcetestdex", ".zip");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(jackAr, dexAr, /* zipFile = */ true);
+
+    // check that resources are contained in dex archive
+    ZipFile zipFile = new ZipFile(dexAr);
+    checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false);
+    checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ false);
+    checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ false);
+    checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ false);
+  }
+
+  @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 */);
+
+    // compile Jack dir to dex archive
+    File dexAr = TestTools.createTempFile("resourcetestdex", ".zip");
+    TestTools.compileJackToDex(new Options(), jackFolder, dexAr, true /* zipped */);
+
+    // check that resources are contained in dex archive
+    ZipFile zipFile = new ZipFile(dexAr);
+    checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ false);
+    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
+  public void testJackArchiveToJackArchive() throws Exception {
+    // compile source file to a Jack archive and add resources
+    File jackAr = createJackArchiveWithResources();
+
+    // run shrobbing from Jack archive to Jack archive
+    File shrobbedJackAr = AbstractTestTools.createTempFile("shrobbedJackAr", ".zip");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new File(FILE, "proguard.flags"));
+    toolchain.libToLib(jackAr, shrobbedJackAr, /* zipFiles = */ true);
+
+    // check that resources are contained in dex archive
+    ZipFile zipFile = new ZipFile(shrobbedJackAr);
+    checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true);
+    checkResourceContentFromZip(zipFile, RESOURCE2_SHORTPATH, "Res2", /*isLib*/ true);
+    checkResourceContentFromZip(zipFile, RESOURCE3_SHORTPATH, "Res3", /*isLib*/ true);
+    checkResourceContentFromZip(zipFile, RESOURCE4_SHORTPATH, "Res4", /*isLib*/ true);
+  }
+
+  @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 */);
+
+    // 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 */);
+
+    // check that resources are contained in Jack archive
+    ZipFile zipFile = new ZipFile(shrobbedJackAr);
+    checkResourceContentFromZip(zipFile, RESOURCE1_SHORTPATH, "Res1", /*isLib*/ true);
+    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
+  public void testJackArchiveToJackDir() throws Exception {
+    // compile source file to a Jack archive and add resources
+    File jackAr = createJackArchiveWithResources();
+
+    // run shrobbing from Jack archive to Jack dir
+    File shrobbedJackDir = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new File(FILE, "proguard.flags"));
+    toolchain.libToLib(jackAr, 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);
+
+  }
+
+  @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 */);
+
+    // 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 */);
+
+    // 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 */);
+
+    // compile Jack dir to a dex dir
+    File dexDir = TestTools.createTempDir("resourcetestdex", "dir");
+    TestTools.compileJackToDex(new Options(), jackFolder, dexDir, false /* zipped */);
+
+    // 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
+  @Category(KnownBugs.class)
+  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 */);
+
+    // compile Jack dir to same dir
+    File dexDir = jackFolder;
+    TestTools.compileJackToDex(new Options(), jackFolder, dexDir, false /* zipped */);
+
+    // 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
+  @Category(KnownBugs.class)
+  public void testResourceContentAdaptation() throws Exception {
+    // compile source file to a Jack dir
+    File jackOutputFolder = AbstractTestTools.createTempDir();
+    //String testName = "resource/test003";
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.resource.test003");
+    File jackTestFolder = AbstractTestTools.getTestRootDir("com.android.jack.resource.test003.jack");
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          jackOutputFolder,
+          /* zipFiles = */ false,
+          testFolder);
+
+    String resource1LongPath = "com/android/jack/resource/test003/jack/A";
+    String resource2LongPath = "com/android/jack/resource/test003/jack/A.txt";
+
+    // add resources to Jack dir
+    copyFileToDir(new File(jackTestFolder, "A.txt"), resource1LongPath, jackOutputFolder);
+    copyFileToDir(new File(jackTestFolder, "A.txt"), resource2LongPath, jackOutputFolder);
+
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13");
+    File shrobbedJackDir = AbstractTestTools.createTempDir();
+    toolchain.addProguardFlags(new File(testFolder, "proguard.flags001"));
+    toolchain.libToLib(jackOutputFolder, shrobbedJackDir, /* zipFiles = */ false);
+
+    // check that resources are contained in Jack dir and check their contents
+    File referenceFileContent = new File(testFolder, "refs/A.txt");
+    checkResourceContent(new File(shrobbedJackDir, "pcz/nbqfcvq/wnpx/frgcifpr/hrgh003/wnpx/A"),
+        referenceFileContent);
+    checkResourceContent(new File(shrobbedJackDir, "pcz/nbqfcvq/wnpx/frgcifpr/hrgh003/wnpx/N.txt"),
+        referenceFileContent);
+  }
+
+  @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 */);
+
+    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,
+      @Nonnull String expectedContent, boolean isLib) throws IOException {
+    ZipEntry entry = zipFile.getEntry((isLib ? FileType.RSC.getPrefix() + '/' : "") + entryName);
+    Assert.assertNotNull(entry);
+    BufferedReader candidateReader = null;
+    BufferedReader referenceReader = null;
+    try {
+      InputStream in = zipFile.getInputStream(entry);
+      candidateReader = new BufferedReader(new InputStreamReader(in));
+      referenceReader = new BufferedReader(new StringReader(expectedContent));
+      compareReadLines(referenceReader, candidateReader);
+    } finally {
+      if (candidateReader != null) {
+        candidateReader.close();
+      }
+      if (referenceReader != null) {
+        referenceReader.close();
+      }
+    }
+  }
+
+  private void checkResourceContentFromDir(@Nonnull File dir, @Nonnull String path,
+      @Nonnull String expectedContent, boolean isLib) throws IOException {
+    assert dir.isDirectory();
+    File file = new File(isLib ? new File(dir, FileType.RSC.getPrefix()) : dir, path);
+    Assert.assertTrue(file.exists());
+    BufferedReader candidateReader = null;
+    BufferedReader referenceReader = null;
+    try {
+      InputStream in = new FileInputStream(file);
+      candidateReader = new BufferedReader(new InputStreamReader(in));
+      referenceReader = new BufferedReader(new StringReader(expectedContent));
+      compareReadLines(referenceReader, candidateReader);
+    } finally {
+      if (candidateReader != null) {
+        candidateReader.close();
+      }
+      if (referenceReader != null) {
+        referenceReader.close();
+      }
+    }
+  }
+
+
+  private void checkResourceContent(@Nonnull File candidateFileContent,
+      @Nonnull File referenceFileContent) throws IOException {
+    Assert.assertTrue(candidateFileContent.exists());
+    BufferedReader candidateReader = null;
+    BufferedReader referenceReader = null;
+    try {
+      candidateReader = new BufferedReader(new InputStreamReader(new FileInputStream(candidateFileContent)));
+      referenceReader = new BufferedReader(new InputStreamReader(new FileInputStream(referenceFileContent)));
+      compareReadLines(referenceReader, candidateReader);
+    } finally {
+      if (candidateReader != null) {
+        candidateReader.close();
+      }
+      if (referenceReader != null) {
+        referenceReader.close();
+      }
+    }
+  }
+
+  private void compareReadLines(@Nonnull BufferedReader referenceReader,
+      @Nonnull BufferedReader candidateReader) throws IOException {
+      String referenceLine = referenceReader.readLine();
+      while (referenceLine != null) {
+        String candidateLine = candidateReader.readLine();
+        Assert.assertEquals(referenceLine, candidateLine);
+        referenceLine = referenceReader.readLine();
+      }
+      Assert.assertNull(candidateReader.readLine());
+  }
+
+  private void copyFileToDir(@Nonnull File fileToCopy, @Nonnull String relativePath,
+      @Nonnull File dir) throws IOException {
+    FileOutputStream fos = null;
+    FileInputStream fis = null;
+    try {
+      fis = new FileInputStream(fileToCopy);
+      File copiedFile = new File(dir, relativePath);
+      File parentDir = copiedFile.getParentFile();
+      if (!parentDir.exists()) {
+        boolean res = parentDir.mkdirs();
+        if (!res) {
+          throw new AssertionError();
+        }
+      }
+      try {
+        fos = new FileOutputStream(copiedFile);
+        ByteStreamSucker sucker = new ByteStreamSucker(fis, fos);
+        sucker.suck();
+      } finally {
+        if (fos != null) {
+          fos.close();
+        }
+      }
+    } finally {
+      if (fis != null) {
+        fis.close();
+      }
+    }
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/returnstatement/ReturnstatementTests.java b/jack-tests/tests/com/android/jack/returnstatement/ReturnstatementTests.java
new file mode 100644
index 00000000..1af46dc7
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/returnstatement/ReturnstatementTests.java
@@ -0,0 +1,75 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.returnstatement;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+public class ReturnstatementTests extends RuntimeTest {
+
+  private RuntimeTestInfo RETURNS = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.returnstatement.returns"),
+    "com.android.jack.returnstatement.returns.dx.Tests");
+
+  private RuntimeTestInfo RETURNVOID = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.returnstatement.returnvoid"),
+    "com.android.jack.returnstatement.returnvoid.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ReturnstatementTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void returns() throws Exception {
+    new RuntimeTestHelper(RETURNS).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void returnvoid() throws Exception {
+    new RuntimeTestHelper(RETURNVOID).compileAndRunTest();
+  }
+
+  @Test
+  public void ropBuildMethodWithSameReturnReg() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+
+    String classpath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath());
+    File dexOutDir = AbstractTestTools.createTempDir();
+    File testSourceDir = AbstractTestTools.getTestRootDir("com.android.jack.analysis.dfa.reachingdefs.test001");
+
+    toolchain.srcToExe(classpath, dexOutDir, /* zipFile = */ false, testSourceDir);
+
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(RETURNS);
+    rtTestInfos.add(RETURNVOID);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/AbstractTest.java b/jack-tests/tests/com/android/jack/shrob/AbstractTest.java
index 319abaff..22896b6a 100644
--- a/jack-tests/tests/com/android/jack/shrob/AbstractTest.java
+++ b/jack-tests/tests/com/android/jack/shrob/AbstractTest.java
@@ -19,8 +19,8 @@ package com.android.jack.shrob;
 import com.android.jack.Main;
 import com.android.jack.ProguardFlags;
 import com.android.jack.TestTools;
-import com.android.jack.category.KnownBugs;
-import com.android.jack.category.SlowTests;
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.test.category.SlowTests;
 
 import org.junit.BeforeClass;
 import org.junit.Test;
diff --git a/jack-tests/tests/com/android/jack/shrob/AnnotationsTest.java b/jack-tests/tests/com/android/jack/shrob/AnnotationsTest.java
new file mode 100644
index 00000000..cf819021
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/AnnotationsTest.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.ProguardFlags;
+import com.android.jack.TestTools;
+import com.android.jack.test.comparator.ComparatorDexAnnotations;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class AnnotationsTest extends AbstractTest {
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+    env.setCandidateTestTools(toolchain);
+    env.setProguardFlags(
+        generateApplyMapping(new File(testFolder,"proguard.flags" + flagNumber + ".mapping" + mappingNumber)),
+//      new ProguardFlags(TestTools.getJackTestFolder("shrob"),"keepDebugInfo.flags"),
+      new ProguardFlags(TestTools.getJackTestFolder("shrob"),"keepAllAttributes.flags"),
+      new ProguardFlags(testFolder,"proguard.flags" + flagNumber));
+    env.runTest(new ComparatorDexAnnotations(env.getCandidateDex(), env.getReferenceDex()));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java b/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java
new file mode 100644
index 00000000..a07b3c9f
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/FlattenPackageTests.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.Options;
+import com.android.jack.test.category.SlowTests;
+import com.android.jack.shrob.obfuscation.NameProviderFactory;
+import com.android.jack.shrob.proguard.GrammarActions;
+import com.android.jack.shrob.spec.Flags;
+import com.android.jack.test.comparator.ComparatorMapping;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.DummyToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+@Category(SlowTests.class)
+public class FlattenPackageTests extends AbstractTest {
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    Flags flags = new Flags();
+    toolchain.setShrobFlags(flags);
+    GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags);
+    GrammarActions.parse("keepPackageName.flags",
+        AbstractTestTools.getTestRootDir("com.android.jack.shrob").getAbsolutePath(), flags);
+    flags.setPackageForFlatHierarchy("flatpackage");
+    File candidateOutputMapping = AbstractTestTools.createTempFile("mapping", ".txt");
+    File refFolder = new File(testFolder, "refsFlattenPackage");
+    File refOutputMapping = new File(refFolder, "expected-" + flagNumber + ".txt");
+    flags.setOutputMapping(candidateOutputMapping);
+    flags.setPrintMapping(true);
+    toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13");
+    toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods");
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+
+    env.setCandidateTestTools(toolchain);
+    env.setReferenceTestTools(new DummyToolchain());
+
+    // TODO(jmhenaff): Find a way to avoid this line?
+    // This removes JUnit from default cp, otherwise this tests seems endless
+    env.setCandidateClasspath(new File[] {toolchain.getDefaultBootClasspath()[0]});
+
+    env.runTest(new ComparatorMapping(refOutputMapping, candidateOutputMapping));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithAttributesTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithAttributesTests.java
new file mode 100644
index 00000000..5a1feaf7
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithAttributesTests.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.ProguardFlags;
+import com.android.jack.test.comparator.ComparatorDex;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.AndroidToolchain;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+
+import org.junit.Test;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class ObfuscationWithAttributesTests extends AbstractTest {
+
+  @Override
+  @Test
+  public void test1_001() throws Exception {
+    super.test1_001();
+  }
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    File [] proguardFlags = new File [] {
+        generateApplyMapping(new File(testFolder,"proguard.flags" + flagNumber + ".mapping" + mappingNumber)),
+        new ProguardFlags(AbstractTestTools.getTestRootDir("com.android.jack.shrob"),"keepAllAttributes.flags"),
+        new ProguardFlags(testFolder,"proguard.flags" + flagNumber)
+    };
+    toolchain.addProguardFlags(proguardFlags);
+
+    AndroidToolchain refToolchain = AbstractTestTools.getReferenceToolchain(AndroidToolchain.class);
+    refToolchain.addProguardFlags(proguardFlags);
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+    env.setCandidateTestTools(toolchain);
+    env.setReferenceTestTools(refToolchain);
+    env.setWithDebugInfo(true);
+    env.runTest(new ComparatorDex(env.getCandidateDex(), env.getReferenceDex()));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithDebugInfoTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithDebugInfoTests.java
new file mode 100644
index 00000000..80eac52d
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithDebugInfoTests.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.ProguardFlags;
+import com.android.jack.test.comparator.ComparatorDex;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class ObfuscationWithDebugInfoTests extends AbstractTest {
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+    env.setWithDebugInfo(true);
+    env.setProguardFlags(
+        generateApplyMapping(
+        new File(testFolder, "proguard.flags" + flagNumber + ".mapping" + mappingNumber)),
+        new ProguardFlags(AbstractTestTools.getTestRootDir("com.android.jack.shrob"),
+            "keepDebugInfo.flags"), new ProguardFlags(testFolder, "proguard.flags" + flagNumber));
+
+    env.runTest(new ComparatorDex(env.getCandidateDex(), env.getReferenceDex()));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithMappingTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithMappingTests.java
new file mode 100644
index 00000000..fb09d898
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithMappingTests.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.shrob.proguard.GrammarActions;
+import com.android.jack.shrob.spec.Flags;
+import com.android.jack.test.comparator.ComparatorMapping;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.DummyToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import org.junit.Test;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class ObfuscationWithMappingTests extends AbstractTest {
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    Flags flags = new Flags();
+    toolchain.setShrobFlags(flags);
+    GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags);
+    File candidateOutputMapping = AbstractTestTools.createTempFile("mapping", ".txt");
+    File refFolder = new File(testFolder, "refsObfuscationWithMapping");
+    File refOutputMapping = new File(refFolder, "expected-" + flagNumber + ".txt");
+    flags.setOutputMapping(candidateOutputMapping);
+    flags.setPrintMapping(true);
+    File inputMapping =
+        new File(testFolder, "proguard.flags" + flagNumber + ".mapping" + mappingNumber);
+    if (inputMapping.exists()) {
+      flags.setObfuscationMapping(inputMapping);
+    }
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+
+    env.setCandidateTestTools(toolchain);
+    env.setReferenceTestTools(new DummyToolchain());
+
+    env.runTest(new ComparatorMapping(candidateOutputMapping, refOutputMapping));
+  }
+
+  @Override
+  @Test
+  public void test33_001() throws Exception {
+    // Test 33 already has a partial mapping, it can't be used in this test suite.
+  }
+
+  @Override
+  @Test
+  public void test33_002() throws Exception {
+    // Test 33 already has a partial mapping, it can't be used in this test suite.
+  }
+
+  @Override
+  @Test
+  public void test34_001() throws Exception {
+    // Test 35 already has a partial mapping, it can't be used in this test suite.
+  }
+
+  @Override
+  @Test
+  public void test35_001() throws Exception {
+    // Test 34 already has a partial mapping, it can't be used in this test suite.
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java
index 26cba495..a17b9fe0 100644
--- a/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java
+++ b/jack-tests/tests/com/android/jack/shrob/ObfuscationWithoutMappingTests.java
@@ -17,7 +17,7 @@
 package com.android.jack.shrob;
 
 import com.android.jack.Options;
-import com.android.jack.category.KnownBugs;
+import com.android.jack.test.category.KnownBugs;
 import com.android.jack.shrob.obfuscation.NameProviderFactory;
 import com.android.jack.shrob.proguard.GrammarActions;
 import com.android.jack.shrob.spec.Flags;
@@ -43,8 +43,6 @@ public class ObfuscationWithoutMappingTests extends AbstractTest {
       @Nonnull String mappingNumber)
       throws Exception {
 
-    String testName = "shrob/test" + testNumber;
-
     String testPackageName = "com.android.jack.shrob.test" + testNumber;
     File testFolder = AbstractTestTools.getTestRootDir(testPackageName);
 
diff --git a/jack-tests/tests/com/android/jack/shrob/RepackagingTest.java b/jack-tests/tests/com/android/jack/shrob/RepackagingTest.java
new file mode 100644
index 00000000..805d2c51
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/RepackagingTest.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.Options;
+import com.android.jack.shrob.obfuscation.NameProviderFactory;
+import com.android.jack.shrob.proguard.GrammarActions;
+import com.android.jack.shrob.spec.Flags;
+import com.android.jack.test.comparator.ComparatorMapping;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.DummyToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class RepackagingTest extends AbstractTest {
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+    Flags flags = new Flags();
+
+    GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags);
+    flags.setPackageForRenamedClasses("");
+    File candidateOutputMapping = AbstractTestTools.createTempFile("mapping", ".txt");
+    File refFolder = new File(testFolder, "refsRepackageClasses");
+    File refOutputMapping = new File(refFolder, "expected-" + flagNumber + ".txt");
+    flags.setOutputMapping(candidateOutputMapping);
+    flags.setPrintMapping(true);
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.setShrobFlags(flags);
+    toolchain.addProperty(NameProviderFactory.NAMEPROVIDER.getName(), "rot13");
+    toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods");
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+
+    env.setCandidateTestTools(toolchain);
+    env.setReferenceTestTools(new DummyToolchain());
+
+    env.runTest(new ComparatorMapping(candidateOutputMapping, refOutputMapping));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/SeedTests.java b/jack-tests/tests/com/android/jack/shrob/SeedTests.java
new file mode 100644
index 00000000..5b966fad
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/SeedTests.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.test.category.SlowTests;
+import com.android.jack.shrob.proguard.GrammarActions;
+import com.android.jack.shrob.spec.Flags;
+import com.android.jack.test.comparator.ComparatorSeeds;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.DummyToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+@Category(SlowTests.class)
+public class SeedTests extends AbstractTest {
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+
+    File testFolder = AbstractTestTools.getTestRootDir("com.android.jack.shrob.test" + testNumber);
+    Flags flags = new Flags();
+    flags.setShrink(false);
+    flags.setObfuscate(false);
+    GrammarActions.parse("proguard.flags" + flagNumber, testFolder.getAbsolutePath(), flags);
+    File refFolder = new File(testFolder, "refsSeed");
+    File candidateOutputSeeds = AbstractTestTools.createTempFile("seeds", ".txt");
+    File refOutputSeeds = new File(refFolder, "expected-" + flagNumber + ".txt");
+    flags.setSeedsFile(candidateOutputSeeds);
+    flags.setPrintSeeds(true);
+
+    JackApiToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+    toolchain.setShrobFlags(flags);
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+
+    env.setCandidateTestTools(toolchain);
+    env.setReferenceTestTools(new DummyToolchain());
+
+    env.runTest(new ComparatorSeeds(refOutputSeeds, candidateOutputSeeds));
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ShrinkMultiDexTests.java b/jack-tests/tests/com/android/jack/shrob/ShrinkMultiDexTests.java
new file mode 100644
index 00000000..b06855a5
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ShrinkMultiDexTests.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.Main;
+import com.android.jack.Options;
+import com.android.jack.ProguardFlags;
+import com.android.jack.backend.dex.DexFileWriter;
+import com.android.jack.backend.dex.MultiDexLegacy;
+import com.android.jack.preprocessor.PreProcessor;
+import com.android.jack.shrob.shrink.ShrinkStructurePrinter;
+import com.android.jack.test.comparator.ComparatorMapping;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+
+import org.junit.BeforeClass;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Tests for verifying that tracing for MultiDex does not disturb shrinking.
+ */
+public class ShrinkMultiDexTests extends AbstractTest {
+
+  private static File shrobTestsDir =
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob");
+
+  private static ProguardFlags dontObfuscateFlagFile =
+      new ProguardFlags(shrobTestsDir, "dontobfuscate.flags");
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+    File testFolder = new File(shrobTestsDir, "test" + testNumber);
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+
+    File refFolder = new File(testFolder, "refsShrinking");
+    toolchain.addProperty(DexFileWriter.DEX_WRITING_POLICY.getName(), "multidex");
+    toolchain.addProperty(MultiDexLegacy.MULTIDEX_LEGACY.getName(), "true");
+    toolchain.addProperty(PreProcessor.ENABLE.getName(), "true");
+    toolchain.addProperty(PreProcessor.FILE.getName(),
+        new File(shrobTestsDir, "legacyMainDexClasses.jpp").getAbsolutePath());
+
+    File candidateNodeListing = AbstractTestTools.createTempFile("nodeListing", ".txt");
+    toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING.getName(), "true");
+    toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING_FILE.getName(),
+        candidateNodeListing.getPath());
+    toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods");
+    toolchain.disableDxOptimizations();
+
+    File out = AbstractTestTools.createTempFile("checklisting", ".zip");
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+    env.setCandidateTestTools(toolchain);
+    env.setWithDebugInfo(true);
+    env.setProguardFlags(dontObfuscateFlagFile,
+        new ProguardFlags(shrobTestsDir, "keepAllAttributes.flags"),
+        new ProguardFlags(testFolder, "proguard.flags" + flagNumber));
+
+    env.runTest(new ComparatorMapping(new File(refFolder, "expected-" + flagNumber + ".txt"),
+        candidateNodeListing));
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ShrinkTests.java b/jack-tests/tests/com/android/jack/shrob/ShrinkTests.java
new file mode 100644
index 00000000..175427c7
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ShrinkTests.java
@@ -0,0 +1,218 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.Main;
+import com.android.jack.Options;
+import com.android.jack.ProguardFlags;
+import com.android.jack.shrob.shrink.ShrinkStructurePrinter;
+import com.android.jack.test.comparator.ComparatorMapping;
+import com.android.jack.test.helper.SourceToDexComparisonTestHelper;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.DummyToolchain;
+import com.android.jack.test.toolchain.JackApiToolchain;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+import com.android.jack.util.TextUtils;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class ShrinkTests extends AbstractTest {
+
+  private static File shrobTestsDir =
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob");
+
+  private static ProguardFlags dontObfuscateFlagFile =
+      new ProguardFlags(shrobTestsDir, "dontobfuscate.flags");
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Override
+  protected void runTest(
+      @Nonnull String testNumber,
+      @Nonnull String flagNumber,
+      @Nonnull String mappingNumber)
+      throws Exception {
+    File testFolder = new File(shrobTestsDir, "test" + testNumber);
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+
+    File refFolder = new File(testFolder, "refsShrinking");
+
+    File candidateNodeListing = AbstractTestTools.createTempFile("nodeListing", ".txt");
+    toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING.getName(), "true");
+    toolchain.addProperty(ShrinkStructurePrinter.STRUCTURE_PRINTING_FILE.getName(),
+        candidateNodeListing.getPath());
+    toolchain.addProperty(Options.METHOD_FILTER.getName(), "supported-methods");
+    toolchain.disableDxOptimizations();
+
+    File outFolder = AbstractTestTools.createTempDir();
+
+    SourceToDexComparisonTestHelper env =
+        new SourceToDexComparisonTestHelper(new File(testFolder, "jack"));
+
+    env.setCandidateTestTools(toolchain);
+    env.setReferenceTestTools(new DummyToolchain());
+    env.setProguardFlags(
+        dontObfuscateFlagFile,
+        new ProguardFlags(shrobTestsDir,"keepAllAttributes.flags"),
+        new ProguardFlags(testFolder, "proguard.flags" + flagNumber));
+
+    env.runTest(new ComparatorMapping(
+        new File(refFolder, "expected-" + flagNumber + ".txt"),
+        candidateNodeListing));
+  }
+
+  @Test
+  public void test020() throws Exception {
+    File libOut = AbstractTestTools.createTempDir();
+    File testOut = null;
+    File shrinkOut = null;
+
+    try {
+      JackApiToolchain toolchain =
+          AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+      toolchain.srcToLib(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          libOut,
+          /* zipFiles = */ false,
+          new File(shrobTestsDir, "test020/lib"));
+
+      toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+      testOut = AbstractTestTools.createTempDir();
+      toolchain.srcToLib(
+          AbstractTestTools.getClasspathsAsString(
+              toolchain.getDefaultBootClasspath(), new File[] {libOut}),
+              testOut,
+          /* zipFiles = */ false,
+          new File(shrobTestsDir, "test020/jack"));
+
+      shrinkOut = AbstractTestTools.createTempDir();
+      toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+      toolchain.addProguardFlags(
+          dontObfuscateFlagFile,
+          new ProguardFlags(new File(shrobTestsDir, "test020"),"proguard.flags"));
+      toolchain.libToLib(
+          testOut,
+          shrinkOut,
+          /* zipFile = */ false);
+    } catch (Exception e) {
+      String message = "Not deleting temp files of failed test ShrinkTest.test20 in:" +
+          TextUtils.LINE_SEPARATOR +
+          "- " + libOut.getAbsolutePath();
+      if (testOut != null) {
+        message += TextUtils.LINE_SEPARATOR + "- " + testOut.getAbsolutePath();
+      }
+      if (shrinkOut != null) {
+        message += TextUtils.LINE_SEPARATOR + "- " + shrinkOut.getAbsolutePath();
+      }
+      System.err.println();
+      System.err.println(message);
+      throw e;
+    }
+  }
+
+  @Test
+  public void test021() throws Exception {
+    File jackOut = AbstractTestTools.createTempDir();
+    File shrinkOut = null;
+    File dexOut = null;
+
+    try {
+      JackApiToolchain toolchain =
+          AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+      toolchain.srcToLib(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+          jackOut,
+          /* zipFiles = */ false,
+          new File(shrobTestsDir, "test021/jack"));
+
+      toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+      toolchain.addProguardFlags(
+          dontObfuscateFlagFile,
+          new ProguardFlags(new File( shrobTestsDir, "test021"),"proguard.flags001"));
+      shrinkOut = AbstractTestTools.createTempDir();
+      toolchain.libToLib(jackOut, shrinkOut, /* zipFiles = */ false);
+
+      dexOut = AbstractTestTools.createTempDir();
+      toolchain = AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
+      toolchain.libToExe(shrinkOut, dexOut, /* zipFile = */ false);
+
+    } catch (Exception e) {
+      String message = "Not deleting temp files of failed ShrinkTest.test20 in:\n" +
+          "- " + jackOut.getAbsolutePath();
+      if (shrinkOut != null) {
+        message += "\n- " + shrinkOut.getAbsolutePath();
+      }
+      if (dexOut != null) {
+        message += "\n- " + dexOut.getAbsolutePath();
+      }
+      System.err.println();
+      System.err.println(message);
+      throw e;
+    }
+  }
+
+  /**
+   * The only purpose of this test is to use jack shrink capabilities and to have no reference to
+   * java/lang/Class. This test will make Jack fail if java/lang/Class methods like getField and
+   * getMethod cannot be looked up (i.e. at the time this test is written, if the structure of
+   * java/lang/Class has not been preloaded).
+   */
+  @Test
+  public void test028() throws Exception {
+    File testFolder = new File(shrobTestsDir, "test028");
+    File jackar = null;
+    File shrinkedjackar = null;
+    jackar = AbstractTestTools.createTempFile("jackar", ".zip");
+    shrinkedjackar = AbstractTestTools.createTempFile("shrinkedjackar", ".zip");
+    ProguardFlags flags = new ProguardFlags(testFolder, "proguard.flags001");
+
+    JackBasedToolchain toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    String classpath = AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath());
+    toolchain.srcToLib(
+        classpath,
+        jackar,
+        /* zipFiles = */ true,
+        testFolder);
+
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToLib(jackar, shrinkedjackar, /* zipFiles = */ true);
+  }
+
+  @Test
+  public void test42_001() throws Exception {
+    runTest("042", "001", "");
+  }
+
+  @Test
+  public void test42_002() throws Exception {
+    runTest("042", "002", "");
+  }
+
+  @Test
+  public void test42_003() throws Exception {
+    runTest("042", "003", "");
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/shrob/ShrobAllTests.java b/jack-tests/tests/com/android/jack/shrob/ShrobAllTests.java
new file mode 100644
index 00000000..fc8e0883
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ShrobAllTests.java
@@ -0,0 +1,22 @@
+package com.android.jack.shrob;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses(value = {
+//    AnnotationsTest.class,
+    FlattenPackageTests.class,
+//    ObfuscationWithAttributesTests.class,
+//    ObfuscationWithDebugInfoTests.class,
+    ObfuscationWithMappingTests.class,
+    ObfuscationWithoutMappingTests.class,
+    RepackagingTest.class,
+    SeedTests.class,
+    ShrinkMultiDexTests.class,
+    ShrinkTests.class,
+    ShrobRuntimeTests.class
+    })
+public class ShrobAllTests {
+}
\ No newline at end of file
diff --git a/jack-tests/tests/com/android/jack/shrob/ShrobRuntimeTests.java b/jack-tests/tests/com/android/jack/shrob/ShrobRuntimeTests.java
new file mode 100644
index 00000000..e6a51804
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/shrob/ShrobRuntimeTests.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.shrob;
+
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.Test;
+
+import java.io.File;
+
+public class ShrobRuntimeTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST011_1 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob.test011"),
+      "com.android.jack.shrob.test011.dx.Tests");
+
+  private RuntimeTestInfo TEST011_2 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob.test011"),
+      "com.android.jack.shrob.test011.dx.Tests2");
+
+  private RuntimeTestInfo TEST016 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob.test016"),
+      "com.android.jack.shrob.test016.dx.Tests");
+
+  private RuntimeTestInfo TEST025 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob.test025"),
+      "com.android.jack.shrob.test025.dx.Tests");
+
+  private RuntimeTestInfo TEST030 = new RuntimeTestInfo(
+      AbstractTestTools.getTestRootDir("com.android.jack.shrob.test030"),
+      "com.android.jack.shrob.test030.dx.Tests");
+
+  @Test
+  public void test011_1() throws Exception {
+    new RuntimeTestHelper(TEST011_1)
+    .setProguardFlagsFileNames(new String[] {"proguard.flags001", "../dontobfuscate.flags"})
+    .compileAndRunTest();
+  }
+
+  @Test
+  public void test011_2() throws Exception {
+    new RuntimeTestHelper(TEST011_2)
+    .setProguardFlagsFileNames(new String[] {"proguard.flags002"})
+     .compileAndRunTest();
+  }
+
+  @Test
+  public void test016() throws Exception {
+    new RuntimeTestHelper(TEST016)
+    .setProguardFlagsFileNames(new String[] {"proguard.flags001","applyMapping.flags"})
+    .compileAndRunTest();
+  }
+
+  @Test
+  public void test025() throws Exception {
+    new RuntimeTestHelper(TEST025)
+    .setProguardFlagsFileNames(new String[] {"proguard.flags001"})
+    .compileAndRunTest();
+  }
+
+  @Test
+  public void test030() throws Exception {
+    new RuntimeTestHelper(TEST030)
+    .setProguardFlagsFileNames(new String[] {new File(TEST030.directory, "proguard.flags001")
+        .getAbsolutePath()})
+    .compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+  }
+
+}
diff --git a/jack-tests/tests/com/android/jack/string/StringTests.java b/jack-tests/tests/com/android/jack/string/StringTests.java
new file mode 100644
index 00000000..92685369
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/string/StringTests.java
@@ -0,0 +1,85 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.string;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.IOException;
+
+public class StringTests extends RuntimeTest {
+
+  private RuntimeTestInfo CONCAT001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.string.concat001"),
+    "com.android.jack.string.concat001.dx.Tests");
+
+  private RuntimeTestInfo CONCAT002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.string.concat002"),
+    "com.android.jack.string.concat002.dx.Tests");
+
+  private RuntimeTestInfo CONCAT003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.string.concat003"),
+    "com.android.jack.string.concat003.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    StringTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  @Test
+  public void testCompileNewString() throws Exception {
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        AbstractTestTools.createTempDir(),
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.string.test001.jack"));
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void concat001() throws Exception {
+    new RuntimeTestHelper(CONCAT001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void concat002() throws Exception {
+    new RuntimeTestHelper(CONCAT002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void concat003() throws Exception {
+    new RuntimeTestHelper(CONCAT003).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(CONCAT001);
+    rtTestInfos.add(CONCAT002);
+    rtTestInfos.add(CONCAT003);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/string001/jack/Strings.java b/jack-tests/tests/com/android/jack/string/test001/jack/Strings.java
index 76abb8f7..a9cdcf19 100644
--- a/jack-tests/tests/com/android/jack/string001/jack/Strings.java
+++ b/jack-tests/tests/com/android/jack/string/test001/jack/Strings.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.string001.jack;
+package com.android.jack.string.test001.jack;
 
 public class Strings {
 
diff --git a/jack-tests/tests/com/android/jack/switchstatement/SwitchstatementTests.java b/jack-tests/tests/com/android/jack/switchstatement/SwitchstatementTests.java
new file mode 100644
index 00000000..53f7e694
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/switchstatement/SwitchstatementTests.java
@@ -0,0 +1,205 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.switchstatement;
+
+import com.android.jack.TestTools;
+import com.android.jack.backend.dex.DexFileWriter;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+
+import junit.framework.Assert;
+
+import org.jf.dexlib.ClassDataItem.EncodedMethod;
+import org.jf.dexlib.DexFile;
+import org.jf.dexlib.Code.Analysis.AnalyzedInstruction;
+import org.jf.dexlib.Code.Analysis.MethodAnalyzer;
+import org.jf.dexlib.Code.Format.PackedSwitchDataPseudoInstruction;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+public class SwitchstatementTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test001"),
+    "com.android.jack.switchstatement.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test002"),
+    "com.android.jack.switchstatement.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test003"),
+    "com.android.jack.switchstatement.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test004"),
+    "com.android.jack.switchstatement.test004.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test005"),
+    "com.android.jack.switchstatement.test005.dx.Tests");
+
+  private RuntimeTestInfo TEST006 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test006"),
+    "com.android.jack.switchstatement.test006.dx.Tests");
+
+  private RuntimeTestInfo TEST007 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test007"),
+    "com.android.jack.switchstatement.test007.dx.Tests");
+
+  private RuntimeTestInfo TEST008 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test008"),
+    "com.android.jack.switchstatement.test008.dx.Tests");
+
+  private RuntimeTestInfo TEST010 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test010"),
+    "com.android.jack.switchstatement.test010.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    SwitchstatementTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  public void testCompile002AsJackThenDex() throws Exception {
+    File outJackTmp = AbstractTestTools.createTempDir();
+    {
+      // build as jack
+      JackBasedToolchain toolchain =
+          AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+      toolchain.srcToLib(
+          AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()), outJackTmp,
+          /* zipFiles = */false,
+          AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test002.jack"));
+    }
+
+    {
+      // build dex from jack
+      JackBasedToolchain toolchain =
+          AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+      toolchain.libToExe(outJackTmp, AbstractTestTools.createTempDir(), /* zipFile = */false);
+    }
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test006() throws Exception {
+    new RuntimeTestHelper(TEST006).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test007() throws Exception {
+    new RuntimeTestHelper(TEST007).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test008() throws Exception {
+    new RuntimeTestHelper(TEST008).compileAndRunTest();
+  }
+
+  /**
+   * Test allowing to check that 'packed-switch-payload' into generated dex is as small as possible.
+   */
+  @Test
+  public void testCompile9() throws Exception {
+    File outFolder = AbstractTestTools.createTempDir();
+    File out = new File(outFolder, DexFileWriter.DEX_FILENAME);
+
+    IToolchain toolchain = AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        outFolder,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.switchstatement.test009.jack"));
+
+    DexFile dexFile = new DexFile(out);
+    EncodedMethod em =
+        TestTools.getEncodedMethod(dexFile,
+            "Lcom/android/jack/switchstatement/test009/jack/Switch;", "switch1",
+            "(Lcom/android/jack/switchstatement/test009/jack/Switch$Num;)Z");
+
+    MethodAnalyzer ma = new MethodAnalyzer(em, false, null);
+    boolean packedSwitchDataPseudo = false;
+    for (AnalyzedInstruction ai : ma.getInstructions()) {
+      if (ai.getInstruction() instanceof PackedSwitchDataPseudoInstruction) {
+        packedSwitchDataPseudo = true;
+        Assert.assertEquals(5,
+            ((PackedSwitchDataPseudoInstruction) ai.getInstruction()).getTargetCount());
+      }
+    }
+
+    Assert.assertTrue(packedSwitchDataPseudo);
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test010() throws Exception {
+    new RuntimeTestHelper(TEST010).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+    rtTestInfos.add(TEST005);
+    rtTestInfos.add(TEST006);
+    rtTestInfos.add(TEST007);
+    rtTestInfos.add(TEST008);
+    rtTestInfos.add(TEST010);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/synchronize/SynchronizeTests.java b/jack-tests/tests/com/android/jack/synchronize/SynchronizeTests.java
new file mode 100644
index 00000000..0ee6ed88
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/synchronize/SynchronizeTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.synchronize;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class SynchronizeTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.synchronize.test001"),
+    "com.android.jack.synchronize.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    SynchronizeTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/threeaddress/ThreeaddressTests.java b/jack-tests/tests/com/android/jack/threeaddress/ThreeaddressTests.java
new file mode 100644
index 00000000..6a172ebc
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/threeaddress/ThreeaddressTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.threeaddress;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ThreeaddressTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.threeaddress.test001"),
+    "com.android.jack.threeaddress.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ThreeaddressTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/threeaddress/dx/Tests.java b/jack-tests/tests/com/android/jack/threeaddress/test001/dx/Tests.java
index eca3c3b6..af80d356 100644
--- a/jack-tests/tests/com/android/jack/threeaddress/dx/Tests.java
+++ b/jack-tests/tests/com/android/jack/threeaddress/test001/dx/Tests.java
@@ -14,16 +14,16 @@
  * limitations under the License.
  */
 
-package com.android.jack.threeaddress.dx;
+package com.android.jack.threeaddress.test001.dx;
+
+import com.android.jack.threeaddress.test001.jack.ThreeAddressCode001;
+import com.android.jack.threeaddress.test001.jack.ThreeAddressCode002;
+import com.android.jack.threeaddress.test001.jack.ThreeAddressCode003;
 
 import junit.framework.Assert;
 
 import org.junit.Test;
 
-import com.android.jack.threeaddress.jack.ThreeAddressCode001;
-import com.android.jack.threeaddress.jack.ThreeAddressCode002;
-import com.android.jack.threeaddress.jack.ThreeAddressCode003;
-
 public class Tests {
 
   @Test
diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode001.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode001.java
index a525ea0c..f5af349b 100644
--- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode001.java
+++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode001.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.threeaddress.jack;
+package com.android.jack.threeaddress.test001.jack;
 
 
 public class ThreeAddressCode001 {
diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode002.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode002.java
index ff201b69..1234ebfc 100644
--- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode002.java
+++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode002.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.threeaddress.jack;
+package com.android.jack.threeaddress.test001.jack;
 
 public class ThreeAddressCode002 {
 
diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode003.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode003.java
index bd9753d0..5b1b8d97 100644
--- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCode003.java
+++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCode003.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.threeaddress.jack;
+package com.android.jack.threeaddress.test001.jack;
 
 public class ThreeAddressCode003 {
 
diff --git a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCodeUtil001.java b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCodeUtil001.java
index e84e841e..0d2c4933 100644
--- a/jack-tests/tests/com/android/jack/threeaddress/jack/ThreeAddressCodeUtil001.java
+++ b/jack-tests/tests/com/android/jack/threeaddress/test001/jack/ThreeAddressCodeUtil001.java
@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package com.android.jack.threeaddress.jack;
+package com.android.jack.threeaddress.test001.jack;
 
 public abstract class ThreeAddressCodeUtil001 {
   public abstract int f(int a, int b);
diff --git a/jack-tests/tests/com/android/jack/throwstatement/ThrowstatementTests.java b/jack-tests/tests/com/android/jack/throwstatement/ThrowstatementTests.java
new file mode 100644
index 00000000..e1e0b870
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/throwstatement/ThrowstatementTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.throwstatement;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class ThrowstatementTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.throwstatement.test001"),
+    "com.android.jack.throwstatement.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    ThrowstatementTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java b/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java
index b163f5b0..b7f50871 100644
--- a/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java
+++ b/jack-tests/tests/com/android/jack/tools/merger/MergerTestTools.java
@@ -20,11 +20,13 @@ import com.android.jack.Options;
 import com.android.jack.TestTools;
 import com.android.jack.backend.dex.DexFileWriter;
 import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackApiToolchain;
 import com.android.jack.test.toolchain.JackBasedToolchain;
 import com.android.sched.scheduler.ScheduleInstance;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.OutputStream;
 
 import javax.annotation.CheckForNull;
 import javax.annotation.Nonnull;
@@ -33,9 +35,9 @@ public class MergerTestTools {
 
   @Nonnull
   protected File buildOneDexPerType(@CheckForNull String classpath, @Nonnull File sourceFolder,
-      boolean withDebug) throws Exception {
-    JackBasedToolchain toolchain =
-        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+      boolean withDebug, @CheckForNull OutputStream out, @CheckForNull OutputStream err) throws Exception {
+    JackApiToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackApiToolchain.class);
     try {
       File multiDexFolder = TestTools.createTempDir("multi", "dex");
       File multiDex = new File(multiDexFolder, DexFileWriter.DEX_FILENAME);
@@ -47,7 +49,14 @@ public class MergerTestTools {
       toolchain.addProperty(Options.INTERMEDIATE_DEX_DIR.getName(),
           multiDexOnTypePerTypeFolder.getAbsolutePath());
 
-      toolchain.srcToExe(classpath, multiDexFolder, sourceFolder);
+      if (out != null) {
+        toolchain.setOutputStream(out);
+      }
+      if (err != null) {
+        toolchain.setErrorStream(err);
+      }
+
+      toolchain.srcToExe(classpath, multiDexFolder, /* zipFile = */ false, sourceFolder);
 
       return multiDex;
 
diff --git a/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java b/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java
index f00da22b..fc593c5c 100644
--- a/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java
+++ b/jack-tests/tests/com/android/jack/tools/merger/test011/MergerTest011.java
@@ -16,10 +16,13 @@
 
 package com.android.jack.tools.merger.test011;
 
+import com.android.jack.JackAbortException;
 import com.android.jack.JackUserException;
 import com.android.jack.Main;
 import com.android.jack.TestTools;
-import com.android.jack.category.SlowTests;
+import com.android.jack.backend.dex.DexWritingException;
+import com.android.jack.backend.dex.SingleDexOverflowException;
+import com.android.jack.test.category.SlowTests;
 import com.android.jack.tools.merger.FieldIdOverflowException;
 import com.android.jack.tools.merger.MergerTestTools;
 import com.android.jack.tools.merger.MethodIdOverflowException;
@@ -31,6 +34,7 @@ import org.junit.BeforeClass;
 import org.junit.Test;
 import org.junit.experimental.categories.Category;
 
+import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
@@ -46,8 +50,10 @@ public class MergerTest011 extends MergerTestTools {
 
   private static int fileCount = 655;
 
-  private static final String expectedExceptionMessage =
-      "Index overflow while merging dex files. Try using multidex";
+  @Nonnull
+  private static final String EXPECTED_MESSAGE =
+      "Error during the dex writing phase: classes.dex has too many IDs. Try using multi-dex";
+
 
   @BeforeClass
   public static void setUpClass() {
@@ -64,13 +70,18 @@ public class MergerTest011 extends MergerTestTools {
     }
     generateJavaFileWithMethods(srcFolder, fileCount, 36);
 
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+
     try {
-      buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, false /* withDebug */);
+      buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder,
+          /* withDebug = */false, /* out = */ null, err);
       Assert.fail();
-    } catch (JackUserException e) {
-      Assert.assertEquals(expectedExceptionMessage, e.getMessage());
+    }  catch (JackAbortException e) {
       Throwable cause = e.getCause();
-      Assert.assertTrue(cause instanceof MethodIdOverflowException);
+      Assert.assertTrue(cause instanceof DexWritingException);
+      Assert.assertTrue(cause.getCause() instanceof SingleDexOverflowException);
+      Assert.assertTrue(cause.getCause().getCause() instanceof MethodIdOverflowException);
+      Assert.assertTrue(err.toString().contains(EXPECTED_MESSAGE));
     }
   }
 
@@ -83,13 +94,18 @@ public class MergerTest011 extends MergerTestTools {
     }
     generateJavaFileWithFields(srcFolder, fileCount, 37);
 
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+
     try {
-      buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, false /* withDebug */);
+      buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder,
+          /* withDebug = */false, /* out = */ null, err);
       Assert.fail();
-    } catch (JackUserException e) {
-      Assert.assertEquals(expectedExceptionMessage, e.getMessage());
+    } catch (JackAbortException e) {
       Throwable cause = e.getCause();
-      Assert.assertTrue(cause instanceof FieldIdOverflowException);
+      Assert.assertTrue(cause instanceof DexWritingException);
+      Assert.assertTrue(cause.getCause() instanceof SingleDexOverflowException);
+      Assert.assertTrue(cause.getCause().getCause() instanceof FieldIdOverflowException);
+      Assert.assertTrue(err.toString().contains(EXPECTED_MESSAGE));
     }
   }
 
@@ -103,13 +119,18 @@ public class MergerTest011 extends MergerTestTools {
     }
     generateJavaFileWithTypes(srcFolder, fileCount, 36);
 
+    ByteArrayOutputStream err = new ByteArrayOutputStream();
+
     try {
-      buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder, false /* withDebug */);
+      buildOneDexPerType(TestTools.getDefaultBootclasspathString(), srcFolder,
+          /* withDebug = */false, /* out = */ null, err);
       Assert.fail();
-    } catch (JackUserException e) {
-      Assert.assertEquals(expectedExceptionMessage, e.getMessage());
+    } catch (JackAbortException e) {
       Throwable cause = e.getCause();
-      Assert.assertTrue(cause instanceof TypeIdOverflowException);
+      Assert.assertTrue(cause instanceof DexWritingException);
+      Assert.assertTrue(cause.getCause() instanceof SingleDexOverflowException);
+      Assert.assertTrue(cause.getCause().getCause() instanceof TypeIdOverflowException);
+      Assert.assertTrue(err.toString().contains(EXPECTED_MESSAGE));
     }
   }
 
diff --git a/jack-tests/tests/com/android/jack/trycatch/TrycatchTests.java b/jack-tests/tests/com/android/jack/trycatch/TrycatchTests.java
new file mode 100644
index 00000000..98694c8d
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/trycatch/TrycatchTests.java
@@ -0,0 +1,128 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.trycatch;
+
+import com.android.jack.Options;
+import com.android.jack.TestTools;
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.IToolchain;
+
+import junit.framework.Assert;
+
+import org.jf.dexlib.CodeItem;
+import org.jf.dexlib.DexFile;
+import org.jf.dexlib.Code.Instruction;
+import org.jf.dexlib.Code.Opcode;
+import org.junit.BeforeClass;
+import org.junit.Ignore;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+
+import javax.annotation.Nonnull;
+
+public class TrycatchTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test001"),
+    "com.android.jack.trycatch.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test002"),
+    "com.android.jack.trycatch.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test003"),
+    "com.android.jack.trycatch.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST005 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test005"),
+    "com.android.jack.trycatch.test005.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    TrycatchTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test005() throws Exception {
+    new RuntimeTestHelper(TEST005).compileAndRunTest();
+  }
+
+  /**
+   * Verify that generated dex does not contains useless 'mov' instructions.
+   */
+  @Test
+  @Ignore("Generated dex contains useless 'mov' instructions")
+  public void uselessMovInstructions() throws Exception {
+    File out =  AbstractTestTools.createTempFile("uselessMovInstructions", ".dex");
+    IToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain();
+    toolchain.srcToExe(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        out,
+        /* zipFile = */ false,
+        AbstractTestTools.getTestRootDir("com.android.jack.trycatch.test004"));
+
+    DexFile dexFile = new DexFile(out);
+    CodeItem ci =
+        TestTools.getEncodedMethod(dexFile, "Lcom/android/jack/trycatch/test004/jack/TryCatch;",
+            "setIconAndText", "(IIILjava/lang/String;II)V").codeItem;
+
+    Assert.assertFalse(hasOpcode(ci, Opcode.MOVE_OBJECT));
+  }
+
+  private boolean hasOpcode(@Nonnull CodeItem codeItem, @Nonnull Opcode opcode) {
+    for (Instruction inst : codeItem.getInstructions()) {
+      if (inst.opcode == opcode) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST005);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/tryfinally/TryfinallyTests.java b/jack-tests/tests/com/android/jack/tryfinally/TryfinallyTests.java
new file mode 100644
index 00000000..15357063
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/tryfinally/TryfinallyTests.java
@@ -0,0 +1,82 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.tryfinally;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class TryfinallyTests extends RuntimeTest {
+
+  private RuntimeTestInfo FINALLY002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finally002"),
+    "com.android.jack.tryfinally.finally002.dx.Tests");
+
+  private RuntimeTestInfo FINALLY003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finally003"),
+    "com.android.jack.tryfinally.finally003.dx.Tests");
+
+  private RuntimeTestInfo FINALLY004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finally004"),
+    "com.android.jack.tryfinally.finally004.dx.Tests");
+
+  private RuntimeTestInfo FINALLYBLOCK = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.tryfinally.finallyblock"),
+    "com.android.jack.tryfinally.finallyblock.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    TryfinallyTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void finally002() throws Exception {
+    new RuntimeTestHelper(FINALLY002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void finally003() throws Exception {
+    new RuntimeTestHelper(FINALLY003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void finally004() throws Exception {
+    new RuntimeTestHelper(FINALLY004).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void finallyblock() throws Exception {
+    new RuntimeTestHelper(FINALLYBLOCK).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(FINALLY002);
+    rtTestInfos.add(FINALLY003);
+    rtTestInfos.add(FINALLY004);
+    rtTestInfos.add(FINALLYBLOCK);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/type/TypeTests.java b/jack-tests/tests/com/android/jack/type/TypeTests.java
new file mode 100644
index 00000000..f908532e
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/type/TypeTests.java
@@ -0,0 +1,60 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.type;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class TypeTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.type.test001"),
+    "com.android.jack.type.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.type.test002"),
+    "com.android.jack.type.test002.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    TypeTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/unary/UnaryTests.java b/jack-tests/tests/com/android/jack/unary/UnaryTests.java
new file mode 100644
index 00000000..2f1485e1
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/unary/UnaryTests.java
@@ -0,0 +1,82 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.unary;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class UnaryTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.unary.test001"),
+    "com.android.jack.unary.test001.dx.Tests");
+
+  private RuntimeTestInfo TEST002 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.unary.test002"),
+    "com.android.jack.unary.test002.dx.Tests");
+
+  private RuntimeTestInfo TEST003 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.unary.test003"),
+    "com.android.jack.unary.test003.dx.Tests");
+
+  private RuntimeTestInfo TEST004 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.unary.test004"),
+    "com.android.jack.unary.test004.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    UnaryTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test002() throws Exception {
+    new RuntimeTestHelper(TEST002).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test003() throws Exception {
+    new RuntimeTestHelper(TEST003).compileAndRunTest();
+  }
+
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test004() throws Exception {
+    new RuntimeTestHelper(TEST004).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+    rtTestInfos.add(TEST002);
+    rtTestInfos.add(TEST003);
+    rtTestInfos.add(TEST004);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/verify/VerifyTests.java b/jack-tests/tests/com/android/jack/verify/VerifyTests.java
new file mode 100644
index 00000000..12c0cfb9
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/verify/VerifyTests.java
@@ -0,0 +1,49 @@
+/*
+* Copyright (C) 2014 The Android Open Source Project
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*      http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+package com.android.jack.verify;
+
+import com.android.jack.test.category.RuntimeRegressionTest;
+import com.android.jack.test.helper.RuntimeTestHelper;
+import com.android.jack.test.runtime.RuntimeTest;
+import com.android.jack.test.runtime.RuntimeTestInfo;
+import com.android.jack.test.toolchain.AbstractTestTools;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+public class VerifyTests extends RuntimeTest {
+
+  private RuntimeTestInfo TEST001 = new RuntimeTestInfo(
+    AbstractTestTools.getTestRootDir("com.android.jack.verify.test001"),
+    "com.android.jack.verify.test001.dx.Tests");
+
+  @BeforeClass
+  public static void setUpClass() {
+    VerifyTests.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+  @Test
+  @Category(RuntimeRegressionTest.class)
+  public void test001() throws Exception {
+    new RuntimeTestHelper(TEST001).compileAndRunTest();
+  }
+
+  @Override
+  protected void fillRtTestInfos() {
+    rtTestInfos.add(TEST001);
+  }
+}
diff --git a/jack-tests/tests/com/android/jack/withphantom/WithPhantomTests.java b/jack-tests/tests/com/android/jack/withphantom/WithPhantomTests.java
new file mode 100644
index 00000000..fbf946c2
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/withphantom/WithPhantomTests.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2014 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.jack.withphantom;
+
+import com.android.jack.ProguardFlags;
+import com.android.jack.test.category.KnownBugs;
+import com.android.jack.library.FileType;
+import com.android.jack.test.toolchain.AbstractTestTools;
+import com.android.jack.test.toolchain.JackBasedToolchain;
+
+import junit.framework.Assert;
+
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+
+import java.io.File;
+import java.io.FilenameFilter;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Test compilation involving phantoms.
+ */
+public class WithPhantomTests {
+
+  @Nonnull
+  private static final String TEST001 = "com.android.jack.withphantom.test001";
+  @Nonnull
+  private static final String TEST001_JACK = TEST001 + ".jack";
+  @Nonnull
+  private static final String TEST002 = "com.android.jack.withphantom.test002";
+  @Nonnull
+  private static final String TEST002_JACK = TEST002 + ".jack";
+
+  @Nonnull
+  private static String fixPath(@Nonnull String unixPath) {
+    return unixPath.replace('/', File.separatorChar);
+  }
+
+  @Test
+  public void testPhantomOuter() throws Exception {
+    File tempJackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir(TEST001_JACK));
+
+    boolean deleted =
+        new File(tempJackFolder, FileType.JAYCE.getPrefix() + File.separatorChar
+            + fixPath("com/android/jack/withphantom/test001/jack/A.jayce")).delete();
+    Assert.assertTrue(deleted);
+
+    File testFolder = AbstractTestTools.getTestRootDir(TEST001);
+
+    File tempOut1 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink1.flags"))
+    .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false);
+
+    File tempOut2 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink2.flags"))
+    .libToLib(tempJackFolder, tempOut2, /* zipFiles = */ false);
+
+    File tempOut3 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf1.flags"))
+    .libToLib(tempJackFolder, tempOut3, /* zipFiles = */ false);
+
+    File tempOut4 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf2.flags"))
+    .libToLib(tempJackFolder, tempOut4, /* zipFiles = */ false);
+
+    File tempOut5 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(tempJackFolder, tempOut5, /* zipFile = */ false);
+  }
+
+  @Test
+  public void testPhantomInner() throws Exception {
+    File tempJackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir(TEST001_JACK));
+
+    boolean deleted =
+        new File(tempJackFolder, fixPath(FileType.JAYCE.getPrefix() + File.separatorChar
+            + "com/android/jack/withphantom/test001/jack/A$Inner1.jayce")).delete();
+    Assert.assertTrue(deleted);
+    deleted =
+        new File(tempJackFolder, fixPath(FileType.DEX.getPrefix() + File.separatorChar
+            + "com/android/jack/withphantom/test001/jack/A$Inner1.dex")).delete();
+    Assert.assertTrue(deleted);
+
+    File testFolder = AbstractTestTools.getTestRootDir(TEST001);
+
+    File tempOut1 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink1.flags"))
+    .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false);
+
+    File tempOut2 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "shrink2.flags"))
+    .libToLib(tempJackFolder, tempOut2, /* zipFiles = */ false);
+
+    File tempOut3 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf1.flags"))
+    .libToLib(tempJackFolder, tempOut3, /* zipFiles = */ false);
+
+    File tempOut4 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf2.flags"))
+    .libToLib(tempJackFolder, tempOut4, /* zipFiles = */ false);
+
+    File tempOutFolder = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(tempJackFolder, tempOutFolder, /* zipFile = */ false);
+  }
+
+  @Category(KnownBugs.class)
+  @Test
+  public void testPhantomLocal() throws Exception {
+    File tempJackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir(TEST002_JACK));
+
+    File[] inners =
+        new File(tempJackFolder, fixPath(FileType.JAYCE.getPrefix() + File.separatorChar
+            + "com/android/jack/withphantom/test002/jack/")).listFiles(new FilenameFilter() {
+          @Override
+          public boolean accept(File dir, String name) {
+            return name.startsWith("A$");
+          }
+        });
+    for (File file : inners) {
+      Assert.assertTrue(file.delete());
+    }
+
+    File testFolder = AbstractTestTools.getTestRootDir(TEST002);
+
+    File tempOut1 = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.addProguardFlags(new ProguardFlags(testFolder, "obf1.flags"))
+    .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false);
+
+    File tempOutFolder = AbstractTestTools.createTempDir();
+    toolchain = AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.libToExe(tempJackFolder, tempOutFolder, /* zipFile = */ false);
+  }
+
+  @Test
+  public void testPhantomLocalOuter() throws Exception {
+    File tempJackFolder = AbstractTestTools.createTempDir();
+    JackBasedToolchain toolchain =
+        AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class);
+    toolchain.srcToLib(
+        AbstractTestTools.getClasspathAsString(toolchain.getDefaultBootClasspath()),
+        tempJackFolder,
+        /* zipFiles = */ false,
+        AbstractTestTools.getTestRootDir(TEST002_JACK));
+
+    boolean deleted =
+        new File(tempJackFolder, fixPath(FileType.JAYCE.getPrefix() + File.separatorChar
+            + "com/android/jack/withphantom/test002/jack/A.jayce")).delete();
+    Assert.assertTrue(deleted);
+
+    File testFolder = AbstractTestTools.getTestRootDir(TEST002);
+
+    File tempOut1 = AbstractTestTools.createTempDir();
+    AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class)
+    .addProguardFlags(new ProguardFlags(testFolder, "obf1.flags"))
+    .libToLib(tempJackFolder, tempOut1, /* zipFiles = */ false);
+
+    File tempOutFolder = AbstractTestTools.createTempDir();
+    AbstractTestTools.getCandidateToolchain(JackBasedToolchain.class)
+    .libToExe(tempJackFolder, tempOutFolder, /* zipFile = */ false);
+  }
+
+}