diff --git a/src/test/java/com/android/tools/r8/AsmTestBase.java b/src/test/java/com/android/tools/r8/AsmTestBase.java
index 34c05d1..6195ea0 100644
--- a/src/test/java/com/android/tools/r8/AsmTestBase.java
+++ b/src/test/java/com/android/tools/r8/AsmTestBase.java
@@ -120,7 +120,7 @@
     ensureSameOutput(main, mergedApp, false, classes);
   }
 
-  protected static AndroidApp readClassesAndAsmDump(List<Class> classes, List<byte[]> asmClasses)
+  protected static AndroidApp readClassesAndAsmDump(List<Class<?>> classes, List<byte[]> asmClasses)
       throws IOException {
     AndroidApp.Builder builder = AndroidApp.builder();
     for (Class clazz : classes) {
diff --git a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
index a90ae25..47aa023 100644
--- a/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
+++ b/src/test/java/com/android/tools/r8/resolution/SingleTargetLookupTest.java
@@ -5,6 +5,7 @@
 
 import com.android.tools.r8.AsmTestBase;
 import com.android.tools.r8.dex.ApplicationReader;
+import com.android.tools.r8.graph.AppInfo;
 import com.android.tools.r8.graph.AppInfoWithSubtyping;
 import com.android.tools.r8.graph.AppServices;
 import com.android.tools.r8.graph.AppView;
@@ -14,10 +15,6 @@
 import com.android.tools.r8.graph.DexMethod;
 import com.android.tools.r8.graph.DexType;
 import com.android.tools.r8.resolution.singletarget.Main;
-import com.android.tools.r8.resolution.singletarget.interfacedefault.A;
-import com.android.tools.r8.resolution.singletarget.interfacedefault.B;
-import com.android.tools.r8.resolution.singletarget.interfacedefault.C;
-import com.android.tools.r8.resolution.singletarget.interfacedefault.I;
 import com.android.tools.r8.resolution.singletarget.one.AbstractSubClass;
 import com.android.tools.r8.resolution.singletarget.one.AbstractTopClass;
 import com.android.tools.r8.resolution.singletarget.one.InterfaceWithDefault;
@@ -71,46 +68,44 @@
    */
   public static AppInfoWithLiveness appInfo;
 
-  public static List<Class> CLASSES = ImmutableList.of(
-      InterfaceWithDefault.class,
-      AbstractTopClass.class,
-      AbstractSubClass.class,
-      SubSubClassOne.class,
-      SubSubClassTwo.class,
-      SubSubClassThree.class,
-      OtherAbstractTopClass.class,
-      OtherAbstractSubClassOne.class,
-      OtherAbstractSubClassTwo.class,
-      OtherSubSubClassOne.class,
-      OtherSubSubClassTwo.class,
-      ThirdAbstractTopClass.class,
-      ThirdSubClassOne.class,
-      A.class,
-      B.class,
-      C.class,
-      I.class,
-      Main.class
-  );
+  public static List<Class<?>> CLASSES =
+      ImmutableList.of(
+          InterfaceWithDefault.class,
+          AbstractTopClass.class,
+          AbstractSubClass.class,
+          SubSubClassOne.class,
+          SubSubClassTwo.class,
+          SubSubClassThree.class,
+          OtherAbstractTopClass.class,
+          OtherAbstractSubClassOne.class,
+          OtherAbstractSubClassTwo.class,
+          OtherSubSubClassOne.class,
+          OtherSubSubClassTwo.class,
+          ThirdAbstractTopClass.class,
+          ThirdSubClassOne.class,
+          Main.class);
 
   public static List<byte[]> ASM_CLASSES = ImmutableList.of(
       getBytesFromAsmClass(IrrelevantInterfaceWithDefaultDump::dump),
       getBytesFromAsmClass(ThirdSubClassTwoDump::dump)
   );
 
-  public SingleTargetLookupTest(String methodName, Class invokeReceiver,
-      Class singleTargetHolderOrNull, List<Class> allTargetHolders) {
+  public SingleTargetLookupTest(
+      String methodName,
+      Class invokeReceiver,
+      Class singleTargetHolderOrNull,
+      List<Class> allTargetHolders) {
     this.methodName = methodName;
     this.invokeReceiver = invokeReceiver;
     this.singleTargetHolderOrNull = singleTargetHolderOrNull;
     this.allTargetHolders = allTargetHolders;
   }
 
-  @BeforeClass
-  public static void computeAppInfo() throws Exception {
+  public static AppInfoWithLiveness createAppInfoWithLiveness(AndroidApp app, Class<?> mainClass)
+      throws Exception {
     // Run the tree shaker to compute an instance of AppInfoWithLiveness.
-    Timing timing = new Timing(SingleTargetLookupTest.class.getCanonicalName());
+    Timing timing = new Timing();
     InternalOptions options = new InternalOptions();
-    AndroidApp app = readClassesAndAsmDump(CLASSES, ASM_CLASSES);
     DexApplication application = new ApplicationReader(app, options, timing).read().toDirect();
     AppView<? extends AppInfoWithSubtyping> appView =
         AppView.createForR8(new AppInfoWithSubtyping(application), options);
@@ -119,23 +114,28 @@
     ExecutorService executor = Executors.newSingleThreadExecutor();
     RootSet rootSet =
         new RootSetBuilder(
-                appView, application, buildKeepRuleForClass(Main.class, application.dexItemFactory))
+                appView, application, buildKeepRuleForClass(mainClass, application.dexItemFactory))
             .run(executor);
-    appInfo =
-        EnqueuerFactory.createForInitialTreeShaking(appView)
-            .traceApplication(rootSet, ProguardClassFilter.empty(), executor, timing);
+    return EnqueuerFactory.createForInitialTreeShaking(appView)
+        .traceApplication(rootSet, ProguardClassFilter.empty(), executor, timing);
     // We do not run the tree pruner to ensure that the hierarchy is as designed and not modified
     // due to liveness.
   }
 
+  @BeforeClass
+  public static void computeAppInfo() throws Exception {
+    appInfo = createAppInfoWithLiveness(readClassesAndAsmDump(CLASSES, ASM_CLASSES), Main.class);
+  }
+
   private static List<ProguardConfigurationRule> buildKeepRuleForClass(Class clazz,
       DexItemFactory factory) {
     Builder keepRuleBuilder = ProguardKeepRule.builder();
     keepRuleBuilder.setSource("buildKeepRuleForClass " + clazz.getTypeName());
     keepRuleBuilder.setType(ProguardKeepRuleType.KEEP);
     keepRuleBuilder.setClassNames(
-        ProguardClassNameList.singletonList(ProguardTypeMatcher.create(factory
-            .createType(DescriptorUtils.javaTypeToDescriptor(clazz.getCanonicalName())))));
+        ProguardClassNameList.singletonList(
+            ProguardTypeMatcher.create(
+                factory.createType(DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName())))));
     return Collections.singletonList(keepRuleBuilder.build());
   }
 
@@ -204,24 +204,22 @@
         singleTarget("instanceMethod", ThirdAbstractTopClass.class, ThirdAbstractTopClass.class),
         singleTarget(
             "otherInstanceMethod", ThirdAbstractTopClass.class, ThirdAbstractTopClass.class),
-        // TODO(b/139823850): Should not include A#confusing. Rather, include default I#confusing.
-        manyTargets("confusing", B.class, A.class, C.class)
     });
   }
 
-  private static DexMethod buildMethod(Class clazz, String name) {
+  public static DexMethod buildMethod(Class clazz, String name, AppInfo appInfo) {
     return appInfo
         .dexItemFactory()
         .createMethod(
-            toType(clazz),
+            toType(clazz, appInfo),
             appInfo.dexItemFactory().createProto(appInfo.dexItemFactory().voidType),
             name);
   }
 
-  private static DexType toType(Class clazz) {
+  public static DexType toType(Class clazz, AppInfo appInfo) {
     return appInfo
         .dexItemFactory()
-        .createType(DescriptorUtils.javaTypeToDescriptor(clazz.getCanonicalName()));
+        .createType(DescriptorUtils.javaTypeToDescriptor(clazz.getTypeName()));
   }
 
   private final String methodName;
@@ -231,26 +229,29 @@
 
   @Test
   public void lookupSingleTarget() {
-    DexMethod method = buildMethod(invokeReceiver, methodName);
-    Assert.assertNotNull(appInfo.resolveMethod(toType(invokeReceiver), method).asResultOfResolve());
+    DexMethod method = buildMethod(invokeReceiver, methodName, appInfo);
+    Assert.assertNotNull(
+        appInfo.resolveMethod(toType(invokeReceiver, appInfo), method).asResultOfResolve());
     DexEncodedMethod singleVirtualTarget = appInfo.lookupSingleVirtualTarget(method, method.holder);
     if (singleTargetHolderOrNull == null) {
       Assert.assertNull(singleVirtualTarget);
     } else {
       Assert.assertNotNull(singleVirtualTarget);
-      Assert.assertEquals(toType(singleTargetHolderOrNull), singleVirtualTarget.method.holder);
+      Assert.assertEquals(
+          toType(singleTargetHolderOrNull, appInfo), singleVirtualTarget.method.holder);
     }
   }
 
   @Test
   public void lookupVirtualTargets() {
-    DexMethod method = buildMethod(invokeReceiver, methodName);
-    Assert.assertNotNull(appInfo.resolveMethod(toType(invokeReceiver), method).asResultOfResolve());
+    DexMethod method = buildMethod(invokeReceiver, methodName, appInfo);
+    Assert.assertNotNull(
+        appInfo.resolveMethod(toType(invokeReceiver, appInfo), method).asResultOfResolve());
     Set<DexEncodedMethod> targets = appInfo.lookupVirtualTargets(method);
     Set<DexType> targetHolders = targets.stream().map(m -> m.method.holder)
         .collect(Collectors.toSet());
     Assert.assertEquals(allTargetHolders.size(), targetHolders.size());
-    Assert.assertTrue(allTargetHolders.stream().map(SingleTargetLookupTest::toType)
-        .allMatch(targetHolders::contains));
+    Assert.assertTrue(
+        allTargetHolders.stream().map(t -> toType(t, appInfo)).allMatch(targetHolders::contains));
   }
 }
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
new file mode 100644
index 0000000..8b71aaf
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodTest.java
@@ -0,0 +1,129 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.CompilationFailedException;
+import com.android.tools.r8.TestBase;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.ImmutableList;
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+
+@RunWith(Parameterized.class)
+public class VirtualOverrideOfPrivateStaticMethodTest extends TestBase {
+
+  public interface I {
+    default void f() {}
+  }
+
+  public static class A {
+    private static void f() {}
+  }
+
+  public static class B extends A implements I {}
+
+  public static class C extends B {
+    public void f() {}
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      B b = new C();
+      b.f();
+    }
+  }
+
+  public static List<Class<?>> CLASSES =
+      ImmutableList.of(A.class, B.class, C.class, I.class, Main.class);
+
+  private static AppInfoWithLiveness appInfo;
+
+  @BeforeClass
+  public static void computeAppInfo() throws Exception {
+    appInfo = SingleTargetLookupTest.createAppInfoWithLiveness(readClasses(CLASSES), Main.class);
+  }
+
+  private static DexMethod buildMethod(Class clazz, String name) {
+    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+  }
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+  private final DexMethod methodOnA = buildMethod(A.class, "f");
+  private final DexMethod methodOnB = buildMethod(B.class, "f");
+  private final DexMethod methodOnC = buildMethod(C.class, "f");
+
+  public VirtualOverrideOfPrivateStaticMethodTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void lookupSingleTarget() {
+    DexEncodedMethod resolved =
+        appInfo.resolveMethod(methodOnB.holder, methodOnB).asResultOfResolve();
+    assertEquals(methodOnA, resolved.method);
+    DexEncodedMethod singleVirtualTarget =
+        appInfo.lookupSingleVirtualTarget(methodOnB, methodOnB.holder);
+    Assert.assertNull(singleVirtualTarget);
+  }
+
+  @Test
+  public void lookupVirtualTargets() {
+    DexEncodedMethod resolved =
+        appInfo.resolveMethod(methodOnB.holder, methodOnB).asResultOfResolve();
+    assertEquals(methodOnA, resolved.method);
+    // This behavior is up for debate as the resolution target is A.f which is private static, thus
+    // the runtime behavior will be to throw a runtime exception. Thus it would be reasonable to
+    // return the empty set as no targets can actually be hit at runtime.
+    Set<DexEncodedMethod> targets = appInfo.lookupVirtualTargets(methodOnB);
+    assertTrue("Expected " + methodOnA, targets.stream().anyMatch(m -> m.method == methodOnA));
+    assertTrue("Expected " + methodOnC, targets.stream().anyMatch(m -> m.method == methodOnC));
+  }
+
+  @Test
+  public void runTest() throws ExecutionException, CompilationFailedException, IOException {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(CLASSES)
+          .run(parameters.getRuntime(), Main.class)
+          .assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+    }
+    testForR8(parameters.getBackend())
+        .addProgramClasses(CLASSES)
+        .addKeepMainRule(Main.class)
+        .setMinApi(parameters.getApiLevel())
+        .run(parameters.getRuntime(), Main.class)
+        .assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+  }
+
+  private String expectedRuntimeError() {
+    if (parameters.isDexRuntime()
+        && parameters.getRuntime().asDex().getVm().isOlderThanOrEqual(DexVm.ART_4_4_4_HOST)) {
+      return "IncompatibleClassChangeError";
+    }
+    return "IllegalAccessError";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
new file mode 100644
index 0000000..a652ea7
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java
@@ -0,0 +1,210 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.AsmTestBase;
+import com.android.tools.r8.D8TestRunResult;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.Set;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest extends AsmTestBase {
+
+  public interface I {
+    default void f() {}
+  }
+
+  public static class Base {
+    private // Made public using ASM.
+    void f() {}
+  }
+
+  public static class A extends Base {
+    private static void f() {}
+  }
+
+  public static class B extends A implements I {}
+
+  public static class C extends B {
+    public void f() {
+      System.out.println("Called C.f");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      B b = new C();
+      b.f();
+    }
+  }
+
+  public static class BaseDump implements Opcodes {
+
+    static String prefix(String suffix) {
+      return VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.class
+              .getTypeName()
+              .replace('.', '/')
+          + suffix;
+    }
+
+    public static byte[] dump() {
+      ClassWriter cw = new ClassWriter(0);
+      MethodVisitor mv;
+      cw.visit(V1_8, ACC_PUBLIC | ACC_SUPER, prefix("$Base"), null, "java/lang/Object", null);
+      cw.visitSource("VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest.java", null);
+      {
+        mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(ALOAD, 0);
+        mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(1, 1);
+        mv.visitEnd();
+      }
+      {
+        // Changed ACC_PRIVATE to ACC_PUBLIC
+        mv = cw.visitMethod(ACC_PUBLIC, "f", "()V", null, null);
+        mv.visitCode();
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(0, 1);
+        mv.visitEnd();
+      }
+      cw.visitEnd();
+      return cw.toByteArray();
+    }
+  }
+
+  public static List<Class<?>> CLASSES =
+      ImmutableList.of(A.class, B.class, C.class, I.class, Main.class);
+
+  public static List<byte[]> DUMPS = ImmutableList.of(BaseDump.dump());
+
+  private static AppInfoWithLiveness appInfo;
+
+  @BeforeClass
+  public static void computeAppInfo() throws Exception {
+    appInfo =
+        SingleTargetLookupTest.createAppInfoWithLiveness(
+            readClassesAndAsmDump(CLASSES, DUMPS), Main.class);
+  }
+
+  private static DexMethod buildMethod(Class clazz, String name) {
+    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+  }
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+  private final DexMethod methodOnA = buildMethod(A.class, "f");
+  private final DexMethod methodOnB = buildMethod(B.class, "f");
+  private final DexMethod methodOnC = buildMethod(C.class, "f");
+
+  public VirtualOverrideOfPrivateStaticMethodWithVirtualParentTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void lookupSingleTarget() {
+    DexEncodedMethod resolved =
+        appInfo.resolveMethod(methodOnB.holder, methodOnB).asResultOfResolve();
+    assertEquals(methodOnA, resolved.method);
+    DexEncodedMethod singleVirtualTarget =
+        appInfo.lookupSingleVirtualTarget(methodOnB, methodOnB.holder);
+    Assert.assertNull(singleVirtualTarget);
+  }
+
+  @Test
+  public void lookupVirtualTargets() {
+    DexEncodedMethod resolved =
+        appInfo.resolveMethod(methodOnB.holder, methodOnB).asResultOfResolve();
+    assertEquals(methodOnA, resolved.method);
+    // See comment in VirtualOverrideOfPrivateStaticMethodTest.lookupVirtualTargets().
+    Set<DexEncodedMethod> targets = appInfo.lookupVirtualTargets(methodOnB);
+    assertTrue("Expected " + methodOnA, targets.stream().anyMatch(m -> m.method == methodOnA));
+    assertTrue("Expected " + methodOnC, targets.stream().anyMatch(m -> m.method == methodOnC));
+  }
+
+  @Test
+  public void runJvmAndD8() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(CLASSES)
+          .addProgramClassFileData(DUMPS)
+          .run(parameters.getRuntime(), Main.class)
+          .assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+    } else {
+      D8TestRunResult runResult =
+          testForD8()
+              .addProgramClasses(CLASSES)
+              .addProgramClassFileData(DUMPS)
+              .setMinApi(parameters.getApiLevel())
+              .run(parameters.getRuntime(), Main.class);
+      if (expectedToIncorrectlyRun(parameters.getRuntime())) {
+        // Do to incorrect resolution, some Art VMs will resolve to Base.f (ignoring A.f) and thus
+        // virtual dispatch to C.f.
+        runResult.assertSuccessWithOutputLines("Called C.f");
+      } else {
+        runResult.assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+      }
+    }
+  }
+
+  @Test
+  public void runR8() throws Exception {
+    R8TestRunResult runResult =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(CLASSES)
+            .addProgramClassFileData(DUMPS)
+            .addKeepMainRule(Main.class)
+            .setMinApi(parameters.getApiLevel())
+            .run(parameters.getRuntime(), Main.class);
+    if (expectedToIncorrectlyRun(parameters.getRuntime())) {
+      // Do to incorrect resolution, some Art VMs will resolve to Base.f (ignoring A.f) and thus
+      // virtual dispatch to C.f.
+      runResult.assertSuccessWithOutputLines("Called C.f");
+    } else {
+      runResult.assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+    }
+  }
+
+  private boolean expectedToIncorrectlyRun(TestRuntime runtime) {
+    return runtime.isDex()
+        && runtime.asDex().getVm().isNewerThan(DexVm.ART_4_4_4_HOST)
+        && runtime.asDex().getVm().isOlderThanOrEqual(DexVm.ART_7_0_0_HOST);
+  }
+
+  private String expectedRuntimeError() {
+    if (parameters.isDexRuntime()
+        && parameters.getRuntime().asDex().getVm().isOlderThanOrEqual(DexVm.ART_4_4_4_HOST)) {
+      return "IncompatibleClassChangeError";
+    }
+    return "IllegalAccessError";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
new file mode 100644
index 0000000..57608d9
--- /dev/null
+++ b/src/test/java/com/android/tools/r8/resolution/VirtualOverrideOfStaticMethodWithVirtualParentTest.java
@@ -0,0 +1,238 @@
+// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+package com.android.tools.r8.resolution;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import com.android.tools.r8.AsmTestBase;
+import com.android.tools.r8.D8TestRunResult;
+import com.android.tools.r8.R8TestRunResult;
+import com.android.tools.r8.TestParameters;
+import com.android.tools.r8.TestParametersCollection;
+import com.android.tools.r8.TestRuntime;
+import com.android.tools.r8.ToolHelper.DexVm;
+import com.android.tools.r8.graph.DexEncodedMethod;
+import com.android.tools.r8.graph.DexMethod;
+import com.android.tools.r8.shaking.AppInfoWithLiveness;
+import com.google.common.collect.ImmutableList;
+import java.util.List;
+import java.util.Set;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.junit.runners.Parameterized.Parameters;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+@RunWith(Parameterized.class)
+public class VirtualOverrideOfStaticMethodWithVirtualParentTest extends AsmTestBase {
+
+  public interface I {
+    default void f() {}
+  }
+
+  public static class Base {
+    private // Made public using ASM.
+    void f() {}
+  }
+
+  public static class A extends Base {
+    private // Made public using ASM.
+    static void f() {}
+  }
+
+  public static class B extends A implements I {}
+
+  public static class C extends B {
+    public void f() {
+      System.out.println("Called C.f");
+    }
+  }
+
+  public static class Main {
+
+    public static void main(String[] args) {
+      B b = new C();
+      b.f();
+    }
+  }
+
+  public static class BaseDump implements Opcodes {
+
+    static String prefix(String suffix) {
+      return VirtualOverrideOfStaticMethodWithVirtualParentTest.class
+              .getTypeName()
+              .replace('.', '/')
+          + suffix;
+    }
+
+    public static byte[] dump() {
+      ClassWriter cw = new ClassWriter(0);
+      cw.visit(V1_8, ACC_PUBLIC | ACC_SUPER, prefix("$Base"), null, "java/lang/Object", null);
+      MethodVisitor mv;
+      {
+        mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(ALOAD, 0);
+        mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(1, 1);
+        mv.visitEnd();
+      }
+      {
+        // Changed ACC_PRIVATE to ACC_PUBLIC
+        mv = cw.visitMethod(ACC_PUBLIC, "f", "()V", null, null);
+        mv.visitCode();
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(0, 1);
+        mv.visitEnd();
+      }
+      cw.visitEnd();
+      return cw.toByteArray();
+    }
+  }
+
+  public static class ADump implements Opcodes {
+
+    static String prefix(String suffix) {
+      return VirtualOverrideOfStaticMethodWithVirtualParentTest.class
+              .getTypeName()
+              .replace('.', '/')
+          + suffix;
+    }
+
+    public static byte[] dump() {
+      ClassWriter cw = new ClassWriter(0);
+      cw.visit(V1_8, ACC_PUBLIC | ACC_SUPER, prefix("$A"), null, prefix("$Base"), null);
+      MethodVisitor mv;
+      {
+        mv = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null, null);
+        mv.visitCode();
+        mv.visitVarInsn(ALOAD, 0);
+        mv.visitMethodInsn(INVOKESPECIAL, prefix("$Base"), "<init>", "()V", false);
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(1, 1);
+        mv.visitEnd();
+      }
+      {
+        // Changed ACC_PRIVATE to ACC_PUBLIC
+        mv = cw.visitMethod(ACC_PUBLIC | ACC_STATIC, "f", "()V", null, null);
+        mv.visitCode();
+        mv.visitInsn(RETURN);
+        mv.visitMaxs(0, 1);
+        mv.visitEnd();
+      }
+      cw.visitEnd();
+      return cw.toByteArray();
+    }
+  }
+
+  public static List<Class<?>> CLASSES = ImmutableList.of(B.class, C.class, I.class, Main.class);
+
+  public static List<byte[]> DUMPS = ImmutableList.of(BaseDump.dump(), ADump.dump());
+
+  private static AppInfoWithLiveness appInfo;
+
+  @BeforeClass
+  public static void computeAppInfo() throws Exception {
+    appInfo =
+        SingleTargetLookupTest.createAppInfoWithLiveness(
+            readClassesAndAsmDump(CLASSES, DUMPS), Main.class);
+  }
+
+  private static DexMethod buildMethod(Class clazz, String name) {
+    return SingleTargetLookupTest.buildMethod(clazz, name, appInfo);
+  }
+
+  @Parameters(name = "{0}")
+  public static TestParametersCollection data() {
+    return getTestParameters().withAllRuntimes().withAllApiLevels().build();
+  }
+
+  private final TestParameters parameters;
+  private final DexMethod methodOnA = buildMethod(A.class, "f");
+  private final DexMethod methodOnB = buildMethod(B.class, "f");
+  private final DexMethod methodOnC = buildMethod(C.class, "f");
+
+  public VirtualOverrideOfStaticMethodWithVirtualParentTest(TestParameters parameters) {
+    this.parameters = parameters;
+  }
+
+  @Test
+  public void lookupSingleTarget() {
+    DexEncodedMethod resolved =
+        appInfo.resolveMethod(methodOnB.holder, methodOnB).asResultOfResolve();
+    assertEquals(methodOnA, resolved.method);
+    DexEncodedMethod singleVirtualTarget =
+        appInfo.lookupSingleVirtualTarget(methodOnB, methodOnB.holder);
+    Assert.assertNull(singleVirtualTarget);
+  }
+
+  @Test
+  public void lookupVirtualTargets() {
+    DexEncodedMethod resolved =
+        appInfo.resolveMethod(methodOnB.holder, methodOnB).asResultOfResolve();
+    assertEquals(methodOnA, resolved.method);
+    // See comment in VirtualOverrideOfPrivateStaticMethodTest.lookupVirtualTargets().
+    Set<DexEncodedMethod> targets = appInfo.lookupVirtualTargets(methodOnB);
+    assertTrue("Expected " + methodOnA, targets.stream().anyMatch(m -> m.method == methodOnA));
+    assertTrue("Expected " + methodOnC, targets.stream().anyMatch(m -> m.method == methodOnC));
+  }
+
+  @Test
+  public void testJvmAndD8() throws Exception {
+    if (parameters.isCfRuntime()) {
+      testForJvm()
+          .addProgramClasses(CLASSES)
+          .addProgramClassFileData(DUMPS)
+          .run(parameters.getRuntime(), Main.class)
+          .assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+    } else {
+      D8TestRunResult runResult =
+          testForD8()
+              .addProgramClasses(CLASSES)
+              .addProgramClassFileData(DUMPS)
+              .setMinApi(parameters.getApiLevel())
+              .run(parameters.getRuntime(), Main.class);
+      if (expectedToIncorrectlyRun(parameters.getRuntime())) {
+        // Do to incorrect resolution, some Art VMs will resolve to Base.f (ignoring A.f) and thus
+        // virtual dispatch to C.f.
+        runResult.assertSuccessWithOutputLines("Called C.f");
+      } else {
+        runResult.assertFailureWithErrorThatMatches(containsString(expectedRuntimeError()));
+      }
+    }
+  }
+
+  @Test
+  public void testR8() throws Exception {
+    R8TestRunResult runResult =
+        testForR8(parameters.getBackend())
+            .addProgramClasses(CLASSES)
+            .addProgramClassFileData(DUMPS)
+            .addKeepMainRule(Main.class)
+            .setMinApi(parameters.getApiLevel())
+            .run(parameters.getRuntime(), Main.class);
+    // TODO(b/139918381): The result of R8 contains invalid code, thus most VMs fail class loading.
+    // Some Art VMs fail too, but not in a consistent manner, so not encoding that here.
+    if (parameters.isCfRuntime()) {
+      runResult.assertFailureWithErrorThatMatches(containsString("ClassFormatError"));
+    }
+  }
+
+  private boolean expectedToIncorrectlyRun(TestRuntime runtime) {
+    return runtime.isDex()
+        && runtime.asDex().getVm().isNewerThan(DexVm.ART_4_4_4_HOST)
+        && runtime.asDex().getVm().isOlderThanOrEqual(DexVm.ART_7_0_0_HOST);
+  }
+
+  private static String expectedRuntimeError() {
+    return "IncompatibleClassChangeError";
+  }
+}
diff --git a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/A.java b/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/A.java
deleted file mode 100644
index 4914380..0000000
--- a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/A.java
+++ /dev/null
@@ -1,10 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.resolution.singletarget.interfacedefault;
-
-public class A {
-  private static void confusing() {
-    System.out.println("A::confusing()");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/B.java b/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/B.java
deleted file mode 100644
index b575db5..0000000
--- a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/B.java
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.resolution.singletarget.interfacedefault;
-
-public class B extends A implements I {
-  @Override
-  public void confusing(int i) {
-    System.out.println("B::confusing(" + i + ")");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/C.java b/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/C.java
deleted file mode 100644
index 2940ea3..0000000
--- a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/C.java
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.resolution.singletarget.interfacedefault;
-
-public class C extends B {
-  @Override
-  public void confusing() {
-    System.out.println("C::confusing()");
-  }
-}
diff --git a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/I.java b/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/I.java
deleted file mode 100644
index 04ff6ba..0000000
--- a/src/test/java/com/android/tools/r8/resolution/singletarget/interfacedefault/I.java
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (c) 2019, the R8 project authors. Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-package com.android.tools.r8.resolution.singletarget.interfacedefault;
-
-public interface I {
-  void confusing(int i);
-
-  default void confusing() {
-    System.out.println("I::confusing()");
-    confusing(0);
-  }
-}