Use new JUnit based test framework

Bug: 18547020

Change-Id: I5d02ebdecbf79bea035ae8a042d50a06aa7c2a62

16 files changed, 2181 insertions, 0 deletions

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 0000000..3a0a93b
--- /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 0000000..fcded87
--- /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/experimental/incremental/DependenciesTest003.java b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest003.java
new file mode 100644
index 0000000..457cd49
--- /dev/null
+++ b/jack-tests/tests/com/android/jack/experimental/incremental/DependenciesTest003.java
@@ -0,0 +1,79 @@
+/*
+ * 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 DependenciesTest003 {
+
+  @BeforeClass
+  public static void setUpClass() {
+    Main.class.getClassLoader().setDefaultAssertionStatus(true);
+  }
+
+  /**
+   * 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(TestTools.createTempDir("DependenciesTest_", "_001"));
+
+    ite.addJavaFile("jack.incremental", "A.java",
+        "package jack.incremental; \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 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() { } } \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"));
+  }
+}
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 0000000..2d3a962
--- /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 0000000..fffd2da
--- /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 0000000..a27b239
--- /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 0000000..329a3e3
--- /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 0000000..2ad9b83
--- /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 0000000..a09a1c0
--- /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 0000000..d5051bf
--- /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 0000000..fb05a07
--- /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 0000000..db6d6a3
--- /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 0000000..de6116e
--- /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 0000000..8f768f0
--- /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 0000000..d6f0ae2
--- /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 0000000..e8b42a8
--- /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